Python内置的pickle库的对象序列化与反序列化【Python教程】,python,pickle,json,序列化,反序列化

我们近来想要对爬虫拿到的下载效果举行存档，这个效果是一个Python对象（我们并不想简朴的存一个HTML或json，想要让全部下载历程能够复原），因而就想到了用Python内置的pickle库（腌黄瓜库），序列化对象成bytes，须要的时刻能够反序列化。

经由过程下面的代码能够简朴相识pickle的用法和功用。

In [2]: import pickle 
In [3]: class A:
        pass 
In [4]: a = A()
In [5]: a.foo = 'hello'
In [6]: a.bar = 2
In [7]: pick_ed = pickle.dumps(a) 
In [8]: pick_ed
Out[8]: b'\x80\x03c__main__\nA\nq\x00)\x81q\x01}q\x02(X\x03\x00\x00\x00fooq\x03X\x05\x00\x00\x00helloq\x04X\x03\x00\x00\x00barq\x05K\x02ub.'
In [9]: unpick = pickle.loads(pick_ed) 
In [10]: unpick
Out[10]: <__main__.A at 0x10ae67278>
In [11]: a
Out[11]: <__main__.A at 0x10ae67128>
In [12]: dir(unpick)
Out[12]:
['__class__',
'__delattr__',
'__dict__',
'__dir__',
'__doc__',
'__eq__',
'__format__',
'__ge__',
'__getattribute__',
'__gt__',
'__hash__',
'__init__',
'__init_subclass__',
'__le__',
'__lt__',
'__module__',
'__ne__',
'__new__',
'__reduce__',
'__reduce_ex__',
'__repr__',
'__setattr__',
'__sizeof__',
'__slotnames__',
'__str__',
'__subclasshook__',
'__weakref__',
'bar',
'foo']
In [13]: unpick.foo
Out[13]: 'hello'
In [14]: unpick.bar
Out[14]: 2

能够看到pickle的用法和json有点像，然则有几点基础区分：

json是跨言语的通用的一种数据交换花样，平常用文本示意，人类可读。pickle是用来序列化Python对象，只是针对Python的，序列化的效果是二进制数据，人类不可读。而且json默许只能够序列化一部分的内置范例，pickle能够序列化相当多的数据。

别的另有一个陈旧的marshal也是内置的。但这个库主假如针对.pyc文件的。不支撑自定义的范例，也不完善。比方不能处置惩罚轮回运用，假如有一个对象引用了本身，那末用marshal的话Python诠释器就挂了。

版本兼容问题

由于pickle是针对Python的，Python有差别的版本（而且2与3之间差别异常大），所以就要斟酌到序列化出来的对象能不能被更高（或低？）版本的Python反序列化出来。

现在一共有5个pickle的协定版本，版本越高对应Pyhton的版本越高，0-2针对Python2，3-4针对Python3.

Protocol version 0 is the original “human-readable” protocol and is backwards compatible with earlier versions of 
Python.Protocol version 1 is an old binary format which is also compatible with earlier versions of Python.Protocol 
version 2 was introduced in Python 2.3. It provides much more efficient pickling of new-style classes. Refer to 
PEP 307for information about improvements brought by protocol 2. （从这个版本今后，机能有明显进步）Protocol version 3 
was added in Python 3.0. It has explicit support for bytes objects and cannot be unpickled by Python 2.x.This is the 
default protocol, and the recommended protocol when compatibility with other Python 3 versions is required.Protocol 
version 4 was added in Python 3.4. It adds support for very large objects, pickling more kinds of objects, and some 
data format optimizations. Refer to PEP 3154 for information about improvements brought byprotocol 4.

pickle的大多数进口函数（比方dump()，dumps()，Pickler组织器）都接收一个协定版本的参数，个中内置了两个变量：

pickle.HIGHEST_PROTOCOL现在是4

pickle.DEFAULT_PROTOCOL现在是3

用法

和内置的json模块接口相似，dumps()用于返回序列化效果，dump()用于序列化然后写入文件。同理也有load()和loads()。个中，序列化dump(s)的时刻能够指定协定的版本，反序列化的时刻就不用了，会自动识别版本。这个和zip敕令很像。

内置范例的序列化

大多数内置的范例都支撑序列化和反序列化。须要特别注重的是函数。函数的序列化只是取其名字和地点的module。函数的代码和属性（Python的函数是第一等对象，能够有属性）都不会被序列化。这就请求函数地点的模块在unpickle的环境中必需是能够import的，不然会涌现ImportError或AttributeError。

这里有个处所很有意义：一切的lambda函数都是不可Pickle的。由于它们的名字都叫做<lambda>。

自定义范例的序列化

犹如本文开首的试验代码一样，对我们自定义的对象在大部分情况下都不须要分外的操纵就能够完成序列化/反序列化的操纵。须要注重的是，在反序列化的历程当中，并非挪用class的__init__()来初始化出一个对象，而是新建出一个未被初始化的实例，然后恢复它的属性（异常奇妙）。伪代码以下：

def save(obj):
    return (obj.__class__, obj.__dict__) 
def load(cls, attributes):
    obj = cls.__new__(cls)
    obj.__dict__.update(attributes)
    return obj

假如愿望在序列化的历程当中做一些分外操纵，比方保留对象的状况，能够运用pickle协定的把戏要领，最常见的是__setstate__()和__getstate__()。

安全问题(!)

pickle文档的开首就说：万万不要unpickle一个未知泉源的二进制。斟酌下面的代码：

>>> import pickle
>>> pickle.loads(b"cos\nsystem\n(S'echo hello world'\ntR.")
hello world
0

这段代码unpickle出来就是导入了os.system()然后挪用echo。并没有啥副作用。但假如是rm -rf /·呢？

文档给出的发起是在Unpickler.find_class()内里完成搜检逻辑。函数要领在请求全局变量的时刻必定挪用。

import builtins
import io
import pickle
 
safe_builtins = {
    'range',
    'complex',
    'set',
    'frozenset',
    'slice',
}
 
class RestrictedUnpickler(pickle.Unpickler):
 
    def find_class(self, module, name):
        # Only allow safe classes from builtins.
        if module == "builtins" and name in safe_builtins:
            return getattr(builtins, name)
        # Forbid everything else.
        raise pickle.UnpicklingError("global '%s.%s' is forbidden" %
                                     (module, name))
 
def restricted_loads(s):
    """Helper function analogous to pickle.loads()."""
    return RestrictedUnpickler(io.BytesIO(s)).load()

紧缩

pickle以后并不会自动紧缩的，我以为这个设想异常好，解耦，pickle就干pickle的事变，紧缩交给别的库去做。而且你本身也能够发明，pickle以后的文件只管不可读，但内容依旧是以ascii码显现的，并非乱码。须要挪用紧缩库的compress。实测紧缩以后，体积是之前的1/3摆布，异常可观。

总结

全局变量要坚持能够导入的，这个有点难。要面临的问题是：我本日pickle的东西，在未来某一天须要翻开，是不是还能翻开呢？

这里有几个版本：项目的版本、python的版本，pickle协定版本，项目依靠的包版本。个中python的版本和pickle版本我以为能够宁神依靠他们的向后兼容，轻易处理。主假如项目和版本和依靠的版本，假如要Pickle的对象异常复杂，那末极能够老版本的备份没法兼容新版本。能够的处理办法就是对一切的依靠完整锁定，比方纪录他们的hash值。假如要恢复某一个二进制序列，那末就复原出当时的特定依靠、项目的特定commit。

然则现在来讲，我们的需求基本上就是pickle一个requests.Response对象。我以为是能够依靠它们的向后兼容的。假如有一天requests有了breaking change，那末就算我们的pickle能兼容，代码也不能够兼容了，那时刻能够斟酌别的战略。

以上就是Python内置的pickle库的对象序列化与反序列化的细致内容，更多请关注ki4网别的相干文章！