什么是序列化对象?

  我们把对象(变量)从内存中编程可存储或传输的过程称之为序列化,在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模块

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

JSON表示的对象就是标准的Javascripts语言的对象,JSON和Python内置的数据类型如下:

JSON类型 python类型
{} dict
[] list
“string” str
“123456” int或float
true/false True/False
null None

 

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}]}

  

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\x00\x00donkeyq\nh\x06X\x03\x00\x00\x00dogq\x0bh\x08K<ues.'
#将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

 

版权声明:本文为wj-1314原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://www.cnblogs.com/wj-1314/p/8206840.html