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__ 迭代后返回自身

小结

每一个魔法方法, 几乎都跟咱用的内置函数是有映射关系的
可以通过重写魔法方法来适应业务, 如运算符重载, 类属性判断, 异常检测等.
还是在于设计类这方面会很有用的.

本篇的目的是大致了解魔法方法, 留印象为主, 具体用啥, 再进行百度即可.而上篇呢重点是举了几个常用来重写魔法方法的应用场景, 当然也是我自己经验有限, 目前只用到的非常少吧.