Python序列化和反序列化

Python中在对象持久化或者跨进程同步对象的时候不可避免的需要时候借助于序列化和反序列化。pickle是在该过程中十分常用的技术。借助pickle我们可以很方便的将一个对象序列化传输，再由接收端还原成所需要的对象。比如：

import pickle
import datetime
# 先实例化一个dt对象，为当前时间。
dt = datetime.datetime.now()
print('dt(%s): %s' % (object.__repr__(dt), dt))
'''
dt(<datetime.datetime object at 0x03AFBB90>): 2018-06-07 14:21:57.093318
'''
# 将dt对象序列化，成为一个bytes实例。
pickle_string = pickle.dumps(dt)
print('pickle_string:%s' % pickle_string)
'''
pickle_string:b'\x80\x03cdatetime\ndatetime\nq\x00C\n\x07\xe2\x06\x07\x0e\x159\x
01l\x86q\x01\x85q\x02Rq\x03.'
'''
# 将pickle_string反序列化成实例dt2
dt2 = pickle.loads(pickle_string)
# 两个不同的对象，但是内容一样
print('dt2(%s): %s' % (object.__repr__(dt2), dt2))
'''
dt2(<datetime.datetime object at 0x03AFBA70>): 2018-06-07 14:21:57.093318
'''

pickle在序列化和反序列化中所作的可以等效为以下代码：

def save(obj):
    # 序列化时将对象的类，对象的obj.__dict__内容记录下来
    return (obj.__class__, obj.__dict__)

def load(cls, attributes):
    # 反序列化时，使用类的cls.__new__方法返回实例，而非使用cls.__init__做进一步初始化
    # 再将保存的对象属性直接还原到新建对象上
    obj = cls.__new__(cls)
    obj.__dict__.update(attributes)
    return obj

这个可能导致以下问题：

• 类型获取不到时无法反序列化
• 类属性在跨进程时无法同步
• 不可序列化的对象

具体对应的现实问题如下：

• 类型获取不到时无法反序列化：

import pickle     
class Example(object):pass

objA = Example()
# objA序列化保存成文件
with open('objA.pickle', 'wb') as pickle_file:
    pickle.dump(objA, pickle_file)

# 读取dt.pickle文件内容，并将objA反序列化回对象并存入objB对象中
with open('objA.pickle', 'rb') as pickle_file:
    objB = pickle.load(pickle_file)
print('%s: %s' % (object.__repr__(objA), objA))
print('%s: %s' % (object.__repr__(objB), objB))
'''
<__main__.Example object at 0x05D79410>: <__main__.Example object at 0x05D79410>
<__main__.Example object at 0x05D79630>: <__main__.Example object at 0x05D79630>
'''

# 删除 class Example定义，objC反序列化失败
del Example
with open('objA.pickle', 'rb') as pickle_file:
    objC = pickle.load(pickle_file)
'''
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-32-cf2baa9bcff6> in <module>()
     16 del Example
     17 with open('objA.pickle', 'rb') as pickle_file:
---> 18     objC = pickle.load(pickle_file)
     19

AttributeError: Can't get attribute 'Example' on <module '__main__'>
'''

• 类属性在跨进程时无法同步：

Example类:

# example.py Example类，类方法set_value更改类属性value
class Example(object):

    value = 0

    @classmethod
    def set_value(cls, value):
        cls.value = value

进程A:

# A.py A进程 间隔1秒将example的类属性value改为i，pickle序列化保存成文件并打印value值
from multiprocessing import Process
import time
import pickle
from example import Example


class A(Process):

    def __init__(self, queue):
        super(A, self).__init__()
        self.queue = queue

    def run(self):
        example = Example()
        # 间隔0.5秒将example的类属性value改为i，pickle序列化放入队列并打印value值
        for i in range(10):
            example.set_value(i)
            self.queue.put(pickle.dumps(example))
            print('Process A: %s' % example.value)
            time.sleep(0.5)

进程B:

# B.py B进程 间隔1秒将example对象用pickle反序列化从文件取出并打印value值
from multiprocessing import Process
import pickle


class B(Process):

    def __init__(self, queue):
        super(B, self).__init__()
        self.queue = queue

    def run(self):
        # 间隔1秒将example对象用pickle反序列化从队列取出并打印value值
        for i in range(10):
            example = pickle.loads(self.queue.get())
            print('Process B: %s' % example.value)

主进程:

# run.py 主进程
from A import A
from B import B
# freeze_support用于Window平台执行，Linux平台可省略
from multiprocessing import Queue, freeze_support

if __name__ == '__main__':
    # freeze_support用于Window平台执行，Linux平台可省略
    freeze_support()
    queue = Queue()
    a = A(queue)
    b = B(queue)
    a.start()
    b.start()
    a.join()
    b.join()
# 虽然每次A进程都对example对象所获取的value值进行更改
# 由于value属性时Example类型的属性所以不会被序列化
'''
Process A: 0
Process B: 0
Process A: 1
Process B: 0
Process A: 2
Process B: 0
Process A: 3
Process B: 0
Process A: 4
Process B: 0
Process A: 5
Process B: 0
Process A: 6
Process B: 0
Process A: 7
Process B: 0
Process A: 8
Process B: 0
Process A: 9
Process B: 0
'''

• 不可序列化的对象

比如，Boost.Python在未实现__getinitargs__, __getstate__, __setstate__前，进行pickle序列化时，会抛出如下错误。

RuntimeError: Pickling of "fly.simtradding.NetEngine.ConnectorManager" instances 
is not enabled (http://www.boost.org/libs/python/doc/v2/pickle.html)

用户可以通过撰写相应的方法实现对序列化反序列化过程的自定义。

object.__getstate__()

用于反序列化状态值的获取，返回只用于还原状态。该方法在缺省状态默认返回self.__dict__

object.__setstate__(state)

用于将序列化的状态值还原到对象上。该方法在缺省状态时，state必须是一个字典，这个字典会被加入self.__dict__属性中。

应用如下:

import pickle


class Example(object):

    value = None

    def __init__(self):
        self.version = 0
        value = 0

    def __getstate__(self):
        return self.version

    def __setstate__(self, state):
        self.version = state + 1

    def __repr__(self):
        return "<Example> version:{version}, value:{value}".format(version=self.version,
                                                                   value=self.value)


if __name__ == '__main__':
    e1 = Example()
    e1.value = 1
    print('e1: %s' % e1)
    # e1的version为0，value为1
    '''
    e1: <Example> version:0, value:1
    '''
    pickle_bit = pickle.dumps(e1)
    print('pickle_bit:%s' % pickle_bit)
    # pickle序列化的时候调用__getstate__，只针对version信息做了序列化
    '''
    pickle_bit:b'\x80\x03c__main__\nExample\nq\x00)\x81q\x01K\x00b.'
    '''
    e2 = pickle.loads(pickle_bit)
    print('e2: %s' % e2)
    # pickle反序列化时将version加1并赋值，
    # 但并没有调用__init__所以value值取用类的属性值，即None。
    '''
    e2: <Example> version:1, value:None
    '''

object.__getnewargs__()

要求返回值是元组，作为当反序列化对象时，调用类型的__new__方法时传入的参数。该方法只支持位置参数。

object.__getnewargs_ex__()

要求返回值是两项的元组，当反序列化对象时，调用类型的__new__方法时传入的参数。元组的第一个是位置参数组成的元组。元组的第而个是键值参数组成的字典。该方法被定义之后object.__getnewargs__()方法就会被忽略。

object.__reduce__()

object.__reduce__不接收参数，返回一个字符串或者2~5个值组成的元组。

返回一个字符串:

反序列化时，会根据字符串在命名空间中去获取字符串所对应的对象。一般用于单例。

import pickle


class Example(object):

    _instance = None

    def __new__(cls):
        if not cls._instance:
            cls._instance = super().__new__(cls)
        return cls._instance

    def __reduce__(self):
        return 'Example._instance'


if __name__ == '__main__':
    e1 = Example()
    print('e1: %s' % e1)
    '''
    e1: <__main__.Example object at 0x022463F0>
    '''
    pickle_bit = pickle.dumps(e1)
    e2 = pickle.loads(pickle_bit)
    print('e2: %s' % e2)
    '''
    e2: <__main__.Example object at 0x022463F0>
    '''
    # e2在反序列化时直接引导向了Example._instance，所以实质上e1、e2是同一个对象

返回2~5个值组成的元组:

• 一个可被调用的对象(函数，类等)，用于生成初始化对象。
• 一个元组作为可被调用的对象的参数，如果可被调用对象不需要参数也需要传一个空元祖。
• state参数，等效object.__getstate__()返回值，作为object.__setstate__(state)参数被调用。该方法在缺省状态时，state必须是一个字典，这个字典会被加入self.__dict__属性中。
• 一个可迭代的对象，这个参数要求反序列化的对象实现object.append(item)和object.extend(items)方法。该可迭代的对象中的内容会作为append或者extend方法的参数被执行。具体使用append还是extend是根据协议版本决定的，原则上两个方法都必须实现。
• 一个键值对内容的可迭代对象。该参数要求反序列化的对象有实现object.__setitem__(key, value)。可迭代的对象中的内容会以obj[key] = value的方式放入被反序列化的对象中。

object.__reduce_ex__(protocol)

功能与object.__reduce__()一致，protocol为协议的版本。