Python数据序列化：①对象序列化 pickle【pickle.dump()、pickle.load()】、②文本序列化 json【json.dump()、json.load()】、③shelve

旧城等待， 2023-10-02 10:45 2阅读 0赞

## 一、pickle模块详解 ##

python的pickle模块实现了基本的数据序列和反序列化。通过pickle模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储；通过pickle模块的反序列化操作，我们能够从文件中创建上一次程序保存的对象。

pickle模块实现了用于序列化和反序列化Python对象结构的二进制协议。

pickle提供了一个简单的持久化功能。可以将对象以文件的形式存放在磁盘上。

pickle模块只能在python中使用，python中几乎所有的数据类型（列表，字典，集合，类等）都可以用pickle来序列化，

“Pickling”是将Python对象层次结构转换为字节流的过程， “unpickling”是反向操作，从而将字节流（来自二进制文件或类似字节的对象）转换回对象层次结构。pickle模块对于错误或恶意构造的数据是不安全的。

pickle协议和JSON（JavaScript Object Notation）的区别 ：

1.  JSON是一种文本序列化格式（它输出unicode文本，虽然大部分时间它被编码utf-8），而pickle是二进制序列化格式;
2.  JSON是人类可读的，而pickle则不是;
3.  JSON是可互操作的，并且在Python生态系统之外广泛使用，而pickle是特定于Python的;

默认情况下，JSON只能表示Python内置类型的子集，而不能表示自定义类; pickle可以表示极其庞大的Python类型（其中许多是自动的，通过巧妙地使用Python的内省工具;复杂的案例可以通过实现特定的对象API来解决）。

pickle 数据格式是特定于Python的。它的优点是没有外部标准强加的限制，例如JSON或XDR（不能代表指针共享）; 但是这意味着非Python程序可能无法重建pickled Python对象。

默认情况下，pickle数据格式使用相对紧凑的二进制表示。如果您需要最佳尺寸特征，则可以有效地压缩数据。

## 二、pickle模块接口 ##

要序列化对象层次结构，只需调用该dumps()函数即可。同样，要对数据流进行反序列化，请调用该loads()函数。但是，如果您想要更多地控制序列化和反序列化，则可以分别创建一个Pickler或一个Unpickler对象。

### 1、pickle模块提供以下常量 ###

pickle.HIGHEST\_PROTOCOL  
整数， 可用的最高协议版本。这个值可以作为一个被传递协议的价值函数 dump()和dumps()以及该Pickler 构造函数。

pickle.DEFAULT\_PROTOCOL  
整数，用于编码的默认协议版本。可能不到HIGHEST\_PROTOCOL。目前，默认协议是3，这是为Python 3设计的新协议。

### 2、pickle模块提供以下功能，使酸洗过程更加方便 ###

#### 2.1 pickle.dump(obj, file, protocol=None, \*, fix\_imports=True, buffer\_callback=None) ####

pickle.dump(obj, file, [,protocol])

注解：将对象obj保存到文件file中去。  
　　　protocol为序列化使用的协议版本，0：ASCII协议，所序列化的对象使用可打印的ASCII码表示；  
　　　1：老式的二进制协议；2：2.3版本引入的新二进制协议，较以前的更高效。其中协议0和1兼容老版本的python。protocol默认值为0。  
　　　file：对象保存到的类文件对象。file必须有write()接口， file可以是一个以’w’方式打开的文件或者一个StringIO对象或者其他任何实现write()接口的对象。如果protocol>=1，文件对象需要是二进制模式打开的。

#使用pickle模块将数据对象保存到文件
    
    import pickle
    
    data1 = {
        'a': [1, 2.0, 3, 4+6j],
             'b': ('string', u'Unicode string'),
             'c': None}
    
    selfref_list = [1, 2, 3]
    selfref_list.append(selfref_list)
    
    output = open('data.pkl', 'wb')
    
    # Pickle dictionary using protocol 0.
    pickle.dump(data1, output)
    
    # Pickle the list using the highest protocol available.
    pickle.dump(selfref_list, output, -1)
    
    output.close()

将obj对象的编码pickle编码表示写入到文件对象中，相当于Pickler(file,protocol).dump(obj)

可供选择的协议参数是一个整数，指定pickler使用的协议版本，支持的协议是0到HIGHEST\_PROTOCOL。如果未指定，则默认为DEFAULT\_PROTOCOL。如果指定为负数，则选择HIGHEST\_PROTOCOL。

文件参数必须具有接受单个字节的参数写方法。因此，它可以是为二进制写入打开的磁盘文件， io.BytesIO实例或满足此接口的任何其他自定义对象。

如果fix\_imports为true且protocol小于3，则pickle将尝试将新的Python 3名称映射到Python 2中使用的旧模块名称，以便使用Python 2可读取pickle数据流。

#### 2.2 pickle.dumps(obj, protocol=None, \*, fix\_imports=True, buffer\_callback=None) ####

序列化对象，并将结果数据流写入到文件对象中。参数protocol是序列化模式，默认值为0，表示以文本的形式序列化。protocol的值还可以是1或2，表示以二进制的形式序列化。

将对象的pickled表示作为bytes对象返回，而不是将其写入文件。

参数protocol和fix\_imports具有与in中相同的含义 dump()。

#### 2.3 pickle.load(file, \*, fix\_imports=True, encoding=“ASCII”, errors=“strict”, buffers=None) ####

pickle.load(file)

注解：从file中读取一个字符串，并将它重构为原来的python对象。  
　　 file:类文件对象，有read()和readline()接口。

反序列化对象。将文件中的数据解析为一个Python对象。

#使用pickle模块从文件中重构python对象
    
    import pprint, pickle
    
    pkl_file = open('data.pkl', 'rb')
    
    data1 = pickle.load(pkl_file)
    pprint.pprint(data1)
    
    data2 = pickle.load(pkl_file)
    pprint.pprint(data2)
    
    pkl_file.close()

其中要注意的是，在load(file)的时候，要让python能够找到类的定义，否则会报错：

import pickle
    class Person:
        def __init__(self,n,a):
            self.name=n
            self.age=a
        def show(self):
            print self.name+"_"+str(self.age)
    aa = Person("JGood", 2)
    aa.show()
    f=open('d:\\p.txt','w')
    pickle.dump(aa,f,0)
    f.close()
    #del Person
    f=open('d:\\p.txt','r')
    bb=pickle.load(f)
    f.close()
    bb.show()

如果不注释掉del Person的话，那么会报错如下，意思就是当前模块找不到类的定义了。  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_18_color_FFFFFF_t_70_g_se_x_16]

从打开的文件对象 文件中读取pickle对象表示，并返回其中指定的重构对象层次结构。这相当于Unpickler(file).load()。

pickle的协议版本是自动检测的，因此不需要协议参数。超过pickle对象的表示的字节将被忽略。

参数文件必须有两个方法，一个采用整数参数的read()方法和一个不需要参数的readline()方法。两种方法都应返回字节。因此，文件可以是为二进制读取而打开的磁盘文件，io.BytesIO对象或满足此接口的任何其他自定义对象。

可选的关键字参数是fix\_imports，encoding和errors，用于控制Python 2生成的pickle流的兼容性支持。如果fix\_imports为true，则pickle将尝试将旧的Python 2名称映射到Python 3中使用的新名称。编码和 错误告诉pickle如何解码Python 2编码的8位字符串实例; 这些默认分别为’ASCII’和’strict’。该编码可以是“字节”作为字节对象读取这些8位串的实例。使用encoding='latin1’所需的取储存NumPy的阵列和实例datetime，date并且time被Python 2解码。

#### 2.4 pickle.loads(data, /, \*, fix\_imports=True, encoding=“ASCII”, errors=“strict”, buffers=None) ####

从bytes对象读取pickle对象层次结构并返回其中指定的重构对象层次结构。

pickle的协议版本是自动检测的，因此不需要协议参数。超过pickle对象的表示的字节将被忽略。

import numpy as np
    import pickle
    import io
    
    if __name__ == '__main__':
        path = 'test'
        f = open(path, 'wb')
        data = {
        'a':123, 'b':'ads', 'c':[[1,2],[3,4]]}
        pickle.dump(data, f)
        f.close()
    
        f1 = open(path, 'rb')
        data1 = pickle.load(f1)
        print(data1)

![在这里插入图片描述][d2dce863c0ac43d197c446b35b322dd8.png]  
对于python格式的数据集，我们就可以使用pickle进行加载了，下面与cifar10数据集为例，进行读取和加载：

import numpy as np
    import pickle
    import random
    import matplotlib.pyplot as plt
    from PIL import Image
    
    path1 = 'D:\\tmp\cifar10_data\cifar-10-batches-py\data_batch_1'
    path2 = 'D:\\tmp\cifar10_data\cifar-10-batches-py\data_batch_2'
    path3 = 'D:\\tmp\cifar10_data\cifar-10-batches-py\data_batch_3'
    path4 = 'D:\\tmp\cifar10_data\cifar-10-batches-py\data_batch_4'
    path5 = 'D:\\tmp\cifar10_data\cifar-10-batches-py\data_batch_5'
    
    path6 = 'D:\\tmp\cifar10_data\cifar-10-batches-py\\test_batch'
    
    if __name__ == '__main__':
        with open(path1, 'rb') as fo:
            data = pickle.load(fo, encoding='bytes')
    
            # print(data[b'batch_label'])
            # print(data[b'labels'])
            # print(data[b'data'])
            # print(data[b'filenames'])
    
            print(data[b'data'].shape)
    
            images_batch = np.array(data[b'data'])
            images = images_batch.reshape([-1, 3, 32, 32])
            print(images.shape)
            imgs = images[5, :, :, :].reshape([3, 32, 32])
            img = np.stack((imgs[0, :, :], imgs[1, :, :], imgs[2, :, :]), 2)
    
            print(img.shape)
    
            plt.imshow(img)
            plt.axis('off')
            plt.show()

运行结果：  
![在这里插入图片描述][893c67a2071c4d7e82dcc5caf986282f.png]  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_18_color_FFFFFF_t_70_g_se_x_16 1]  
接下来就可以读取数据进行训练了。

--------------------

参考资料：  
[Python之数据序列化（json、pickle、shelve）][Python_json_pickle_shelve]  
[pickle — Python 对象序列化][pickle _ Python]  
[python——pickle模块的详解][python_pickle]  
[Python pickle模块学习][Python pickle]  
[Python pickle模块学习（超级详细）][Python pickle 1]

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_18_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/89331c4cc1ac4c57ad9504cce2e986c5.jpg?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO,size_18,color_FFFFFF,t_70,g_se,x_16
[d2dce863c0ac43d197c446b35b322dd8.png]: https://img-blog.csdnimg.cn/d2dce863c0ac43d197c446b35b322dd8.png
[893c67a2071c4d7e82dcc5caf986282f.png]: https://img-blog.csdnimg.cn/893c67a2071c4d7e82dcc5caf986282f.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO_size_18_color_FFFFFF_t_70_g_se_x_16 1]: https://img-blog.csdnimg.cn/ea851c3bf4ff4896b86b0bddd62327fc.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5b-N6ICF44Gu5Lmx5aSq6YOO,size_18,color_FFFFFF,t_70,g_se,x_16
[Python_json_pickle_shelve]: https://www.cnblogs.com/yyds/p/6563608.html
[pickle _ Python]: https://docs.python.org/zh-cn/3/library/pickle.html
[python_pickle]: https://www.cnblogs.com/baby-lily/p/10990026.html
[Python pickle]: https://blog.csdn.net/imzoer/article/details/8637473#
[Python pickle 1]: https://blog.csdn.net/chunmi6974/article/details/78392230