pickle是一个Python的内置模块，用于在Python中实现对象结构序列化和反序列化。Python序列化是一个将Python对象层次结构转换为可以本地存储或者网络传输的字节流的过程，反序列化则是将字节流还原为将Python对象层次结构。

数据序列化的功能简单理解为把不能直接存储的数据存储到磁盘中，从而延长对象的生命周期。Python的常用序列化库有两个，即json和pickle。json库和pickle库的主要区别有两点：

• pickle可以序列化Python中所有的数据类型，包括类，函数，一般存储为二进制文件。而json只能序列化Python基本的数据类型，转储结果非常容易阅读。
• pickle只能在Python中使用，而json是能够在不同语言之间交换数据的。

pickle一般情况下比json慢，尤其是数据量很大的情况下。pickle和json都有四种基础方法：

1 pickle使用

pickle.dump()函数用于将python结构序列化，并存为二进制文件。 pickle.dump函数接受三个参数，其中第一个参数包含要存储在文件中的对象，第二个参数给出以二进制模式写入所需文件时获得的文件对象。第三个参数表示序列化协议。

对于pickle的协议选取，目前有5种不同的协议可用(出自Python object serialization)。使用的协议越高，读取生成的pickle所需的Python版本越新。这些协议包括：

• 协议版本0是原始的“人类可读”协议，与Python的早期版本向后兼容。
• 协议版本1是一种旧的二进制格式，也与Python的早期版本兼容。
• 协议版本2于Python2.3引入，提供了更为有效的序列化方式。
• 协议版本3于Python3.0引入。它明确支持bytes对象，这也是Python的默认协议，也是需要与其他Python3版本兼容时的推荐协议。
• 协议版本4于Python3.4引入。它增加了对超大对象的支持，对更多类型的对象进行序列化，并对一些数据格式优化。

通过0到4可以设置不同的协议，该协议参数默认为None，None表示使用Python版本使用的默认协议。选择-1表示最高协议。此外可以通过常量设置该协议，分别是：

• pickle.HIGHEST_PROTOCOL：表示最高协议。
• pickle.DEFAULT_PROTOCOL：表示默认协议。

import pickle
print("当前python环境最高序列化协议版本为：{}".format(pickle.HIGHEST_PROTOCOL))
print("当前python环境默认序列化协议版本为：{}".format(pickle.DEFAULT_PROTOCOL))

当前python环境最高序列化协议版本为：4
当前python环境默认序列化协议版本为：3

# 序列化实例
import pickle
import numpy as np

data = {
    "name": "data struct",
    "number": 123.456,
    "tuple": ("first", False, 10.01),
    "numpy_data": np.ones((9,9),np.uint8)
}

# 保存到本地，这个文件名包含后缀可以随意命名，反正是二进制文件
with open('data.bin', 'wb') as f:
    # 设置最底层协议
    pickle.dump(data, f, 0)

# 查看文件大小
!du -h data.bin
print('---分界线---')
# 查看文件前十行，发现有可读文字
!cat data.bin | head -n 5

4.0K	data.bin
---分界线---
(dp0
Vname
p1
Vdata struct
p2

# 保存到本地，这个文件名包含后缀可以随意命名，反正是二进制文件
with open('data.bin', 'wb') as f:
    # 设置最底层协议
    pickle.dump(data, f, 1)

# 查看文件大小
!du -h data.bin
print('---分界线---')
# 查看文件前2行
!cat data.bin | head -n 2

4.0K	data.bin
---分界线---
}q (X   nameqX   data structqX   numberqG@^�/��wX   tupleq(X   firstqI00
G@$�Q�tqX

# 保存到本地，这个文件名包含后缀可以随意命名，反正是二进制文件
with open('data.bin', 'wb') as f:
    # 设置默认协议
    pickle.dump(data, f, pickle.DEFAULT_PROTOCOL)

# 查看文件大小
!du -h data.bin
print('---分界线---')
# 查看文件前2行
!cat data.bin | head -n 2

4.0K	data.bin
---分界线---
�}q (X   nameqX   data structqX   numberqG@^�/��wX   tupleqX   firstq�G@$�Q녇qX
   numpy_dataqcnumpy.core.multiarray

# 保存到本地，这个文件名包含后缀可以随意命名，反正是二进制文件
with open('data.bin', 'wb') as f:
    # 设置默认协议
    pickle.dump(data, f, 4)

# 查看文件大小
!du -h data.bin
print('---分界线---')
# 查看文件前2行
!cat data.bin | head -n 2

4.0K	data.bin
---分界线---
��/      }�(�name��data struct��number�G@^�/��w�tuple��first��G@$�Q녇��
numpy_data��numpy.core.multiarray��_reconstruct����numpy��ndarray���K ��Cb���R�(KK	K	��h�dtype����u1�����R�(K�|�NNNJ����J����K t�b�CQ�t�bu.

如果想反序列化，重新读入文件，直接用pickle.load函数就行了。序列化协议是自动检测的，不需要指定。此外还有两个参数encoding和errors告诉pickle如何反序列低于当前python版本的序列化文件，默认值就行了。

import pickle

with open('data.bin', 'rb') as f:
    data = pickle.load(f)
    print(type(data))
    print(data['name'])
    print(data.keys())

<class 'dict'>
data struct
dict_keys(['name', 'number', 'tuple', 'numpy_data'])

通过dumps函数将对象的序列化表示作为bytes对象返回，而不是将其写入文件。通过loads函数则将bytes对象反序列化。注意bytes是 Python3新增的类型，bytes只负责以二进制形式来存储数据。

data = [1,2,3]

# 序列化，返回bytes对象
dumped = pickle.dumps(data)
print(dumped)
print(type(dumped))
print(len(dumped))

# 反序列化
loaded = pickle.loads(dumped)
print(loaded)

b'\x80\x03]q\x00(K\x01K\x02K\x03e.'
<class 'bytes'>
14
[1, 2, 3]

序列化和反序列化的过程可以通过__getstate__ 和__setstate__函数来影响。其中__getstate__函数在序列化时调用，__setstate__函数在反序列化时调用。

一个实例如下，在序列化时指定序列化某些参数，反序列化时恢复参数。

import pickle

class MyData:

    def __init__(self, x):

        self.x = x
        self.y = self.sqrt(x)

    def sqrt(self,x):
        return x**x

    def __getstate__(self):
        self.state = "ok"
        print("enter getstate")
        #  self.__dict__存储关于的一些东西
        odict = self.__dict__.copy()
        del odict['y']
        print(odict)
        return odict

    def __setstate__(self, input):
        print("enter setstate")
        print(input)
        self.x = input['x']
        self.y = self.sqrt(self.x)

obj = MyData(3)
# 序列化
print("序列化")
dumped = pickle.dumps(obj)
# 反序列化
print("反序列化")
loaded = pickle.loads(dumped)
print("反序列化结果", loaded.y)

序列化
enter getstate
{'x': 3, 'state': 'ok'}
反序列化
enter setstate
{'x': 3, 'state': 'ok'}
反序列化结果 27

2 pickle加速

当要序列化的对象特别大时，pickle加载和保存序列化对象会成为代码的性能瓶颈。一般有三种办法加速pickle序列化过程。主要有：

• 使用更高的协议版本
• 使用cPickle代替pickle
• 禁用垃圾收集器

下面几个例子会给出使用方法，不过加速效果不明显，因为数据量不大，写个代码mark下。

直接使用pickle

import time
import pickle
import numpy as np
import os 
def time_count(func):
    def inner(*args,**kwargs):
        start = time.time()
        func(*args,**kwargs)
        end = time.time()
        print('{}用时:{}秒'.format(func.__name__,end-start))
    return inner

@time_count
def pickle_dump(data,filepath):
    with open(filepath, 'wb') as f:
        pickle.dump(data, f)


@time_count
def pickle_load(filepath):
    with open(filepath, 'rb') as f:
        data = pickle.load(f)
    return data

data = np.ones((10000, 10000))
filepath = "file.dat"
pickle_dump(data,filepath)
pickle_load(filepath)
os.remove(filepath)
time.sleep(2)

pickle_dump用时:1.7647628784179688秒
pickle_load用时:1.7913622856140137秒

使用pickle最高协议

将参数协议指定为-1，即可，但是加速可能效果不明显。具体看数据。

import time
import pickle
import numpy as np
import os

def time_count(func):
    def inner(*args,**kwargs):
        start = time.time()
        func(*args,**kwargs)
        end = time.time()
        print('{}用时:{}秒'.format(func.__name__,end-start))
    return inner

@time_count
def pickle_dump(data,filepath):
    with open(filepath, 'wb') as f:
        # 使用最高版本协议
        pickle.dump(data, f, -1)


@time_count
def pickle_load(filepath):
    with open(filepath, 'rb') as f:
        data = pickle.load(f)
    return data

data = np.ones((10000, 10000))
filepath = "file.dat"
pickle_dump(data,filepath)
pickle_load(filepath)
os.remove(filepath)
time.sleep(2)

pickle_dump用时:1.731525182723999秒
pickle_load用时:1.7664134502410889秒

用cPickle代替pickle

最简单方式是使用cPickle而不是pickle。cPickle与pickle是完全相同的模块，具有相同的功能、相同的参数。唯一区别是cPickle用C语言编写的，这使cPickle速度更快。

import time
# python3 导入cPickle方式
import _pickle as cPickle
import numpy as np
import os

def time_count(func):
    def inner(*args,**kwargs):
        start = time.time()
        func(*args,**kwargs)
        end = time.time()
        print('{}用时:{}秒'.format(func.__name__,end-start))
    return inner

@time_count
def pickle_dump(data,filepath):
    with open(filepath, 'wb') as f:
        # 使用最高版本协议
        cPickle.dump(data, f, -1)


@time_count
def pickle_load(filepath):
    with open(filepath, 'rb') as f:
        data = cPickle.load(f)
    return data

data = np.ones((10000, 10000))
filepath = "file.dat"
pickle_dump(data,filepath)
pickle_load(filepath)
os.remove(filepath)
time.sleep(2)

pickle_dump用时:1.7443737983703613秒
pickle_load用时:1.7894999980926514秒

禁用垃圾回收

垃圾收集器会减慢处理速度，禁用它可以提高性能。

import time
import pickle
import numpy as np
import os
import gc

# 禁用垃圾回收
gc.disable()

def time_count(func):
    def inner(*args,**kwargs):
        start = time.time()
        func(*args,**kwargs)
        end = time.time()
        print('{}用时:{}秒'.format(func.__name__,end-start))
    return inner

@time_count
def pickle_dump(data,filepath):
    with open(filepath, 'wb') as f:
        # 使用最高版本协议
        pickle.dump(data, f, -1)


@time_count
def pickle_load(filepath):
    with open(filepath, 'rb') as f:
        data = pickle.load(f)
    return data

data = np.ones((10000, 10000))
filepath = "file.dat"
pickle_dump(data,filepath)
pickle_load(filepath)
os.remove(filepath)
time.sleep(2)

# 开启垃圾回收
gc.enable()

pickle_dump用时:1.8271889686584473秒
pickle_load用时:1.7800366878509521秒

3 参考

• Python Pickle
• Python pickle
• How to make pickle faster?
• Python object serialization