Python开发之序列化与反序列化：pickle、json模块使用详解

1 引言

　　在日常开发中，所有的对象都是存储在内存当中，尤其是像python这样的坚持一切接对象的高级程序设计语言，一旦关机，在写在内存中的数据都将不复存在。另一方面，存储在内存够中的对象由于编程语言、网络环境等等因素，很难在网络中进行传输交互。由此，就诞生了一种机制，可以实现内存中的对象与方便持久化在磁盘中或在网络中进行交互的数据格式（str、bites)之间的相互转换。这种机制就叫序列化与发序列化：

　　序列化：将内存中的不可持久化和传输对象转换为可方便持久化和传输对象的过程。

　　反序列化：将可持久化和传输对象转换为不可持久化和传输对象的过程。

　　python中提供pickle和json两个模块来实现序列化与反序列化，pickle模块和json模块dumps()、dump()、loads()、load()这是个函数，其中dumps()、dump()用于实现序列化，loads()、load()用于实现反序列化。下面，我们分别对pickle和json模块进行介绍。

2  pickle模块

　　pickle模块的dumps()、dump()、loads()、load()是个函数按功能划分可以分为两组：

　　序列化：dumps()、dump()

　　反序列化：loads()、load()

　　dumps()与dump()的区别是dumps()只是单纯得将对象序列化，而dump()会在序列化之后将结果写入到文件当中；与之对应，loads()与load()区别至于loads()是对dumps的序列化结果进行反序列化，而dump()会从文件中读取内容进行反序列化。

2.1 dumps()与loads()

>>> import pickle
>>> p_dict = {'name':'张三' , 'age':30 , 'ismarried':false} # 定义一个字典
>>> p_str = pickle.dumps(p_dict) # 序列化
>>> type(p_dict)
<class 'dict'>
>>> type(p_str)
<class 'bytes'>
>>> p_str
b'\x80\x03}q\x00(x\x04\x00\x00\x00nameq\x01x\x06\x00\x00\x00\xe5\xbc\xa0\xe4\xb8\x89q\x02x\x03\x00\x00\x00ageq\x03k\x1ex\t\x00\x00\x00ismarriedq\x04\x89u.'
>>> p = pickle.loads(p_str)
>>> type(p)
<class 'dict'>
>>> p
{'name': '张三', 'age': 30, 'ismarried': false}

　　可以看到，反序列化后得到的p和序列化之前的p_dict内容是一模一样的。不过，p与p_dict已经是两个不同的对象了：

>>> id(p)==id(p_dict)
false

2.2 dump()与load()

　　序列化：

>>> import pickle
>>> p_dict = {'name':'张三' , 'age':30 , 'ismarried':false} # 定义一个字典
>>> file = open("my_dump.txt", "wb") # 因为序列化只有的是bites类型，所以必须以wb模式打开
>>> pickle.dump(p_dict, file)
>>> file.close()

　　此时，通过上面代码我们已经将p_dict序列化成功，并写入到了一个名为my_dump.txt文件中。你可以找到这个文件，然后将它拷贝到任何电脑上进行反序列化：

>>> file=open("my_dump.txt","rb")
>>> p=pickle.load(file)
>>> file.close()
>>> type(p)
<class 'dict'>
>>> p
{'name': '张三', 'age': 30, 'ismarried': false}

　　看，反序列化后得到的内容与序列化之前的内容完全一样。体会到序列化与反序列化的作用了吗？序列化之后的内容可以方便得保存到磁盘中，电脑关机也不怕。

3 json模块

　　如果你阅读并理解了上文中关于pickle的部门内容，对于这一部分的json模块内容，你可以不费吹灰之力掌握。上文中说到过，与pickle一样，json模块也提供了dumps()、dump()、loads()、load()则是个函数，且其中区别也与pickle中是个函数的区别是一样的。

3.1 dumps()与loads()

>>> import pickle
>>> p_dict = {'name':'张三' , 'age':30 , 'ismarried':false} # 定义一个字典
>>> import json
>>> p_dict = {'name':'张三' , 'age':30 , 'ismarried':false} # 定义一个字典
>>> p_str = json.dumps(p_dict)
>>> type(p_str)
<class 'str'>
>>> p_str
'{"name": "\\u5f20\\u4e09", "age": 30, "ismarried": false}'

　　可以看到，json序列化之后得到的是json格式字符串，但上述json字符串中，中文部分内容显示为了“乱码”。怎么办呢？json的dumps()函数（dump()函数也有）中提供了一个ensure_ascii参数，将该参数的值设置为false，可令序列化后中文依然正常显示。

>>> p_str2 = json.dumps(p_dict, ensure_ascii=false)
>>> p_str2
'{"name": "张三", "age": 30, "ismarried": false}'

　　接着上面的内容进行反序列化：

>>> p1 = json.loads(p_str)
>>> p1
{'name': '张三', 'age': 30, 'ismarried': false}
>>> p2 = json.loads(p_str)
>>> p2
{'name': '张三', 'age': 30, 'ismarried': false}

3.2 dump()与load()

>>> import json
>>> p_dict = {'name':'张三' , 'age':30 , 'ismarried':false} # 定义一个字典
>>> file = open('d:/mydump.txt' , 'w')
>>> json.dump(p_dict , file)
>>> file.close()

　　当然，你也可以加上ensure_ascii这一参数，并将其值设置为false，这样你打开mydump.txt文件里面的中文就能正常显示。（执行完代码之后，本地会有一个mydump.txt文件，诸位可以验证该内容）

>>> file = open('d:/mydump.txt' , 'w')
>>> json.dump(p_dict , file , ensure_ascii=false)
>>> file.close()

　　继续反序列化：

>>> file = open('d:/mydump.txt' , 'r')
>>> p = json.load(file)
>>> file.close()
>>> type(p)
<class 'dict'>
>>> p
{'name': '张三', 'age': 30, 'ismarried': false}

　　通过上面内容，pickle和json模块关于序列化与反序列化的操作就介绍完了。我们可以发现，pickle与json两个模块无论是在函数名，还是在功能上，都是机器相似的。既然这样，有了pickle模块，为什么还有json模块的诞生呢？接下来来说说pickle与json模块的区别。

4 pickle模块与json模块的区别

　　（1）pickle模块用于python语言特有的类型和用户自定义类型与python基本数据类型之间的转换

　　json模块用于字符串和python数据类型间进行转换。如下所示，我们自定义一个person类，分别用pickle和json进行序列化：

>>> class person:
def __init__(self , name , age , ismarried):
self.name = name
self.age = age
self.ismarried = ismarried
>>> p = person('张三' , 30 , false)

　　使用pickle模块进行序列化与反序列化：

>>> p = person('张三' , 30 , false)
>>> import pickle
>>> pp = pickle.dumps(p)
>>> type(pp)
<class 'bytes'>
>>> pp
b'\x80\x03c__main__\nperson\nq\x00)\x81q\x01}q\x02(x\x04\x00\x00\x00nameq\x03x\x06\x00\x00\x00\xe5\xbc\xa0\xe4\xb8\x89q\x04x\x03\x00\x00\x00ageq\x05k\x1ex\t\x00\x00\x00ismarriedq\x06\x89ub.'
>>> p2 = pickle.loads(pp)
>>> type(p2)
<class '__main__.person'>
>>> p2.name
'张三'

　　甚至pickle模块还能够对peron本身进行序列化：

>>> per = pickle.dumps(person)
>>> per
b'\x80\x03c__main__\nperson\nq\x00.'
>>> per2 = pickle.loads(per)
>>> per2
<class '__main__.person'>

　　如果用json对person实例对象进行序列化，就会报错：

>>> import json
>>> p = person('张三' , 30 , false)
>>> json.dumps(p)
traceback (most recent call last):
file "<pyshell#49>", line 1, in <module>
json.dumps(p)
……
typeerror: object of type 'person' is not json serializable

　　如果非要用json对person对象进行序列化，必须先定义一个将person对象转化为字典（dict)的方法：

>>> def person2dict(per):
return {
'name':per.name ,
'age':per.age ,
'ismarried':per.ismarried
}
>>> p3 = json.dumps(p , default=person2dict)
>>> type(p3)
<class 'str'>
>>> p3
'{"name": "\\u5f20\\u4e09", "age": 30, "ismarried": false}'
>>> p3 = json.dumps(p , default=person2dict , ensure_ascii=false)
>>> type(p3)
<class 'str'>
>>> p3
'{"name": "张三", "age": 30, "ismarried": false}'

　　当然，也不能直接进行反序列化，不然也只会得到一个字典：

>>> p4 = json.loads(p3)
>>> type(p4)
<class 'dict'>
>>> p4
{'name': '张三', 'age': 30, 'ismarried': false}

　　此时，也要定义一个将字典转换为person类实例的方法，在进行反序列化：

>>> def dict2person(d):
return person(d['name'],d['age'],d['ismarried'])
>>> p5 = json.loads(p3 , object_hook=dict2person)
>>> type(p5)
<class '__main__.person'>
>>> p5.name
'张三'

　　（2）pickle序列化结果为bites类型，只适合于python机器之间的交互。

　　　　json序列化结果为str类型，能够被多种语言识别，可用于与其他程序设计语言交互。

　　目前，json格式字符串已经成为网络传输中的一种标准格式，所以在web后台开发中通常用json模块来序列化而不是pickle模块。

　　json和python内置的数据类型对应如下：

json类型	python类型
{}	dict
[]	list
"string"	'str'或u'unicode'
1234.56	int或float
true/false	true/false
null	none

5 总结

　　（1）序列化与反序列化是为了解决内存中对象的持久化与传输问题；

　　（2）python中提供了pickle和json两个模块进行序列化与反序列化；

　　（3）dumps()和dump()用于序列化，loads()和load()用于反序列化；

　　（4）pickle模块能序列化任何对象，序列化结果为bites类型，只适合于python机器之间交互；

　　json模块只能序列化python基本类型，序列化结果为json格式字符串，适合不同开发语言之间交互。