Python之路(第二十六篇) 面向对象进阶:内置方法
object.__getattribute__(self, name)
无条件被调用,通过实例访问属性。如果class中定义了__getattr__()
,则__getattr__()
不会被调用(除非显示调用或引发AttributeError异常)
class Foo: def __init__(self,x): self.x = x def __getattr__(self, item): print("执行__getattr__") def __getattribute__(self, item): print("执行__getattribute__") # raise AttributeError("不存在的异常") f = Foo("nick") print(f.x) print(f.xxxx)#这里本来调用后应该在__getattribute__中产生AttributeError,然后调用__getattr__,但在#这里__getattribute__被重写了,没有产生AttributeError,所以就没调用__getattr__
输出结果
执行__getattribute__ None 执行__getattribute__ None
object.__getattr__(self, name)
当一般位置找不到attribute的时候,会调用getattr,返回一个值或AttributeError异常。
class Foo: def __init__(self,x): self.x = x def __getattr__(self, item): print("执行__getattr__") # def __getattribute__(self, item): # print("执行__getattribute__") # raise AttributeError("不存在的异常") f = Foo("nick") print(f.x) print(f.xxxx) #这里是执行了新定义的__getattr__方法,并没有直接报错
输出结果
nick 执行__getattr__ None
每次通过实例访问属性,都会经过__getattribute__
函数。
而当属性不存在时,仍然需要访问__getattribute__
,不过接着要访问__getattr__
。这就好像是一个异常处理函数。 需要注意的是,当使用类访问不存在的变量是,不会经过__getattr__
函数。
当属性存在时,经过__getattribute__
函数,返回属性的值。
二、__setitem__,__getitem,__delitem__
在类中,对象以object["key"]形式访问属性或方法时调用item系列内置方法,对象以object.属性(以点的形式)调用属性或方法时调用attr系列内置方法。
class Foo: def __init__(self,name): self.name = name 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) f = Foo("nick") print(f["name"]) #获取属性, 执行__getitem__方法 f["age"] = 18 #设置属性,执行__setitem__方法 print(f.__dict__) del f["name"] #删除属性,执行__delitem__方法 print(f.__dict__)
输出结果
执行__getitem__ nick 执行__setitem__ {'name': 'nick', 'age': 18} 执行__delitem__ {'age': 18}
三、__str__,__repr__
,__format__
__str__
是控制改变对象的字符串显示
在print(obj)/'%s'%obj/str(obj)
时,实际上是内部调用了obj.__str__
方法,如果str方法有,那么他返回的必定是一个字符串,如果没有__str__
方法,会先找本类中的__repr__
方法,再没有再找父类(object)中的__str__
。
例子1
class Foo: def __str__(self): return "控制打印对象时的显示形式" f = Foo() print(f) #输出结果: 控制打印对象时的显示形式
分析:这里打印对象直接调用了被重新定义的__str__
方法
例子2
class Foo: def __str__(self): return "控制打印对象时的显示形式" f = Foo() a = str(f) print(a) #输出结果: 控制打印对象时的显示形式
分析:这里的str(object)也是调用了__str__
方法
例子3
class Foo: def __str__(self): return "控制打印对象时的显示形式" f = Foo() print("%s"%f) #输出结果: 控制打印对象时的显示形式
分析:这里的“%s”%f也是调用了__str__
方法
__repr__
也是显示对象的名字方式,用repr(object)或者“%r”%object会调用__repr__
方法
repr 是str的备胎,但str不能做repr的备胎
例子4
class Foo: def __str__(self): return "控制打印对象时的显示形式" def __repr__(self): print("在执行repr") return "repr Foo" pass f = Foo() print("%r"%f) print(f)
输出结果
在执行repr repr Foo 控制打印对象时的显示形式
分析:这里print("%r"%f) 调用重新定义的__repr__
方法,print(f)调用__str__
方法
例子5
class Foo: def __str__(self): return "控制打印对象时的显示形式" def __repr__(self): print("在执行repr") return "repr Foo" pass f = Foo() print(repr(f))
输出结果
在执行repr repr Foo
例子6
class Foo: # def __str__(self): # return "控制打印对象时的显示形式" def __repr__(self): print("在执行repr") return "repr Foo" pass f = Foo() print(f)
输出结果
在执行repr repr Foo
分析:如果要调用__str__
方法,首先在本类中查找有没有__str__
方法,如果没有就找本类有没有__repr__
方法,如果有就执行__repr__
方法,不再借用父类的__str__
方法。所以repr 是str的备胎,但str不能做repr的备胎。
例子7
class Foo: def __str__(self): return "控制打印对象时的显示形式" # def __repr__(self): # print("在执行repr") # return "repr Foo" pass f = Foo() print(repr(f)) #输出结果 <__main__.Foo object at 0x002EB550>
分析:要调用__repr__
方法,本类没有,直接借用父类的__repr__
方法,而不执行__str__
方法。所以repr 是str的备胎,但str不能做repr的备胎。
__format__
自定制格式化字符串__format__
,
format_dic = { "ymd":"{0.year}{0.month}{0.day}", "dmy":"{0.day}:{0.month}:{0.year}", "mdy":"{0.month}-{0.day}-{0.year}" } class Foo: def __init__(self,year,month,day): self.year = year self.month = month self.day = day def __format__(self, format_spec): if not format_spec or format_spec not in format_dic: format_spec = "ymd" fmt = format_dic[format_spec] return fmt.format(self) f = Foo(2018,8,20) print(format(f)) print(format(f,"dmy")) print(format(f,"mdy")) print("{:mdy}".format(f))
输出结果
2018820 20:8:2018 8-20-2018 8-20-2018
分析:调用format方法自定制字符串格式化,这里调用__format__
方法
四、__slots__
__slots__
:其实就是将类中的名称锁定,实例化对象,只可以赋值和调用,不可以删除属性和增加新的属性
1、__slots__
是什么:是一个类变量,变量值可以是列表,元祖,或者可迭代对象,也可以是一个字符串(也就是意味着所有实例只有一个数据属性)
2、使用点来访问属性本质就是在访问类或者对象的__dict__
属性字典(类的字典是共享的,而每个实例的是独立的)
3、字典会占用大量内存,如果你有一个属性很少的类,但是有很多实例,为了节省内存可以使用__slots__
取代实例的__dict__
当你定义__slots__
后,__slots__
就会为实例使用一种更加紧凑的内部表示。实例通过一个很小的固定大小的数组来构建,而不是为每个实例定义一个字典,这跟元组或列表很类似。在__slots__
中列出的属性名在内部被映射到这个数组的指定小标上。使用__slots__
一个不好的地方就是我们不能再给实例添加新的属性了,只能使用在__slots__
中定义的那些属性名。
4、应用场景:当实例化几万个对象的时候,每个对象都会生成一个名称空间__dict__
,而每一个名称空间都会各自占用一个内存,造成内存的浪费,用 __slots__
,不用再产生每个对象的 dict 了,省内存,对象的 dict 都统一用类的 dict,属性都是用 slots 给定义的
class Foo: __slots__ = ["name","age"] #在类中定义属性"name"、"age" f1 = Foo() f1.name = "nick" #首先要进行赋值,不赋值调用会出错 print(f1.name) # f1.gender = "female" # 新增__slots__之外的属性会报错 # del f1.age #删除属性也会报错
五、__doc__
__doc__
显示文档注释信息,文档注释信息无法继承给子类。
例子
class Foo: """ 我是文档注释 """ pass f = Foo() print(f.__doc__) #输出结果 : 我是文档注释
例子2
class Foo: """ 我是文档注释 """ pass class Son(Foo): pass s = Son() print(s.__doc__) #输出结果:None
六、__module__
和__class__
__module__
表示当前操作的对象在那个模块
__class__
表示当前操作的对象的类是什么
例子1
class Foo: def __init__(self,name): self.name = name f = Foo("nick") print(f.__module__) #当执行文件为当前文件时,__module__ = __main__ #输出结果:__main__ print(f.__class__) #输出当前操作的类名是什么 #输出结果:<class '__main__.Foo'>
例子2
文件结构
├── index.py #执行文件
│ ├── test
│ │ ├── a.py
a.py内容:
class Bar: def __init__(self): self.name = "nicholas"
index.py内容:
from test.a import Bar class Foo: def __init__(self,name): self.name = name b = Bar() print(b.name) #输出结果 nicholas print(b.__module__) #输出结果 test.a ,表示当前操作的类在test.a下 print(b.__class__) #表示当前操作的类名是<class 'test.a.Bar'>
七、 __del__
析构方法
析构方法,当对象在内存中被释放时,自动触发执行。即清除释放内存的方法。
这个是在回收实例化对象时触发执行的方法,删除对象的属性不会触发__del__
方法
注:此方法一般无须定义,因为Python是一门高级语言,程序员在使用时无需关心内存的分配和释放,因为此工作都是交给Python解释器来执行,所以,析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。
例子1
class Foo: def __init__(self,name): self.name = name def __del__(self): print("我执行啦!") f = Foo("nick") print("-----1") del f.name print("-----2") #这里是先执行print("-----1")然后执行print("-----2") , # 执行del f.name只是删除对象字典的"name"属性,并不会触发__del__方法
输出结果
-----1 -----2 我执行啦!
例子2
class Foo: def __init__(self,name): self.name = name def __del__(self): print("我执行啦!") f = Foo("nick") print("-----1") del f #删除对象才能调用__del__,这里既执行了__del__方法,又删除了对象 print("-----2")
输出结果
-----1 我执行啦! -----2
例子3
class Foo: def __init__(self,name): self.name = name def __del__(self): print("我执行啦!") f = Foo("nick") import time time.sleep(2)
输出结果
我执行啦!
分析:这里在程序结束时,python解释器自动回收内存,执行了__del__
方法
典型的应用场景:
创建数据库类,用该类实例化出数据库链接对象,对象本身是存放于用户空间内存中,而链接则是由操作系统管理的,存放于内核空间内存中
当程序结束时,python只会回收自己的内存空间,即用户态内存,而操作系统的资源则没有被回收,这就需要我们定制__del__
,在对象被删除前向操作系统发起关闭数据库链接的系统调用,回收资源。
例子
class Foo: def __del__(self): print("我执行了") f = Foo() f.file = open("test.txt") #打开文件,在操作系统中打开了一个文件, # 拿到了文件操作符存在了内存中 del f.file #删除了内存中的文件操作符,但是并未关闭操作系统中的文件, # 这时需要在__del__中加入定制f.file.close(),关闭操作系统的文件 print("-----1") #最后程序结束python解释器自动执行内存回收,执行了__del__方法
输出结果
-----1 我执行了
posted on 2018-08-08 00:29 Nicholas-- 阅读(331) 评论(0) 编辑 收藏 举报