day5-python中的序列化与反序列化-json&pickle

时间  2020-06-02
标签 day5 day python 序列 json&pickle json pickle 栏目 Python 繁體版
原文   原文链接

1、概述

玩过稍微大型一点的游戏的朋友都知道，不少游戏的存档功能使得咱们能够方便地迅速进入上一次退出的状态（包括装备、等级、经验值等在内的一切运行时数据），那么在程序开发中也存在这样的需求：比较简单的程序，对象的处理都在内存中直接实现，程序退出后对象就消失；但对于功能需求稍微拔高一点的程序来说，不少时候每每须要须要把对象持久化保存起来，以便下次启动程序时还能直接进入最后一次的状态。html

这个处理过程在程序开发中就是序列化与反序列化。python

2、序列化与反序列化的概念

概述中引入了一个游戏存档的场景，本质上是游戏程序把运行时的对象转换成能够持久存储的对象，而后保存（到数据库）的过程。仍是以这个为引子来说讲序列化与反序列化的概念（如下概念整合自网络资料，我的认为解释比较到位了）。数据库

  • 序列化
    咱们把程序运行时内存中的数据结构或对象转换成二进制串字节序列的过程称之为序列化，这样咱们就能够对对象实现持久化存储或网络传输。
    请注意如下重点：
    1. 序列化的对象
            是内存中的数据结构或对象，也就是咱们在程序运行中操纵的一切对象（这是一个面向对象的时代，固然包括不少地方说的变量啦~）
    2. 序列化后的对象
            变为二进制串字节序列，这个不做过多解释，要持久化保存到硬件或进行网络传输，必须是bytes对象。
    3. 序列化的目的
            想一想本身玩游戏时存档的那种便利性和必要性把，有些对象必须可以持久化地保存（通常文件，数据库，巴拉巴拉…）或进行网络传输（分布式程序），才能知足功能需求。
  • 反序列化
    反序列化就是序列化的逆向过程，持久化保存或网络传输数据的最终目的也是为了后续使用，必须能够逆向加载到内存中二次利用，这就是反序列化。

python中的序列化与反序列化模块有json和pickle，下面就来看看怎么玩转它们。编程

3、json模块

json模块提供了dumps，loads，dump和load四种方法，下面展开来阐述：json

  1. dumps序列化和loads反序列化
    dumps和loads是成对出现的：
    dumps用于将python中的简单数据类型（典型的是字典和列表，还有字符串）进行json格式encode编码，转换为符合json格式的字符串（返回标准的json格式字符串）；
    loads则恰好相反，用于把符合json格式的字符串decode成python中特定的数据类型（注意是简单的数据类型，下文会详细解释）。 
     1 >>> import json
 2 >>> list1=['a','b','c']
 3 >>> print(type(list))
 4 <class 'type'>
 5 
 6 #dumps序列化，能够理解为encode json过程
 7 >>> print(json.dumps(list1))
 8 ["a", "b", "c"]
 9 >>> print(type(json.dumps(list1)))
 10 <class 'str'>   #list dumps处理后变为str类型
 11 >>> dict1={'id':'001','name':'Maxwell'}
 12 >>> print(type(dict1))
 13 <class 'dict'>
 14 >>> print(type(json.dumps(dict1)))
 15 <class 'str'>   #dict通过dumps处理后也变成str类型
 16 >>>
 17 
 18 #loads反序列化
 19 >>> print(json.loads(json.dumps(list1)))
 20 ['a', 'b', 'c']
 21 >>> print(json.loads(json.dumps(dict1)))
 22 {'id': '001', 'name': 'Maxwell'}
 23 >>> print(type(json.loads(json.dumps(list1))))
 24 <class 'list'>  #把通过json dumps处理过的字符串loads序列化，可还原为原来的数据类型
 25 >>> print(type(json.loads(json.dumps(dict1))))
 26 <class 'dict'>  #把通过json dumps处理过的字符串loads序列化，可还原为原来的数据类型
    以上代码仅仅是展现loads方法的效果，实际使用中咱们能够把符合python中json格式的自定义字符串（好比程序中的输入）转换成特定的数据类型，这样就能够在程序中跑起来： 
     1 >>> str1='["a", "b", "c"]'
 2 >>> print(type(json.loads(str1)))
 3 <class 'list'>  #反序列化为list
 4 >>> print(json.loads(str1))
 5 ['a', 'b', 'c']
 6 >>> str2='{"id":"001","name":"Maxwell"}'
 7 >>> print(json.loads(str2))
 8 {'id': '001', 'name': 'Maxwell'}
 9 >>> print(json.loads(str2))
 10 {'id': '001', 'name': 'Maxwell'}
 11 >>> print(type(json.loads(str2)))
 12 <class 'dict'>  #反序列化为dict
    注意：经过loads方法反序列化自定义的字符串时，外层的引号必须是单引号，内层的引号是双引号（能够对照dumps后输出的引号是双引号来看），这是python的规范，别问为何了。

    好了，以上展现了dumps和loads的处理过程，咱们的目的不是把python中的运行时对象能进行持久化保存或网络传输吗？下面展现经过dumps处理后保存到文本文件和从文本文件中loads出历史保存的数据效果：
    (1) dumps序列化后保存 
     1 import json
 2 dict1={'id':'001','name':'Maxwell'}
 3 with open('dumps.txt','w',encoding='utf-8') as f:
 4     f.write(json.dumps(dict1))
 5
    看看保存后的文本文件dumps.txt的内容：
    image

    (2) loads反序列化从文件中加载数据 
     1 >>> import json
 2 >>> with open('dumps.txt','r',encoding='utf-8') as f:
 3 ...     content = f.read()
 4 >>> print(json.loads(content))
 5 {'id': '001', 'name': 'Maxwell'}
 6 >>> print(type(json.loads(content)))
 7 <class 'dict'>  #loads反序列化后成功还原为原来的数据类型dict
 8 >>> print(json.loads(content).get('name'))
 9 Maxwell  #此时能够应用dict的各类大法了
 10 >>> print(json.loads(content)['name'])
 11 Maxwell
  2. dump序列化和load反序列化
    dump和load也是成对出现的，dump能够把python中的特定数据类型（比较多用的仍是dict和list）转换为json格式，并直接写入写入一个file-like Object（操做的对象包括未转换的python对象和file-like Object），load则与此相反，可从文件对象中反序列化出python的原生对象出来。 
     1 >>> import json
 2 >>> dict1={'id': '001', 'name': 'Maxwell'}
 3 >>> with open('dump.txt','w',encoding='utf-8') as f:
 4 ...     json.dump(dict1,f)   #dump序列化，直接操做原生数据类型对象和文件句柄
 5 ...
 6 
 7 #load反序列化
 8 >>> with open('dump.txt','r',encoding='utf-8') as f:
 9 ...     content = json.load(f)  #注意这里先用一个对象把load的内容保存起来，不然关闭文件后就不能再访问了
 10 ...
 11 >>> print(content)
 12 {'id': '001', 'name': 'Maxwell'}
 13 >>> print(type(content))
 14 <class 'dict'>   #成功反序列化成dict
 15 >>> print(content['name'])
 16 Maxwell          #试试dict大法
  3. （dumps & loads） VS （dump & load）
    对比下dumps & loads和dump & load吧：
    （1）dumps & loads
           只能解决python中能够被json模块处理的对象和json格式字符串之间相互转换的问题，它们操做的对象分别是能够被json模块处理的对象和json格式  
           字符串。
    （2）dump和load
            能够理解为json文件处理函数，操做的对象是python中能够被json模块处理的对象和file-like Object，屏蔽或者说省略了json格式字符串这一细节
    综合对比起来，若是要经过文件保存或从文件中加载运行时对象，使用dump和load更方便，代码更少；反之若是仅仅须要进行json格式处理，则建议使用dumps和loads。

4、pickle

pickle模块实现了用于对Python对象结构进行序列化和反序列化的二进制协议，与json模块不一样的是pickle模块序列化和反序列化的过程分别叫作 pickling 和 unpickling，且转换先后是二进制字节码，再也不是简单的可阅读的字符串：网络

  • pickling： 是将Python对象转换为字节流的过程；
  • unpickling： 是将字节流二进制文件或字节对象转换回Python对象的过程；
  1. dumps序列化和loads反序列化
    与jsonddumps和loads很是相似，不一样的就在于转换后的格式是二进制字节码 
     1 >>> import pickle
 2 >>> dict1={'id':'001','name':'Maxwell'}
 3 >>> pickle.dumps(dict1)
 4 b'\x80\x03}q\x00(X\x02\x00\x00\x00idq\x01X\x03\x00\x00\x00001q\x02X\x04\x00\x00\
 5 x00nameq\x03X\x07\x00\x00\x00Maxwellq\x04u.' #序列化成二进制字节码
 6 >>> print(type(pickle.dumps(dict1)))
 7 <class 'bytes'>
 8 >>> pickle.loads(pickle.dumps(dict1))        #成功反序列化
 9 {'id': '001', 'name': 'Maxwell'}
 10 >>> print(type(pickle.loads(pickle.dumps(dict1))))
 11 <class 'dict'>
 12 >>> pickle.loads(pickle.dumps(dict1))['name']
 13 'Maxwell'
    因为pickle序列化后数据类型变为二进制字节码，所以在保存文件和读取文件时须要分别以wb和rb模式打开： 
     1 >>> import pickle
 2 >>> dict1={'id':'001','name':'Maxwell'}
 3 >>> with open('picklt.txt','wb') as f:  #以wb模式打开文件后写入dumps内容
 4 ...     f.write(pickle.dumps(dict1))
 5 ...
 6 
 7 >>> with open('picklt.txt','rb') as f:  #以rb模式打开后读取内容
 8 ...     data = pickle.loads(f.read())
 9 ...
 10 >>> print(data)
 11 {'id': '001', 'name': 'Maxwell'}
    经过dumps写入后，因为是二进制字节码，因此打开会有乱码显示了：
    image
  2. dump序列化和load反序列化
    同理，pickle的dump序列化和load反序列化也和json的dump、load很是相似，仍是看相同的例子吧： 
     1 >>> import pickle
 2 >>> dict1={'id': '001', 'name': 'Maxwell'}
 3 >>> with open('pickle.txt','wb') as f:
 4 ...     pickle.dump(dict1,f)
 5 ...
 6 >>> with open('pickle.txt','rb') as f:
 7 ...     content = pickle.load(f)
 8 ...
 9 >>> print(content)
 10 {'id': '001', 'name': 'Maxwell'}
 11 >>> print(content['name'])
 12 Maxwell
    dump保存写入的文件内容：
    image
  3. 序列化函数
    （1）序列化 
     1 # !/usr/bin/env python
 2 # -*- coding: utf-8 -*-
 3 __author__ = 'Maxwell'
 4 
 5 import pickle
 6 
 7 def sayhi(name):
 8     print('Hello:', name)
 9 
 10 info = {'name':'Maxwell', 'func':sayhi}  #func对应的值是一个函数
 11 
 12 with open('test.txt', 'wb') as f:
 13     data = pickle.dumps(info)
 14     f.write(data)
 15

    （2）反序列化 
     1 # !/usr/bin/env python
 2 # -*- coding: utf-8 -*-
 3 __author__ = 'Maxwell'
 4 
 5 import pickle
 6 
 7 def sayhi(name):   #此处须要定义出函数,由于它不能被直接加载到内存中
 8     print('Hello:',name)
 9 
 10 with open('test.txt','rb') as f:
 11     data = pickle.loads(f.read())
 12 
 13 print(data.get('name'))
 14 data.get('func')('Tom')
 15 
 16 结果输出：
 17 Maxwell
 18 Hello: Tom

4、json和pickle对比

  • JSON是一种文本序列化格式（它输出的是unicode文件，大多数时候会被编码为utf-8），而pickle是一个二进制序列化格式;
  • JOSN处理的是python对象和字符串的转换问题，是咱们能够读懂的数据格式，而pickle是二进制格式，咱们没法读懂；
  • JSON是与特定的编程语言或系统无关的，且它在Python生态系统以外被普遍使用，而pickle使用的数据格式是特定于Python的；
  • 默认状况下，JSON只能表示Python内建数据类型，并且是仅限于比较简单的数据类型，如dict，list和str，对于自定义数据类型须要一些额外的工做来完成；pickle能够直接表示大量的Python数据类型，包括自定数据类型（其中，许可能是经过巧妙地使用Python内省功能自动实现的；复杂的状况能够经过实现specific object API来解决）

以上内容摘自http://www.cnblogs.com/yyds/p/6563608.html
数据结构

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程