_ getattribute_()
是__getattr__()的升级版,当两个方法都存在的时候,会先调用__getattribute__()方法
不论实例的属性字典中是否存在该属性,都会执行__getattribute__()
class Foo:
def __init__(self, y):
self.y = y
def __getattr__(self, item):
print("执行的是getattr")
def __getattribute__(self, item):
print("执行的是getattribute")
f1 = Foo(10)
f1.y
f1.xxx
当__getattribute__()方法中存在升起异常时,就会调用__getattr__(),AttributeError相当于两个方法之间的口令
class Foo:
def __init__(self, y):
self.y = y
def __getattr__(self, item):
print("执行的是getattr")
def __getattribute__(self, item):
print("执行的是getattribute")
raise AttributeError("抛出异常")
f1 = Foo(10)
f1.y
f1.xxx
_getattribute__方法在python中的实现是先判断属性是否存在,存在则返回,不存在则抛出异常进入__getattr _()
class Foo(object):
def __init__(self, y):
self.y = y
def __getattr__(self, item):
print("执行的是getattr")
def __getattribute__(self, item):
if object.__getattribute__(self, item):
return object.__getattribute__(self, item)
else:
raise AttributeError
f1 = Foo(10)
print(f1.y)
f1.xxx
_ iter_()、_ next_()实现迭代器协议
_ iter_()、_ next_()是类的两个内置函数,可以通过定义他们两个实现迭代器协议,产生的实例就可以变成一个迭代器
未定义__iter__()方法会导致无法执行iter()函数
class Foo:
def __init__(self, n):
self.n = n
f1 = Foo(10)
for i in f1:
print(i)
#for函数的本质是调用iter(f1)或者f1.__iter__()方法,将f1变为一个迭代器,但是此处的类未定义__iter__()方法,所以会报
#'Foo' object is not iterable的错
_ iter_()方法的返回值需要实现可迭代
class Foo:
def __init__(self, n):
self.n = n
def __iter__(self):
pass
f1 = Foo(10)
for i in f1:
print(i)
#此处的类的__iter__()方法没有定义返回值,所以会报iter() returned non-iterator of type 'NoneType'的错
两个方法实现迭代器协议
class Foo:
def __init__(self, n):
self.n = n
def __iter__(self):
return self
def __next__(self):
self.n += 1
return self.n
f1 = Foo(10)
print(f1.__next__())
for i in f1:
print(i)
#每一次的f1.__next__()的结果传给i,f1调用f1.__iter__()变为一个可迭代对象
但是现在没有定义for循环的终止
通过升起StopIteration的异常来终止循环
class Foo:
def __init__(self, n):
self.n = n
def __iter__(self):
return self
def __next__(self):
if self.n < 13:
self.n += 1
return self.n
else:
raise StopIteration
f1 = Foo(10)
for i in f1:
print(i)
#for函数会帮忙捕捉异常并终止循环不会报错。如果采用f1.__next__()方法获得下一个值则在最后一个值位置会报错
一个例子:
通过迭代器协议实现的斐波那切数列
class Fib:
def __init__(self, start1, start2):
self.start1 = start1
self.start2 = start2
def __iter__(self):
return self
def __next__(self):
self.start1, self.start2 = self.start2, self.start1 + self.start2
return self.start2
f1 = Fib(1, 2)
print(f1.__next__())
print(f1.__next__())
print(f1.__next__())
print(f1.__next__())
print(f1.__next__())
_ setitem_()、_ getitem_()、_ delitem_()
item类方法可以实现像操作字典一样操作实例的属性
class Foo:
def __init__(self, name):
self.name = name
def __setitem__(self, key, value):
print("执行setitem")
self.__dict__[key] = value
def __delitem__(self, key):
print("执行delitem")
self.__dict__.pop(key)
def __getitem__(self, item):
print("执行getitem")
if self.__dict__[item]:
return self.__dict__[item]
else:
print("属性不存在")
f1 = Foo("Cjj")
print(f1["name"])
f1["name"] = "MB"
print(f1["name"])
del f1["name"]
_ slots_
_ _slots__是一个类变量,变量值可以是列表 、元组或者可迭代对象,也可以是一个字符串
_ slots__的使用原因: 每创建一个实例就会创建一个独立的属性字典,而字典会占用大量内存,如果有一个属性很少的类但是这个类产生了很多事例,为了节省内存,可以使用__slots__变量来取代__dict_
__slots__的原理:当定义__slots__后,__slots__就会为实力使用一种更加紧凑的内部表示,实例通过一个很小的固定大小的数组来构建,而不是为每个实例定义一个字典
class Foo:
__slots__ = ["name", "age"]
f1 = Foo() # f1已经没有f1.__dict__,打印__dict__会报错
f1.name = "MB"
f1.age = 18
print(f1.name)
print(f1.age)
print(f1.__slots__) # 相当于调用类的__slots__(print(Foo.__slots__))
这种方法限制了实例创建新的属性,只能定义已经写入__slots__的属性
定义__slots__的副作用较大,会影响所有操作__dict__的方法
_ str_()、_ repr_()
通过两个函数可以改变实例的字符串显示
class Foo:
def __init__(self, name):
self.name = name
def __str__(self):
return "自定义的str"
f1 = Foo("Cjj")
print(f1)
repr是用在解释器当中的改变实例字符串显示的方法
>>> class Foo:
... def __repr__(self):
... return "爱你"
...
>>> f1 = Foo()
>>> print(f1)
当两个方法在python中共存时调用__str__()方法
class Foo:
def __init__(self, name):
self.name = name
def __str__(self):
return "自定义的str"
def __repr__(self):
return "自定义的repr"
f1 = Foo("Cjj")
print(f1)
当__str__()方法不存在时,调用__repr__()方法
class Foo:
def __init__(self, name):
self.name = name
def __repr__(self):
return "自定义的repr"
f1 = Foo("Cjj")
print(f1)
注意:_ str_()、_ repr_()的return值必须都是字符串
_ format_()
自定义format方法
class Foo:
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"
return format_dic[format_spec].format(self)
f1 = Foo(2018, 11, 12)
print(f1.__format__("y-m-d"))
print(format(f1, "ymd"))#本质是调用__fomat__()方法
_ doc_
调用类的文本
文本的东西无法继承给子类
class Foo:
"Foo的描述信息"
pass
class Bar(Foo):
pass
f1 = Foo()
b1 = Bar()
print(f1.__doc__)
print(b1.__doc__)
_ mocule_、_ class_
_ module_ 表示当前操作的对象在哪个模块
_ class_ 表示当前操作的对象的类是什么
#module文件夹下module.py中
class C:
def __init__(self):
self.name = "SB"
#和module文件夹同级的文件中
from module.module import C
c1 = C()
print(c1.name)
print(c1.__module__)
print(c1.__class__)
_ del_()
析构方法,当对象在内存中被释放的时候自动触发执行
class Foo:
def __init__(self, name):
self.name = name
def __del__(self):
print("我执行啦")
f1 = Foo("MB")
del f1
注意如果不以删除对象的方式释放内存,在程序执行完毕后也会自动释放对象的内存
_ call_()
对象后面加括号触发执行的方法
class Foo:
def __init__(self, name):
self.name = name
def __call__(self, *args, **kwargs):
print("call执行啦")
f1 = Foo("MB")
f1()
Foo("MB")()
注意,在类实例化的时候,类名()的方式其实也是调用产生该类的那个类的__call__()方法