magic method -- 魔术方法

special method 的非正式同义词。

special method -- 特殊方法

一种由 Python 隐式调用的方法，用来对某个类型执行特定操作例如相加等等。这种方法的名称的首尾都为双下划线。

文档：

特殊方法的文档参见特殊方法名称。

Python 常用指引中的描述器使用指南。

Python中的魔术方法

Catalogue

1.魔术方法简介

Python 中的魔术方法(Magic)方法，是那些被__包围的方法，在对象继承时，子类可以重写父类的魔术方法以实现定制功能，用于增强Python面向对象编程的能力。魔术方法在创建对象或对象操作时自动调用，不需要显式使用。譬如当我们判断对象是否相等时只使用了==符号，并未显式调用__eq__方法，但却实现了判断两个实例是否相等的功能，犹如变魔法一般。魔术方法按功能可分为如下几类，

1.构造、初始化和析构对象
2.控制属性读写
3.对象的表示和描述，如__str__等
4.在定制类对象间支持使用运算符号，如+,-,*,/,//,==,<=等
5.定义个性化序列
6.反射
7.可调用对象
8.上下文管理
9.描述器
10.复制
11.使对象支持pickle序列化反序列化

因不同的PEP(Python Enhancement Proposal)会不断添加删除魔术方法，故本文具有一定时效性。本文中涉及的魔术方法列表:

python的魔术方法大全
在Python中，所有以“__”双下划线包起来的方法，都统称为“Magic Method”（魔术方法）,例如类的初始化方法 __init__ ,Python中所有的魔术方法均在官方文档中有相应描述，这边给大家把所有的魔术方法汇总了一下，希望对大家的学习有所帮助。

一、基本的魔法方法

方法	说明
`__new__(cls[, ...])`	创建对象的方法，当通过类去创建对象时就是调用`__new__`方法去创建的
`__init__(self[, ...])`	初始化方法，当实例被创建的时候调用的初始化方法
`__del__(self)`	析构方法，当实例被销毁的时候调用的方法
`__call__(self[, args...])`	允许一个类的实例像函数一样被调用：x(a, b) 调用 x.`__call__`(a, b)
`__repr__(self)`	定义当被 repr() 调用时的行为
`__str__(self)`	定义当被 str() 调用时的行为
`__bytes__(self)`	定义当被 bytes() 调用时的行为
`__hash__(self)`	定义当被 hash() 调用时的行为
`__bool__(self)`	定义当被 bool() 调用时的行为，应该返回 True 或 False
`__format__(self, format_spec)`	定义当被 format() 调用时的行为

二、属性相关的魔法方法

方法	说明
`__getattr__(self, name)`	定义当用户试图获取一个不存在的属性时的行为
`__getattribute__(self, name)`	定义当该类的属性被访问时的行为
`__setattr__(self, name, value)`	定义当一个属性被设置时的行为
`__delattr__(self, name)`	定义当一个属性被删除时的行为
`__dir__(self)`	定义当 dir() 被调用时的行为
`__get__(self, instance, owner)`	定义当描述符的值被取得时的行为
`__set__(self, instance, value)`	定义当描述符的值被改变时的行为
`__delete__(self, instance)`	定义当描述符的值被删除时的行为

三、上下文管理器

方法	说明
`__enter__`(self)	定义当使用 with 语句进入上下文管理器执行的方法 ,`__enter__` 的返回值被 with 语句的目标或者 as 后的名字绑定
`__exit__`(self, exc_type, exc_value, traceback)	当with中的代码块执行完毕后调用的方法。一般被用来处理异常，清除工作或者做一些代码块执行完毕之后的日常工作

四、容器类型数据相关

方法	说明
`__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）时的行为

五、比较运算符

方法	说明
`__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() 调用或 ` 运算时的行为
`__lshift__(self, other)`	定义按位左移位的行为：<<
`__rshift__(self, other)`	定义按位右移位的行为：>>
`__and__(self, other)`	定义按位与操作的行为：&
`__xor__(self, other)`	定义按位异或操作的行为：^
`__or__(self, other)`	定义按位或操作的行为：\|

七、反运算

方法	说明
`__radd__(self, other)`	（与上方相同，当左操作数不支持相应的操作时被调用）
`__rsub__(self, other)`	（与上方相同，当左操作数不支持相应的操作时被调用）
`__rmul__(self, other)`	（与上方相同，当左操作数不支持相应的操作时被调用）
`__rtruediv__(self, other)`	（与上方相同，当左操作数不支持相应的操作时被调用）
`__rfloordiv__(self, other)`	（与上方相同，当左操作数不支持相应的操作时被调用）
`__rmod__(self, other)`	（与上方相同，当左操作数不支持相应的操作时被调用）
`__rdivmod__(self, other)`	（与上方相同，当左操作数不支持相应的操作时被调用）
`__rpow__(self, other)`	（与上方相同，当左操作数不支持相应的操作时被调用）
`__rlshift__(self, other)`	（与上方相同，当左操作数不支持相应的操作时被调用）
`__rrshift__(self, other)`	（与上方相同，当左操作数不支持相应的操作时被调用）
`__rand__(self, other)`	（与上方相同，当左操作数不支持相应的操作时被调用）
`__rxor__(self, other)`	（与上方相同，当左操作数不支持相应的操作时被调用）
`__ror__(self, other)`	（与上方相同，当左操作数不支持相应的操作时被调用）

八、增量赋值运算

方法	说明
`__iadd__(self, other)`	定义赋值加法的行为：+=
`__isub__(self, other)`	定义赋值减法的行为：-=
`__imul__(self, other)`	定义赋值乘法的行为：*=
`__itruediv__(self, other)`	定义赋值真除法的行为：/=
`__ifloordiv__(self, other)`	定义赋值整数除法的行为：//=
`__imod__(self, other)`	定义赋值取模算法的行为：%=
`__ipow__(self, other[, modulo])`	定义赋值幂运算的行为：`=
`__ilshift__(self, other)`	定义赋值按位左移位的行为：<<=
`__irshift__(self, other)`	定义赋值按位右移位的行为：>>=
`__iand__(self, other)`	定义赋值按位与操作的行为：&=
`__ixor__(self, other)`	定义赋值按位异或操作的行为：^=
`__ior__(self, other)`	定义赋值按位或操作的行为：\|=

九、一元操作符

方法	说明
`__pos__(self)`	定义正号的行为：+x
`__neg__(self)`	定义负号的行为：-x
`__abs__(self)`	定义当被 abs() 调用时的行为
`__invert__(self)`	定义按位求反的行为：~x

十、类型转换

方法	说明
`__complex__(self)`	定义当被 complex() 调用时的行为（需要返回恰当的值）
`__int__(self)`	定义当被 int() 调用时的行为（需要返回恰当的值）
`__float__(self)`	定义当被 float() 调用时的行为（需要返回恰当的值）
`__round__(self)`	定义当被 round() 调用时的行为（需要返回恰当的值）
`__index__(self)`	1. 当对象是被应用在切片表达式中时，实现整形强制转换 2. 如果你定义了一个可能在切片时用到的定制的数值型,你应该定义 `__index__` 3. 如果 `__index__` 被定义，则 int 也需要被定义，且返回相同的值

2.不同类型的魔术方法

2.1 用于对象构造析构的魔术方法

__init__:在定义class时使用最多的方法，用于初始化对象, 在创建对象时自动调用。
__new__:初始化对象时，在__init__之前调用的方法，该方法实现对象的构造，返回对象实例给__init__中的self。
__del__：__del__方法是定义类的析构函数，其并不是为了定义del Object时对象的行为，而是为了在对象被垃圾回收时执行特定的操作，如关闭socket,文件描述符等。因为当Python解释器退出时，对象有可能依然未被释放，因此__del__中定义册操作不一定能被执行，故在实际中应避免使用__del__。

示例：

class World:
    def __new__(cls, *args, **kargs):
        print("__new__ method called.")
        inst = super(World, cls).__new__(cls)
        return inst
    def __init__(self, countries):
        print("__init__ method called.")
        self.countrie = countries
    def __del__(self):
        print("Your World Is Cleaned Up.")

w = World(1)
o = World(2)
del o
"""
Output:
# __new__ method called.
# __init__ method called.
# __new__ method called.
# __init__ method called.
# Your World Is Cleaned Up.
"""

2.2 用于控制属性读写的魔术方法

__getattr__:拦截通过obj.key获取对象不存在的key属性时调用的方法，注意与__getattribute__方法的区别，可实现懒加载，在调用属性时再去操作耗时的动作，如文件读取等。
__getattribute__：拦截所有的属性访问，注意避免在此方法中使用self.key，以免造成死循环
__setattr__:拦截所有属性的赋值操作，注意避免在此方法中通过self.key=value的方式给实例赋值，以免造成死循环。
__delattr__:拦截所有属性的清除操作，注意避免在此方法中通过del self.key的方式清除实例属性，以免造成死循环。
示例：

class World:
    def __init__(self, countries):
        self.countries = countries
    
    def __getattr__(self, key):
        print(f"__getattr__ called: unexisted key {key}")
        return None
    
    def __getattribute__(self, key):
        print(f"__getattribute__ called: key {key}")
        return super(World, self).__getattribute__(key)

    def __setattr__(self, key, value):
        if key in self.__dict__:
            print(f"__setattr__ called: key existed {key}")
        else:
            print(f"__setattr__ called: key unexisted {key}")
        self.__dict__[key] = value
    
    def __delattr__(self, key):
        print(f"__delattr__ called: key {key}")
        del self.__dict__[key]

w = World(256)
w.oceans = 5
del w.countries
"""
Output:
# __getattribute__ called: key __dict__
#__setattr__ called: key unexisted countries
# __getattribute__ called: key __dict__

# __getattribute__ called: key __dict__
# __setattr__ called: key unexisted oceans
# __getattribute__ called: key __dict__

# __delattr__ called: key countries
# __getattribute__ called: key __dict__
"""

2.3 对象的表示和描述

__str__：使得可通过str()方法获取对象的可读信息,__str__输出的应该是用户关注的容易理解的信息，因此对那些负责与客户交互的类，至少更应该重写__str__方法。
__repr__:使得可通过repr()方法获取对象的详细信息，包括存储地址等，__str__中的信息是__repr__中的一部分。stackoverflow上有个回答。1，__str__是面向普通用户的信息，__repr__是面向开发者的信息，倒也形象。如果开发者要输出开发人员足够知悉的属性，就需要重写该方法。重写__repr__方法注意：__repr__方法是实例方法，因此带一个参数self，也只能带这个参数；输出的信息尽可能满足开发者的要求，信息必须详尽和准确。
__format__:定义通过"prefix {:code}".format(obj)时实例输出的形式，code是__format__的参数，用来确定以哪种格式format,定制数值或字符串类型时常希望重写此方法
__hash__:定义hash对象实例的返回值，需要为1个整数，默认的hash方法根据对象的地址和属性值算出来int类型整数为对象的hash值。一个对象在其生命周期内，如果保持不变，就是hashable（可哈希的）。像int,string是可哈希的，dict,list等是不可哈希的。哈希性使得对象可以用作dictionary键和set成员，因为这些数据结构在内部使用了哈希值。如果要判断 item in set为True,则item==set中的一个元素且hash(item)==hash(set中的一个元素)。
__bool__:调用bool()方法时对象的返回值，需为True/False。
__dir__：调用dir()方法时对象的返回值，一般不需要重写该方法，但在定义__getattr__时有可能需要重写，以打印动态添加的属性。
__sizeof__:定义sys.getsizeof() 方法调用时的返回，指类的实例的大小，单位是字节，在使用C扩展编写Python类时比较有用。
示例：

formats = {
    "long":"Country Has {c.provinces} Provinces",
    "short":"C H {c.provinces} P",
}
class Country:
    def __init__(self, provinces, name):
        self.provinces = provinces
        self.name = name
    def __str__(self):
        return f"Country has {self.provinces} provinces"
    def __repr__(self):
        s="In __repr__:\n<{} object at {:#016x}>\n".format(repr(self.__class__),id(self) )
        s+=super().__repr__()
        s+="\n"
        s+=repr(self.__dict__)
        return s
    def __format__(self, code):
        return formats
.format(c=self)
    
    def __eq__(self, obj):
        return self.provinces == obj.provinces
    
    def __hash__(self):
        return 12
        #return hash(self.name)
    def __bool__(self):
        print(self.name)
        return self.name == "Hunan"
    def __dir__(self):
        l = list(self.__dict__.keys())
        l.append("GDP")
        return l
    def __sizeof__(self):
        print("__sizeof__ called")
        return len(self.__dict__)
c = Country(264, "Hunan")
d = Country(264, "Henan")
print(hash(c))
print(hash(d))
print(c == d)
s = set()
s.add(c)
print(d in s)
print(bool(c), bool(d))
import sys
print(sys.getsizeof(c))

2.4 在定制类对象间支持使用运算符号

2.4.1支持比较运算符号

__eq__(self, obj):支持==
__ne__(self, obj):支持!=
__le__(self, obj):支持<=
__ge__(self, obj):支持>=
__lt__(self, obj):支持<
__gt__(self, obj):支持>
示例：

class Point3D:
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z
        
    def __square_sum(self, obj:Point3D):
        return sum([pow(getattr(obj, k), 2) for k in obj.__dict__])
    
    def __eq__(self, obj):
        print("equal called")
        d1 = self.__square_sum(self)
        d2 = self.__square_sum(obj)
        return d1 == d2
    
    def __ne__(self, obj):
        print("not equal called")
        d1 = self.__square_sum(self)
        d2 = self.__square_sum(obj)
        return d1 != d2

    def __le__(self, obj):
        print("not equal called")
        d1 = self.__square_sum(self)
        d2 = self.__square_sum(obj)
        return d1 <= d2
    
    def __ge__(self, obj):
        print("not equal called")
        d1 = self.__square_sum(self)
        d2 = self.__square_sum(obj)
        return d1 >= d2
    
    
    def __lt__(self, obj):
        print("less than called")
        d1 = self.__square_sum(self)
        d2 = self.__square_sum(obj)
        return d1 < d2
    
    def __gt__(self, obj):
        print("great than called")
        d1 = self.__square_sum(self)
        d2 = self.__square_sum(obj)
        return d1 > d2      
p1 = Point3D(1,2,3)
p2 = Point3D(2,2,3)
print(p1 == p2)
print(p1 != p2)
print(p1 <= p2)
print(p1 >= p2)
print(p1 > p2)
print(p1 < p2)

2.4.2支持一元运算符

__pos__：支持+,大多数情况下+x依然是x,一元运算符+没有执行任何操作，如+(-1)还是-1，在__pos__中可以定义+的操作。
__neg__:支持-运算符
__invert__:~符号的逻辑
__abs__:定制abs()方法调用时的逻辑
__round__：round()方法调用时的逻辑
__floor__：定制math.floor()方法调用时的逻辑,譬如向下取整
__ceil__：定制math.ceil()方法调用时的逻辑,譬如向上取整
__trunc__:定制math.trunc()方法调用时的逻辑
示例

class MyNum(int):
    def __init__(self, x):
        self.x = x
    
    def __pos__(self):
        return abs(self.x)
    
    def __neg__(self):
        return -self.x
    
    def __abs__(self):
        return pow(self.x,2)
    
    def __invert__(self):
        return -1 if self.x > 0 else 1

    def __round__(self, n):
        print(f"{n} digits after point would be remained.")
        return 1 if self.x > 0 else 0

    def __floor__(self):
        return self.x - 1
    
    def __ceil__(self):
        return self.x + 1
    
    def __trunc__(self):
        return self.x // 10
a = MyNum(-12)
print(abs(a))
print(+a)
print(~a)
print(-a)
round(a, 10)

2.4.3支持算术运算符

__add__: 支持+
__sub__:支持-
__mul__:支持*
__matmul__:支持@，矩阵乘法，Python3.5后引入的新特性，支持numpy数组表示的矩阵乘法
__truediv__:支持/, __div__是Python2中的属性，Python3中用__truediv__
__floordiv__: 支持//
__mod__:支持%，取余
__divmod__:支持divmod()方法，返回tuple(x//y,x%y)
__pow__:支持**
__lshift__:支持左移位<<
__rshift__:支持右移位>>
__and__:支持&,按位与
__or__:支持|，按位或
__xor__:支持^,按位异或
示例：

class Point2D:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __add__(self, obj):
        print("__add__ called")
        return (self.x + obj.x, self.y + obj.y)
    
    def __sub__(self, obj):
        print("__sub__ called")
        return (self.x - obj.x, self.y - obj.y)
    
    def __mul__(self, obj):
        print("__mul__ called")
        return (self.x * obj.x, self.y * obj.y)
    
    def __matmul__(self, obj):
        import numpy as np
        print("__matmul__ called")
        return np.array([self.x, obj.x]) @ np.array([self.y, obj.y])
    
    def __floordiv__(self, obj):
        print("__floordiv__ called")
        return (self.x // obj.x, self.y // obj.y)
    
    def __truediv__(self, obj):
        print("__div__ called")
        return (self.x / obj.x, self.y / obj.y)
    
    def __mod__(self, obj):
        print("__mod__ called")
        return (self.x % obj.x, self.y % obj.y)
    
    def __divmod__(self, obj):
        print("__divmod__ called")
        return (divmod(self.x, obj.x), divmod(self.y, obj.y))
    
    def __pow__(self, obj):
        print("__pow__ called")
        return (self.x ** obj.x, self.y ** obj.y)
    
    def __lshift__(self, obj):
        print("__lshift__ called")
        return (self.x << obj.x, self.y << obj.y)
    
    def __rshift__(self, obj):
        print("__rshift__ called")
        return (self.x >> obj.x, self.y >> obj.y)
    
    def __and__(self, obj):
        print("__and__ called")
        return (self.x & obj.x, self.y & obj.y)    
    
    def __or__(self, obj):
        print("__or__ called")
        return (self.x | obj.x, self.y | obj.y)
    
    def __xor__(self, obj):
        print("__xor__ called")
        return (self.x ^ obj.x, self.y ^ obj.y)

p1 = Point2D(8, 16)
p2 = Point2D(1, 3)

print(p1 + p2)
print(p1 - p2)
print(p1 * p2)
print(p1 @ p2)
print(p1 / p2)
print(p1 // p2)
print(p1 % p2)
print(divmod(p1, p2))
print(p1 ** p2)
print(p1 << p2)
print(p1 >> p2)
print(p1 & p2)
print(p1 | p2)
print(p1 ^ p2)

2.4.4反射算术运算符

2.4.3中的是常规算术运算符，a+b或者b+a都可以进行运算，反射运算符指如a+b时，a中没有定义需调用b的运算方法实现运算的运算符。如__radd__,则要执行此方法a中需没有实现__add__和__radd__方法，才会去调用b中对应的r方法3
示例

class Point2DA:
    def __init__(self, x, y):
        self.x = x
        self.y = y
        
class Point2DB:
    def __init__(self, x, y):
        self.x = x
        self.y = y    
        
    def __radd__(self, obj):
        print("__radd__ called")
        return (self.x + obj.x, self.y + obj.y)
    
    def __rsub__(self, obj):
        print("__rsub__ called")
        return (self.x - obj.x, self.y - obj.y)
    
    def __rmul__(self, obj):
        print("__rmul__ called")
        return (self.x * obj.x, self.y * obj.y)
    
    def __rmatmul__(self, obj):
        import numpy as np
        print("__rmatmul__ called")
        return np.array([self.x, obj.x]) @ np.array([self.y, obj.y])

    def __rfloordiv__(self, obj):
        print("__rfloordiv__ called")
        return (self.x // obj.x, self.y // obj.y)
    
    def __rtruediv__(self, obj):
        print("__rtruediv__ called")
        return (self.x / obj.x, self.y / obj.y)
    
    def __rmod__(self, obj):
        print("__rmod__ called")
        return (self.x % obj.x, self.y % obj.y)
    
    def __rpow__(self, obj):
        print("__rpow__ called")
        return (self.x ** obj.x, self.y ** obj.y)
    
    def __rlshift__(self, obj):
        print("__rlshift__ called")
        return (self.x << obj.x, self.y << obj.y)
    
    def __rrshift__(self, obj):
        print("__rrshift__ called")
        return (self.x >> obj.x, self.y >> obj.y)
    
    def __rand__(self, obj):
        print("__rand__ called")
        return (self.x & obj.x, self.y & obj.y)    
    
    def __ror__(self, obj):
        print("__ror__ called")
        return (self.x | obj.x, self.y | obj.y)
    
    def __rxor__(self, obj):
        print("__rxor__ called")
        return (self.x ^ obj.x, self.y ^ obj.y)

p1 = Point2DA(3,4)
p2 = Point2DB(2,3)

print(p1 + p2)
print(p1 - p2)
print(p1 * p2)
print(p1 @ p2)
print(p1 / p2)
print(p1 // p2)
print(p1 % p2)
print(p1 ** p2)
print(p1 << p2)
print(p1 >> p2)
print(p1 & p2)
print(p1 | p2)
print(p1 ^ p2)

2.4.5自增算术运算符

自增运算符：执行相应运算，并将结果赋予左值，如a+=b。
示例

class Point2D:
    def __init__(self, x, y):
        self.x = x
        self.y = y
        
    def __iadd__(self, other):
        print("__iadd__ called")
        self.x += other.x
        self.y += other.y
        return self
    
    def __isub__(self, other):
        print("__isub__ called")
        self.x -= other.x
        self.y -= other.y
        return self

    def __imul__(self, other):
        print("__imul__ called")
        self.x *= other.x
        self.y *= other.y
        return self

    def __imatmul__(self, other):
        print("__imatmul__ called")
        import numpy as np
        v = np.array([self.x, other.x]) @ np.array([self.y, other.y])
        self.x = v
        self.y = v
        return self

    def __itruediv__(self, other):
        print("__itruediv__ called")
        self.x /= other.x
        self.y /= other.y
        return self

    def __ifloordiv__(self, other):
        print("__ifloordiv__ called")
        self.x //= other.x
        self.y //= other.y
        return self

    def __imod__(self, other):
        print("__imod__ called")
        self.x %= other.x
        self.y %= other.y
        return self

    def __ipow__(self, other):
        print("__ipow__ called")
        self.x **= other.x
        self.y **= other.y
        return self

    def __ilshift__(self, other):
        print("__ilshift__ called")
        self.x <<= other.x
        self.y <<= other.y
        return self

    def __irshift__(self, other):
        print("__irshift__ called")
        self.x >>= other.x
        self.y >>= other.y
        return self

    def __iand__(self, other):
        print("__iand__ called")
        self.x &= other.x
        self.y &= other.y
        return self

    def __ixor__(self, other):
        print("__ixor__ called")
        self.x |= other.x
        self.y |= other.y
        return self

    def __ior__(self, other):
        print("__ior__ called")
        self.x ^= other.x
        self.y ^= other.y
        return self

p1 = Point2D(2,3)
p2 = Point2D(3,4)

p1 += p2
print(p1.x, p1.y)
p1 -= p2
print(p1.x, p1.y)
p1 *= p2
print(p1.x, p1.y)
p1 @= p2
print(p1.x, p1.y)
p1 /= p2
print(p1.x, p1.y)
p1 = p2
print(p1.x, p1.y)
p1 //= p2
print(p1.x, p1.y)
p1 %= p2
print(p1.x, p1.y)
p1 **= p2
print(p1.x, p1.y)
p1 <<= p2
print(p1.x, p1.y)
p1 >>= p2
print(p1.x, p1.y)
p1 &= p2
print(p1.x, p1.y)
p1 |= p2
print(p1.x, p1.y)
p1 ^= p2
print(p1.x, p1.y)

2.4.6支持类型转换运算符

__int__:支持int()
__float__:支持float()
__oct__:支持oct()
__hex__:支持hex()
__index__:返回1个整数，支持作为list下标
__complex__:支持complex()函数
示例

class MyNum(int):
    def __init__(self, x):
        self.x = x
        
    def __int__(self):
        print("__int__ called")
        return int(self.x)
    
    def __float__(self):
        print("__float__ called")
        return float(self.x)

    def __oct__(self):
        print("__oct__ called")
        return oct(self.x)
    
    def __hex__(self):
        print("__hex__ called")
        return hex(self.x)
    
    def __index__(self):
        print("__index__ called")
        return int(self.x + 1)
    
    def __complex__(self):
        print("__complex__ called")
        return complex(self.x, self.x)

n = MyNum(1.2)
m = MyNum(2)
a = [1,2,3]
print(int(n))
print(float(n))
print(oct(n))
print(hex(n))
print(a[n])
print(complex(n))

2.5定制个性化序列

定义一个不可变容器，只需要实现__len__和__getitem__,可变容器在此基础上还需实现__setitem__和__delitem__,如果希望容器是可迭代的，还需实现__iter__方法。

__len__:返回序列的长度，支持len()
__getitem__:支持self[key]
__setitem__:支持self[key]=value
__delitem__:支持del self[key]
__iter__:支持for item in self
__reversed__:支持reversed()方法
__contains__:支持in判断
__missing__:当定制序列是dict的子类时，使用dict[key]读取元素而key没有定义时调用。
示例：

class FunctionalList:

    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):
        # if key is of invalid type or value, the list values will raise the error
        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 reversed(self.values)

    def __contains__(self, val):
        print("__contains__ called")
        return True if val in self.values else False
    
    def append(self, value):
        self.values.append(value)    
    def head(self):
        # get the first element
        return self.values[0]
    def tail(self):
        # get all elements after the first
        return self.values[1:]
    def init(self):
        # get elements up to the last
        return self.values[:-1]
    def last(self):
        # get last element
        return self.values[-1]
    def drop(self, n):
        # get all elements except first n
        return self.values[n:]
    def take(self, n):
        # get first n elements
        return self.values[:n]
    
l = FunctionalList()
l.append(2)
l.append(5)
l.append(4)
print(l)
for i in l:
    print(i)
del l[1]
print(2 in l)
for i in l:
    print(i)
print(l[0])
l = reversed(l)
for i in l:
    print(i)

2.6 反射，实例类型判断

__instancecheck__:支持instancecheck方法
__subclasscheck__:支持subclasscheck方法，此两个方法需定义在元类中，否则调用的还是type中的方法4

示例

class MyType(type):
    def __instancecheck__(self, instance):
        print("__instancecheck__ called")
        if hasattr(instance, "password"):
            return True
        # 否则返回False
        return False


class A(metaclass=MyType):
    def __init__(self, x):
        super(A, self).__init__()
        self.x = x
    
a = []
print(isinstance(a, A))  

class MyType(type):

    def __subclasscheck__(self, subclass):
        print("__subclasscheck__ called.")
        return hasattr(subclass, "password")

class B(metaclass=MyType):
    pass

b = B()
print(issubclass(b, B))  
b = B()
b.password = "12"
print(issubclass(b, B))

2.7可调用对象

__call__:对象像函数一样可调用
示例

class Entity:
    def __init__(self, size, x, y):
        self.x, self.y = x, y
        self.size = size

    def __call__(self, s):
        return self.x*self.y + s
e = Entity(2, 2, 3)
print(e(3))

2.8 上下文管理

python中使用with语句执行上下文管理，处理内存块被创建时和内存块执行结束时上下文应该执行的操作，上下文即程序执行操作的环境，包括异常处理，文件开闭。有两个魔术方法负责处理上下文管理。

__enter__:上下文创建时执行的操作,该方法返回as后面的对象。
__exit__：上下文结束时执行的操作

示例

class Closer:
    '''A context manager to automatically close an object with a close method
    in a with statement.'''

    def __init__(self, obj):
        self.obj = obj

    def __enter__(self):
        print('__enter__ called')
        return self.obj # bound to target

    def __exit__(self, exception_type, exception_val, trace):
        print('__exit__ called')
        try:
            
           self.obj.close()
        except AttributeError:
           print('Not closable. here')
           return True

with Closer(open("1.txt", "w")) as f:
    f.write("1")

2.9描述器

描述器让对象能够自定义属性查找、存储和删除的操作。描述器是任何一个定义了 __get__()，__set__() 或__delete__() 的对象。描述器的主要目的是提供一个挂钩，允许存储在类变量中的对象控制在属性查找期间发生的情况。5。类似于Java类中的getters\setters6。常用于动态查找，属性托管，定制名称，自定义验证等。
__get__:查找属性时调用
__set__:给属性赋值时调用
__delete__:移除属性时调用