面向对象 - 绑定方法与非绑定方法：
定义：
在类内部定义的函数，分为两大类：
1.绑定方法：绑定给谁，就应该由谁来调用，谁来调用 就会把调用者当作第一个参数自动传入
绑定到对象的方法：在类内部定义的，没有被任何装饰器修饰的
对于类来说 它就是个 普通函数 <function Foo.tell at 0x000001FD0D800B70>
对于对象来说 它就是个 绑定方法 <bound method Foo.tell of <__main__.Foo object at 0x000001FD0D832710>>
绑定到类的方法：在类内部定义的，被装饰器@classmethod 修饰的方法
对于类和对象来说 它就是个 绑定方法 <bound method Foo.func1 of <class '__main__.Foo'>>
2.非绑定方法：
非绑定方法：不与类或对象绑定 在类内部定义的，被装饰器@staticmethod 修饰的方法
对于类和对象来说 它就是个 普通函数 < function Foo.fun2 at 0x00000157332C0C80>
应用：
1.绑定给对象 就应该由对象来调用 自动将对象本身当作第一个参数 传入
def tell_info(self):
2.绑定给类 就应该由类来调用 自动将类本身当作第一个参数 传入
@classmethod def from_conf(cls) # 读配置文件里的内容 一种实例化的方式
3.非绑定方法 不与类或者对象绑定 谁都可以调用 没有自动传值一说
@staticmethod def create_id(): # 创建随机的 id
1 class Foo: 2 all_type='hello' # 公用的 3 def __init__(self,name): # 绑定到 对象 4 self.name=name 5 6 def tell(self): # 绑定到 对象 7 print('名字是 %s'%self.name) 8 9 @classmethod # 绑定到 类 10 def func1(cls,data): 11 print(cls,data) 12 13 @staticmethod # 非绑定 方法 14 def fun2(x,y): 15 print(x+y) 16 17 f=Foo('alice') 18 # f.tell() 19 # f.func1(2) # 不限制 你使用 20 # Foo.func1(4) 21 # f.fun2(2,3) 22 # Foo.fun2(3,4) 23 24 # print(Foo.tell) 25 # print(f.tell) 26 # print((Foo.func1)) 27 # print(f.func1) 28 # print(Foo.fun2) 29 # print(f.fun2) 30 # print(Foo.tell) 31 # print(f.tell) 32 # print(Foo.__init__) 33 # print(f.__init__) 34 # print(Foo.all_type) 35 # print(f.all_type) 36 # Foo.tell(f) 37 # Foo.__init__(f,'aa') 38 # f.tell() 39 # Foo.func1(3) 40 41 import settings 42 import hashlib 43 import time 44 import string 45 import random 46 47 class People: 48 def __init__(self,name,age,sex): 49 self.id=self.create_id() 50 self.name=name 51 self.age=age 52 self.sex=sex 53 54 def tell_info(self): # 绑定到对象 # 根据函数体的逻辑 来想 参数 应该传什么进来 55 print('Name:%s Age:%s Sex:%s'%(self.name,self.age,self.sex)) 56 57 @classmethod 58 def from_conf(cls): # 读配置文件里的内容 一种实例化的方式 59 obj=cls( 60 settings.name, 61 settings.age, 62 settings.sex 63 ) 64 return obj 65 66 @staticmethod 67 def create_id(): # 创建随机的 id 68 # m=hashlib.md5(str(time.time()).encode('utf-8')) 69 m=hashlib.md5(''.join(random.sample(string.ascii_letters+string.digits+string.punctuation,8)).encode('utf-8')) 70 return m.hexdigest() 71 72 p=People('alice',12,'female') 73 p2=People('alice',12,'female') 74 p3=People('alice',12,'female') 75 # p.tell_info() 76 # print(settings.name,settings.age,settings.sex) 77 78 # People.from_conf().tell_info() 79 80 # print(p.create_id()) 81 # print(People.create_id()) 82 # print(p.id) 83 # print(p2.id) 84 # print(p3.id)
面向对象 - 反射:
反射:通过字符串来映射到一个对象的属性上面,与用户交互
hasattr(obj,'name')
getattr(obj,'talk',None)
getattr(obj,'age')
setattr(obj,'sex','male')
delattr(obj,'age')
注：obj可以是对象也可以是类
hasattr(People,'country')
getattr(People,'country',None)
setattr(People,'city','中国')
delattr(People,'country')
总结:通过字符串来访问到对象或类的数据属性和函数属性
用处:接受用户的输入触发对象的某一个方法
if hasattr(self,cmds[0]):
func=getattr(self,cmds[0])
func(cmds)
1 class People: 2 country='China' 3 def __init__(self,name,age): 4 self.name=name 5 self.age=age 6 7 def talk(self): 8 print('%s is talking'%self.name) 9 10 # obj=People('alice',12) 11 # print(obj.name) #obj.__dict___['name'] 12 # print(obj.__dict__) 13 # print(obj.__dict__['age']) 14 # obj.talk() 15 16 # choice=input('>>:').strip() 17 # print(obj.choice) 18 # print(hasattr(obj,choice)) 19 # print(getattr(obj,choice)) 20 # print(getattr(obj,choice,None)) 21 22 # if hasattr(obj,choice): 23 # print(getattr(obj,choice)) 24 # setattr(obj,'sex','male') 25 # print(obj.sex) 26 # print(obj.__dict__) 27 # delattr(obj,choice) 28 # print(obj.__dict__) 29 # 30 # print(getattr(People,'country',None)) 31 32 # print(hasattr(obj,choice)) 33 # print(getattr(obj,choice,None)) 34 # print(getattr(obj,choice)) 35 # print(getattr(obj,'talk')) 36 # setattr(obj,'sex','male') 37 # print(obj.__dict__) 38 # delattr(obj,'name') 39 # print(obj.__dict__) 40 # setattr(obj,'age',18) 41 # print(obj.__dict__) 42 # print(getattr(People,'country')) 43 # setattr(People,'city','中国') 44 # print(People.__dict__) 45 # delattr(People,'country') 46 # print(People.__dict__) 47 # print(hasattr(People,'country')) 48 49 class Service: 50 def run(self): 51 while True: 52 inp=input('>>:').strip() 53 cmds = inp.split() 54 print(cmds) 55 if hasattr(self,cmds[0]): 56 func=getattr(self,cmds[0]) 57 func(cmds) 58 59 def get(self,cmds): 60 print('get...',cmds) 61 62 def put(self,cmds): 63 print('put...',cmds) 64 65 # obj=Service() 66 # obj.run()
面向对象 - 内置方法：
1.isinstance() isinstance(f,Foo) 什么是什么的对象
2.issubclass() issubclass(Foo,Bar) 什么是什么的子类
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): return ... print(obj) 触发
5.__del__()
del obj 会触发 __del__():... 在这里面做一些 回收机制 删除os的资源
因为py只会回收应用程序的资源，不会回收os的资源 eg:关掉文件
应用程序 不能直接操作 硬盘 需要通过 操作系统
涉及到两方面得资源 应用程序得资源 和操作系统得资源 一定要在 程序结束之前 关闭操作系统得资源
with open() as f: #会自动关闭文件
f=open() f.close() #需要回收资源
注：在类内部定义 __开头 __结尾得方法，这些方法会在某种情况下自动触发，完成定制化得效果
参考：http://www.cnblogs.com/linhaifeng/articles/6204014.html
1 class Bar: 2 pass 3 class Foo(Bar): 4 pass 5 f=Foo() 6 # print(isinstance(f,Foo)) 7 # print(issubclass(Foo,Bar)) 8 # print(issubclass(Bar,Foo)) 9 10 # item 系列 11 class Foo: 12 def __init__(self,name): 13 self.name=name 14 15 def __getitem__(self, item): 16 # return self.__dict__[item] # 若是没有 会报错 17 return self.__dict__.get(item) 18 19 def __setitem__(self, key, value): 20 self.__dict__[key]=value 21 22 def __delitem__(self, key): 23 del self.__dict__[key] 24 25 def __str__(self): 26 return '<name:%s>'%self.name 27 28 def __del__(self): 29 # self.close() 30 print('回收操作系统的 资源') 31 32 obj=Foo('alice') 33 # print(obj.__dict__) 34 # print(obj.name) 35 # print(obj['name']) 36 # obj['name']='aaaa' 37 # print(obj.__dict__) 38 # del obj['name'] 39 # print(obj.__dict__) 40 # obj.sex='12' 41 # print(obj.__dict__) 42 43 # print(obj) 44 45 # del obj 46 # print('---main---')