__str__和__repr__：
实例化一个对象，该对象的返回值是一个指向这个类的内存地址
class A: pass a = A() print(a) #打印： <__main__.A object at 0x000001FA526DA108>
自定义__str__和__repr__方法：
class Func: pass def __str__(self): return '我是自定义的str' def __repr__(self): return '我是自定义的repr' a = Func() print(a) print(repr(a)) print(str(a)) #打印： 我是自定义的str 我是自定义的repr 我是自定义的str
结论：
什么时候执行__str__:遇到print(obj),'%s'%obj,str(obj)的时候
什么时候执行__repr__:遇到repr(obj),'%r'%obj的时候
执行__str__时，首先找类中是否有自定义的__str__方法，若没有，则找自定义的__repr__方法，若类中没有这两个自定义方法，则向父类查找，不管在哪里找，执行__str__时，先找__str__方法，再找__repr__方法
执行__repr__时，若类中没有自定义的__repr__方法，则向父类查找，不会找__str__的自定义方法或者父类的__str__
所以，一个类中需要自定义__str__和__repr__时，首先考虑的应该是__repr__，因为他可以被str使用
使用场景：实例化一个对象，对象的返回值默认是指向这个类的一个内存地址，当打印这个对象时，遇到print会执行这个类的内置函数__str__，若在类中自定义__str__这个方法，则可以设置成其他更直观的返回值，返回值必须为字符串类型
class Teacher: def __init__(self,name,course): self.name = name self.course = course def __repr__(self): return '我是老师%s，教%s的'%(self.name,self.course) aike = Teacher('aike','python') print(aike) print(str(aike)) print(repr(aike)) #打印： 我是老师aike，教python的 我是老师aike，教python的 我是老师aike，教python的
__len__:在外部调用len方法，传入实例化的对象，实际上执行的是这个类的__len__方法，当类里自定义过__len__方法，外部用对象使用len时，会先找自定义的__len__方法，而这个自定义的__len__方法需要实现什么功能，可以自己自定义，返回值必须为int的数据类型
class A: pass def __len__(self): print('执行了我') return 2 a = A() print(len(a)) #打印： 执行了我 2
例：：
class Grade: def __init__(self,teacher): self.teacher = teacher self.student = [] three_grade = Grade('aike') three_grade.student.append('chen') three_grade.student.append('chen') three_grade.student.append('chen') print(len(three_grade.student))#没有自定义的len方法，向父类找 #打印： 3 class Grade: def __init__(self,teacher): self.teacher = teacher self.student = [] def __len__(self): return len(self.student) three_grade = Grade('aike') three_grade.student.append('chen') three_grade.student.append('chen') three_grade.student.append('chen') print(len(three_grade))#调用的是自定义的len方法 #打印： 3
__del__:称为构析函数，主要作用是在删除一个对象之前进行一些收尾工作；同理，类中有自定义的del方法时，优先执行自定义的，没有则向父类找，需要注意的是，尽管自定义的del方法没有实现删除操作，但执行完后依然会执行父类的del方法进行删除操作
class A: pass a = A() del a print(a)#报错，a已经删除
class A: pass def __del__(self): print('删除之前执行了我，执行之后依然进行删除操作') a = A() del a print(a)#报错，a已经删除，但类中自定义的del方法会执行
__call__:在实例化一个类时，在后边加上（），执行的就是call方法，它没有返回值，所以没有真正实例化一个对象出来，所以call方法中的操作不会影响到其它对象
class Person: def __init__(self,name,money): self.name = name self.__money = money def __call__(self, money): self.__money += money print(self.__money) @property def money(self): return self.__money aike = Person('aike',1000)(100) print(aike)#执行call无返回值 # print(aike.money)#报错，没有aike这个对象 aike1 = Person('aike',1000) print(aike1.money) #打印： 1100 None 1000
__getitem__，__setitem__，__delitem__：
打印一个实例化的对象时默认是打印这个对象的内存地址（可以用双下__str__或者__repr__方法更直观的打印这个对象，而不是打印内存地址,但只能以字符串的数据类型打印，因为返回值只能是字符串的数据类型）
而一个对象是以字典的形式存在内存当中，所以可以以字典的形式对他进行增删改查，以字典的形式操作便需要实现__getitem__，__setitem__，__delitem__方法
import json class Teacher: def __init__(self,name,sex): self.name = name self.sex = sex self.studet = [] def __repr__(self): return json.dumps(self.__dict__) #序列化，以字符串的数据类型返回对象的属性 def __getitem__(self, item): #通过key查找 return self.__dict__[item] def __setitem__(self, key, value): #修改或者添加 self.__dict__[key] = value #没有该对象则添加，有则修改值 #self.__dict__.setdefault(key,value) #setdefault 没有该对象则添加，有则不修改 def __delitem__(self, key): #与__del__方法不一样，__del__没有实现删除方法，依然会找父类进行删除操作，而__delitem__没有实现删除操作，不会进行删除，证明父类object没有__getitem__，__setitem__，__delitem__方法 print('执行我了') # del self.__dict__[key] self.__dict__.pop(key) aike = Teacher('aike','man') aike['age'] = 18 #添加，受到__setitem__的具体实现影响 print(aike['age']) print(aike.age) #成功添加属性 aike['name'] = '艾克' #添加，受到__setitem__的具体实现影响 print(aike.name) print(aike['name']) print(aike['sex']) del aike['name'] # print(aike['name'])#报错，已经被删除 print(aike) #以字典形式的操作会影响对象的属性 #打印： 18 18 艾克 艾克 man 执行我了 {"sex": "man", "studet": [], "age": 18}
结论：以字典的形式操作对象需要实现__getitem__，__setitem__，__delitem__方法，增删改查的操作的具体实现可以自定义，比如在修改时可以使用字典的setdefault方法实现没有该对象则添加，有则不修改的操作
而在进行删除操作时，__delitem__方法与__del__方法不一样，__del__没有实现删除方法，依然会找父类进行删除操作，而__delitem__没有实现删除操作，不会进行删除，证明父类object没有__getitem__，__setitem__，__delitem__方法
__new__:实例化一个对象时，类会执行内置__new__方法创建一个对象self，再执行__init__方法添加属性
class Teacher: def __init__(self,name,sex): self.name = name self.sex = sex def __new__(cls, *args, **kwargs): print('先执行的我') return object.__new__(cls) aike = Teacher('aike','man') print(aike.__dict__) #打印: 先执行的我 {'name': 'aike', 'sex': 'man'}
利用__new__方法实现单例模式：
每实例化一个对象都会new一次，每个对象都会新建一个新的内存地址，那么可以自定义new方法实现单例模式，即每创建一个对象都继用实例化的第一个对象的内存地址，不管对哪个对象进行操作，都是操作同一个对象
class Teacher: __new_teacher = False #私有化一个属性 def __init__(self,name,sex): self.name = name self.sex = sex def __new__(cls, *args, **kwargs):#实现了不管如何创建对象，都是返回这个私有属性，这个私有属性一直是第一次实例化的对象 if cls.__new_teacher: #如果私有化属性不为空 return cls.__new_teacher #返回这个属性（对象） else: cls.__new_teacher = object.__new__(cls) #否则就创建一个对象赋值给私有化的属性 return cls.__new_teacher #返回这个属性（对象） aike = Teacher('aike','man') aike1= Teacher('aike','man') print(aike)#内存地址一样 print(aike1)#内存地址一样 aike.name = '艾克' print(aike.name)#艾克 print(aike1.name)#艾克 #打印： <__main__.Teacher object at 0x000001C184484D48> <__main__.Teacher object at 0x000001C184484D48> 艾克 艾克
__eq__:对象碰到==，执行的是__eq__
默认情况下：
class A: def __init__(self,name,sex): self.name = name self.sex = sex a = A('aike','男') b = A('aike','男') print(a == b)#默认比较的是内存地址 #打印： Flase
可以自定义实现：
class A: def __init__(self,name,sex): self.name = name self.sex = sex def __eq__(self, other): # if self.sex == other.sex and self.name == other.name: if self.__dict__ == other.__dict__: return True else: return False a = A('aike','男') b = A('aike','男') print(a == b)#默认比较的是内存地址 #打印： True
__hash__:对一个不可变数据类型hash时，执行的是类的内置方法__hash__，该方法同样可以自定义要求实现
正常情况下hash的是对象的内存地址:
class Teacher: def __init__(self,name,sex): self.name = name self.sex = sex aike = Teacher('aike','man') aike1= Teacher('aike','man') print(hash(aike)) print(hash(aike1)) #打印： -9223371930212113252 -9223371930212113244
自定义实现：
class Teacher: def __init__(self,name,sex): self.name = name self.sex = sex def __hash__(self): return hash(self.name+self.sex) #实现在外部hash返回字符串的hash值 aike = Teacher('aike','man') #属性相同 aike1= Teacher('aike','man')#属性相同 print(hash(aike)) print(hash(aike1)) #打印： -2452999456034038120 #哈希值相同 -2452999456034038120 #哈希值相同