1、介绍
在Python中,所有以“__”双下划线包起来的方法,都统称为“Magic Method”,中文称『魔术方法』,例如类的初始化方法__init__
,Python中所有的魔术方法均在官方文档中有相应描述,但是对于官方的描述比较混乱而且组织比较松散。很难找到有一个例子。
2、构造和初始化
每个Pythoner都知道一个最基本的魔术方法, __init__
。通过此方法我们可以定义一个对象的初始操作。然而,当调用 x = SomeClass()
的时候, __init__
并不是第一个被调用的方法。实际上,还有一个叫做__new__
的方法,两个共同构成了“构造函数”。
__new__
是用来创建类并返回这个类的实例, 而__init__
只是将传入的参数来初始化该实例
在对象生命周期调用结束时,__del__
方法会被调用,可以将__del__
理解为“构析函数”。下面通过代码的看一看这三个方法:
from os.path import join
class FileObject:
'''给文件对象进行包装从而确认在删除时文件流关闭'''
def __init__(self, filepath='~', filename='sample.txt'):
#读写模式打开一个文件
self.file = open(join(filepath, filename), 'r+')
def __del__(self):
self.file.close()
del self.file
3、控制属性访问
许多从其他语言转到Python的人会抱怨它缺乏类的真正封装。(没有办法定义私有变量,然后定义公共的getter和setter)。Python其实可以通过魔术方法来完成封装。我们来看一下:
__getattr__(self, name):
定义当用户试图获取一个不存在的属性时的行为。这适用于对普通拼写错误的获取和重定向,对获取一些不建议的属性时候给出警告(如果你愿意你也可以计算并且给出一个值)或者处理一个 AttributeError 。只有当调用不存在的属性的时候会被返回。
__setattr__(self, name, value):
与__getattr__(self, name)
不同,__setattr__
是一个封装的解决方案。无论属性是否存在,它都允许你定义对对属性的赋值行为,以为这你可以对属性的值进行个性定制。实现__setattr__
时要避免"无限递归"的错误。
__delattr__:
与__setattr__
相同,但是功能是删除一个属性而不是设置他们。实现时也要防止无限递归现象发生。
__getattribute__(self, name):
__getattribute__
定义了你的属性被访问时的行为,相比较,__getattr__
只有该属性不存在时才会起作用。因此,在支持__getattribute__
的Python版本,调用__getattr__
前必定会调用 __getattribute__
。__getattribute__
同样要避免"无限递归"的错误。需要提醒的是,最好不要尝试去实现__getattribute__
,因为很少见到这种做法,而且很容易出bug。
在进行属性访问控制定义的时候很可能会很容易引起“无限递归”。如下面代码:
# 错误用法
def __setattr__(self, name, value):
self.name = value
# 每当属性被赋值的时候(如self.name = value), ``__setattr__()`` 会被调用,这样就造成了递归调用。
# 这意味这会调用 ``self.__setattr__('name', value)`` ,每次方法会调用自己。这样会造成程序崩溃。
# 正确用法
def __setattr__(self, name, value):
self.__dict__[name] = value # 给类中的属性名分配值
# 定制特有属性
Python的魔术方法很强大,但是用时却需要慎之又慎,了解正确的使用方法非常重要。
4、创建自定义容器
有很多方法可以让你的Python类行为向内置容器类型一样,比如我们常用的list、dict、tuple、string等等。Python的容器类型分为可变类型(如list、dict)和不可变类型(如string、tuple),可变容器和不可变容器的区别在于,不可变容器一旦赋值后,不可对其中的某个元素进行修改。
在讲创建自定义容器之前,应该先了解下协议。这里的协议跟其他语言中所谓的"接口"概念很像,它给你很多你必须定义的方法。然而在Python中的协议是很不正式的,不需要明确声明实现。事实上,他们更像一种指南。
5、自定义容器的magic method
下面细致了解下定义容器可能用到的魔术方法。首先,实现不可变容器的话,你只能定义__len__
和 __getitem__
(下面会讲更多)。可变容器协议则需要所有不可变容器的所有,另外还需要 __setitem__
和__delitem__
。如果你希望你的对象是可迭代的话,你需要定义 __iter__
会返回一个迭代器。迭代器必须遵循迭代器协议,需要有 __iter__
(返回它本身) 和next
。
__len__(self):
返回容器的长度。对于可变和不可变容器的协议,这都是其中的一部分。
__getitem__(self, key):
定义当某一项被访问时,使用self[key]
所产生的行为。这也是不可变容器和可变容器协议的一部分。如果键的类型错误将产生TypeError;如果key没有合适的值则产生KeyError。
__setitem__(self, key, value):
当你执行self[key] = value时,调用的是该方法。
__delitem__(self, key):
定义当一个项目被删除时的行为(比如 del self[key])。这只是可变容器协议中的一部分。当使用一个无效的键时应该抛出适当的异常。
__iter__(self):
返回一个容器迭代器,很多情况下会返回迭代器,尤其是当内置的iter()方法被调用的时候,以及当使用for x in container
:方式循环的时候。迭代器是它们本身的对象,它们必须定义返回self的__iter__
方法。
__reversed__(self):
实现当reversed()被调用时的行为。应该返回序列反转后的版本。仅当序列可以是有序的时候实现它,例如对于列表或者元组。
__contains__(self, item):
定义了调用in和not in来测试成员是否存在的时候所产生的行为。你可能会问为什么这个不是序列协议的一部分?因为当__contains__
没有被定义的时候,如果没有定义,那么Python会迭代容器中的元素来一个一个比较,从而决定返回True或者False。
__missing__(self, key):
dict字典类型会有该方法,它定义了key如果在容器中找不到时触发的行为。比如d = {'a': 1}
, 当你执行d[notexist]时,d.__missing__['notexist']
就会被调用。
- 实例
下面是书中的例子,用魔术方法来实现Haskell语言中的一个数据结构。
# -*- coding: utf-8 -*-
class FunctionalList:
''' 实现了内置类型list的功能,并丰富了一些其他方法: head, tail, init, last, drop, take'''
def __init__(self, values=None):
if values is None:
self.values = []
else:
self.values = values
def __len__(self):
return len(self.values)
def __getitem__(self, key):
return self.values[key]
def __setitem__(self, key, value):
self.values[key] = value
def __delitem__(self, key):
del self.values[key]
def __iter__(self):
return iter(self.values)
def __reversed__(self):
return FunctionalList(reversed(self.values))
def append(self, value):
self.values.append(value)
def head(self):
# 获取第一个元素
return self.values[0]
def tail(self):
# 获取第一个元素之后的所有元素
return self.values[1:]
def init(self):
# 获取最后一个元素之前的所有元素
return self.values[:-1]
def last(self):
# 获取最后一个元素
return self.values[-1]
def drop(self, n):
# 获取所有元素,除了前N个
return self.values[n:]
def take(self, n):
# 获取前N个元素
return self.values[:n]
其实在collections模块中已经有了很多类似的实现,比如Counter、OrderedDict等等。
6、可调用的对象
python中一切皆对象,函数也是对象,同时也是可调用对象(callable)。
关于可调用对象,我们平时自定义的函数、内置函数和类都属于可调用对象,但凡是可以把一对括号()应用到某个对象身上都可称之为可调用对象,判断对象是否为可调用对象可以用函数 callable
一个类实例要变成一个可调用对象,只需要实现一个特殊方法__call__()
在Python中,一个特殊的魔术方法可以让类的实例的行为表现的像函数一样,你可以调用它们,将一个函数当做一个参数传到另外一个函数中等等。这是一个非常强大的特性,其让Python编程更加舒适甜美。
__call__(self, [args...]):
允许一个类的实例像函数一样被调用。实质上说,这意味着x()
与 x.__call__()
是相同的。注意 __call__
的参数可变。这意味着你可以定义 __call__
为其他你想要的函数,无论有多少个参数。
__call__
在那些类的实例经常改变状态的时候会非常有效。调用这个实例是一种改变这个对象状态的直接和优雅的做法。用一个实例来表达最好不过了:
# -*- coding: UTF-8 -*-
class Entity:
"""
调用实体来改变实体的位置
"""
def __init__(self, size, x, y):
self.x, self.y = x, y
self.size = size
def __call__(self, x, y):
"""
改变实体的位置
"""
self.x, self.y = x, y
e = Entity(1, 2, 3)
print(e.x)
print(e.y)
e(4, 5) #允许一个类的实例像函数一样被调用。实质上说,这意味着` e(4,5) `与 `x.__call__() `是相同的
print(e.x)
print(e.y)
## 输出
2
3
4
5
其他方法
- 用于比较的魔术方法
__cmp__(self, other) 是比较方法里面最基本的的魔法方法
__eq__(self, other) 定义相等符号的行为,==
__ne__(self,other) 定义不等符号的行为,!=
__lt__(self,other) 定义小于符号的行为,<
__gt__(self,other) 定义大于符号的行为,>
__le__(self,other) 定义小于等于符号的行为,<=
__ge__(self,other) 定义大于等于符号的行为,>=
- 单目运算符和函数
__pos__(self) 实现一个取正数的操作
__neg__(self) 实现一个取负数的操作
__abs__(self) 实现一个内建的abs()函数的行为
__invert__(self) 实现一个取反操作符(~操作符)的行为
__round__(self, n) 实现一个内建的round()函数的行为
__floor__(self) 实现math.floor()的函数行为
__ceil__(self) 实现math.ceil()的函数行为
__trunc__(self) 实现math.trunc()的函数行为
- 双目运算符或函数
__add__(self, other) 实现一个加法
__sub__(self, other) 实现一个减法
__mul__(self, other) 实现一个乘法
__floordiv__(self, other) 实现一个“//”操作符产生的整除操作()
__div__(self, other) 实现一个“/”操作符代表的除法操作
__truediv__(self, other) 实现真实除法
__mod__(self, other) 实现一个“%”操作符代表的取模操作
__divmod__(self, other) 实现一个内建函数divmod()
__pow__ 实现一个指数操作(“**”操作符)的行为
__lshift__(self, other) 实现一个位左移操作(<<)的功能
__rshift__(self, other) 实现一个位右移操作(>>)的功能
__and__(self, other) 实现一个按位进行与操作(&)的行为
__or__(self, other) 实现一个按位进行或操作的行为
__xor__(self, other) __xor__(self, other)
- 增量运算
__iadd__(self, other) 加法赋值
__isub__(self, other) 减法赋值
__imul__(self, other) 乘法赋值
__ifloordiv__(self, other) 整除赋值,地板除,相当于 //= 运算符
__idiv__(self, other) 除法赋值,相当于 /= 运算符
__itruediv__(self, other) 真除赋值
__imod_(self, other) 模赋值,相当于 %= 运算符
__ipow__ 乘方赋值,相当于 **= 运算符
__ilshift__(self, other) 左移赋值,相当于 <<= 运算符
__irshift__(self, other) 左移赋值,相当于 >>= 运算符
__iand__(self, other) 与赋值,相当于 &= 运算符
__ior__(self, other) 或赋值
__ixor__(self, other) 异或运算符,相当于 ^= 运算符
- 类型转换
__int__(self) 转换成整型
__long__(self) 转换成长整型
__float__(self) 转换成浮点型
__complex__(self) 转换成 复数型
__oct__(self) 转换成八进制
__hex__(self) 转换成十六进制
__index__(self) 如果你定义了一个可能被用来做切片操作的数值型,你就应该定义__index__
__trunc__(self) 当 math.trunc(self) 使用时被调用__trunc__返回自身类型的整型截取
__coerce__(self, other) 执行混合类型的运算
- 示例
重写__add__
的方法
# -*- coding: utf-8 -*-
class Person(object):
def __init__(self, num):
self.num = num
# 运算符重载
def __add__(self, other):
return Person(self.num + other.num)
def __str__(self): # 重写print的方法
return "num = " + str(self.num)
per1 = Person(1)
per2 = Person(2)
print(per1 + per2) #per1 + per2 ==== per1.__add__(per2)
#print(per1.__add__(per2))
print(per1)
print(per2)
# 输出
num = 3
num = 1
num = 2