Python 常用魔法方法(下)
Python 常用魔法方法(下)
回顾
魔法方法是 Python 内置方法, 不需要我们手动调用, 它存在的目的是给 解释器 调用的. 比如我们在写 "1 + 1 " 的时候, 这个 "+ " 就会自动调用内置的魔法方法 "__ add__" . 几乎每个魔法方法, 都有一个对应的内置函数或运算符. 当我们使用这些方法去操作数据时, 解释器会自动调用这些对应的魔法方法. 也可以理解为, 重写内置函数, 如果改变的话.
具体的魔法方法等. 可以去看 内置的 builtins.py 这个接口文档.
内置函数对应魔法方法: 如 next() 对应 __ next __ , 类名() 对应 __ call __ 等这样的映射关系 ....
这一块的上篇呢, 还主要分享 type 类和 object 类来阐明 "万物皆对象". object 类是所有类的 基类. 而 type 类则用来判断某个实例对象所属的 "父类" 是谁, 类似父类,不绝对准确, 用来理解. 比如, 123 是 "int" class; "123" 是 "str" class; "str" 的 type 就是 type; object 的类型也是 type, 但 object 是 type 类的基类.
上篇引出 type 类, 当时用了一些哲学概念上的, "一, 二, 三" 来比喻, 仔细一想, 表述不太对, "元类" 的概念没说
元类 (metaclass): 如果是 type类是用来 静态创建类, 则 metaclass 是用来创建类的行为.
这一块先不谈了, 不太敢妄言, 待之后仔细查完资料在总结吧.
本篇还是继续介绍常用的魔法方法. 上篇主要对 __ new __, __ __ init __, __ __ call __ , __ str __, __ __ del __ 初步认识, 并应用场景简单举了例子. go on...
补: 关于 __ new __:
- 通常与 __ init __, 被称为 "构造函数". _____ del __ 被称为 "析构函数".
- 我目前用的的例子, 就只用 "单例" 用到.
- new 方法还涉及到 metaclass 的知识, 平时也不太用得到, 姑且先不涉及了.
- 用于继承一个不可边类型对象类 (tuple, int, str...) 的构造器, 当一个实例被创建时的初始化方法.
魔法方法总结
常用
__ new__ (cls, ....) 实例化所调用, 返回一个实例对象,(若无, 则不会调 __ init __ 在单例场景中时有用过.
__ init __ (self,...) 类实例化时, 的初始化值设置.
__ del __ (self) 也称为析构器. 当一个实例被 del 的时候会被触发.
__ call __(self, ...) 将类实例对象, "装饰" 为像函数一行可调用, 即 obj(*args.), 在 装饰器 有用到.
__ str __ (self) 描述对象信息, 在 print(obj) 时被触发.
__ len __ (self) 在使用 len() 时被调用.
__ repr __ (self) 在使用 repr() 时被调用.
repr(), 返回一个对象的 string 格式, 就是在外面套一个 "", 跟 eval() 函数像是其逆.
# repr(obj) -> str
# eval(str) -> obj
>>> repr(123)
'123'
>>> repr([1,2,"cj", [1,[2]]])
"[1, 2, 'cj', [1, [2]]]"
t = repr({'a':123, 'b':{"c":4}})
>>> t
"{'a': 123, 'b': {'c': 4}}"
>>> eval(t)
{'a': 123, 'b': {'c': 4}}
__ bytes __ (self) 在使用 bytes() 时被调用.
__ hash __ (self) 在使用 hash() 时被调用. 返回可哈希对象的数值, 传不可哈希(如list) 则报错
__ bool __ (self) 在 bool() 时被调用.
__ format __ (self,...) 在使用 format() 被调用. 不过我更多使用 f"{变量名} hello" 这样的语法多一点.
....
属性的
__ getattr __(self, item) 试图获取一个不存在属性的行为. 曾用来, 用来做异常判断.
__ getattribute __(self, item) 该类属性被访问时的行为. 跟 getattr 其实不太好搭配.
__ setattr __(self, key, value) 当一个属性被设置时的行为, obj.name = "youge"
__ delattr __(self, item) 属性被删除时的行为.
__ dir __(self) 定义当 dir() 被调用时的行为
__ get__ (self, instance, owner) 定义当描述符的值被取得时的行为
__ set__ (self, instance, value) 定义当描述符的值被改变时的行为
__ delete __(self, instance) 定义当描述符的值被删除时的行为
...
比较的
__ lt__ (self, other) 小于号的行为：x < y 调用 x.__ lt __(y)
__ le__ (self, other) 小于等于号的行为：x <= y 调用 x.__ le__(y)
__ eq__ (self, other) 等于号的行为：x == y 调用 x.__ eq__(y)
__ ne__ (self, other) 不等号的行为：x != y 调用 x.__ ne__(y)
__ gt __ (self, other) 大于号的行为：x > y 调用 x.__ gt__(y)
__ ge __ (self, other) 大于等于号的行为：x >= y 调用 x.__ ge__(y)
...
算数的
__ add__(self, other) 定义加法的行为：+
__ sub__(self, other) 定义减法的行为：-
__ mul__(self, other) 定义乘法的行为：*
__ truediv__(self, other) 定义真除法的行为：/
__ floordiv__(self, other) 定义整数除法的行为：//
__ mod__(self, other) 定义取模算法的行为：%
__ divmod__(self, other) 定义当被 divmod() 调用时的行为
__ pow__(self, other[, modulo]) 定义当被 power() 调用或 ** 运算时的行为
... 还有什么 位运算, 逆运算, 增量赋值 .. 各种计算符号, 都是一个个的魔法方法, 即都是可以改写的.
这些有啥用呢, 举个算数的, 通过重写, 可以自定义 运算符, 比如 1 +1 = 3 是可以的
# 重写 "+" 这个运算符, 即重写 __add__ 这个方法
class Num:
def __init__(self, value):
self.value = value
def __add__(self, other):
print(self.value + other + 1)
if __name__ == '__main__':
one = Num(1)
one + 1
# output
3
类型转换
__ complex__(self) 定义当被 complex() 调用时的行为（需要返回恰当的值）
__ int__(self) 定义当被 int() 调用时的行为
__ float__(self) 定义当被 float() 调用时的行为
__ round__(self[, n]) 定义当被 round() 调用时的行为
__ index__(self)
这一块了解就行, 建议不要乱改, 是关联的, 比如 index 被重写, 那 int 也有重写, 而且返回值也是要相同的.
上下文管理
__ enter__ (self)
定义当使用 with 语句时的初始化行为
__ enter__ 的返回值被 with 语句的目标或者 as 后的名字绑定
__ exit__ (self, exc_type, exc_value, traceback)
定义当一个代码块被执行或者终止后上下文管理器应该做什么
一般被用来处理异常，清除工作或者做一些代码块执行完毕之后的日常工作
容器类型
__ len__(self) 定义当被 len() 调用时的行为（返回容器中元素的个数）
__ getitem__(self, key) 定义获取容器中指定元素的行为，相当于 self[key]
__ setitem__(self, key, value) 定义设置容器中指定元素的行为，相当于 self[key] = value
__ delitem__(self, key) 定义删除容器中指定元素的行为，相当于 del self[key]
__ iter__(self) 定义当迭代容器中的元素的行为
__ reversed__(self) 定义当被 reversed() 调用时的行为
__ contains__(self, item) 定义当使用成员测试运算符（in 或 not in）时的行为
容器这个概念, 很直观有抽象, 是有点矛盾, 但 非常重要.
这里举个 迭代器 的栗子, 后面会单独来讲, 这里引入一波, 迭代器: 实现了 __ iter __ , __ next __ 的类 (容器)
class Iterator:
"""迭代器, 以list 作为底层结构"""
def __init__(self, lst):
self.lst = lst
self.index = 0
def __iter__(self):
return self
def __next__(self):
if self.index < len(self.lst):
# get current value
value = self.lst[self.index]
self.index += 1
else:
raise StopIteration
return value
# __next__ 为了能与 for 对应上
# __iter__ 迭代后返回自身
小结
- 每一个魔法方法, 几乎都跟咱用的 内置函数是有映射关系的
- 可以通过重写魔法方法来适应业务, 如运算符重载, 类属性判断, 异常检测等.
- 还是在于设计类这方面会很有用的.
本篇的目的是大致了解魔法方法, 留印象为主, 具体用啥, 再进行百度即可.而上篇呢重点是举了几个常用来重写魔法方法的应用场景, 当然也是我自己经验有限, 目前只用到的非常少吧.
