楔子
本次来聊一聊序列化和反序列化，像内置的 pickle, json 库都可以将对象序列化和反序列化，这里我们说的是 pickle。
pickle 和 json 不同，json 序列化之后的结果是人类可阅读的，但是能序列化的对象有限，因为序列化的结果可以在不同语言之间传递；而 pickle 序列化之后是二进制格式，只有 Python 才认识，因此它可以序列化 Python 的绝大部分对象。
import pickle
class Girl:
def __init__(self, name, age):
self.name = name
self.age = age
girl = Girl("古明地觉", 16)
# 这便是序列化的结果
dumps_obj = pickle.dumps(girl)
# 显然这是什么东西我们不认识, 但解释器认识
print(dumps_obj[: 20])
"""
b'\x80\x04\x95;\x00\x00\x00\x00\x00\x00\x00\x8c\x08__main_'
"""
# 我们可以再进行反序列化
loads_obj = pickle.loads(dumps_obj)
print(loads_obj.name) # 古明地觉
print(loads_obj.age) # 16这里我们不探究 pickle 的实现原理，我们来说一下如何自定制序列化和反序列化的过程。如果想自定制的话，需要实现 __getstate__ 和 __setstate__ 两个魔法方法：
import pickle
class Girl:
def __init__(self, name, age):
self.name = name
self.age = age
def __getstate__(self):
"""序列化的时候会调用"""
# 对 Girl 的实例对象进行序列化的时候
# 默认会返回其属性字典
# 这里我们多添加一个属性
print("被序列化了")
return {**self.__dict__, "gender": "female"}
def __setstate__(self, state):
"""反序列化时会调用"""
# 对 Girl 的实例对象进行反序列化的时候
# 会将 __getstate__ 返回的字典传递给这里的 state 参数
# 我们再设置到 self 当中
# 如果不设置，那么反序列化之后是无法获取属性的
print("被反序列化了")
self.__dict__.update(**state)
girl = Girl("古明地觉", 16)
dumps_obj = pickle.dumps(girl)
"""
被序列化了
"""
loads_obj = pickle.loads(dumps_obj)
print(loads_obj.name)
print(loads_obj.age)
print(loads_obj.gender)
"""
被反序列化了
古明地觉
16
female
"""虽然反序列化的时候会调用 __setstate__，但实际上会先调用 __reduce__，__reduce__ 必须返回一个字符串或元组。
我们先来看看返回字符串是什么结果。
import pickle
class Girl:
def __init__(self, name, age):
self.name = name
self.age = age
def __reduce__(self):
print("__recude__")
# 当返回字符串时，这里是 "girl"
# 那么在反序列化之后就会返回 eval("girl")
return "girl"
girl = Girl("古明地觉", 16)
dumps_obj = pickle.dumps(girl)
# 反序列化
loads_obj = pickle.loads(dumps_obj)
print(loads_obj.name)
print(loads_obj.age)
"""
__recude__
古明地觉
16
"""如果我们返回一个别的字符串是会报错的，假设返回的是 "xxx"，那么反序列化的时候会提示找不到变量 xxx。那如果我们在外面再定义一个变量 xxx 呢？比如 xxx = 123，这样做也是不可以的，因为 pickle 要求序列化的对象和反序列化得到的对象必须是同一个对象。
因此 __reduce__ 很少会返回一个字符串，更常用的是返回一个元组，并且元组里面的元素个数为 2 到 6 个，每个含义都不同，我们分别举例说明。
返回的元组包含两个元素
当只有两个元素时，第一个元素必须是可调用对象，第二个元素表示可调用对象的参数（必须也是一个元组），相信你已经猜到会返回什么了：
import pickle
class Girl:
def __init__(self, name, age):
self.name = name
self.age = age
def __reduce__(self):
# 反序列化时会返回 range(*(1, 10, 2))
return range, (1, 10, 2)
# 如果是 return int, ("123",)
# 那么反序列化时会返回 int("123")
# 所以此时返回的可以是任意的对象
girl = Girl("古明地觉", 16)
dumps_obj = pickle.dumps(girl)
loads_obj = pickle.loads(dumps_obj)
print(loads_obj) # range(1, 10, 2)
print(list(loads_obj)) # [1, 3, 5, 7, 9]返回的元组包含三个元素
包含三个元素时，那么第三个元素是一个字典，会将该字典设置到返回对象的属性字典中。
import pickle
class A: pass
class Girl:
def __init__(self, name, age):
self.name = name
self.age = age
def __reduce__(self):
# 当然返回 Girl 的实例也是可以的
# 只要保证对象有属性字典即可
return A, (), {"a": 1, "b": 2}
girl = Girl("古明地觉", 16)
dumps_obj = pickle.dumps(girl)
loads_obj = pickle.loads(dumps_obj)
print(loads_obj.__class__)
print(loads_obj.__dict__)
"""
<class '__main__.A'>
{'a': 1, 'b': 2}
"""如果定义了 __reduce__ 的同时还定义了 __setstate__，那么第三个元素就不会设置到返回对象的属性字典中了，而是会作为参数传递到 __setstate__ 中进行调用：
import pickle
class Girl:
def __init__(self, name, age):
self.name = name
self.age = age
def __setstate__(self, state):
# state 就是 __reduce__ 返回的元组里的第三个元素
# 注意这个 self 也是 __reduce__ 的返回对象
print(state)
def __reduce__(self):
# 此时的第三个元素可以任意
return Girl, ("古明地恋", 15), ("ping", "pong")
girl = Girl("古明地觉", 16)
dumps_obj = pickle.dumps(girl)
loads_obj = pickle.loads(dumps_obj)
"""
('ping', 'pong')
"""
print(loads_obj.__dict__)
"""
{'name': '古明地恋', 'age': 15}
"""所以当定义了 __reduce__ 的同时还定义了 __setstate__，那么第三个元素就可以不是字典了。如果没有 __setstate__，那么第三个元素必须是一个字典（或者指定为 None 相当于没指定）。
返回的元组包含四个元素
当包含四个元素时，那么第四个元素必须是一个迭代器，然后返回的对象内部必须有 append 方法。会遍历迭代器的每一个元素，并作为参数传递到 append 中进行调用。
import pickle
class Girl:
def __init__(self, name, age):
self.name = name
self.age = age
self.where = []
def append(self, item):
self.where.append(item)
def __reduce__(self):
"""
从第三个元素开始，如果指定为 None，那么相当于什么也不做
比如这里第三个元素我们指定为 None
那么是不会有 "往属性字典添加属性" 这一步的
即使定义了 __setstate__，该方法也不会调用
但是前两个元素必须指定、且不可以为 None
"""
return Girl, ("雾雨魔理沙", 17), None, \
iter(["雾雨魔理沙", "雾雨魔法店", "魔法森林"])
girl = Girl("古明地觉", 16)
dumps_obj = pickle.dumps(girl)
loads_obj = pickle.loads(dumps_obj)
print(
loads_obj.where
) # ['雾雨魔理沙', '雾雨魔法店', '魔法森林']注意 append 方法里面的 self，这个 self 指的是 __reduce__ 的返回对象。因此这种方式非常适合列表，因为列表本身就有 append 方法。
import pickle
class Girl:
def __init__(self, name, age):
self.name = name
self.age = age
def __reduce__(self):
return list, (), None, \
iter(["雾雨魔理沙", "雾雨魔法店", "魔法森林"])
girl = Girl("古明地觉", 16)
dumps_obj = pickle.dumps(girl)
loads_obj = pickle.loads(dumps_obj)
print(
loads_obj
) # ['雾雨魔理沙', '雾雨魔法店', '魔法森林']所以还是有点神奇的，我们明明是对 Girl 的实例序列化之后的结果进行反序列化，理论上也应该得到 Girl 的实例才对，现在却得到了一个列表，原因就是里面指定了 __reduce__。
并且此时第三个元素就不能指定了，如果指定为字典，那么会加入到返回对象的属性字典中。但我们的返回对象是一个列表，列表没有自己的属性字典，并且它也没有 __setstate__。
返回的元组包含五个元素
当包含五个元素时，那么第五个元素必须也是一个迭代器，并且内部的每个元素都是一个 2-tuple。同时要求返回的对象必须有 __setitem__ 方法，举个栗子：
import pickle
class Girl:
def __init__(self, name, age):
self.name = name
self.age = age
def __reduce__(self):
# 依旧会遍历可迭代对象, 得到的是一个 2-tuple
# 然后传递到 __setitem__ 中
return Girl, ("古明地觉", 16), None, None, \
iter([("name", "雾雨魔理沙"), ("age", "17")])
def __setitem__(self, key, value):
print(f"key = {key!r}, value = {value!r}")
self.__dict__[key] = value
girl = Girl("古明地觉", 16)
dumps_obj = pickle.dumps(girl)
loads_obj = pickle.loads(dumps_obj)
"""
key = 'name', value = '雾雨魔理沙'
key = 'age', value = '17'
"""
# 在 __setitem__ 中我们将 name 和 age 属性给换掉了
print(
loads_obj.__dict__
) # {'name': '雾雨魔理沙', 'age': '17'}返回的元组包含六个元素
当包含六个元素时，那么第六个元素必须是一个可调用对象，但是在测试的时候发现这个可调用对象始终没被调用。
因为 pickle 底层实际上是 C 写的，位于 Modules/_pickle.c 中，所以试着查看了一下，没想到发现了玄机。
我们说在没有定义 __setstate__ 的时候，__reduce__ 返回的元组的第三个元素应该是一个字典（或者 None），会将字典加入到返回对象的属性字典中；但如果定义了，那么就不会加入到返回对象的属性字典中了，而是会作为参数传递给 __setstate__（此时第三个元素就可以不是字典了）。而第六个元素和 __setstate__ 的作用是相同的，举个栗子：
import pickle
class Girl:
def __init__(self, name, age):
self.name = name
self.age = age
def __setstate__(self, state):
print("__setstate__ 被调用了")
def sixth_element(self, ins, val):
print(f"sixth_element 被调用了")
print(ins.__dict__, val)
self.__dict__["name"] = val
def __reduce__(self):
# 我们指定的第六个元素需要是一个可调用对象
# 如果指定了，那么此时 __setstate__ 会无效化
return Girl, ("古明地觉", 16), "古明地恋", \
None, None, self.sixth_element
girl = Girl("古明地觉", 16)
dumps_obj = pickle.dumps(girl)
# 反序列化的时候，会将返回对象和第三个元素作为参数
# 传递给 self.sixth_element 进行调用
loads_obj = pickle.loads(dumps_obj)
"""
sixth_element 被调用了
{'name': '古明地觉', 'age': 16} 古明地恋
"""
# 这里我们将 name 属性的值给换掉了
print(
loads_obj.__dict__
) # {'name': '古明地恋', 'age': 16}我们看到当指定了第六个元素的时候，__setstate__ 就不会被调用了，但是需要注意的是：self.sixth_element 里面的 self 指的是元组的前两个元素组成的返回对象。
假设返回的不是 Girl 实例，而是一个列表，那么就会报错，因为列表没有 sixth_element 方法。当然第六个元素比较特殊，我们也可以不指定为方法，指定为普通的函数也是可以的，只要它是一个接收两个参数的可调用对象即可。
以上就是 __reduce__ 的相关内容，除了 __reduce__ 之外还有一个 __reduce_ex__，用法类似，只不过在调用的时候会传递协议的版本。
关于 pickle 底层的原理其实也是蛮有意思的，这里就不展开了，总之 pickle 不是安全的，它在反序列化的时候不会对数据进行检测。这个特点可以被坏蛋们用来攻击别人，因此建议在反序列化的时候，只对那些受信任的数据进行反序列化。
扩展类实例的序列化和反序列化
最后是扩展类实例的序列化和反序列化，终于到我们的主角了。默认情况下 Cython 编译器也会为扩展类生成 __reduce__ 方法，和动态类一样，扩展类实例在反序列化之后和序列化之前的表现也是一致的，但是仅当所有成员都可以转成 Python 对象并且没有 __cinit__ 方法时才可以序列化。
cdef class Girl:
cdef int *p如果是这样一个扩展类，那么在对它的实例序列化时就会报错：self.p cannot be converted to a Python object for pickling。
如果我们想禁止扩展类的实例被 pickle 的话，可以通过装饰器 @cython.auto_pickle(False) 来实现，此时 Cython 编译器不会再为该扩展类生成 __reduce__ 方法。
cimport cython
@cython.auto_pickle(False)
cdef class Girl1:
cdef readonly str name
cdef int age
def __init__(self):
self.name = "古明地觉"
self.age = 16
cdef class Girl2:
cdef readonly str name
cdef int age
def __init__(self):
self.name = "古明地觉"
self.age = 16文件名为 cython_test.pyx，下面编译测试一下：
import pyximport
pyximport.install(language_level=3)
import pickle
import cython_test
girl1 = cython_test.Girl1()
try:
pickle.dumps(girl1)
except Exception as e:
print(e)
"""
cannot pickle 'cython_test.Girl1' object
"""
girl2 = cython_test.Girl2()
loads_obj = pickle.loads(pickle.dumps(girl2))
print(loads_obj.name) # 古明地觉
try:
loads_obj.age
except AttributeError as e:
print(e)
"""
'cython_test.Girl2' object has no attribute 'age'
"""
# 因为 age 没有对外暴露，所以访问不到
# 因此序列化之前的 girl2 和反序列化之后的 loads_obj 是一致的以上就是自定义序列化和反序列化操作，说实话一般用 __getstate__ 和 __setstate__ 就足够了。
E N D
联系客服
