python序列化及其相关模块（json,pickle,shelve,xml）详解

python序列化及其相关模块（json,pickle,shelve,xml）详解
什么是序列化对象？
我们把对象（变量）从内存中编程可存储或传输的过程称之为序列化，在python中称为pickle，其他语⾔称之为serialization ,marshalling ,flatterning 等等，都是⼀个意思。

序列化之后，就可以把序列化后的内容写⼊磁盘，或者通过⽹络传输到别的机器上（因为硬盘或⽹络传输时只接受bytes）。

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

为什么要序列化？
举个例⼦，你在打游戏过程中，打累了，停下来，想过两天再玩，两天之后，游戏⼜从你上次停⽌的地⽅继续运⾏，你上次游戏的进度肯定保存到硬盘上了，那么是以何种形式呢？游戏过程中产⽣的很多临时数据是不规律的，可能在你关掉游戏时正好是10个列表，3个嵌套字典的数据集合在内存⾥⾯，需要存下来，你如何存？把列表变成⽂件⾥的多⾏多列形式？那嵌套字典呢？根本没法存吧，所以，若是有种办法可以直接把内存数据存到硬盘上，下次程序再启动，再从硬盘上读出来，还是原来的格式，那是最好的，所以这就是我们要说的序列化。

1、持久保存状态
⼀个软件/程序的执⾏就在处理⼀系列状态的变化，在编程语⾔中，‘状态’会以各种各样有结构的数据类型（也可以简单的理解为变量）的形式被保存在内存中
内存是⽆法永久保存数据的，当程序运⾏了⼀段时间，我们断电或者重启程序，内存中关于这个程序的之前⼀段时间的数据（有结构）都被清空了。

在断电或重启程序之前将程序当前内存中所有的数据都保存下来（保存到⽂件中），以便于下次程序执⾏能够从⽂件中载⼊之前的数据，然后继续执⾏，这就是序列化。

2、跨平台数据交互
序列化之后，不仅可以把序列化后的内容写⼊磁盘，还可以通过⽹络传输到别的机器上，如果收发的双⽅约定好使⽤⼀种序列化的格式，那么变打破了平台/语⾔差异化带来的限制，实现了跨平台的数据交互。

反过来，把变量内容从序列化的对象重新读到内存⾥称之为反序列化，即unpickling.
什么可以序列化操作？
在python中，可以使⽤pickle和json两个模块对数据进⾏序列化操作
其中：
json可以⽤于字符串或者字典等与python数据类型之间的序列化与反序列化操作
pickle可以⽤于python特有类型与python数据类型之间的序列化与反序列化操作
提问：这时候有⼈肯定要问，两个都可以对数据进⾏序列化，为什么不只学习⼀个就好了，⾮要学习两个呢？
这个问题问的好，我们下⾯详细讲⼀下两个的区别。

关于json
优点：跨语⾔，体积⼩
缺点：只能⽀持int(整形)，str(字符串)，list(列表)，tuple（元祖），dict（字典）
关于pickle
优点：专门为python设计，只⽀持python所有的数据类型
缺点：只能在python中使⽤，存储数据占空间⼤
下⾯主要说⼀下json和pickle模块
json模块
什么是json？
JSON(JavaScript Object Notation) 是⼀种轻量级的数据交换格式。

它使得⼈们很容易的进⾏阅读和编写。

同时也⽅便了机器进⾏解析和⽣成。

它是基于 , 的⼀个⼦集。

JSON采⽤完全独⽴于程序语⾔的⽂本格式，但是也使⽤了类C语⾔的习惯（包括C, C++, C#, Java, JavaScript, Perl, Python等）。

这些特性使JSON成为理想的数据交换语⾔。

如果我们要在不同的编程语⾔中传递对象，就必须把对象序列化称为标准格式，⽐如XML，但是更好的⽅法是序列化为JSON，因为JSON表⽰出来就是⼀个字符串，可以被所有的语⾔读取，也可以⽅便的存储到磁盘或者通过⽹络传输。

JSON不仅是标准格式，⽽且⽐XML更快，⽽且可以在web页⾯直接读取，⾮常⽅便。

1.查看json模块内的⽅法
import json
dir(json)
['JSONDecodeError', 'JSONDecoder', 'JSONEncoder', '__all__', '__author__', '__builtins__',
'__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__path__',
'__spec__', '__version__', '_default_decoder', '_default_encoder', 'codecs', 'decoder',
'detect_encoding', 'dump', 'dumps', 'encoder', 'load', 'loads', 'scanner']
2.json模块提供了四个常⽤的功能：dumps，dump，loads，load
其中：json.dumps()⽅法可以将字典等数据（特殊的形式）格式化成⼀个所有语⾔认识的字符串，这样可以⽅便别的编程语⾔调⽤
import json
data = {
'roles':[
{'role':'monster','type':'pig','life':50},
{'role':'donkey','type':'dog','life':60},
]
}
j_str = json.dumps(data)
print("以前的数据类型：",type(data),data)
print("通过json转化后的数据类型",type(j_str),j_str)
# 以前的数据类型： <class 'dict'> {'roles': [{'role': 'monster', 'type': 'pig', 'life': 50}, {'role': 'donkey', 'type': 'dog', 'life': 60}]}
# 通过json转化后的数据类型 <class 'str'> {"roles": [{"role": "monster", "type": "pig", "life": 50}, {"role": "donkey", "type": "dog", "life": 60}]}
json.loads()⽅法可以进⾏反序列化
import json
data = {
'roles':[
{'role':'monster','type':'pig','life':50},
{'role':'donkey','type':'dog','life':60},
]
}
j_str = json.dumps(data)
ww = json.loads(j_str)
print("原来的格式：",type(j_str),j_str) #json把字典读成字符串
print("反序列化：",type(ww),ww) #通过loads反序列化成字典
# 原来的格式： <class 'str'> {"roles": [{"role": "monster", "type": "pig", "life": 50}, {"role": "donkey", "type": "dog", "life": 60}]}
# 反序列化： <class 'dict'> {'roles': [{'role': 'monster', 'type': 'pig', 'life': 50}, {'role': 'donkey', 'type': 'dog', 'life': 60}]}
json.dump()⽅法可以把字典等数据类型（特殊的形式）序列化成所有程序语⾔认识的字符串，进⼊⼀个⽂件中，等待别的程序进⾏调⽤import json
f = open('study.json','w')
dd = json.dump(data,f)
print(dd,type(dd))
#None <class 'NoneType'> 因为这个是在python读取的，它本来是⼤家都认识的，所以没有任何类型，
#json.dump将数据通过特殊的形式转化为所有语⾔都认识的字符串，并写⼊⽂件
json.load()⽅法可以读取⽂件中的内容
import json
f = open('study.json','r')
read_load = json.load(f)
print("读取的类型和内容 ",type(read_load),read_load)
结果：
读取的类型和内容 <class 'dict'> {'roles': [{'role': 'monster', 'type': 'pig', 'life': 50}, {'role': 'donkey', 'type': 'dog', 'life': 60}]}
易错点：如何把⼀个⽂件内的字符串形式通过json转化为相应的字典格式？
常见错误：
#account_file是⽂件的绝对路径
with open(account_file, "r", encoding="utf-8") as f: #打开⽂件
file_data = json.load(account_file)
print(file_data)
这样竟然出错了！！
错误信息：AttributeError: 'str' object has no attribute 'read'
改正后为：
#改正：
if os.path.isfile(account_file): #如果⽤户⽂件存在(即⽤户存在)
with open(account_file, "r", encoding="utf-8") as f: #打开⽂件
file_data = json.load(f)
print(file_data)
下⾯我们来测试⼀下json字符串和json对象到底是什么？
import json
i=10
s='hello'
t=(1,4,6)
l=[3,5,7]
d={'name':"james"}
json_str1=json.dumps(i)
json_str2=json.dumps(s)
json_str3=json.dumps(t)
json_str4=json.dumps(l)
json_str5=json.dumps(d)
print(json_str1) #'10'
print(json_str2) #'"hello"'
print(json_str3) #'[1, 4, 6]'
print(json_str4) #'[3, 5, 7]'
print(json_str5) #'{"name": "james"}'
这⾥⾯的json_str就是json字符串。

JSON字符串内的值：
数字（整数或浮点数）
字符串（在双引号中）
逻辑值（true 或 false）
数组（在⽅括号中）
对象（在花括号中，引号⽤双引）
null
请⼤家记住⼀句话：json字符串就是js对象的⼀种表现形式（字符串的形式）
JSON表⽰的对象就是标准的Javascripts语⾔的对象，JSON和Python内置的数据类型如下：
JSON类型python类型
{}dict
[]list
"string"str
"123456"int或float
true/false True/False
null None
或者看下表，更清晰：
python --> json
dict object
list,tuple array
str,unicode string
int,long,float number
True true
False false
None null
下⾯看⼀个带⽅法的json对象：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
</body>
<script>
var person = {
"name":"james",
"sex":"men",
"teacher":{
"name":"denken",
"sex":"male",
},
"boddy":["basketball","running"],
"getName":function () {
return 80;
}
};
alert();
alert(person.getName());
alert();
alert(person.boddy[0]);
</script>
</html>
parse()
parse() ⽤于从⼀个json字符串中解析出json对象
如：var str = '{"name":"james","age":"23"}'
结果：JSON.parse(str) ------> Object {age: "23",name: "james"}　
.stringify()
stringify() ⽤于从⼀个json对象解析成json字符串
如 var c = {a:1 , b:2 }
结果： JSON.stringify(c) ------> '{"a":1,"b":2}'
注意事项
注意1：单引号写在{}外，每个属性名都必须⽤双引号，否则会抛出异常。

a={name:"james"}; //ok
b={'name':'james'}; //ok
c={"name":"james"}; //ok
alert(); //ok
alert(a[name]); //undefined
alert(a['name']) //ok
pickle模块
1.查看pickle模块内的⽅法
import pickle
dir(pickle)
['ADDITEMS', 'APPEND', 'APPENDS', 'BINBYTES', 'BINBYTES8', 'BINFLOAT', 'BINGET',
'BININT', 'BININT1', 'BININT2', 'BINPERSID', 'BINPUT', 'BINSTRING', 'BINUNICODE',
'BINUNICODE8', 'BUILD', 'DEFAULT_PROTOCOL', 'DICT', 'DUP', 'EMPTY_DICT', 'EMPTY_LIST',
'EMPTY_SET', 'EMPTY_TUPLE', 'EXT1', 'EXT2', 'EXT4', 'FALSE', 'FLOAT', 'FRAME', 'FROZENSET',
'FunctionType', 'GET', 'GLOBAL', 'HIGHEST_PROTOCOL', 'INST', 'INT', 'LIST', 'LONG',
'LONG1', 'LONG4', 'LONG_BINGET', 'LONG_BINPUT', 'MARK', 'MEMOIZE', 'NEWFALSE',
'NEWOBJ', 'NEWOBJ_EX', 'NEWTRUE', 'NONE', 'OBJ', 'PERSID', 'POP', 'POP_MARK', 'PROTO',
'PUT', 'PickleError', 'Pickler', 'PicklingError', 'PyStringMap', 'REDUCE', 'SETITEM', 'SETITEMS',
'SHORT_BINBYTES', 'SHORT_BINSTRING', 'SHORT_BINUNICODE', 'STACK_GLOBAL', 'STOP',
'STRING', 'TRUE', 'TUPLE', 'TUPLE1', 'TUPLE2', 'TUPLE3', 'UNICODE', 'Unpickler',
'UnpicklingError', '_Framer', '_Pickler', '_Stop', '_Unframer', '_Unpickler', '__all__',
'__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__',
'__spec__', '_compat_pickle', '_dump', '_dumps', '_extension_cache', '_extension_registry',
'_getattribute', '_inverted_registry', '_load', '_loads', '_test', '_tuplesize2code', 'bytes_types',
'codecs', 'compatible_formats', 'decode_long', 'dispatch_table', 'dump', 'dumps',
'encode_long', 'format_version', 'io', 'islice', 'load', 'loads', 'maxsize', 'pack', 'partial',
're', 'sys', 'unpack', 'whichmodule']
2.想查看某个⽅法的帮助⽂档
help(pickle.modules_name) #就是help（）+pickle.模块名
#这样就可以得到模块⽅法的帮助⽂档
3.pickle模块常⽤的⽅法有：dumps,loads,dump,load
pickle.dumps对数据进⾏序列化操作
import pickle
data = {
'roles':[
{'role':'monster','type':'pig','life':50},
{'role':'donkey','type':'dog','life':60},
]
}
lis = [1,2,3,4,'rain']
res_lis = pickle.dumps(lis)
res_dic = pickle.dumps(data)
print(type(res_lis),res_lis)
print(type(res_dic),res_dic)
# <class 'bytes'> b'\x80\x03]q\x00(K\x01K\x02K\x03K\x04X\x04\x00\x00\x00rainq\x01e.'
# <class 'bytes'> b'\x80\x03}q\x00X\x05\x00\x00\x00rolesq\x01]q\x02(}q\x03(X\x04\x00\x00\x00roleq\x04X\x07\x00\x00\x00monsterq\x05X\x04\x00\x00\x00typeq\x06X\x03\x00\x00\x00pigq\x07X\x04\x00\x00\x00lifeq\x08K2u}q\t(h\x04X\x06\x00 #将data写⼊⽂件中
pk = open('data.pkl','wb')
print(type(pk),pickle.dump(data,pk))
# <class '_io.BufferedWriter'> None
使⽤pickle.loads进⾏反序列化操作
import pickle
data = {
'roles':[
{'role':'monster','type':'pig','life':50},
{'role':'donkey','type':'dog','life':60},
]
}
lis = [1,2,3,4,'rain']
res_lis = pickle.dumps(lis)
res_dic = pickle.dumps(data)
back_reslis = pickle.loads(res_lis)
back_resdic = pickle.loads(res_dic)
print(type(back_reslis),back_reslis)
print(type(back_resdic),back_resdic)
# <class 'list'> [1, 2, 3, 4, 'rain']
# <class 'dict'> {'roles': [{'role': 'monster', 'type': 'pig', 'life': 50}, {'role': 'donkey', 'type': 'dog', 'life': 60}]}
pickle.dump() 将数据通过特殊的形式转化为只有python语⾔认识的字符串，并写⼊⽂件
import pickle
data = {
'roles':[
{'role':'monster','type':'pig','life':50},
{'role':'donkey','type':'dog','life':60},
]
}
pk = open('data.pkl','wb')
print(type(pk),pickle.dump(data,pk))
pickle.load()对⽂件进⾏反序列化，得到⽂件⾥⾯保存的数据
import pickle
data = {
'roles':[
{'role':'monster','type':'pig','life':50},
{'role':'donkey','type':'dog','life':60},
]
}
with open('data.pkl','rb') as f:
result = pickle.load(f)
print(result)
# {'roles': [{'role': 'monster', 'type': 'pig', 'life': 50}, {'role': 'donkey', 'type': 'dog', 'life': 60}]}
shelve模块
　shelve模块是⼀个简单的k,v将内存数据通过⽂件持久化的模块，返回类似于字典的对象，可读可写；key必须是字符串，⼆值可以持久化任何pickle可⽀持的python数据格式
shelve模块很简单，只有⼀个open函数，json和pickle模块只能dumps和loads只能⼀次，但是shelve就能dumps多次。

这就是shelve存在的必要性，其中shelve对pickle进⾏了包装，是⼀个键值对的形式。

序列化
import shelve
f = shelve.open('shelve_test')
names = ['laex','howard','batumu']
info = {'name':'howard','age':22}
f['names'] = names #持久化列表
f['info_dic'] = info
f.close()
反序列化
import shelve
d = shelve.open('shelve_test') #打开⼀个⽂件
print(d['name'])
print(d['info_dic'])
# del d['test'] #还可以删除
# ['laex', 'howard', 'batumu']
# {'name': 'howard', 'age': 22}
xml模块
什么是xml模块呢？
xml是实现不同语⾔或程序之间进⾏数据交换的协议，跟json差不多，但json使⽤起来更简单，不过，古时候，在json还没诞⽣的⿊暗年代，⼤家只能选择⽤xml呀，⾄今很多传统公司如⾦融⾏业的很多系统的接⼝还主要是xml。

xml的格式如下，就是通过<>节点来区别数据结构的：
<?xml version="1.0"?>
<data>
<country name="Liechtenstein">
<rank updated="yes">2</rank>
<year>2008</year>
<gdppc>141100</gdppc>
<neighbor name="Austria" direction="E"/>
<neighbor name="Switzerland" direction="W"/>
</country>
<country name="Singapore">
<rank updated="yes">5</rank>
<year>2011</year>
<gdppc>59900</gdppc>
<neighbor name="Malaysia" direction="N"/>
</country>
<country name="Panama">
<rank updated="yes">69</rank>
<year>2011</year>
<gdppc>13600</gdppc>
<neighbor name="Costa Rica" direction="W"/>
<neighbor name="Colombia" direction="E"/>
</country>
</data>
xml数据
View Code
xml协议在各个语⾔⾥的都是⽀持的，在python中可以⽤以下模块操作xml：
import xml.etree.ElementTree as ET
tree = ET.parse("xmltest.xml")
root = tree.getroot()
print(root.tag)
#遍历xml⽂档
for child in root:
print(child.tag, child.attrib)
for i in child:
print(i.tag,i.text)
#只遍历year 节点
for node in root.iter('year'):
print(node.tag,node.text)
#---------------------------------------
import xml.etree.ElementTree as ET
tree = ET.parse("xmltest.xml")
root = tree.getroot()
#修改
for node in root.iter('year'):
new_year = int(node.text) + 1
node.text = str(new_year)
node.set("updated","yes")
tree.write("xmltest.xml")
#删除node
for country in root.findall('country'):
rank = int(country.find('rank').text)
if rank > 50:
root.remove(country)
tree.write('output.xml')
⾃⼰创建的xml⽂档
import xml.etree.ElementTree as ET
new_xml = ET.Element("namelist")
name = ET.SubElement(new_xml,"name",attrib={"enrolled":"yes"})
age = ET.SubElement(name,"age",attrib={"checked":"no"})
sex = ET.SubElement(name,"sex")
sex.text = '33'
name2 = ET.SubElement(new_xml,"name",attrib={"enrolled":"no"})
age = ET.SubElement(name2,"age")
age.text = '19'
et = ET.ElementTree(new_xml) #⽣成⽂档对象
et.write("test.xml", encoding="utf-8",xml_declaration=True)
ET.dump(new_xml) #打印⽣成的格式
创建xml⽂档
View Code
注意：⾃⼰创建xml⽂档的时候⼀定不要把代码⽂件名称命名为xml.py，不然会报错，因为Python引⽤包的时候应该是先在代码⽂件所在的⽂件夹查找，把⽂件名命名为xml.py时，import xml.etree.Element 这⼀句就在当前⽂件夹找到了⾃⾝源⽂件，⾃⼰写的xml.py⾥⾯根本就没有etree.Element这些模块，当然是要报错了。

Json和XML的⽐较
⼀，可读性
JSON和XML的可读性可谓不相上下，⼀边是简易的语法，⼀边是规范的标签形式，很难分出胜负。

⼆，可扩展性
XML天⽣有很好的扩展性，JSON当然也有，没有什么是XML可以扩展⽽JSON却不能扩展的。

不过JSON在Javascript主场作战，可以存储Javascript复合对象，有着xml不可⽐拟的优势。

三，编码难度
XML有丰富的编码⼯具，⽐如Dom4j、JDom等，JSON也有提供的⼯具。

⽆⼯具的情况下，相信熟练的开发⼈员⼀样能很快的写出想要的xml⽂档和JSON字符串，不
过，xml⽂档要多很多结构上的字符。

四，解码难度
XML的解析⽅式有两种：
⼀是通过⽂档模型解析，也就是通过⽗标签索引出⼀组标记。

例如：xmlData.getElementsByTagName("tagName")，但是这样是要在预先知道⽂档结构的情况下使⽤，⽆法进⾏通⽤的封装。

另外⼀种⽅法是遍历节点（document 以及 childNodes）。

这个可以通过递归来实现，不过解析出来的数据仍旧是形式各异，往往也不能满⾜预先的要求。

凡是这样可扩展的结构数据解析起来⼀定都很困难。

JSON也同样如此。

如果预先知道JSON结构的情况下，使⽤JSON进⾏数据传递简直是太美妙了，可以写出很实⽤美观可读性强的代码。

如果你是纯粹的前台开发⼈员，⼀定会⾮常喜欢JSON。

但是如果你是⼀个应⽤开发⼈员，就不是那么喜欢了，毕竟xml才是真正的结构化标记语⾔，⽤于进⾏数据传递。

⽽如果不知道JSON的结构⽽去解析JSON的话，那简直是噩梦。

费时费⼒不说，代码也会变得冗余拖沓，得到的结果也不尽⼈意。

但是这样也不影响众多前台开发⼈员选择JSON。

因为json.js中的toJSONString()就可以看到JSON的字符串结构。

当然不是使⽤这个字符串，这样仍旧是噩梦。

常⽤JSON的⼈看到这个字符串之后，就对JSON的结构很明了了，就更容易的操作JSON。

以上是在Javascript中仅对于数据传递的xml与JSON的解析。

在Javascript地盘内，JSON毕竟是主场作战，其优势当然要远远优越于xml。

如果JSON中存储Javascript复合对象，⽽且不知道其结构的话，我相信很多程序员也⼀样是哭着解析JSON的。

除了上述之外，JSON和XML还有另外⼀个很⼤的区别在于有效数据率。

JSON作为数据包格式传输的时候具有更⾼的效率，这是因为JSON不像XML那样需要有严格的闭合标签，这就让有效数据量与总数据包⽐⼤⼤提升，从⽽减少同等数据流量的情况下，⽹络的传输压⼒。