类的内置方法
它与内置函数有紧密的联系，有的内置函数就是调用的内置方法。
在*父类obj中有：
两个双下方法
obj.__str__ str(obj)
obj.__repr__ repr(obj)
1、__str__ 与 __repr__
class Teacher:
def __init__(self, name, salary):
self.name = name
self.salary = salary def __str__(self):
return "Teacher's object :%s" % self.name def __repr__(self):
return str(self.__dict__) def func(self):
return 'wahaha' nezha = Teacher('哪吒', 250)
print(nezha) # 打印一个对象的时候，就是调用a.__str__
print(repr(nezha))
print('>>> %r' % nezha)
a.__str__ --> object
object 里有一个__str__，一旦被调用，就返回调用这个方法的对象的内存地址
l = [1,2,3,4,5] # 实例化 实例化了一个列表类的对象
print(l)
%s str() 直接打印 实际上都是走的__str__
%r repr() 实际上都是走的__repr__
repr 是str的备胎，但str不能做repr的备胎
print(obj)/'%s'%obj/str(obj)的时候，实际上是内部调用了obj.__str__方法，如果str方法有，那么他返回的必定是一个字符串
如果没有__str__方法，会先找本类中的__repr__方法，再没有再找父类中的__str__。
repr(),只会找__repr__,如果没有找父类的
内置的方法有很多，但是不一定全都在object中
class Classes:
def __init__(self, name):
self.name = name
self.student = [ ] def __len__(self):
return len(self.student) # obj中没有该方法，因为obj只存所有对象共有的！ def __str__(self):
return 'classes' py_s9 = Classes('九年级三班')
py_s9.student.append('董青')
py_s9.student.append('久美')
print(len(py_s9))
print(py_s9) # 1、__str__
print(str(12)) # 其实就是调用int类型的__str__方法 # 为了验证，可以来一个例子:
class StrDemo:
def __init__(self, name):
self.name = name # def __str__(self):
# print('调用我的str双下方法了！')
# return self.name
def __repr__(self):
print('调用我的repr双下方法了！')
return self.name s = StrDemo("string")
print(str(s)) # 2、__repr__
print(repr(''))
print(repr(1))
# 我们将StrDemo类中的__str__方法注释掉，看看发生什么？
print(repr(s)) # 当一个类没有重写__str__方法，但是重写了__repr__方法，当使用str（本类实例）的时候，就调用了__repr__
# 即__repr__是__str__的备胎，但是反过来就不行！
2、析构函数（__del__）
功能是在回收内存中的对象，并在回收前做一些收尾工作，如打开的文件没关闭，将其关闭等！
class A:
def __init__(self, f):
self.f = f def __del__(self):
print('it deling')
self.f.close() # 析构函数: 在删除一个对象之前进行一些收尾工作 a = A(open('2_反射进阶.py'))
del a # del 既执行了这个方法，又删除了变量 # del a NameError: name 'a' is not defined # 引用计数中用到该内置方法
3、item相关方法：__getitem__ __setitem__ __delitem__
class Person:
def __init__(self, name,age,ginder):
self.name = name
self.age = age
self.ginder = ginder def __getitem__(self, item):
if hasattr(self, item):
return self.__dict__[item] def __setitem__(self, key, value):
self.__dict__[key] = value def __delitem__(self, key):
print('it is calling me !')
self.__dict__.pop(key) tom = Person('tom', 22, 'male')
# 得到属性
print(tom['ginder']) # __getitem__可以用访问字典中的元素一样访问对象的属性！
# 设置属性
tom['kind'] = 'superman'
print(tom.kind, tom['kind'])
#del tom.kind # object 原生支持 __delattr__
del tom['kind'] # 通过自己实现的
print(tom.kind, tom['kind'])
4、__hash__ 对应 hash()内置函数
查看hash值，可以修改hash规则，是的本来有不同hash值的两个对象有一样的hash值
lass Hash:
def __init__(self, name):
self.name = name def __hash__(self):
return hash(self.name) ha_a = Hash('a_Hash')
hah = Hash('a_Hash')
print(hash(ha_a), hash(hah)) # 两个对象虽然名字一样，但是hash值不同：-9223371888545262739 148309513073
# 实现object中的__hash__方法，并只返回name的hash值，就相等了：-9184190014575666570 -9184190014575666570
5、__new__ 构造函数，在初始化函数前，将self构造出来。
典型使用：单例模式（23种设计模式第一个）
即：一个类在内存中，始终只有一个实例
__init__ 初始化方法
__new__ 构造方法 : 创建一个对象
class Singleton():
__instance = False
def __init__(self, name):
self.name = name def __new__(cls, *args, **kwargs):
'''实现单例'''
if cls.__instance:
return cls.__instance
else:
cls.__instance = object.__new__(cls)
return cls.__instance a = Singleton('a')
a.nm = '单例'
b = Singleton('b')
print(b.nm)
print(id(a), id(b)) # 没有实现__new__方法前的结果是：2681905465888 2681905467232 地址不同，说明是两个对象
# __实现__new__方法后，即使不写具体操作，直接pass，也返回相同的地址：1760945392 1760945392
# 实现单例的操作后，地址变为：2491487242000 2491487242000 还是相同，即为同一对象！
6、 __eq__方法
class Equal:
def __init__(self, name):
self.name = name def __eq__(self, other):
if self.name == other.name:
return True double_eq = Equal('双等于号')
eq = Equal('双等于号')
# 问：两个对象相等吗？
print(double_eq, eq, double_eq == eq)
# <__main__.Equal object at 0x0000027726CA3828> <__main__.Equal object at 0x0000027726CA3860> False
# 内存地址不一样，是两个对象，所以不等，双下eq方法，是继承自*的object类，原来就是比较内存地址的！
# 实现该方法的其他类，如str，int等，改为值等就是相等了！
# 如何让两个相同的名字的Equal对象，变为相等了？只有重写eq方法了
print(double_eq == eq)
7、__call__ 方法
class B:
def __init__(self, name):
self.name = name def __call__(self):
for k in self.__dict__:
print(k, self.__dict__[ k ]) B('sb')() # 最后一个()就是在调用该类中的双下call方法!