专栏首页python3python序列化:json,pickl

python序列化:json,pickl

什么是序列化

什么是序列化,把程序中的对象或者变量,从内存中转换为可存储或可传输的过程称为序列化。在 Python 中,这个过程称为 pickling,在其他语言中也被称为 serialization,marshalling,flattening 等。程序中的对象(或者变量)在序列化之后,就可以直接存放到存储设备上,或者直接发送到网络上进行传输。

序列化的逆向过程,即为反序列化(unpickling),就是把序列化的对象(或者变量)重新读到内存中~

json模块

json 模块就用于序列化和反序列化。对象(变量)使用json模块序列化后,表现为一个字符串,序列化为字符串格式的好处是:序列化后的对象可以在不同的编程语言之间传递。 python 数据类型和 json 中的字符串对应关系如下:

python数据类型

json字符串

dict

'{}'

list

'[]'

tuple

'[]'

str

'string'

int/float

'1.23'

True/False

true/false

None

null

json模块常用的就4个方法:dump,dumps,load,loads~

json.dump / json.dumps

这两个方法用于序列化对象,两个方法的功能类似,区别在于,json.dumps 方法接收一个参数,即需要序列化的对象,其余参数为可选参数,方法执行完成后,会返回序列化后得到的字符串;json.dump 接收两个参数,第一个参数和 dumps方法 相同,即需要序列化的对象,第二个参数为文件对象,例如 open方法 的返回对象,其余为可选参数,方法执行后,序列化后的字符串会直接写到文件中~ dump / dumps 示例:

import json

d = {'name': '贝贝', 'age': 18}
lst = [1, 2, 3]
tup = ('a', 'b', 'c')
s = 'hello'
i = 3
f = 1.2
flag_1 = True
flag_2 = False
abc = None

print(type(json.dumps(d)))   # <class 'str'>
print(json.dumps(d))           # {"name": "\u8d1d\u8d1d", "age": 18}
print(json.dumps(lst))         # [1, 2, 3]
print(json.dumps(tup))        # ["a", "b", "c"]
print(json.dumps(s))           # "hello"
print(json.dumps(i))            # 3
print(json.dumps(f))            # 1.2
print(json.dumps(flag_1))   # true
print(json.dumps(flag_2))   # false
print(json.dumps(abc))       # null

# 以上的输出类型都是 class 'str' 类型,即字符串类型~

#################################
d = {'name': '贝贝', 'age': 18}
with open(file='/tmp/test_json', mode='w') as f:
    json.dump(d, f)

# 执行完成后,查看输出的文件内容:
➜  ~ cat /tmp/test_json
{"name": "\u8d1d\u8d1d", "age": 18}%   

json.load / json.loads

这两个方法用于序列化后的字符串 反序列化,两者的区别和 dump、dumps 类似,json.loads 接收一个字符串参数,其余参数为可选参数,json.load 也接收一个参数,该参数为包含 json 字符串的文件对象~

json.loads示例:

d = json.loads('{"name": "\u8d1d\u8d1d", "age": 18}')
print(type(d), '--', d)

abc = json.loads('null')
print(type(abc), '--', abc)

tup = json.loads('["a", "b", "c"]')
print(type(tup), '--', tup)

s = json.loads('"hello"')
print(type(s), '--', s)

# 输出结果:
<class 'dict'> -- {'name': '贝贝', 'age': 18}
<class 'NoneType'> -- None
<class 'list'> -- ['a', 'b', 'c']
<class 'str'> -- hello

注意:传递给 json.loads 方法的参数必须用 单引号括起来,里面的字符串使用双引号,例如不能有这样的写法:json.loads("hello"),json.loads("['a', 'b', 'c']"),json 字符串中不支持单引号~ json.load示例:

with open(file='/tmp/test_json', mode='r') as f:
    json_data = json.load(f)
    print(type(json_data), '--', json_data)

# 输出结果:
<class 'dict'> -- {'name': '贝贝', 'age': 18}

json模块中的字符编码问题

我们可以看到上述示例中,字典对象中包含有中文字符,在进行序列化后,不管是使用 dumps 存放到字符串中 还是使用 dump 存放到文件中,中文字符串是使用 unicode 编码格式存放的。 在Python3中,代码中的字符串都是使用 unicode 格式存放的,序列化之后也是以unicode 格式存放,所以序列化和反序列化过程都不存在问题。

Python2中,代码中的字符串是 str类型,str类型 和 unicode类型 的关系如下所示:

unicode -----> encode --------> str(例如为 utf-8编码)
utf-8(例如为 utf-8编码) --------> decode ----------> unicode

所以在Python2中,序列化过程和反序列化过程都有涉及到转码过程(encode和decode),序列化过程 会先将对象中的字符串 使用utf-8 进行解码(decode),转换为unicode类型后,再存放到文件或者字符串中,反序列化过程 会将 json字符串 使用utf-8 编码(encode),然后存放到内存中的变量~ 说明:在Python2中,dumps(dump)和loads(load)默认使用 utf-8 进行 encode和decode,若要使用使用其他编码方式,可以通过 encode参数 指定;在Python3中,dumps(dump)和loads(load)方法都没有 encode参数~ 来看如下示例:

# -*- coding:utf-8 -*-
d = {'name': '贝贝', 'age': 18}
print type(json.dumps(d)), '--', json.dumps(d)

res_d = json.loads('{"age": 18, "name": "\u8d1d\u8d1d"}')
print type(res_d), '--', res_d

# 结果输出:
<type 'str'> -- {"age": 18, "name": "\u8d1d\u8d1d"}
<type 'dict'> -- {u'age': 18, u'name': u'\u8d1d\u8d1d'}

如上过程,序列化和反序列化都没有问题,这是因为,文件的开头指定了 ‘# -- coding:utf-8 --’,程序中的字符串(str类型)就是使用utf-8编码后存放于内存中~ 现在修改一下文件开头的编码:

# -*- coding:gbk -*-
d = {'name': '贝贝', 'age': 18}
print type(json.dumps(d)), '--', json.dumps(d)

res_d = json.loads('{"age": 18, "name": "\u8d1d\u8d1d"}')
print type(res_d), '--', res_d

这个时候就会报出如下错误信息,很简单,utf-8 无法解码 gbk编码的字符串('贝贝')

UnicodeDecodeError: 'utf8' codec can't decode byte 0xb1 in position 0: invalid start byte

解决方法就是,在 dumps 过程中指定使用 gbk 进行解码,然后输出就正常了~

# -*- coding:gbk -*-
d = {'name': '贝贝', 'age': 18}
json_str = json.dumps(d, encoding='gbk')
print type(json_str), '--', json_str

res_d = json.loads('{"age": 18, "name": "\u8d1d\u8d1d"}')
print type(res_d), '--', res_d

# 输出结果:
<type 'str'> -- {"age": 18, "name": "\u8d1d\u8d1d"}
<type 'dict'> -- {u'age': 18, u'name': u'\u8d1d\u8d1d'}

注意:这里 loads 过程不需要指定编码格式,因为反序列化之后存放到内存中的依旧是unicode格式的字符串~ 还有一种更简单的解决方式,即在中文字符前加 u

d = {'name': u'贝贝', 'age': 18}
json_str = json.dumps(d)

pickle 模块

pickle 模块也用于序列化和反序列化Python对象(变量),其用法和 json 模块的使用基本一致。pickle 模块 和 json 模块 区别在于:pickle 模块 仅用于Python的数据类型,序列化后的对象不能再不同的编程语言之间传递,但是 pickle 模块 可序列化几乎所有的Python数据类型,包括时间对象,函数,类…

序列化基本数据类型

import pickle

d = {'name': '贝贝', 'age': 18}
d_dump = pickle.dumps(d)
print(d_dump)

d_load = pickle.loads(d_dump)
print(type(d_load), '--', d_load)

# 结果输出:
b'\x80\x03}q\x00(X\x04\x00\x00\x00nameq\x01X\x06\x00\x00\x00\xe8\xb4\x9d\xe8\xb4\x9dq\x02X\x03\x00\x00\x00ageq\x03K\x12u.'    # 注意 输出的是 byte 类型(即python2中的str类型)
<class 'dict'> -- {'name': '贝贝', 'age': 18}

####################################
lst = [1, 2, 3]
with open('/tmp/test_pickle', mode='wb') as f:     # 打开文件的模式为二进制写
    pickle.dump(lst, f)

with open('/tmp/test_pickle', mode='rb') as f:       # 打开文件的模式为二进制读
    lst_load = pickle.load(f)
    print(type(lst_load), '--', lst_load)

# 结果输出:
<class 'list'> -- [1, 2, 3]

# 存放序列化对象的文件:
➜  ~ cat /tmp/test_pickle 
q(KKKe.% 

可以看到 pickle序列化后的数据,可读性差,不像json那样一目了然~

序列化类class对象

import pickle

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def say_hello(self):
        print('hello %s' % (self.name))

p = Person('贝贝', 18)
# p.say_hello()
# del Person

with open('/tmp/test_pickle', mode='wb') as f:
    pickle.dump(p, f)

with open('/tmp/test_pickle', mode='rb') as f:
    p_load = pickle.load(f)
    p_load.say_hello()

# 输出结果:
hello 贝贝

注意:中途不能del Person,不然会出现如下错误

_pickle.PicklingError: Can't pickle <class '__main__.Person'>: attribute lookup Person on __main__ failed

shelve 模块

shelve 模块也用于序列化,shelve 模块是在 pickle 模块上做了一层封装,也仅支持两个Python程序之间进行交换~,优点是 shelve 模块 可以序列化 Python 的所有数据类型~ shelve 模块比 pickle 模块更加简单,只有一个 open函数,返回类似字典的对象,可读可写,当为某个 key 赋值时,这个值会被序列化,并进行存储;通过某个 key 读出对应的值时,即是一个反序列化过程,其中 key 必须为字符串,而值可以是python所支持的数据类型。 shelve 模块存取过程:

import shelve

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def say_hello(self):
        print('hello %s' % (self.name))

p = Person('贝贝', 18)
d = {'name': 'abc', 'age': 20}

f = shelve.open(r'/tmp/test_shelve')
f['d_info'] = d
f['p_info'] = p

print(f.get('d_info'))
f.get('p_info').say_hello()

f.close()

如上过程,class对象和基本数据类型会被序列化并存放在文件 '/tmp/test_shelve' 中,f.get() 取出过程即是一个反序列化过程~

若是一个可变对象,使用 shelve 模块序列化之后存放到文件中,然后取出(get)对可变对象进行更改,这个时候,已经改变的可变对象只是保存在内存中,不会被写入到文件中,看如下示例:

import shelve

f = shelve.open(r'/tmp/test_shelve')
f['lst_info'] = [1,2,3]

f.get('lst_info').append(4)
print(f.get('lst_info'))

# 输出结果:
[1, 2, 3]

若要进行更改需要重新写入,即重新序列化:

import shelve

f = shelve.open(r'/tmp/test_shelve')
f['lst_info'] = [1, 2, 3]

lst = f.get('lst_info')
lst.append(4)
f['lst_info'] = lst
print(f.get('lst_info'))

# 输出结果:
[1, 2, 3, 4]

或者在使用 shelve 打开文件时,设置 writeback 为True:

f = shelve.open(r'/tmp/test_shelve', writeback=True)
f['lst_info'] = [1, 2, 3]

f.get('lst_info').append(4)
print(f.get('lst_info'))

# 输出结果:
[1, 2, 3, 4]

.................^_^

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • Scrapy快速上手

    https://blog.csdn.net/fly_yr/article/details/51540269

    py3study
  • Python自动化开发学习4-3

    python自带的str()可以完成序列化,然后eval()可以反序列化,但是我们先把他们忘记。不知道适用范围是多大。

    py3study
  • python3--序列化模块,hashlib模块

    __len__    len(obj)的结果依赖于obj.__len__()的结果,计算对象的长度

    py3study
  • 如何实现一个优雅的Python的Json序列化库

    在Python的世界里,将一个对象以json格式进行序列化或反序列化一直是一个问题。Python标准库里面提供了json序列化的工具,我们可以简单的用json....

    ThoughtWorks
  • 函数 | Python内置函数详解—集合操作类

    Python内置的函数及其用法。为了方便记忆,已经有很多开发者将这些内置函数进行了如下分类:

    潘永斌
  • Python函数的介绍

    Python技术与生活认知的分享
  • AAAI最新公布12名资深会员:3位华人教授入选,论文引用近2万次!

    日前,AAAI(Association for the Advancement of Artificial Intelligence)在其官方推特上宣布,12名...

    新智元
  • 我没啥特长,如何找好工作

    很多同学感慨:感觉自己工作了一段时间,没啥特别牛逼的能力,做的事情都很普通。这样怎么找个好工作呢?今天系统解答一下。

    接地气的陈老师
  • 深入 Python 流程控制

    可能会有零到多个 elif 部分,else 是可选的。关键字 ‘elif’ 是 ’else if’ 的缩写,这个可以有效地避免过深的缩进。if … elif …...

    py3study
  • kubernetes部署jenkins

    问题出在pod挂载了nfs共享过来的目录,但没有写的权限。启动一个Jenkins docker查看Jenkins用户:

    菲宇

扫码关注云+社区

领取腾讯云代金券