__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 #哈希值相同
来源：https://www.cnblogs.com/aizhinong/p/11483283.html