Python的序列化与反序列化_序列化和反序列化 python

序列化和反序列化可以大致分为两类：文本序列化和二进制序列化。比如python提供的pickle库，他就是基于二进制方式的序列化。而json则是文本方式的序列化，需要遵守相应的文件格式。

由于pickle序列化和发序列化仅仅同版本的Python可以使用(pickle库的序列化在python2，python3也存在不兼容的问题)。因此我们还会学习MessagePack，它是一个基于二进制高效的对象序列化类库，可用于跨语言通信。

一.序列化概述

1.为什么要序列化

内存中的字典，列表，集合以及各种对象，如何保存到一个文件中？

如果是自己定义的类的实例，如何保存到一个文件中？

如何从文件中读取数据，并让他在内存中再次恢复成自己对应的类的实例？

要设计一套协议，按照某种规则，把内存这种数据保存到文件中。文件是一个字节序列，所以必须把数据转换成字节序列，输出到文件。这就是序列化。

反之，从文件的字节序列恢复到内存并且还要原来的类型，就是反序列化。

2. 序列化相关术语

serialization
将内存中对象存储下来，把它变成一个个字节。

deserialization
将文件的一个个字节恢复成内存中对象。
1
2
3
4
5

序列化保存到文件就是持久化。

可以将数据序列化后持久化，或者网络传输；也可以将从文件中或者网络接受到的字节序列反序列化。Python提供了pickle库，它是一种基于二进制方式的序列化。

3.序列化应用

一般来说，本地序列化的情况，应用较少。大多数场景都应用在网络传输中。

将数据序列化后通过网络传输到远程节点，远程服务器上的服务将接收的数据反序列化后，就可以使用了。

但是，要注意一点，远程接收端，反序列化时必须有对应的数据类型，否则就会报错。尤其是自定义类，必须远程得有一致的定义。

现在，大多数项目，都不是单机的，也不是单服务的，需要多个程序之间配合。需要通过网络将数据传送到其它节点上去，这就需要大量的序列化，反序列化过程。

但是，问题是Python程序之间可以使用pickle解决序列化，反序列化，，如果是跨平台，跨语言，跨协议pickle就不太适合了，就需要公共的协议。例如XML，JSON，PROTOCOL BUFFER等。

不同的协议，效率不同，学习曲线不同，适用不同场景，要根据不同的情况分析选型。

二.pikcle模块

1.方法说明

dumps：
　　对象序列化为bytes对象，一般用于处理网络传输的数据。

dump：
　　对象序列化到文件对象，比如存入本地文件。

loads：
　　从bytes对象反序列化，一般用于处理网络接受的数据。

load：
　　对象发序列化，从文件读取数据。
1
2
3
4
5
6
7
8
9
10
11

2.序列化和反序列化基础数据类型

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：579817333 
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
#！/usr/bin/env python
#_*_conding:utf-8_*_
import pickle

file_name = r"E:\temp\test\ser.txt"

s1 = 99
s2 = 'c'
s3 = list("123")
s4 = {"a":1,"b":"abc","c":[1,2,3]}

#序列化
with open(file_name,"wb") as f:
    pickle.dump(s1,f)
    pickle.dump(s2,f)
    pickle.dump(s3,f)
    pickle.dump(s4,f)

#反序列化
with open(file_name,"rb") as f:
    print(f.read(),f.seek(0))
    for i in range(4):
        x = pickle.load(f)
        print(x,type(x))

#以上代码执行结果如下:
b'\x80\x03Kc.\x80\x03X\x01\x00\x00\x00cq\x00.\x80\x03]q\x00(X\x01\x00\x00\x001q\x01X\x01\x00\x00\x002q\x02X\x01\x00\x00\x003q\x03e.\x80\x03}q\x00(X\x01\x00\x00\x00aq\x01K\x01X\x01\x00\x00\x00bq\x02X\x03\x00\x00\x00abcq\x03X\x01\x00\x00\x00cq\x04]q\x05(K\x01K\x02K\x03eu.' 0
99 <class 'int'>
c <class 'str'>
['1', '2', '3'] <class 'list'>
{'a': 1, 'b': 'abc', 'c': [1, 2, 3]} <class 'dict'>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

3.序列化和反序列化对象

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：579817333 
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
#！/usr/bin/env python
#_*_conding:utf-8_*_
import pickle

file_name = r"E:\temp\test\ser.txt"

#定义对象
class Person:
    def __init__(self,name,age=18):
        self.__name = name
        self.__age = age

    @property
    def name(self):
        return self.__name

    @name.setter
    def name(self,name):
        self.__name = name

    def getage(self):
        return self.__age

    def setage(self,age):
        self.__age = age

    age = property(fget=getage,fset=setage,doc="age property")

    def __repr__(self):
        return "{} 今年已经 {} 岁啦!".format(self.__name,self.__age)

p1 = Person("Yinzhengjie",20)

p1.age = 27

#序列化
ser = pickle.dumps(p1)
print("ser = {}".format(ser))

#反序列化
p2 = pickle.loads(ser)
print(type(p2))
print(p2)

#以上代码执行结果如下:
ser = b'\x80\x03c__main__\nPerson\nq\x00)\x81q\x01}q\x02(X\r\x00\x00\x00_Person__nameq\x03X\x0b\x00\x00\x00Yinzhengjieq\x04X\x0c\x00\x00\x00_Person__ageq\x05K\x1bub.'
<class '__main__.Person'>
Yinzhengjie 今年已经 27 岁啦!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

三.json模块

1.Json概述
JSON（JavaScript Object Notation,JS对象标记）是一种轻量级的数据交换格式。它基于ECMAScript（w3c组织制定的JS规范）的一个子集，采用完全独立与编程语言的文本格式来存储和表示数据。

一般来说，json编码的数据很少落地，数据都是通过网络传输，传输的时候，需考虑压缩它。本质上来说它就是个文本，就是个字符串。

json很简单，几乎所有编程都支持Json，所以应用范围十分广泛。

官方网址请参考：http://json.org/。

2.Json数据类型

值：
　　双引号引起来的字符串，数值，true和false，null，对象，数组，这些都是值。

字符串：
　　由双引号包围起来的任意字符的组合，可以有转义字符。

数值：
　　有正负，有整数，浮点数。

对象：
　　无序的键值对的集合。
　　格式：{key1:value1,…keyn:valulen}
　　key必须是一个字符串，需要双引号包围这个字符串。
　　value可以是任意合法的值。

数组：
　　有序的值和集合。
　　格式：[val1,…valn]

案例如下：

{
　　"person":[
　　　　{
　　　　　　"name":"jason",
　　　　　　"age":18
　　　　}，
　　　　{
　　　　　　"name":"yinzhengjie"
　　　　　　"age":16
　　　　}
　　],
　　"total":2
}
1
2
3
4
5
6
7
8
9
10
11
12
13

3.Python与Json

Python支持少量内建数据类型到Json类型的转换，大致如下：

4.json模块应用案例

#！/usr/bin/env python
#_*_conding:utf-8_*_

import json

src = {'name':'Jason','age':20,'interest':('music','movie'),'class':['python']}

json_ser = json.dumps(src)              #进行json编码
print(json_ser,type(json_ser))          #注意引号，括号的变化，数据类型的变化。

dest = json.loads(json_ser)
print(dest)
print(id(src),id(dest))

#以上代码执行结果如下:
{"name": "Jason", "age": 20, "interest": ["music", "movie"], "class": ["python"]} <class 'str'>
{'name': 'Jason', 'age': 20, 'interest': ['music', 'movie'], 'class': ['python']}
2114747181640 2114747436952
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

三.MessagePack模块

1.MessagePack概述

MessagePack是一个基于二进制高效的对象序列化类库，可用于跨语言通信。

它可以像JSON那样，在许多种语言之间交换结构对象。

但是它比JSON更快速也更轻巧。

支持Python，Ruby，Java，C/C++等众多语言。宣称比Google Protocol Buffers还要快4倍（这话建议大家听听就好，要以实际测试为准）。
　　
兼容json和pickle。

2.MessagePack安装

messagePack官网地址：https://msgpack.org/

安装messagePack方式：
　　　　C:\Users\yinzhengjie>pip install msgpack
　　　　Collecting msgpack
  　　　　Downloading https://files.pythonhosted.org/packages/41/0a/49b522c5b23006d60669ec8dc97558e91880673e170108e0e9e21fc452e3/msgpack-0.6.2-cp37-cp37m-win_amd64.whl (68kB)
　　　　    100% |████████████████████████████████| 71kB 112kB/s
　　　　Installing collected packages: msgpack
　　　　Successfully installed msgpack-0.6.2

　　　　C:\Users\yinzhengjie>
1
2
3
4
5
6
7
8
9
10
11

3 . 常用方法

packb序列化对象。提供了dumps来兼容pickle和json。
unpackb反序列化对象。提供了loads来兼容。

pack序列化对象保存到文件对象。提供了dump来兼容。
unpack反序列化对象保存到文件对象。提供红了load来兼容。

上面的内容了解一下即可，咱们生产环境中还是只用dump(s)和load(s)方法来进行序列化和反序列化，没有必要记得太多，反而浪费脑细胞~嘿嘿嘿。

4.对比pickle，json和messagePack的序列化字节大小

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：579817333 
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
#！/usr/bin/env python
#_*_conding:utf-8_*_

import pickle
import json
import msgpack

#导入模块，都是标识符
methods = (pickle,json,msgpack)

src = {'person':[
                    {'name':'Jason','age':18,'hobby':('movie','music','Mountain climbing')},
                    {'name':'YinZhengjie','age':20,'hobby':('Basketball','ping-pong','Blogging')}
                ],
        'total':2
       }

#进行序列化操作
for method in methods:
    s1 = method.dumps(src)
    if method == json:          #我们这里仅对json格式文件做一个简单的压缩处理，但生产环境建议不要这样用，因为这样写逻辑并不严谨。
        s1 = s1.replace(' ','')
    print(method.__name__,type(s1),len(s1),s1)


print("*" * 20 + "我是分割线" + "*" * 20)

#进行反序列话操作
# s2 = msgpack.loads(s1,encoding="utf8")        #这个方法不推荐使用，使用后会抛出"DeprecationWarning: encoding is deprecated, Use raw=False instead."的警告信息哟~
# print(type(s2),s2)
s3 = msgpack.loads(s1,raw=False)                #官方推荐使用"raw=False"的方式
print(type(s3),s3)

#以上代码执行结果如下:
pickle <class 'bytes'> 225 b'\x80\x03}q\x00(X\x06\x00\x00\x00personq\x01]q\x02(}q\x03(X\x04\x00\x00\x00nameq\x04X\x05\x00\x00\x00Jasonq\x05X\x03\x00\x00\x00ageq\x06K\x12X\x05\x00\x00\x00hobbyq\x07X\x05\x00\x00\x00movieq\x08X\x05\x00\x00\x00musicq\tX\x11\x00\x00\x00Mountain climbingq\n\x87q\x0bu}q\x0c(h\x04X\x0b\x00\x00\x00YinZhengjieq\rh\x06K\x14h\x07X\n\x00\x00\x00Basketballq\x0eX\t\x00\x00\x00ping-pongq\x0fX\x08\x00\x00\x00Bloggingq\x10\x87q\x11ueX\x05\x00\x00\x00totalq\x12K\x02u.'
json <class 'str'> 171 {"person":[{"name":"Jason","age":18,"hobby":["movie","music","Mountainclimbing"]},{"name":"YinZhengjie","age":20,"hobby":["Basketball","ping-pong","Blogging"]}],"total":2}
msgpack <class 'bytes'> 130 b'\x82\xa6person\x92\x83\xa4name\xa5Jason\xa3age\x12\xa5hobby\x93\xa5movie\xa5music\xb1Mountain climbing\x83\xa4name\xabYinZhengjie\xa3age\x14\xa5hobby\x93\xaaBasketball\xa9ping-pong\xa8Blogging\xa5total\x02'
********************我是分割线********************
<class 'dict'> {'person': [{'name': 'Jason', 'age': 18, 'hobby': ['movie', 'music', 'Mountain climbing']}, {'name': 'YinZhengjie', 'age': 20, 'hobby': ['Basketball', 'ping-pong', 'Blogging']}], 'total': 2}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

5.总结

MessagePack简单易用，高效压缩，支持语言丰富。所以，用它序列化也是一种很好的选择。Python很大大名鼎鼎的库都是用了msgpack。

上例中，之所以pickle比json序列化的结果还要大，原因主要是pickle要解决所有python数据类型的序列化，要记录各种数据类型包括自定义的类。而json只需要支持少数几种类型，所以就可以很简单，都不需要类型的描述字符。但大多数情况下，我们序列化的数据都是这些简单的类型。