内置函数：类中存在一些名字带有__(双下滑线)开头的内置函数，这些函数会在某些时候被自动调用
1. isinstance & issubclass
isinstance：判断一个对象是否是某个类的实例
用法：isinstance(obj, cls) 检查 obj 对象是否是 cls 类 (不仅限于类中)
issubclass：判断一个类是否是另一个类的子类
用法：issubclass(sub, super) 检查 sub 类是否是 super 类的派生类
2. __str__
用法：调用 str 函数或者 print 函数时（输出结果为字符串）自动执行，返回值作为显示内容
使用场景：我们可以利用该函数来自定义对象的打印格式（不设置则默认解释器里面内置的）
class Person: def __init__(self, name, age): self.name = name self.age = age def __str__(self): return '我叫%s,我今年%s岁了' % (self.name, self.age) # 可以自定义输出格式 p = Person('zhao', 24) print(p) # 我叫zhao,我今年24岁了
3. __del__
当对象在内存中被释放时（手动删除对象、程序运行结束时），会自动触发执行
使用场景：当你的对象在使用过程中打开了不属于解释器的资源：例如文件、网络端口
class File: def __del__(self): print('已删除...') f = File() del f # 已删除...
4. __call__
在对象被调用时执行
用法：对象()
注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 call 方法的执行是由对象后加括号触发的，即：对象() 或者 类()的区别
class Person: def __init__(self,name,age): self.name = name self.age = age def __call__(self, *args, **kwargs): print('执行我了') print(*args) print(**kwargs) p = Person('zhao', 24) # 执行 __init__ p() # 执行我了 执行 __call__ p('hobby = read') # 执行我了 hobby = read 执行 __call__
5. __slots__
该属性是一个类属性，用于优化对象内存占用
优化的原理：将原本不固定的属性数量，变得固定了
这样的解释器就不会为这个对象创建名称空间，所以__dict__也没了
从而达到减少内存开销的效果
用法：
class Person: __slots__ = ['name'] p = Person() p.name = 'jake' print(p.__slots__) # ['name'] p.age = 18 # 报错，当类中出现了slots时将导致这个类的对象无法在添加新的属性
''' Traceback (most recent call last): File "D:/代码练习/7.29/clots.py", line 10, in <module> p.age = 18 AttributeError: 'Person' object has no attribute 'age '''' print(p.__dict__) # 报错，使用slots后就不存在__dict__ ''' AttributeError: 'Person' object has no attribute 'age '''' ^ SyntaxError: EOL while scanning string literal '''
6. __getattribute__ & __getattr__ & __setattr__ & __delattr__
__getattribute__：使用 点语法 调用 属性的时候触发，无论属性是否存在都会执行
__getattr__：使用 点语法 调用 属性且属性不存在的时候才会触发
__setattr__：使用 点语法 添加/修改 属性会触发它的执行
__delattr__：使用 点语法 删除 属性的时候会触发
注意：当 __getattribute__ 与 __getattr__ 同时存在时，仅执行 __getattribute__
class Person: def __init__(self,name): self.name = name def __getattr__(self, item): return self.__dict__[item] def __setattr__(self, key, value): self.__dict__[key] = value def __delattr__(self, item): del self.__dict__[item] p = Person('zhao') print(p.__dict__) # {'name': 'zhao'} 此时只有这么一个元素 p.age = 24 print(p.__dict__) # {'name': 'zhao', 'age': 24} 触发了__setattr__,成功添加进去 print(p.age) # 24 触发了__getattr__,成功访问到新添加进去的值 del p.age # 触发__delattr__，成功删除p.age属性 print(p.__dict__) # {'name': 'zhao'}
7. __getitem__ & __setitem__ & __delitem__
__getitem__：使用 key 的形式获取属性时触发
__setitem__：使用 key 的形式添加/修改属性时触发
__delitem__：使用 key 的形式删除属性时触发
class Person: def __init__(self,name,age): self.name = name self.age = age def __getitem__(self, item): return self.__dict__[item] def __setitem__(self, key, value): self.__dict__[key] = value def __delitem__(self, key): self.__dict__.pop(key) p = Person('zhao', 24) print(p.__dict__) # {'name': 'zhao', 'age': 24} p['name'] # 触发了__getitem__方法 print(p['name']) # zhao p['age'] = 18 # 触发了__setitem__方法 print(p['age']) # 18 del p['name'] # 触发__delitem__方法 print(p.__dict__) # {'age': 18}
8. __gt__ & __lt__ & __eq__ （运算符重载）
当我们在使用某个符号时，python解释器都会为这个符号定义一个含义，同时调用对应的处理函数
当我们需要自定义对象的比较规则时，就可在子类中覆盖大于、等于、小于等一系列方法....
class Person: def __init__(self,name,age): self.name = name self.age = age def __gt__(self, other): # 自定义比较的方法，在这里比较的是对象中的年龄，覆盖了原来的 other指的是另一个参与比较的对象 return self.age > other.age def __lt__(self, other): # 自定义比较的方法，在这里比较的是对象中的年龄，覆盖了原来的 other指的是另一个参与比较的对象 return self.age < other.age def __eq__(self, other): # 自定义比较的方法，在这里比较的是对象中的年龄，覆盖了原来的 other指的是另一个参与比较的对象 if self.age == other.age: return True return False p = Person('赵', 24) p1 = Person('张', 18) p2 = Person('王', 18) print(p > p1) # True print(p < p1) # False print(p1 == p2) # True
9. __iter__ & __next__ （迭代器协议）
回顾：迭代器是指具有__iter__和__next__的对象
因此：我们可以为对象增加这两个方法来让对象变成一个迭代器
''' 定义自己的range方法 ''' class MyRange: # 定义自己的range def __init__(self,start,end,step): self.start = start # 起始 self.end = end # 结束 self.step = step # 步长 def __iter__(self): return self # 迭代器对象调用__iter__方法后还是迭代器，生成器对象调用__iter__方法后生成迭代器对象 def __next__(self): a = self.start self.start += self.step if a < self.end: return a else: raise StopIteration # 不知道这是啥，也没讲，也不敢问 myrange = MyRange(1,6,2) for i in myrange: print(i) # 1 3 5
10. __enter__ & __exit__ （上下文管理）
上下文：context 在这个代码中python解释器分析出你的代码想要做的事情，然后在结束的时候自动帮你将资源释放了
with中的所有代码都在一个上下文中，你可以把他理解为一个代码范围---------仅在上下文范围内有效
__enter__：出现 with语句，对象的 __enter__ 被触发，有返回值则赋值给 as 声明的变量
__exit__： with 中代码块执行完毕时执行
只要一个类实现了这两个方法就可以被 with 语句使用
class MyOpen: # 定义自己的打开
def __init__(self, filepath, mode='r', encoding='utf-8'):
self.filepath = filepath
self.mode = mode
self.encoding = encoding
def __enter__(self):
self.f = open(self.filepath, mode=self.mode, encoding=self.encoding)
return self.f
def __exit__(self, exc_type, exc_val, exc_tb): # 三个参数分别代表异常类型，异常值和追溯信息
self.f.close()
print('文件关闭了')
# return True
with MyOpen('xxx.txt', 'a') as f:
print(f) # <_io.TextIOWrapper name='xxx.txt' mode='a' encoding='utf-8'> 这是啥.....
f.write('你好啊！') # 结果成功写入
f.wasdf #抛出异常，交给__exit__处理
# 反正最后自己定义的MyOpen成功了，与内置的open具有相同的效果
注：1. with 语句中代码块出现异常时，会立即触发方法 __exit__ 的执行，并将异常信息错误参数传入
2. with 语句中代码块未出现异常正常结束时也会触发方法 __exit__ 的执行，此时参数中的异常信息为空
3. 如果 __exit__ 返回值为 True ，那么异常会被清空，就好像啥都没发生一样，with后的语句正常执行
总结：
使用 with 语句的目的就是把代码块放入 with 中执行，with 结束后，自动完成清理工作，无须手动干预
在需要管理一些资源比如文件，网络连接和锁的编程环境中，可以在 __exit__ 中定制自动释放资源的机制，你无须再去关系这个问题，这将大有用处
*******与del的区别：del管理的是对象的生命周期 ，会在对象销毁时执行清理