pickle是一个Python的内置模块，用于在Python中实现对象结构序列化和反序列化。Python序列化是一个将Python对象层次结构转换为可以本地存储或者网络传输的字节流的过程，反序列化则是将字节流还原为将Python对象层次结构。
数据序列化的功能简单理解为把不能直接存储的数据存储到磁盘中，从而延长对象的生命周期。Python的常用序列化库有两个，即json和pickle。json库和pickle库的主要区别有两点：
- pickle可以序列化Python中所有的数据类型，包括类，函数，一般存储为二进制文件。而json只能序列化Python基本的数据类型，转储结果非常容易阅读。
- pickle只能在Python中使用，而json是能够在不同语言之间交换数据的。
pickle一般情况下比json慢，尤其是数据量很大的情况下。pickle和json都有四种基础方法：
| 方法 | 作用 |
|---|---|
| dump | 序列化写入文件 |
| load | 读取文件反序列化 |
| dumps | 序列化返回对象 |
| loads | 反序列化对象 |
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__存储关于self.xxx的一些东西
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秒
2062
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
