类的魔术方法
class的内置方法
一、 __getattribute__
class Foo: def __init__(self,x): self.x=x def __getattr__(self, item): print('执行的是我') # return self.__dict__[item] f1=Foo(10) print(f1.x) f1.xxxxxx #不存在的属性访问,触发__getattr__
class Foo: def __init__(self,x): self.x=x def __getattribute__(self, item): print('不管是否存在,我都会执行') f1=Foo(10) f1.x f1.xxxxxx __getattribute__
class Foo: def __init__(self,x): self.x=x def __getattr__(self, item): print('执行的是我') # return self.__dict__[item] def __getattribute__(self, item): print('不管是否存在,我都会执行') raise AttributeError('哈哈') f1=Foo(10) f1.x f1.xxxxxx #当__getattribute__与__getattr__同时存在,只会执行__getattrbute__,除非__getattribute__在执行过程中抛出异常AttributeError 二者同时出现
二、__getitem__,__setitem__,__delitem__
同__getattr__,__setattr__,__delattr__;
只是在操作时以字典的方式操作
class foo: def __init__(self,name,age): self.name = name self.age = age def __getitem__(self, item): print("触发__getitem__") return self.__dict__[item] def __setitem__(self, key, value): print("触发__setitem__") self.__dict__[key] = value def __delitem__(self, key): print("触发__delitem__") self.__dict__.pop(key) f1 = foo("alex",18) f1["name"] #触发__getitem__ f1["name"] = "egen" #触发__setitem__ del f1["name"] #触发__delitem__ 代码演示
三、自定制__str__、__repr__
class foo: pass f1 = foo() print(f1) 打印的是f1在哪个对象中 <__main__.foo object at 0x000002415359D198> 默认情况下
class foo: def __str__(self): return "执行的__str__" f1 = foo() print(f1) print(str(f1)) print(f1.__str__()) 输出结果: 执行的__str__ 执行的__str__ 执行的__str__ 实际上print(f1)内部做的就是print(str(f1))=print(f1.__str__()) 注意__str__的返回值必须是字符串 定制__str__
__repr__同__str__
__repr__应用在解释器中显示
class foo: def __str__(self): return "执行的__str__" def __repr__(self): return "执行的__repr__" f1 = foo() print(f1) #执行的__str__ --------------------------------------------------------------------------- class foo: # def __str__(self): # return "执行的__str__" def __repr__(self): return "执行的__repr__" f1 = foo() print(f1) #执行的__repr__ #注意print(f1)默认做的是str(f1),只有在找不到的时候才会用__repr__代替 二者同时出现时
四、自定制格式化方法__fomat__
format_dic = { "ymd":"{0.year}{0.mon}{0.day}", "y:m:d":"{0.year}:{0.mon}:{0.day}", "m-d-y":"{0.mon}-{0.day}-{0.year}", } class Date: def __init__(self,year,mon,day): self.year = year self.mon = mon self.day = day def __format__(self, format_spec): # 判断没有指定格式或格式指定错误情况下按照默认格式执行 if not format_spec or format_spec not in format_dic: format_spec = "ymd" fm = format_dic[format_spec] return fm.format(self) f1 = Date(2018,12,14) print(format(f1))#无参数 print(format(f1,"m-d-y"))#有参数 print(format(f1,"m-y:d"))#错误参数 12-14-2018 定制显示时间格式
五、__slots__
''' 1.__slots__是什么:是一个类变量,变量值可以是列表,元祖,或者可迭代对象,也可以是一个字符串(意味着所有实例只有一个数据属性) 2.引子:使用点来访问属性本质就是在访问类或者对象的__dict__属性字典(类的字典是共享的,而每个实例的是独立的) 3.为何使用__slots__:字典会占用大量内存,如果你有一个属性很少的类,但是有很多实例,为了节省内存可以使用__slots__取代实例的__dict__ 当你定义__slots__后,__slots__就会为实例使用一种更加紧凑的内部表示。实例通过一个很小的固定大小的数组来构建,而不是为每个实例定义一个 字典,这跟元组或列表很类似。在__slots__中列出的属性名在内部被映射到这个数组的指定小标上。使用__slots__一个不好的地方就是我们不能再给 实例添加新的属性了,只能使用在__slots__中定义的那些属性名。 4.注意事项:__slots__的很多特性都依赖于普通的基于字典的实现。另外,定义了__slots__后的类不再 支持一些普通类特性了,比如多继承。大多数情况下,你应该 只在那些经常被使用到 的用作数据结构的类上定义__slots__比如在程序中需要创建某个类的几百万个实例对象 。 关于__slots__的一个常见误区是它可以作为一个封装工具来防止用户给实例增加新的属性。尽管使用__slots__可以达到这样的目的,但是这个并不是它的初衷。 更多的是用来作为一个内存优化工具。 ''' class Foo: __slots__='x' f1=Foo() f1.x=1 f1.y=2#报错 print(f1.__slots__) #f1不再有__dict__ class Bar: __slots__=['x','y'] n=Bar() n.x,n.y=1,2 n.z=3#报错 slots使用
class Foo: __slots__=['name','age'] f1=Foo() f1.name='alex' f1.age=18 print(f1.__slots__) f2=Foo() f2.name='egon' f2.age=19 print(f2.__slots__) print(Foo.__dict__) #f1与f2都没有属性字典__dict__了,统一归__slots__管,节省内存
六、__doc__
class Foo: '我是描述信息' pass print(Foo.__doc__)
class Foo: '我是描述信息' pass class Bar(Foo): pass print(Bar.__doc__) #该属性无法继承给子类
七、__module__和__class__
__module__ 表示当前操作的对象在那个模块
__class__ 表示当前操作的对象的类是什么
class C: def __init__(self): self.name = ‘SB'
from lib.aa import C obj = C() print obj.__module__ # 输出 lib.aa,即:输出模块 print obj.__class__ # 输出 lib.aa.C,即:输出类
八、__del__
析构方法,当对象在内存中被释放时,自动触发执行。
注:如果产生的对象仅仅只是python程序级别的(用户级),那么无需定义__del__,如果产生的对象的同时还会向操作系统发起系统调用,即一个对象有用户级与内核级两种资源,比如(打开一个文件,创建一个数据库链接),则必须在清除对象的同时回收系统资源,这就用到了__del__
class foo: def __init__(self,name): self.name = name def __del__(self): print("我是析构方法") f1 = foo("alex") del f1 print("------------") #输出结果 我是析构方法 ------------ 代码演示
典型的应用场景:
创建数据库类,用该类实例化出数据库链接对象,对象本身是存放于用户空间内存中,而链接则是由操作系统管理的,存放于内核空间内存中
当程序结束时,python只会回收自己的内存空间,即用户态内存,而操作系统的资源则没有被回收,这就需要我们定制__del__,在对象被删除前向操作系统发起关闭数据库链接的系统调用,回收资源
这与文件处理是一个道理:
f=open('a.txt') #做了两件事,在用户空间拿到一个f变量,在操作系统内核空间打开一个文件 del f #只回收用户空间的f,操作系统的文件还处于打开状态 #所以我们应该在del f之前保证f.close()执行,即便是没有del,程序执行完毕也会自动del清理资源,于是文件操作的正确用法应该是 f=open('a.txt') 读写... f.close() 很多情况下大家都容易忽略f.close,这就用到了with上下文管理
九、__cal__
对象后面加括号,触发执行。
注:构造方法的执行是由创建对象触发的,即:对象 = 类名() ;而对于 __call__ 方法的执行是由对象后加括号触发的,即:对象() 或者 类()()
class Foo: def __init__(self): pass def __call__(self, *args, **kwargs): print('__call__') obj = Foo() # 执行 __init__ obj() # 执行 __call__
十、__next__和__iter__实现迭代器协议
__author__ = 'Linhaifeng' class Foo: def __init__(self,x): self.x=x def __iter__(self): return self def __next__(self): n=self.x self.x+=1 return self.x f=Foo(3) for i in f: print(i) 简单示范
class Foo: def __init__(self,start,stop): self.num=start self.stop=stop def __iter__(self): return self def __next__(self): if self.num >= self.stop: raise StopIteration n=self.num self.num+=1 return n f=Foo(1,5) from collections import Iterable,Iterator print(isinstance(f,Iterator)) for i in Foo(1,5): print(i) 简单示例
class Foo: def __init__(self): self._a = 1 self._b = 1 def __iter__(self): return self def __next__(self): #a,b = b,a if self._b > 100: raise StopIteration("终止运行") self._a,self._b = self._b,self._a + self._b return self._a f1 = Foo() for i in f1: print(i) 斐波那契数列
十一、__get__,__set__,__delete__描述符
1 描述符是什么:描述符本质就是一个新式类,在这个新式类中,至少实现了__get__(),__set__(),__delete__()中的一个,这也被称为描述符协议
__get__():调用一个属性时,触发
__set__():为一个属性赋值时,触发
__delete__():采用del删除属性时,触发
class Foo: #在python3中Foo是新式类,它实现了三种方法,这个类就被称作一个描述符 def __get__(self, instance, owner): pass def __set__(self, instance, value): pass def __delete__(self, instance): pass 定义一个描述符
2 描述符是干什么的:描述符的作用是用来代理另外一个类的属性的(必须把描述符定义成这个类的类属性,不能定义到构造函数中)