Python中的魔术方法入门
Python魔法方法指南： https://zhuanlan.zhihu.com/p/26488074
介绍
在Python中，所有以“__”双下划线包起来的方法，都统称为“Magic Method”，中文称『魔术方法』,例如类的初始化方法 __init__ ,Python中所有的魔术方法均在官方文档中有相应描述，但是对于官方的描述比较混乱而且组织比较松散。很难找到有一个例子。
构造和初始化
每个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
输出实例化对象时的信息
__repr__和__str__：https://zhuanlan.zhihu.com/p/53864366
函数默认参数
def hello(a, b, c=1, d=2): print(a, b, c, d) print(hello.__defaults__) # (1, 2) hello.__defaults__ = (3, 4) print(hello.__defaults__) # (3, 4) hello(5, 6) # (5, 6, 3, 4)
控制属性访问
许多从其他语言转到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的魔术方法很强大，但是用时却需要慎之又慎，了解正确的使用方法非常重要。
有很多方法可以让你的Python类行为向内置容器类型一样，比如我们常用的list、dict、tuple、string等等。Python的容器类型分为可变类型(如list、dict)和不可变类型（如string、tuple），可变容器和不可变容器的区别在于，不可变容器一旦赋值后，不可对其中的某个元素进行修改。
在讲创建自定义容器之前，应该先了解下协议。这里的协议跟其他语言中所谓的"接口"概念很像，它给你很多你必须定义的方法。然而在Python中的协议是很不正式的，不需要明确声明实现。事实上，他们更像一种指南。
自定义容器的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等等。
反射
你也可以控制怎么使用内置在函数isinstance()和issubclass()方法 反射定义魔术方法. 这个魔术方法是:
__instancecheck__(self, instance):
检查一个实例是不是你定义的类的实例
__subclasscheck__(self, subclass):
检查一个类是不是你定义的类的子类
这些魔术方法的用例看起来很小, 并且确实非常实用. 它们反应了关于面向对象程序上一些重要的东西在Python上,并且总的来说Python: 总是一个简单的方法去找某些事情, 即使是没有必要的. 这些魔法方法可能看起来不是很有用, 但是一旦你需要它们，你会感到庆幸它们的存在。
可调用的对象
你也许已经知道，在Python中，方法是最高级的对象。这意味着他们也可以被传递到方法中，就像其他对象一样。这是一个非常惊人的特性。
在Python中，一个特殊的魔术方法可以让类的实例的行为表现的像函数一样，你可以调用它们，将一个函数当做一个参数传到另外一个函数中等等。这是一个非常强大的特性，其让Python编程更加舒适甜美。
__call__(self, [args...]):
允许一个类的实例像函数一样被调用。实质上说，这意味着 x() 与 x.__call__() 是相同的。注意 __call__ 的参数可变。这意味着你可以定义 __call__ 为其他你想要的函数，无论有多少个参数。
__call__ 在那些类的实例经常改变状态的时候会非常有效。调用这个实例是一种改变这个对象状态的直接和优雅的做法。用一个实例来表达最好不过了:
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
上下文管理
with声明是从Python2.5开始引进的关键词。你应该遇过这样子的代码:
with open('foo.txt') as bar: # do something with bar
在with声明的代码段中，我们可以做一些对象的开始操作和退出操作,还能对异常进行处理。这需要实现两个魔术方法: __enter__ 和 __exit__。
__enter__(self):
定义了当使用with语句的时候，会话管理器在块被初始创建时要产生的行为。请注意，__enter__的返回值与with语句的目标或者as后的名字绑定。
__exit__(self, exception_type, exception_value, traceback):
定义了当一个代码块被执行或者终止后，会话管理器应该做什么。它可以被用来处理异常、执行清理工作或做一些代码块执行完毕之后的日常工作。如果代码块执行成功，exception_type，exception_value，和traceback将会为None。否则，你可以选择处理这个异常或者是直接交给用户处理。如果你想处理这个异常的话，请确保__exit__在所有语句结束之后返回True。如果你想让异常被会话管理器处理的话，那么就让其产生该异常。
创建对象描述器
描述器是通过获取、设置以及删除的时候被访问的类。当然也可以改变其它的对象。描述器并不是独立的。相反，它意味着被一个所有者类持有。当创建面向对象的数据库或者类，里面含有相互依赖的属相时，描述器将会非常有用。一种典型的使用方法是用不同的单位表示同一个数值，或者表示某个数据的附加属性。
为了成为一个描述器，一个类必须至少有__get__，__set__，__delete__方法被实现：
__get__(self, instance, owner):
定义了当描述器的值被取得的时候的行为。instance是拥有该描述器对象的一个实例。owner是拥有者本身
__set__(self, instance, value):
定义了当描述器的值被改变的时候的行为。instance是拥有该描述器类的一个实例。value是要设置的值。
__delete__(self, instance):
定义了当描述器的值被删除的时候的行为。instance是拥有该描述器对象的一个实例。
下面是一个描述器的实例：单位转换。
# -*- coding: UTF-8 -*- class Meter(object): """ 对于单位"米"的描述器 """ def __init__(self, value=0.0): self.value = float(value) def __get__(self, instance, owner): return self.value def __set__(self, instance, value): self.value = float(value) class Foot(object): """ 对于单位"英尺"的描述器 """ def __get__(self, instance, owner): return instance.meter * 3.2808 def __set__(self, instance, value): instance.meter = float(value) / 3.2808 class Distance(object): """ 用米和英寸来表示两个描述器之间的距离 """ meter = Meter(10) foot = Foot() 使用时： >>>d = Distance() >>>print d.foot >>>print d.meter 32.808 10.0
复制
有时候，尤其是当你在处理可变对象时，你可能想要复制一个对象，然后对其做出一些改变而不希望影响原来的对象。这就是Python的copy所发挥作用的地方。
__copy__(self):
定义了当对你的类的实例调用copy.copy()时所产生的行为。copy.copy()返回了你的对象的一个浅拷贝——这意味着，当实例本身是一个新实例时，它的所有数据都被引用了——例如，当一个对象本身被复制了，它的数据仍然是被引用的（因此，对于浅拷贝中数据的更改仍然可能导致数据在原始对象的中的改变）。
__deepcopy__(self, memodict={}):
定义了当对你的类的实例调用copy.deepcopy()时所产生的行为。copy.deepcopy()返回了你的对象的一个深拷贝——对象和其数据都被拷贝了。memodict是对之前被拷贝的对象的一个缓存——这优化了拷贝过程并且阻止了对递归数据结构拷贝时的无限递归。当你想要进行对一个单独的属性进行深拷贝时，调用copy.deepcopy()，并以memodict为第一个参数。
其他方法
用于比较的魔术方法
__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) 执行混合类型的运算
__mro__ ： 继承关系
class A(object): pass class B(A): pass class C(object): pass class D(C, B): pass print(D.__mro__) # (<class '__main__.D'>, <class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>)
__dict__
原文作者：//偏执
我们都知道Python一切皆对象，那么Python究竟是怎么管理对象的呢？
无处不在的__dict__
首先看一下类的__dict__属性和类对象的__dict__属性
class A(object): """ Class A. """ a = 0 b = 1 def __init__(self): self.a = 2 self.b = 3 def test(self): print('a normal func.') @staticmethod def static_test(): print('a static func.') @classmethod def class_test(cls): print('a class func.') obj = A() print(A.__dict__) print(obj.__dict__)
运行结果如下：
{'__module__': '__main__', '__doc__': '\n Class A.\n ', 'a': 0, 'b': 1, '__init__': <function A.__init__ at 0x7fd668900620>, 'test': <function A.test at 0x7fd6689008c8>, 'static_test': <staticmethod object at 0x7fd66a623978>, 'class_test': <classmethod object at 0x7fd6688fea58>, '__dict__': <attribute '__dict__' of 'A' objects>, '__weakref__': <attribute '__weakref__' of 'A' objects>}
{'a': 2, 'b': 3}
由此可见， 类的静态函数、类函数、普通函数、全局变量以及一些内置的属性都是放在类__dict__里的
对象的__dict__中存储了一些self.xxx的一些东西
Python里什么没有__dict__属性
虽然说一切皆对象，但对象也有不同，就好比不是每个人的女朋友都是一个人一样，一些内置的数据类型是没有__dict__属性的，如下：
num = 3 ll = [] dd = {} print(num.__dict__) print(ll.__dict__) print(dd.__dict__)
当我们运行这样的代码时，解释器就会告诉我们
Traceback (most recent call last): File "f:\python\test.py", line 54, in <module> print num.__dict__ AttributeError: 'int' object has no attribute '__dict__' Traceback (most recent call last): File "f:\python\test.py", line 55, in <module> print ll.__dict__ AttributeError: 'list' object has no attribute '__dict__' Traceback (most recent call last): File "f:\python\test.py", line 56, in <module> print dd.__dict__ AttributeError: 'dict' object has no attribute '__dict__'
int, list, dict等这些常用的数据类型是没有__dict__属性的，其实这是可预料的，就算给了它们dict属性也没啥用，毕竟它们只是用来做数据容器的。
发生继承时候的__dict__属性
子类有自己的__dict__, 父类也有自己的__dict__,子类的全局变量和函数放在子类的dict中，父类的放在父类dict中。
class Parent(object): a = 0 b = 1 def __init__(self): self.a = 2 self.b = 3 def p_test(self): pass class Child(Parent): a = 4 b = 5 def __init__(self): super(Child, self).__init__() self.a = 6 self.b = 7 def c_test(self): pass def p_test(self): pass p = Parent() c = Child() print(Parent.__dict__) print(Child.__dict__) print(p.__dict__) print(c.__dict__)
运行上面的代码，结果入下：
{'__module__': '__main__', 'a': 0, 'b': 1, '__init__': <function Parent.__init__ at 0x7f24a4c96620>, 'p_test': <function Parent.p_test at 0x7f24a4c968c8>, '__dict__': <attribute '__dict__' of 'Parent' objects>, '__weakref__': <attribute '__weakref__' of 'Parent' objects>, '__doc__': None}
{'__module__': '__main__', 'a': 4, 'b': 5, '__init__': <function Child.__init__ at 0x7f24a4c96950>, 'c_test': <function Child.c_test at 0x7f24a4c969d8>, 'p_test': <function Child.p_test at 0x7f24a4c96a60>, '__doc__': None}
{'a': 2, 'b': 3}
{'a': 6, 'b': 7}
1）上段输出结果中，用红色字体标出的是类变量和函数，由结果可知，每个类的类变量、函数名都放在自己的__dict__中
2） 再来看一下实力变量的__dict__中，由蓝色字体标识，父类和子类对象的__dict__是公用的
总结：
1） 内置的数据类型没有__dict__属性
2） 每个类有自己的__dict__属性，就算存着继承关系，父类的__dict__ 并不会影响子类的__dict__
3） 对象也有自己的__dict__属性， 存储self.xxx 信息，父子类对象公用__dict__
实战
Python中__setattr__, __getattr__和__getattribute__
作者：氨基钠 来源：简书
链接：https://www.jianshu.com/p/0beee5a49b90
__setattr__
如果类自定义了__setattr__方法，当通过实例(包括self)获取属性尝试赋值时，就会调用__setattr__.
class SetAttrTest(object): def __setattr__(self, name, value): # self.name = value # 调用 __setattr__ 出现无限递归的情况 self.__dict__[name] = value print('invoke __setattr__') instance = SetAttrTest() instance.tag = 'insA' # invoke __setattr__ print(instance.__dict__)
__getattr__
特点：当访问某个未被定义的实例属性时， __getattr__会被无条件调用
示例1：链式调用
充分利用__getattr__会在没有查找到相应实例属性时被调用的特点，方便的通过链式调用生成对应的url，链式的操作不仅优雅而且还能很好的说明调用的接口的意义（restful的接口啦）。
# 例子在原来的基础上简化了一下，排除依赖和干扰，详细参见原项目 class UrlGenerator(object): def __init__(self, root_url): self.url=root_url def __getattr__(self, item): if item == 'get' or item == 'post': print (self.url) return UrlGenerator('{}/{}'.format(self.url, item)) url_gen = UrlGenerator('http://xxxx') url_gen.users.show.get >>> http://xxxx/users/show
示例2：提供默认值
class Test(object): def __init__(self, name): self.name = name def __getattr__(self, value): if value == 'address': # 未定义的属性 return 'China' elif value == 'getLength': # 未定义的方法 return len return "default" if __name__ == "__main__": test = Test('猪八戒') print test.name print test.address # 获取未定义的属性 print test.getLength('猪八戒') # 调用未定义的方法
__getattribute__
特点：当访问某个实例属性时， __getattribute__会被无条件调用
示例：同时覆盖掉__getattribute__和__getattr__的时候，在__getattribute__中需要模仿原本的行为抛出AttributeError或者手动调用__getattr__
这里通过调用绑定的super对象来获取队形的属性，对新式类来说其实和object.__getattribute__(self, item)一样的道理
class AboutAttr(object): def __init__(self, name): self.name = name def __getattribute__(self, item): try: return super(AboutAttr, self).__getattribute__(item) except KeyError: return 'default' except AttributeError as ex: print ex def __getattr__(self, item): return 'default' at = AboutAttr('test') print at.name print at.not_exised >>>test >>>'AboutAttr' object has no attribute 'not_exised' >>>None
上面例子里面的__getattr__方法根本不会被调用，因为原本的AttributeError被我们自行处理并未抛出，也没有手动调用__getattr__，所以访问not_existed的结果是None而不是default.
测试方法调用顺序
__getattribute__ > __getattr__ > __dict__
class TestMain(object): def __init__(self): print('TestMain:__init__') self.a = 1 def __getattr__(self, item): print('TestMain:__getattr__') return 2 def __getattribute__(self, item): print('TestMain:__getattribute__') if item == 'c': raise AttributeError return 3 if __name__ == '__main__': t = TestMain() print(t.a) # 3 print(t.b) # 3 print(t.c) # 2
总结
- 如果定义了
__getattribute__，那么无论访问什么属性，都是通过这个函数获取，包括方法，t.f()这种也是访问的这个函数，此时这个函数应该放回一个方法，如果像例子中，仍然返回一个数字，你会获得一个TypeError: 'int' object is not callable错误 - 只要定义了
__getattribute__方法，不管你访问一个存在的还是不存在的属性，都由这个方法返回，比如访问t.a，虽然a存在，但是只要定义了这个访问，那么就不是访问最开始的a了 - 如果
__getattribute__抛出了AttributeError异常，并且定了了__getattr__函数，那么会调用__getattr__这个函数，不论这个属性到底是不是存在 - 也就是说属性访问的一个大致优先级是：
__getattribute__>__getattr__>__dict__
Python中的序列化
- Pickle 反序列化漏洞：https://www.jianshu.com/p/8fd3de5b4843
Python对象的序列化操作是pickling进行的。pickling非常的重要，以至于Python对此有单独的模块pickle，还有一些相关的魔术方法。使用pickling, 你可以将数据存储在文件中，之后又从文件中进行恢复。
下面举例来描述pickle的操作。从该例子中也可以看出,如果通过pickle.load 初始化一个对象, 并不会调用__init__方法。
# -*- coding: utf-8 -*- from datetime import datetime import pickle classDistance(object): def__init__(self, meter): print 'distance __init__' self.meter = meter data = { 'foo': [1, 2, 3], 'bar': ('Hello', 'world!'), 'baz': True, 'dt': datetime(2016, 10, 01), 'distance': Distance(1.78), } print 'before dump:', data with open('data.pkl', 'wb') as jar: pickle.dump(data, jar) # 将数据存储在文件中 del data print 'data is deleted!' with open('data.pkl', 'rb') as jar: data = pickle.load(jar) # 从文件中恢复数据 print 'after load:', data
值得一提，从其他文件进行pickle.load操作时，需要注意有恶意代码的可能性。另外，Python的各个版本之间,pickle文件可能是互不兼容的。
pickling并不是Python的內建类型，它支持所有实现pickle协议(可理解为接口)的类。pickle协议有以下几个可选方法来自定义Python对象的行为。
__getinitargs__
如果你希望unpickle时，__init__方法能够调用，那么就需要定义__getinitargs__, 该方法需要返回一系列参数的元组，这些参数就是传给__init__的参数。
该方法只对old-style class有效。所谓old-style class,指的是不继承自任何对象的类，往往定义时这样表示: class A:, 而非class A(object):
__getnewargs__
跟__getinitargs__很类似，只不过返回的参数元组将传值给__new__
__getstate__
在调用pickle.dump时，默认是对象的__dict__属性被存储，如果你要修改这种行为，可以在__getstate__方法中返回一个state。state将在调用pickle.load时传值给__setstate__
__setstate__
一般来说,定义了__getstate__,就需要相应地定义__setstate__来对__getstate__返回的state进行处理。
__reduce__(self)
如果pickle的数据包含了自定义的扩展类（比如使用C语言实现的Python扩展类）时，就需要通过实现__reduce__方法来控制行为了。由于使用过于生僻，这里就不展开继续讲解了。
令人容易混淆的是，我们知道, reduce()是Python的一个內建函数, 需要指出__reduce__并非定义了reduce()的行为，二者没有关系。
__reduce_ex__(self)
__reduce_ex__ 是为了兼容性而存在的, 如果定义了__reduce_ex__, 它将代替__reduce__ 执行。
下面的代码示例很有意思，我们定义了一个类Slate(中文是板岩的意思)。这个类能够记录历史上每次写入给它的值,但每次pickle.dump时当前值就会被清空，仅保留了历史。
# -*- coding: utf-8 -*- import pickle import time classSlate: '''Class to store a string and a changelog, and forget its value when pickled.''' def__init__(self, value): self.value = value self.last_change = time.time() self.history = [] defchange(self, new_value): # 修改value, 将上次的valeu记录在history self.history.append((self.last_change, self.value)) self.value = new_value self.last_change = time.time() defprint_changes(self): print 'Changelog for Slate object:' for k, v in self.history: print '%s %s' % (k, v) def__getstate__(self): # 故意不返回self.value和self.last_change, # 以便每次unpickle时清空当前的状态，仅仅保留history return self.history def__setstate__(self, state): self.history = state self.value, self.last_change = None, None slate = Slate(0) time.sleep(0.5) slate.change(100) time.sleep(0.5) slate.change(200) slate.change(300) slate.print_changes() # 与下面的输出历史对比 with open('slate.pkl', 'wb') as jar: pickle.dump(slate, jar) del slate # delete it with open('slate.pkl', 'rb') as jar: slate = pickle.load(jar) print 'current value:', slate.value # None print slate.print_changes() # 输出历史记录与上面一致
参考地址：
https://www.cnblogs.com/pyxiaomangshe/p/7927540.html
python的常用魔法方法详细总结：https://www.cnblogs.com/zhouyixian/p/11129347.html
浙公网安备 33010602011771号