1.绑定方法与非绑定方法介绍
在类内部定义的函数，分为两大类：
1.绑定方法:绑定给谁，就应该由谁来调用，谁来调用 就会把调用者当作第一个参数自动传入
绑定到对象的方法：在类内定义的没有被任何装饰器修饰的
绑定到类的方法：在类内定义的被装饰器 @classmethod 修饰的方法
2.非绑定方法:没有自动传值这么一说，就类中定义的一个普通工具，对象和类都可以使用
非绑定方法：不与类或对象绑定 在类内定义的被装饰器 @staticmethod 修饰的方法
1 class Foo: 2 def __init__(self,name): 3 self.name = name 4 5 def tell(self): # 绑定给对象使用的 6 print('名字是%s' % self.name) 7 8 @classmethod # 绑定给类 9 def func(cls): # cls = Foo 10 print(cls) 11 12 @staticmethod # 普通函数 13 def func1(x,y): 14 print(x+y) 15 16 f = Foo('agon') 17 18 print(Foo.tell) # 普通函数 <function Foo.tell at 0x00520150> 19 Foo.tell(f) 20 print(f.tell) # 绑定方法 <bound method Foo.tell of <__main__.Foo object at 0x0051FF70>> 21 22 # print(Foo.func) 23 # Foo.func() 24 25 print(Foo.func1) 26 print(f.func1) 27 28 Foo.func1(1,2) 29 f.func1(2,3)
2.绑定方法与非绑定方法应用
# 绑定给对象 就应该由对象来调用 自动将对象本身当作第一个参数 传入
def tell_info(self):
# 绑定给类 就应该由类来调用，自动将类本身当作第一个参数传入
@classmethod
def from_conf(cls):
# 非绑定方法 不与类或者对象绑定，谁都可以调用，没有自动传值一说
@staticmethod
def create_id():
1 import settings 2 import hashlib 3 import time 4 5 class People: 6 def __init__(self,name,age,sex): 7 self.id = self.create_id() 8 self.name = name 9 self.age = age 10 self.sex = sex 11 12 def tell_info(self): # 绑定到对象的方法 # 根据函数体的逻辑 来想 参数 应该传什么进来 13 print('Name:%s Age:%s Sex:%s'% (self.name,self.age,self.sex)) 14 15 @classmethod 16 def from_conf(cls): # 读配置文件里的内容 一种实例化的方式 17 obj = cls( 18 settings.name, 19 settings.age, 20 settings.sex 21 ) 22 return obj 23 24 @staticmethod 25 def create_id(): 26 m = hashlib.md5(str(time.time()).encode('utf-8')) 27 return m.hexdigest() 28 29 # p = People('egon',18,'male') # 一种实例化的方式 30 31 # 绑定给对象，就应该由对象来调用，自动将对象本身当作第一个参数传入 32 # p.tell_info() # tell_info(p) 33 34 # 绑定给类，就应该由类来调用，自动将类本身当作第一个参数传入 35 # p = People.from_conf() # from_conf(People) 36 # p.tell_info() 37 38 # 非绑定方法：不与类或者对象绑定，谁都可以调用，没有自动调用一说 39 p1 = People('egon1',18,'male') 40 time.sleep(1) 41 p2 = People('egon2',28,'male') 42 time.sleep(1) 43 p3 = People('egon3',38,'male') 44 45 print(p1.id) 46 print(p2.id) 47 print(p3.id)
3.反射
# 需求 通过用户的输入 让用户来控制 我要访问你什么样的属性
反射：通过字符串 来映射到一个对象的属性上 ----》反射
hasattr(obj,'name')
getattr(obj,'talk',None)
setattr(obj,'name','alex')
setattr(obj,'sex','male')
delattr(obj,'age')
# 可以是对象 可以是类
getattr(People,'country',None)
hasattr()
setattr()
delattr()
总结：通过字符串来访问到对象或类的数据属性和函数属性
用处：接收用户的输入触发对象下面的某一个方法
1 # 反射：通过字符串映射到对象的属性 2 class People: 3 country = 'China' 4 def __init__(self,name,age): 5 self.name = name 6 self.age = age 7 8 def talk(self): 9 print('%s is talking...' % self.name) 10 11 obj = People('egon',18) 12 # print(obj.name) #.name属性 本质 obj.__dict__['name'] 13 # print(obj.talk) #.talk属性 14 15 # 需求 通过用户的输入 让用户来控制 我要访问你什么样的属性 16 # 通过字符串 来映射到一个对象的属性上 ----》反射 17 # 用户的输入是个字符串 18 # choice = input('>>:') # choice = 'name' 19 # print(obj.choice) # print(obj.'name') 这是错误的，调用的应该是属性而不是字符串 20 21 # 判断 22 # print(hasattr(obj,'name')) # 23 # # obj.name 判断obj中有没有name这个属性(本质就是obj.__dict__['name'],判断有没name这个key) 24 # print(hasattr(obj,'talk')) 25 26 # 查 27 # print(getattr(obj,'name',None)) 28 # print(getattr(obj,'talk',None)) 29 30 # 增,改 31 # setattr(obj,'sex','male') # obj.sex = 'male' 32 # print(obj.sex) 33 34 # 删 35 # delattr(obj,'age') # del obj.age 36 # print(obj.__dict__) 37 38 # print(getattr(obj,'country')) # People.country 39 40 41 # 反射的应用： 42 43 # 接收用户的输入，然后触发对象下面的某一个方法 44 45 # class Service: 46 # def run(self): 47 # while True: 48 # cmd = input('>>:').strip() 49 # if hasattr(self,cmd): 50 # func = getattr(self,cmd) 51 # func() 52 # 53 # def get(self): 54 # print('get...') 55 # 56 # def put(self): 57 # print('put...') 58 # 59 # obj = Service() 60 # obj.run() 61 62 63 class Service: 64 def run(self): 65 while True: 66 inp = input('>>:').strip() # inp = 'get a.txt' 67 cmds = inp.split() # cmds = ['get','a.txt'] 68 # print(cmds) 69 70 if hasattr(self,cmds[0]): 71 func = getattr(self,cmds[0]) 72 func(cmds) 73 74 def get(self,cmds): 75 print('get...',cmds) 76 77 def put(self,cmds): 78 print('put...',cmds) 79 80 obj = Service() 81 obj.run()
4.内置方法
内置方法：
参考：http://www.cnblogs.com/linhaifeng/articles/6204014.html
1.isinstance()
2.issubclass()
3.item 系列 ---> 把对象做成一个像字典对象那样 像字典对象那样访问数据
#查看属性 def __getitem__(self, item): obj['name'] 触发
#设置属性 def __setitem__(self, key, value): obj['sex']='male' 触发
#删除属性 def __delitem__(self, key): del obj['name'] 触发
在类内部定义 __开头 __结尾得方法，这些方法会在某种情况下自动触发，完成定制化得效果 定制一些功能
4.__str__()
#设置打印得格式 def __str__(self): print(obj) 触发
5.__del__()
#del f 会触发__del__() # f.__del__() # 这里会 先触发__del__() 在删除f
#应用程序结束后 回收f时 会触发 __del__() # 因为py只会回收应用程序得资源，不会回收操作系统得资源，在这做一些跟对象相关联得回收机制
1 # class Foo(): 2 # pass 3 # obj=Foo() 4 # print(isinstance(obj,Foo)) 5 6 # ------------------------------------------- 7 # class Foo(): 8 # pass 9 # 10 # class Bar(Foo): 11 # pass 12 # 13 # print(issubclass(Bar,Foo)) 14 15 # ------------------------------------------- 16 17 # item系列 18 # __x__这种方法不需要自己用，python会自动调用 19 # class Foo: # Dick 20 # def __init__(self,name): 21 # self.name = name 22 # 23 # def __getitem__(self, item):# item = 'name' 24 # # print('getitem...') 25 # # print(item) 26 # return self.__dict__.get(item) 27 # 28 # def __setitem__(self, key, value): 29 # # print('setitem...') 30 # # print(key,value) 31 # self.__dict__[key] = value 32 # 33 # def __delitem__(self, key): 34 # # print('delitem') 35 # # print(key) 36 # # del self.__dict__[key] # 这种删除方式，或者下面那种 37 # self.__dict__.pop(key) 38 # 39 # obj = Foo('agen') 40 # print(obj.__dict__) 41 42 # 查看属性： 43 # obj.属性名 44 # obj['name'] 45 # print(obj['name']) 46 47 # 设置属性： 48 # obj.sex = 'male' 49 # obj['sex'] = 'male' 50 # 51 # print(obj.__dict__) 52 # print(obj.sex) 53 54 # 删除属性： 55 # print(obj.__dict__) 56 # del obj['sex'] 57 # print(obj.__dict__) 58 59 60 # __str__方法 打印对象的时候自动触发对象下面的__str__方法,把一个字符串的返回结果作为打印结果打印出来 61 # 数据类型就是类 62 # d = dict({'name':'egon'}) 63 # # print(isinstance(d,dict)) 64 # print(d) 65 66 # class Foo: 67 # pass 68 # obj = Foo() 69 # print(obj) 70 71 # class People: 72 # def __init__(self,name,age): 73 # self.name = name 74 # self.age = age 75 # 76 # def __str__(self): 77 # # print('======>str') 78 # r eturn '<name:%s,age:%s>' % (self.name,self.age) 79 # 80 # obj = People('egon',18) 81 # print(obj) # res = obj.__str__() 82 83 # ------------------------------------------------------- 84 # __del__方法： 85 # 应用程序 不能直接操作 硬盘 需要通过 操作系统 86 # 涉及到两方面得资源 应用程序得资源 和操作系统得资源 一定要在 程序结束之前 关闭操作系统得资源 87 # with open() as f: 会自动回收 f 88 # f = open('settings.py') # 通知操作系统 打开文件 # 涉及到两方面得资源 89 # f.read() # 应用程序向操作系统 发了个调用 让os从硬盘上读出来 90 # 91 # f.close() # 回收操作系统的资源 92 93 class Open: # 如何关闭操作系统 得资源 open()打开文件 94 def __init__(self,filename): 95 print('open file......') 96 self.filename = filename 97 98 def __del__(self): # 程序结束后 py会回收掉应用程序得资源 会触发 __del__() 在这回收os得资源 99 print('回收操作系统资源') 100 # 做一些跟对象相关联 回收机制 101 # 因为py只会回收 应用程序得资源 不会回收操作系统得 资源 102 f = Open('settings.py') 103 # del f # f.__del__() # 这里会 先触发__del__() 在删除f 104 print('----main----') # 到这一步python回收机制会回收f,但留下操作系统的资源,这时候程序结束的时候触发__del__，可以回收操作系统资源