1、attr 系列
class foo: def __init__(self,NAME): self.name=NAME def __setattr__(self, key, value): # 作用：可以对 value 进行类型限制 if not isinstance(value,str): # 对 value 限制只能是字符串 raise TypeError('must be str') # print('setattr----key:%s,value:%s'%(key,value)) # print(type(key)) # key 是字符串类型 # print(type(value)) # self.key=value # key 是字符串类型，self.属性，属性不能为字符串类型，不能这样赋值 # setattr(self,key,value) # 跟上面一样 self.key=valuse 会触发 setattr 的执行，会造成递归 self.__dict__[key]=value # 直接在对象的 dict 字典里面操作 def __delattr__(self, item): print('delattr:%s'%item) # del self.__dict__[item] # 同样，删除直接去删除对象的字典，法1 self.__dict__.pop(item) # 法2 def __getattr__(self, item): print('getattr:%s'%item) f1=foo('egon') # f1.name='egon' 赋值操作会先触发setattr 的执行 f1.age='18' del f1.age print(f1.__dict__) getattr 单独拿出来 class foo: def __init__(self, NAME): self.name = NAME # 只有属性不存在才会触发 getattr 的执行 def __getattr__(self, item): print('getattr:%s %s' % (item,type(item))) f1 = foo('egon') # f1.name='egon' 赋值操作会先触发setattr 的执行 # print(f1.name) print(f1.xxxx) # 属性不存在才会触发 getattr 的执行
2、item 系列
__setitem__(self,key,value):当对类中的某个属性进行"赋值"时触发的函数(只有使用字典赋值的方式时才会触发此方法的执行) 与Attr系列的区分:__setattr__(self):是在对象打点儿的方式赋值时,才会触发的方法 class Foo: def __setitem__(self, key, value): print(key,"获得",value) f = Foo() f["name"] = "egon" value = egon
__delitem__(self,key):当类中的某个属性被删除时,触发此方法(只有使用del字典方式删除属性时,才会触发此方法) 与Attr系列的区分:__delattr__(self):使用del类打点儿属性的方式删除属性,才会触发此方法 class Foo: name = "egon" def __delitem__(self, key): print(key,"已被删除") f = Foo() del f["name"]
__getitem__(self,item):当调用类中的属性或方法时触发此方法的执行(只在使用类[key]字典的方式调用时,才会触发此方法) 与Attr系列的区分:其实这里已经很明显了,__getattr__(self):是类打点儿调用且命名空间没有发现名字的情况下,触发此方法 class Foo: name = "egon" def __getitem__(self, item): print(item,"已被调用") f = Foo() f["name"]
3、__slots__
__slots__:其实就是将类中的名称锁定,实例化对象,只可以赋值和调用,不可以删除属性和增加新的属性
应用场景：当实例化几万个对象的时候，每个对象都会生成一个名称空间__dict__，而每一个名称空间都会各自占用一个内存，造成内存的浪费，用 __slots__，不用再产生 dict 了，省内存，对象的 dict 都统一用类的 dict，属性都是用 slots 给定义的
class Foo: __slots__ = ["x","y"]#在类中定义属性x和y f = Foo()#实例化Foo f.x = 1#此时我们可以使用实例化对象调用类中的属性x f.y = 2 #如果现在,我们在实例化对象中增加一个z f.z = 3 #会得到如下错误 #AttributeError: 'Foo' object has no attribute 'z' #也就是不可以,对实例化对象增加新的属性 #如果现在,我们在实例化对象中删除一个x del f.x#此时程序执行并不会出错,但是我们打印一下Foo的命名空间 print(Foo.__dict__) #{'__doc__': None, 'y': <member 'y' of 'Foo' objects>, '__module__': '__main__', 'x': <member 'x' of 'Foo' objects>, '__slots__': ['x', 'y']} #依然可以看到x的存在,所以,实例化对象不可以删除__slots__定义的属性
class Foo: __slots__ = ["x","y"] Foo.__slots__ = "z" print(Foo.__dict__) #{'__doc__': None, 'x': <member 'x' of 'Foo' objects>, '__slots__': 'z', '__module__': '__main__', 'y': <member 'y' of 'Foo' objects>} del Foo.x print(Foo.__dict__) #{'__doc__': None, '__slots__': 'z', '__module__': '__main__', 'y': <member 'y' of 'Foo' objects>} # f.z=3 对象也无法赋值 __slots__只是针对实例化对象的禁锢,直接对类中的属性进行修改,是可以的
4、__next__ 和 __iter__
class foo: def __init__(self,start): self.start=start def __next__(self): return self def __iter__(self): n=self.start self.start=+1 return self f=foo(0) print(next(f)) # f.__next__() print(next(f)) # f.__next__() for i in f: # 执行 i=f.__iter__ 方法，转化为一个迭代器 print(i) # next(i) 执行 next 方法
5、__del__
这个是在回收实例化对象时触发执行的方法
每当 del 实例化对象时会触发
或者是程序结束时,会触发,总之就是实例化对象失效时都会执行__del__方法
注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的
class Foo: def __del__(self): print(self,"被释放掉了") f = Foo() print(f) del f import time class Open: def __init__(self,file,mode='r',encoding='utf8'): self.x=open(file,mode=mode,encoding=encoding) self.file=file self.mode=mode self.encoding=encoding def write(self): pass def __del__(self): print('del') self.x.close() # Open('a.txt','w') 需要开辟一个内存空间来存放值，产生一个对象，变量 f 与它进行绑定，此时 f 在引用，引用计数不为0 # 当引用计数为 0 的时候，就去对象里面找 析构函数 del f=Open('a.txt','w') # 当跑完程序，f 与Open 的绑定关系就解除，触发 del 的执行，回收值的内存 del f # 下面程序还没跑完，就执行 del，删除 f ，Open 没有被引用，引用计数为 0 ，回收 Open time.sleep(1000) # 注意，如果没有 del 方法，对象被删除后，不会被立即回收，python回收机制会定期去回收
6、__str__
class Pepole: def __init__(self,name,age): self.name=name self.age=age def __str__(self): # return 'abc' # __str__ 方法必须返回字符串 obj=Pepole('egon',18) print(obj) # 当打印对象的时候触发 __str__方法
7、__enter__和__exit__
所谓上下文管理协议,就是咱们打开文件时常用的一种方法:with
__enter__(self):当with开始运行的时候触发此方法的运行
__exit__(self, exc_type, exc_val, exc_tb):当with运行结束之后触发此方法的运行
exc_type如果抛出异常,这里获取异常的类型
exc_val如果抛出异常,这里显示异常内容
exc_tb如果抛出异常,这里显示所在位置
用途或者说好处：
1.使用with语句的目的就是把代码块放入with中执行，with结束后，自动完成清理工作，无须手动干预
2.在需要管理一些资源比如文件，网络连接和锁的编程环境中，可以在__exit__中定制自动释放资源的机制，你无须再去关系这个问题，这将大有用处
class Foo: def __enter__(self): print('=======================》enter') return 111111111111111 def __exit__(self, exc_type, exc_val, exc_tb): print('exit') print('exc_type',exc_type) print('exc_val',exc_val) print('exc_tb',exc_tb) return True # 如果不加这一行，表示抓到报错，整个程序退出，不再往下执行 # 如果__exit()返回值为True,那么异常会被清空，就好像啥都没发生一样，with后的语句正常执行 # with Foo(): #res=Foo().__enter__() # pass with Foo() as obj: #res=Foo().__enter__() #obj=res print('with foo的自代码块',obj) raise NameError('名字没有定义') # with语句中代码块出现异常，则with后的代码都无法执行 print('************************************') # 执行与否，看 exit 返回的是否 true print('1111111111111111111111111111111111111111')
class Open: def __init__(self,file,mode='r',encoding='utf8'): # 使用系统函数open()传入相应打开文件所需的参数,将文件句柄传递给self.f self.f=open(file,mode=mode,encoding=encoding) def __enter__(self): return self # 这里要返回 self 而不是 self.f，self.f 是调用真实的 open 文件操作的方法 # 这里 self 调用的是 Open 类里面的各个函数属性 def __exit__(self, exc_type, exc_val, exc_tb): self.f.close() print('关闭') def write(self,line): #自己定义write方法 print('ok') self.f.write(line) #使用self.f 文件句柄 write 方法将内容写入文件 # 利用__getattr__(),Attr系列中的getattr,当对象没有找到Open中传递过来的名字时,调用此方法 def __getattr__(self, item): return getattr(self,item) # 返回self.f 文件句柄中,被对象调用,且不在Open类中的名字 with Open('a.txt','w',encoding='utf8') as obj: # obj=Open('a.txt','w',encoding='utf8') obj.write('123') # 调用的是类里面的 write 方法，方法里面有 obj.f.write 调用真实的 write
8、__doc__
描述信息用的
class Foo: '我是描述信息' pass print(Foo.__doc__) class Foo: '我是描述信息' pass class Bar(Foo): pass print(Bar.__doc__) #该属性无法继承给子类 该属性无法被继承
9、__call__
对象后面加括号，触发执行。
注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()
class Foo: def __init__(self): pass def __call__(self, *args, **kwargs): print('__call__') obj = Foo() # 执行 __init__ obj() # 执行 __call__
.