Python序列化与反序列化相关知识总结_Python

python序列化与反序列

在程序运行的过程中，所有的变量都是在内存中，比如，定义一个 dict：

				?

									d = dict(name='bob', age=20, score=88)

可以随时修改变量，比如把 name 改成 ‘bill'，但是一旦程序结束，变量所占用的内存就被操作系统全部回收。如果没有把修改后的 ‘bill' 存储到磁盘上，下次重新运行程序，变量又被初始化为 ‘bob'。

我们把变量从内存中变成可存储或传输的过程称之为序列化，在 python 中叫 pickling，在其他语言中也被称之为 serialization，marshalling，flattening 等等，都是一个意思。
序列化之后，就可以把序列化后的内容写入磁盘，或者通过网络传输到别的机器上。

Python序列化与反序列化相关知识总结

反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化，即 unpickling。

python 提供了 pickle 模块来实现序列化。首先，我们尝试把一个对象序列化并写入文件：

				?

									in [1]: import pickle

									in [2]: d = dict(name='bob', age=20, score=88)

									in [3]: pickle.dumps(d)

									out[3]: b'\x80\x04\x95$\x00\x00\x00\x00\x00\x00\x00}\x94(\x8c\x04name\x94\x8c\x03bob\x94\x8c\x03age\x94k\x14\x8c\x05score\x94kxu.'

pickle.dumps() 方法把任意对象序列化成一个 bytes，然后，就可以把这个 bytes 写入文件。或者用另一个方法 pickle.dump() 直接把对象序列化后写入一个 file-like object：

				?

									in [5]: f = open('dump.txt', 'wb')

									in [6]: d = dict(name='bob', age=20, score=88)

									in [7]: pickle.dump(d, f)

									in [8]: f.close()

看看写入的 dump.txt 文件，一堆乱七八糟的内容，这些都是 python 保存的对象内部信息。

Python序列化与反序列化相关知识总结

当我们要把对象从磁盘读到内存时，可以先把内容读到一个 bytes，然后用 pickle.loads() 方法反序列化出对象，也可以直接用 pickle.load() 方法从一个 file-like object 中直接反序列化出对象。我们打开另一个 python 命令行来反序列化刚才保存的对象：

				?

									in [23]: f = open('dump.txt', 'rb')

									in [24]: d = pickle.load(f)

									in [25]: f.close()

									in [26]: d

									out[26]: {'name': 'bob', 'age': 20, 'score': 88}

变量的内容又回来了！

当然，这个变量和原来的变量是完全不相干的对象，它们只是内容相同而已。

pickle 的问题和所有其他编程语言特有的序列化问题一样，就是它只能用于 python，并且可能不同版本的 python 彼此都不兼容，因此，只能用 pickle 保存那些不重要的数据，不能成功地反序列化也没关系。

json

如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如 xml，但更好的方法是序列化为 json，因为 json 表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。json 不仅是标准格式，并且比 xml 更快，而且可以直接在 web 页面中读取，非常方便。

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：

				?

									in [27]: import json

									in [28]: d = dict(name='bob', age=20, score=88)

									in [29]: json.dumps(d)

									out[29]: '{"name": "bob", "age": 20, "score": 88}'

									in [30]: type(json.dumps(d))

									out[30]: str

dumps() 方法返回一个 str，内容就是标准的 json。类似的，dump() 方法可以直接把 json 写入一个 file-like object。

要把 json 反序列化为 python 对象，用 loads() 或者对应的 load() 方法，前者把 json 的字符串反序列化，后者从 file-like object 中读取字符串并反序列化：

				?

									in [31]: json_str = '{"age": 20, "score": 88, "name": "bob"}'

									in [32]: json.loads(json_str)

									out[32]: {'age': 20, 'score': 88, 'name': 'bob'}

									in [33]: type(json.loads(json_str))

									out[33]: dict

由于 json 标准规定 json 编码是 utf-8，所以我们总是能正确地在 python 的 str 与 json 的字符串之间转换。

json 进阶

python 的 dict 对象可以直接序列化为 json 的 {}，不过，很多时候，我们更喜欢用 class . 表示对象，比如定义 student 类，然后序列化：

				?

									import json

									class student(object):

									    def __init__(self, name, age, score):

									        self.name = name

									        self.age = age

									        self.score = score

									s = student('bob', 20, 88)

									print(json.dumps(s))

运行代码，毫不留情地得到一个 typeerror：

				?

									traceback (most recent call last):

									  ...

									typeerror: object of type student is not json serializable

错误的原因是 student 对象不是一个可序列化为 json 的对象。

如果连 class 的实例对象都无法序列化为 json，这肯定不合理！

别急，我们仔细看看 dumps() 方法的参数列表，可以发现，除了第一个必须的 obj 参数外，dumps() 方法还提供了一大堆的可选参数：

这些可选参数就是让我们来定制 json 序列化。前面的代码之所以无法把 student 类实例序列化为 json，是因为默认情况下，dumps() 方法不知道如何将 student 实例变为一个 json 的 {} 对象。

可选参数 default 就是把任意一个对象变成一个可序列为 json 的对象，我们只需要为 student 专门写一个转换函数，再把函数传进去即可：

				?

									in [40]: s.name

									out[40]: 'bob'

									in [41]: s.age

									out[41]: 20

									in [42]: s.score

									out[42]: 88

				?

									def student2dict(std):

									    return {

									        'name': std.name,

									        'age': std.age,

									        'score': std.score

									    }

这样，student 实例首先被 student2dict() 函数转换成 dict，然后再被顺利序列化为 json：

				?

									print(json.dumps(s, default=student2dict))

不过，下次如果遇到一个 teacher 类的实例，照样无法序列化为 json。再写一个函数也可以，但是我们可以偷个懒，把任意 class 的实例变为 dict：

				?

									print(json.dumps(s, default=lambda obj: obj.__dict__))

因为通常 class 的实例都有一个 __dict__ 属性，它就是一个 dict，用来存储实例变量。也有少数例外，比如定义了 __slots__ 的 class。

同样的道理，如果我们要把 json 反序列化为一个 student 对象实例，loads() 方法首先转换出一个 dict 对象，然后，我们传入的 object_hook 函数负责把 dict 转换为 student 实例：

				?

									def dict2student(d):

									    return student(d['name'], d['age'], d['score'])

运行结果如下：

				?

									in [48]: json_str = '{"age": 20, "score": 88, "name": "bob"}'

									in [49]: def dict2student(d):

									    ...:     return student(d['name'], d['age'], d['score'])

									    ...:

									in [50]: print(json.loads(json_str, object_hook=dict2student))

									<__main__.student object at 0x1065c6f70>

打印出的是反序列化的 student 实例对象。

练习

对中文进行 json 序列化时，json.dumps() 提供了一个 ensure_ascii 参数，观察该参数对结果的影响：

				?

									import json

									obj = dict(name='小明', age=20)

									s = json.dumps(obj, ensure_ascii=true)

									print(s)

小结

python 语言特定的序列化模块是pickle，但如果要把序列化搞得更通用、更符合 web 标准，就可以使用 json 模块。

json 模块的 dumps() 和 loads() 函数是定义得非常好的接口的典范。当我们使用时，只需要传入一个必须的参数。但是，当默认的序列化或反序列机制不满足我们的要求时，我们又可以传入更多的参数来定制序列化或反序列化的规则，既做到了接口简单易用，又做到了充分的扩展性和灵活性。

到此这篇关于python序列化与反序列化相关知识总结的文章就介绍到这了,更多相关python序列化与反序列内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！

原文链接：https://blog.csdn.net/qq_33254766/article/details/117628406

Python序列化与反序列化相关知识总结