参考链接：
前言
前面在学习文件读写时，简单介绍了Python中的序列化和反序列化。我们已经知道，在程序运行的过程中，所有的变量都是在内存中，比如，定义一个dict：d = dict(name='张三', age=16, grade='五年级', score=90)，我们可以随时修改变量的值，比如把name改成'李四'。但是一旦程序结束，变量所占用的内存就***作系统全部回收。如果没有把修改后的'李四'存储到磁盘上，下次重新运行程序，变量又被初始化为'张三'。
今天我们就来系统地学习Python中的序列化和反序列化。
序列化和反序列化
在python中，序列化可以理解为：把python的对象编码转换为json格式的字符串，反序列化可以理解为：把json格式字符串解码为python数据对象。
我们把变量从内存中变成可存储或传输的过程称之为序列化，在Python中叫pickling，在其他语言中也被称之为serialization，marshalling，flattening等等都是一个意思。序列化之后，就可以把序列化后的内容写入磁盘，或者通过网络传输到别的机器上。反过来，把内容从序列化的对象重新读到内存里称之为反序列化，即unpickling。
在python的标准库中，专门提供了json库与pickle库来处理这部分。
pickle模块
使用pickle模块，首先要导入该模块：import pickle
-
把序列化后的内容存储在变量中
dumps(obj)返回结果是序列化后的字节数据。
import pickle d = dict(name="张三", age=16, grade="五年级", score="90") # 把序列化后的内容保存在变量中 data = pickle.dumps(d) print(data) 运行结果：
b'\x80\x03}q\x00(X\x03\x00\x00\x00ageq\x01K\x10X\x05\x00\x00\x00gradeq\x02X\t\x00\x00\x00\xe4\xba\x94\xe5\xb9\xb4\xe7\xba\xa7q\x03X\x05\x00\x00\x00scoreq\x04X\x02\x00\x00\x0090q\x05X\x04\x00\x00\x00nameq\x06X\x06\x00\x00\x00\xe5\xbc\xa0\xe4\xb8\x89q\x07u.'
-
把序列化后的数据还原为对象（反序列化）
经过上面的序列化后，数据以字节保存在了data变量中，需要再次使用的时候使用loads函数就行了。如下：
import pickle d = dict(name="张三", age=16, grade="五年级", score="90") # 把序列化后的内容保存在变量中 data = pickle.dumps(d) print("序列化:{}".format(data)) # 把序列化后的数据还原为对象（反序列化） obj = pickle.loads(data) print("反序列化:{}".format(obj)) 运行结果：
序列化:b'\x80\x03}q\x00(X\x05\x00\x00\x00gradeq\x01X\t\x00\x00\x00\xe4\xba\x94\xe5\xb9\xb4\xe7\xba\xa7q\x02X\x05\x00\x00\x00scoreq\x03X\x02\x00\x00\x0090q\x04X\x03\x00\x00\x00ageq\x05K\x10X\x04\x00\x00\x00nameq\x06X\x06\x00\x00\x00\xe5\xbc\xa0\xe4\xb8\x89q\x07u.' 反序列化:{'grade': '五年级', 'score': '90', 'age': 16, 'name': '张三'} -
直接存储在文件中
上面的pickle.dumps(obj)方法把任意对象序列化成一个bytes，然后，就可以把这个bytes写入文件。或者用另一个方法pickle.dump()直接把对象序列化后写入一个file-like Object，进行持久化。注意这次用的方法中少了个s，即：pickle.dump()，而不是上面用到的pickle.dumps()。
由于pickle写入的是二进制数据，所以打开方式需要以wb和rb的模式。
import pickle d = dict(name="张三", age=16, grade="五年级", score="90") # 直接把序列化后的内容写入到文件中 with open("json_pickle.txt","wb") as f: pickle.dump(d, f) 运行结果：
也可以直接用pickle.load()方法从一个file-like Object中直接反序列化出对象。如下：
import pickle # 从文件中反序列化出对象 with open("json_pickle.txt", "rb") as f: d2 = pickle.load(f) print(d2) 运行结果：
{'grade': '五年级', 'age': 16, 'score': '90', 'name': '张三'}
这样我们的数据就从文件中成功地反序列化到内存，保存到变量d2中了。要注意的是：这个变量和原来的变量是完全不相干的对象，它们只是内容相同而已。
-
序列化用户自定义对象
开发中用的最多的就是我们自己定义类的对象，pickle当然也能写入，不仅可以写入类本身，也能写入它的一个实例。
假设我们现在设计了一个Student类：
class Student(object): def __init__(self, name, age, grade, score): self.name = name self.age = age self.grade = grade self.score = score def study(self): print(self.name + "正在学习...") 将类本身序列化到文件中
import pickle # 序列化自定义的类、对象 # 此处为类的定义，同上 # 将类本身序列化到文件中 with open("json_pickle_Student_class.txt", "wb") as f: pickle.dump(Student, f) 运行结果：
将自定义类从json_pickle_Student_class.txt文件中反序列化出来，并创建对象：
# 将类反序列化出来 with open("json_pickle_Student_class.txt", "rb") as f: Stu = pickle.load(f) s = Stu("小明", 18, "高二", "135") s.study() 运行结果：
小明正在学习...
接下来，看下如何序列化自定义类的对象：
import pickle # 此处为类的定义，同上 # 序列化自定义类的对象 with open("json_pickle_Student_obj.txt", "wb") as f: # 创建一个学生类对象s s = Student("小红", 18, "高二", "135") s.study() # 序列化自定义类的对象 pickle.dump(s, f) 运行结果：(2处影响)：
1.创建了json_pickle_Student_obj.txt文件，并写入了序列化后的数据到该文件中。
2.打印结果：
小红正在学习...
从文件中反序列化出对象:
# 反序列化自定义类的对象 with open("json_pickle_Student_obj.txt", "rb") as f: # 从文件中反序列化出对象 s2 = pickle.load(f) s2.study() 运行结果:
小红正在学习...
上面演示了pickle模块序列化和反序列化，两套方法：序列化到文件并反序列化到变量的pickle.dumps(d)和pickle.loads(f)和序列化到文件并反序列化的pickle.dump(d)和pickle.load(f)。
json模块
如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如XML，但更好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。
提示：JSON本质就是字符串，是一个特殊格式的字符串而已。
JSON表示的对象就是标准的JavaScript语言的对象，JSON和Python内置的数据类型对应如下：
| JSON类型 | Python类型 |
|---|---|
| {} | dict |
| [] | list |
| "string" | str |
| 1234.56 | int或float |
| true/false | True/False |
| null | None |
Python内置的json模块提供了非常完善的Python对象到JSON格式的转换。我们先看看如何把Python对象变成一个JSON：
如果您有一个对象x，则可以使用一行简单的代码查看其JSON字符串表示：
import json # 把对象转换为Json字符串 t = [2018, "21届世界杯", '俄罗斯'] # 核心代码，使用前要先导入json模块，此处是json.dumps(t)方法，区别于方法json.dump(t，f) json_str = json.dumps(t) print(t) print(json_str) 运行结果：
[2018, '21届世界杯', '俄罗斯']
[2018, "21\u5c4a\u4e16\u754c\u676f", "\u4fc4\u7f57\u65af"]
提示：
1.使用前要先导入json模块，此处是json.dumps(t)方法，区别于方法json.dump(t，f)。如果你遇到了下面错误，请检查方法是否使用错误：
Traceback (most recent call last): File "F:/python_projects/io_file/my_file.py", line 84, in <module> json_str = json.dump(t) TypeError: dump() missing 1 required positional argument: 'fp' 此文中用的python是3.5，在版本3.6中已更改：所有可选参数现在仅为关键字。
json.dumps（obj，*，skipkeys = False，ensure_ascii = True，check_circular = True，allow_nan = True，cls = None，indent = None，separators = None，default = None，sort_keys = False，** kw ）
2.json.dumps(t)方法的另一个变体json.dump(t，f)，只是将对象序列化为文本文件。
dumps()方法返回一个str，内容就是标准的JSON。类似的，dump()方法可以直接把JSON写入一个file-like Object。
import json # 直接把对象以Json字符串写入文件 t = [2018, "21届世界杯", '俄罗斯'] with open('file_write_json.txt','w') as f: json_str = json.dump(t,f) 要把JSON反序列化为Python对象，用loads()或者对应的load()方法，前者把JSON的字符串反序列化，后者从file-like Object中读取字符串并反序列化。
-
用
loads()反序列化
import json # 直接把对象以Json字符串写入文件 t = [2018, "21届世界杯", '俄罗斯'] with open('file_write_json.txt','w') as f: json_str = json.dumps(t) print(json_str) # 反序列化 t2 = json.loads(json_str) print(t2) 运行结果：
[2018, "21\u5c4a\u4e16\u754c\u676f", "\u4fc4\u7f57\u65af"]
[2018, '21届世界杯', '俄罗斯']
-
用
load()反序列化
用load()反序列化，直接将文件反序列化为内存中的对象。
import json t = [2018, "21届世界杯", '俄罗斯'] with open('file_write_json.txt', 'r+') as f: t3 = json.load(f) print(t3) 运行结果：
[2018, '21届世界杯', '俄罗斯']
JSON进阶
Python的tuple\dict等对象可以直接序列化为JSON的{}，不过，很多时候，我们更喜欢用class表示对象，比如定义Student类，然后序列化：
import json # 序列化用户自定义对象 class Student(object): def __init__(self, name, age, grade, score): self.name = name self.age = age self.grade = grade self.score = score def study(self): print(self.name + "正在学习...") s = Student("李杰", 17, "高三", "120") s.study() # 对自定义类的对象进行序列化操作 print(json.dumps(s)) 运行结果：
Traceback (most recent call last): 李杰正在学习... File "F:/python_projects/io_file/json_pickle.py", line 85, in <module> print(json.dumps(s)) File "F:\Program Files\Anaconda3\lib\json\__init__.py", line 230, in dumps return _default_encoder.encode(obj) File "F:\Program Files\Anaconda3\lib\json\encoder.py", line 198, in encode chunks = self.iterencode(o, _one_shot=True) File "F:\Program Files\Anaconda3\lib\json\encoder.py", line 256, in iterencode return _iterencode(o, 0) File "F:\Program Files\Anaconda3\lib\json\encoder.py", line 179, in default raise TypeError(repr(o) + " is not JSON serializable") TypeError: <__main__.Student object at 0x000001D54F008160> is not JSON serializable 解析：发现报错了TypeError，错误的原因是Student对象不是一个可序列化为JSON的对象。
查看该方法官方文档，此文中用的python是3.5，在版本3.6中已更改：所有可选参数现在仅为关键字。
json.dumps（obj，*，skipkeys = False，ensure_ascii = True，check_circular = True，allow_nan = True，cls = None，indent = None，separators = None，default = None，sort_keys = False，** kw ）
这些参数就是让我们来定制JSON序列化。前面的代码之所以无法把Student类实例序列化为JSON，是因为默认情况下，dumps()方法不知道如何将Student实例变为一个JSON的{}对象。
可选参数default就是把任意一个对象变成一个可序列为JSON的对象，我们只需要为Student专门写一个转换函数，再把函数传进去即可：
# 将对象转换为字典 def student2dict(student): return { 'name': student.name, 'age': student.age, 'grade': student.grade, 'score': student.score } 我们再进行序列化时，就可以用到该函数了：
s = Student("李杰", 17, "高三", "120") s.study() # 将对象转换为字典 def student2dict(student): return { 'name': student.name, 'age': student.age, 'grade': student.grade, 'score': student.score } # 对自定义类的对象进行序列化操作 print(json.dumps(s, default=student2dict)) 运行结果：
李杰正在学习...
{"grade": "\u9ad8\u4e09", "age": 17, "name": "\u674e\u6770", "score": "120"}
不过，下次如果遇到一个Car、SmartPhone类的实例，照样无法序列化为JSON。我们可以偷个懒，把任意class的实例变为dict，我们可以这么干：
json.dumps(s, default=lambda obj: obj.__dict__) 之所以可以这么写，是因为通常class的实例都有一个__dict__属性，它就是一个dict，用来存储实例变量。要特别注意，也有少数例外，比如定义了__slots__的class。
同样的道理，如果我们要把JSON反序列化为一个Student对象实例，loads()方法首先转换出一个dict对象，然后，我们传入的object_hook函数负责把dict转换为Student实例：
import json # 序列化用户自定义对象 # Student类的定义同上 s = Student("李杰", 17, "高三", "120") s.study() # 将对象转换为字典 def student2dict(student): return { 'name': student.name, 'age': student.age, 'grade': student.grade, 'score': student.score } # 对自定义类的对象进行序列化操作 s1 = json.dumps(s, default=lambda obj:obj.__dict__) print(s1) # 用于反序列化 def dict2student(d): return Student(d['name'], d['age'], d["grade"], d['score']) s2 = json.loads(s1, object_hook=dict2student) print("反序列化后：{}".format(s2)) 核心代码：
# 用于反序列化 def dict2student(d): return Student(d['name'], d['age'], d["grade"], d['score']) s2 = json.loads(s1, object_hook=dict2student) print("反序列化后：{}".format(s2)) 运行结果：
李杰正在学习...
{"age": 17, "score": "120", "grade": "\u9ad8\u4e09", "name": "\u674e\u6770"}
反序列化后：<__main__.Student object at 0x000002CBF19444A8>
打印出的是反序列化的Student实例对象:<__main__.Student object at 0x000002CBF19444A8>
以上是存储到变量，存储到文件也是类似操作。
小结
本小节系统地学习了python中如何序列化和反序列化。重点学习python的标准库中的专门提供的：json库与pickle库。
京公网安备 11010502036488号