用于序列化的两个模块
json：用于字符串和Python数据类型间进行转换
pickle: 用于python特有的类型和python的数据类型间进行转换
json提供四个功能：dumps,dump,loads,load
pickle提供四个功能：dumps,dump,loads,load
pickle可以存储什么类型的数据呢？
- 所有python支持的原生类型：布尔值，整数，浮点数，复数，字符串，字节，None。
- 由任何原生类型组成的列表，元组，字典和集合。
- 函数，类，类的实例
pickle模块中常用的方法有：
1. pickle.dump(obj, file, protocol=None,)
必填参数obj表示将要封装的对象
必填参数file表示obj要写入的文件对象，file必须以二进制可写模式打开，即“wb”
可选参数protocol表示告知pickler使用的协议，支持的协议有0,1,2,3，默认的协议是添加在Python 3中的协议3。
- Protocol version 0 is the original “human-readable” protocol and is backwards compatible with earlier versions of Python.
- Protocol version 1 is an old binary format which is also compatible with earlier versions of Python.
- Protocol version 2 was introduced in Python 2.3. It provides much more efficient pickling of new-style classes. Refer to PEP 307 for information about improvements brought by protocol 2.
- Protocol version 3 was added in Python 3.0. It has explicit support for bytes objects and cannot be unpickled by Python 2.x. This is the default protocol, and the recommended protocol when compatibility with other Python 3 versions is required.
- Protocol version 4 was added in Python 3.4. It adds support for very large objects, pickling more kinds of objects, and some data format optimizations. Refer to PEP 3154 for information about improvements brought by protocol 4.
2. pickle.load(file,*,fix_imports=True, encoding="ASCII", errors="strict")
必填参数file必须以二进制可读模式打开，即“rb”，其他都为可选参数
3. pickle.dumps(obj)：以字节对象形式返回封装的对象，不需要写入文件中
4. pickle.loads(bytes_object): 从字节对象中读取被封装的对象，并返回
pickle模块可能出现三种异常：
1. PickleError：封装和拆封时出现的异常类，继承自Exception
2. PicklingError: 遇到不可封装的对象时出现的异常，继承自PickleError
3. UnPicklingError: 拆封对象过程中出现的异常，继承自PickleError
应用：
1 # dumps功能 2 import pickle 3 data = ['aa', 'bb', 'cc'] 4 # dumps 将数据通过特殊的形式转换为只有python语言认识的字符串 5 p_str = pickle.dumps(data) 6 print(p_str)
7 b'\x80\x03]q\x00(X\x02\x00\x00\x00aaq\x01X\x02\x00\x00\x00bbq\x02X\x02\x00\x00\x00ccq\x03e.
1 # loads功能 2 # loads 将pickle数据转换为python的数据结构 3 mes = pickle.loads(p_str) 4 print(mes) 5 ['aa', 'bb', 'cc']
1 # dump功能
2 # dump 将数据通过特殊的形式转换为只有python语言认识的字符串，并写入文件
3 with open('D:/tmp.pk', 'w') as f:
4 pickle.dump(data, f)
1 # load功能
2 # load 从数据文件中读取数据，并转换为python的数据结构
3 with open('D:/tmp.pk', 'r') as f:
4 data = pickle.load(f)
=====================================================================
在机器学习中，我们常常需要把训练好的模型存储起来，这样在进行决策时直接将模型读出，而不需要重新训练模型，这样就大大节约了时间。Python提供的pickle模块就很好地解决了这个问题，它可以序列化对象并保存到磁盘中，并在需要的时候读取出来，任何对象都可以执行序列化操作。
Pickle模块中最常用的函数为：
（1）pickle.dump(obj, file, [,protocol])
函数的功能：将obj对象序列化存入已经打开的file中。
参数讲解：
- obj：想要序列化的obj对象。
- file:文件名称。
- protocol：序列化使用的协议。如果该项省略，则默认为0。如果为负值或HIGHEST_PROTOCOL，则使用最高的协议版本。
（2）pickle.load(file)
函数的功能：将file中的对象序列化读出。
参数讲解：
- file：文件名称。
（3）pickle.dumps(obj[, protocol])
函数的功能：将obj对象序列化为string形式，而不是存入文件中。
参数讲解：
- obj：想要序列化的obj对象。
- protocal：如果该项省略，则默认为0。如果为负值或HIGHEST_PROTOCOL，则使用最高的协议版本。
（4）pickle.loads(string)
函数的功能：从string中读出序列化前的obj对象。
参数讲解：
- string：文件名称。
【注】 dump() 与 load() 相比 dumps() 和 loads() 还有另一种能力：dump()函数能一个接着一个地将几个对象序列化存储到同一个文件中，随后调用load()来以同样的顺序反序列化读出这些对象。
【代码示例】
pickleExample.py
- #coding:utf-8
- __author__ = 'MsLili'
- #pickle模块主要函数的应用举例
- import pickle
- dataList = [[1, 1, 'yes'],
- [1, 1, 'yes'],
- [1, 0, 'no'],
- [0, 1, 'no'],
- [0, 1, 'no']]
- dataDic = { 0: [1, 2, 3, 4],
- 1: ('a', 'b'),
- 2: {'c':'yes','d':'no'}}
- #使用dump()将数据序列化到文件中
- fw = open('dataFile.txt','wb')
- # Pickle the list using the highest protocol available.
- pickle.dump(dataList, fw, -1)
- # Pickle dictionary using protocol 0.
- pickle.dump(dataDic, fw)
- fw.close()
- #使用load()将数据从文件中序列化读出
- fr = open('dataFile.txt','rb')
- data1 = pickle.load(fr)
- print(data1)
- data2 = pickle.load(fr)
- print(data2)
- fr.close()
- #使用dumps()和loads()举例
- p = pickle.dumps(dataList)
- print( pickle.loads(p) )
- p = pickle.dumps(dataDic)
- print( pickle.loads(p) )
出处：https://blog.csdn.net/coffee_cream/article/details/51754484
================================================================
持久性的基本思想很简单。假定有一个 Python 程序，它可能是一个管理日常待办事项的程序，您希望在多次执行这个程序之间可以保存应用程序对象（待办事项）。换句话说，您希望将对象存储在磁盘上，便于以后检索。这就是持久性。要达到这个目的，有几种方法，每一种方法都有其优缺点。
例如，可以将对象数据存储在某种格式的文本文件中，譬如 CSV 文件。或者可以用关系数据库，譬如 Gadfly、MySQL、PostgreSQL 或者 DB2。这些文件格式和数据库都非常优秀，对于所有这些存储机制，Python 都有健壮的接口。
这些存储机制都有一个共同点：存储的数据是独立于对这些数据进行操作的对象和程序。这样做的好处是，数据可以作为共享的资源，供其它应用程序使用。缺点是，用这种方式，可以允许其它程序访问对象的数据，这违背了面向对象的封装性原则 — 即对象的数据只能通过这个对象自身的公共（public）接口来访问。
另外，对于某些应用程序，关系数据库方法可能不是很理想。尤其是，关系数据库不理解对象。相反，关系数据库会强行使用自己的类型系统和关系数据模型（表），每张表包含一组元组（行），每行包含具有固定数目的静态类型字段（列）。如果应用程序的对象模型不能够方便地转换到关系模型，那么在将对象映射到元组以及将元组映射回对象方面，会碰到一定难度。这种困难常被称为阻碍性不匹配（impedence-mismatch）问题。
序列化：dumps(object) 返回一个字符串，它包含一个 pickle 格式的对象。
dump(object, file) 将对象写到文件，这个文件可以是实际的物理文件，但也可以是任何类似于文件的对象，这个对象具有 write() 方法，可以接受单个的字符串参数
反序列化： loads(string) 返回包含在 pickle 字符串中的对象
load(file) 返回包含在 pickle 文件中的对象
清单1 ：dumps() 和 loads() 的演示
- >>> import cPickle as pickle
- >>> t1 = ('this is a string', 42, [1, 2, 3], None)
- >>> t1
- ('this is a string', 42, [1, 2, 3], None)
- >>> p1 = pickle.dumps(t1)
- >>> p1
- "(S'this is a string'/nI42/n(lp1/nI1/naI2/naI3/naNtp2/n."
- >>> print p1
- (S'this is a string'
- I42
- (lp1
- I1
- aI2
- aI3
- aNtp2
- .
- >>> t2 = pickle.loads(p1)
- >>> t2
- ('this is a string', 42, [1, 2, 3], None)
- >>> p2 = pickle.dumps(t1, True)
- >>> p2
- '(U/x10this is a stringK*]q/x01(K/x01K/x02K/x03eNtq/x02.'
- >>> t3 = pickle.loads(p2)
- >>> t3
- ('this is a string', 42, [1, 2, 3], None)
接下来，我们看一些示例，这些示例用到了 dump() 和 load() ，它们使用文件和类似文件的对象。这些函数的操作非常类似于我们刚才所看到的 dumps() 和 loads() ，区别在于它们还有另一种能力 — dump() 函数能一个接着一个地将几个对象转储到同一个文件。随后调用 load() 来以同样的顺序检索这些对象。清单 2 显示了这种能力的实际应用：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
>>> a1
=
'apple'
>>> b1
=
{
1
:
'One'
,
2
:
'Two'
,
3
:
'Three'
}
>>> c1
=
[
'fee'
,
'fie'
,
'foe'
,
'fum'
]
>>> f1
=
file
(
'temp.pkl'
,
'wb'
)
>>> pickle.dump(a1, f1,
True
)
>>> pickle.dump(b1, f1,
True
)
>>> pickle.dump(c1, f1,
True
)
>>> f1.close()
>>> f2
=
file
(
'temp.pkl'
,
'rb'
)
>>> a2
=
pickle.load(f2)
>>> a2
'apple'
>>> b2
=
pickle.load(f2)
>>> b2
{
1
:
'One'
,
2
:
'Two'
,
3
:
'Three'
}
>>> c2
=
pickle.load(f2)
>>> c2
[
'fee'
,
'fie'
,
'foe'
,
'fum'
]
>>> f2.close()
|