老生常谈Python序列化和反序列化

概述通过将对象序列化可以将其存储在变量或者文件中，可以保存当时对象的状态，实现其生命周期的延长。并且需要时可以再次将这个对象读取出来。Python中有几个常用模块可实现这一功能。

通过将对象序列化可以将其存储在变量或者文件中，可以保存当时对象的状态，实现其生命周期的延长。并且需要时可以再次将这个对象读取出来。Python中有几个常用模块可实现这一功能。

pickle模块

存储在变量中

dumps(obj)返回存入的字节

dic = {'age': 23,'job': 'student'}byte_data = pickle.dumps(dic)# out -> b'\x80\x03}q\x00(X\x03\x00\x00\...'print(byte_data)

读取数据

数据以字节保存在了byte_data变量中，需要再次使用的时候使用loads函数就行了。

obj = pickle.loads(byte_data)print(obj)

存储在文件中

也可以存在文件中，使得对象持久化。使用的是dump和load函数，注意和上面的区别，少了s。由于pickle写入的是二进制数据，所以打开方式需要以wb和rb的模式。

# 序列化with open('abc.pkl','wb') as f:  dic = {'age': 23,'job': 'student'}  pickle.dump(dic,f)# 反序列化with open('abc.pkl','rb') as f:  aa = pickle.load(f)  print(aa)  print(type(aa)) # <class 'dict'>

序列化用户自定义对象

假如我写了个类叫做Person

class Person:  def __init__(self,name,age,job):    self.name = name    self.age = age    self.job = job  def work(self):    print(self.name,'is working...')

pickle当然也能写入，不仅可以写入类本身，也能写入它的一个实例。

# 将实例存储在变量中，当然也能存在文件中a_person = Person('abc',22,'waiter')person_abc = pickle.dumps(a_person)p = pickle.loads(person_abc)p.work()# 将类本身存储在变量中，loads的时候返回类本身，而非它的一个实例class_Person = pickle.dumps(Person)Person = pickle.loads(class_Person)p = Person('Bob',23,'Student')p.work()# 下面这个例子演示的就是将类存储在文件中# 序列化with open('person.pkl','wb') as f:  pickle.dump(Person,f)# 反序列化with open('person.pkl','rb') as f:  Person = pickle.load(f)  aa = Person('gg','6')  aa.work()

Json模块

pickle可以很方便地序列化所有对象。不过Json作为更为标准的格式，具有更好的可读性（pickle是二进制数据）和跨平台性。是个不错的选择。

Json使用的四个函数名和pickle一致。

序列化为字符串

dic = {'age': 23,'job': 'student'}dic_str = Json.dumps(dic)print(type(dic_str),dic_str)# out: <class 'str'> {"age": 23,"job": "student"}dic_obj = Json.loads(dic_str)print(type(dic_obj),dic_obj)# out: <class 'dict'> {'age': 23,'job': 'student'}

可以看到，dumps函数将对象转换成了字符串。loads函数又将其恢复成字典。

存储为Json文件

也可以存储在Json文件中

dic = {'age': 23,'job': 'student'}with open('abc.Json','w',enCoding='utf-8') as f:  Json.dump(dic,f)with open('abc.Json',enCoding='utf-8') as f:  obj = Json.load(f)  print(obj)

存储自定义对象

还是上面的Person对象。如果直接序列化会报错

aa = Person('Bob','Student')with open('abc.Json',enCoding='utf-8') as f:  Json.dump(aa,f) # 报错

Object of type 'Person' is not JsON serializable此时dump函数里传一个参default就可以了，这个参数接受一个函数，这个函数可以将对象转换为字典。

写一个就是了

def person2dict(person):  return {'name': person.name,'age': person.age,'job': person.job}

这样返回的就是一个字典了，对象实例有个方法可以简化这一过程。直接调用实例的__dict__。例如

print(aa.__dict) # {'name': 'Bob','age': 23,'job': 'Student'}

很方便。

同时在读取的时候load出来的是一个字典，再转回对象就可，同样需要一个object_hook参数，该参数接收一个函数，用于将字典转为对象。

def dict2person(dic):  return Person(dic['name'],dic['age'],dic['job'])

于是完整的程序应该写成下面这样

with open('abc.Json',f,default=person2dict)with open('abc.Json',enCoding='utf-8') as f:  obj = Json.load(f,object_hook=dict2person)  print(obj.name,obj.age,obj.job)  obj.work()

由于可以使用__dict__代替person2dict函数，再使用lambda函数简化。

with open('abc.Json',default=lambda obj: obj.__dict__)

以上是存储到文件，存储到变量也是类似 *** 作。

不过就我现在所学，不知道如何像pickle一样方便的将我们自定义的类本身使用Json序列化，或许要用到其他扩展函数。以后用到了再说。

shelve模块

还有一个模块，不太常用，通常使用一个open就好。shelve以键值对的形式存储数据。

with shelve.open('aa') as f:  f['person'] = {'age': 23,'job': 'student'}  f['person']['age'] = 44 # 这里试图改变原来的年龄23  f['numbers'] = [i for i in range(10)]with shelve.open('aa') as f:  person = f['person']  print(person) # {'age': 23,'job': 'student'}  nums = f['numbers']  print(nums) # [0,1,2,3,4,5,6,7,8,9]

文件不要有后缀名，在windows下会生成aa.bak,aa.dat,aa.dir三个文件（有点多）。其中bak和dir文件是可以查看的（貌似两个文件内容一样）在下面这个例子中生成这样的数据。

'person',(0,44)'numbers',(512,28)

允许写回--writeback

有个细节，我们读取键person时候，发现age还是23岁，f['person']['age'] = 44后并没有变成44。下面的写法

with shelve.open('aa',writeback=True) as f:  dic = {'age': 23,'job': 'student'}  f['person'] = dic  dic['age'] = 44  f['person'] = dic

相当于赋值了两次，这种方法是可以改变值的。

默认情况下直接使用f['person']改变其中的值之后，不会更新已存储的值，也就是没有把更新写回到文件，即使是文件被close后。如果有此需要，在open函数中添加一个参数writeback=True。再次运行下看看年龄就被改变了。

写入自定义对象

依然使用上面的Person对象

with shelve.open('aa') as f:  f['class'] = Person  # 写入类本身with shelve.open('aa') as f:  Person = f['class']  a = Person('Bob','Student')  a.work()

上面的例子说明shelve也可以序列化类本身。当然序列化实例肯定可以。

with shelve.open('aa') as f:  a = Person('God',100,'watch')  f['class'] = awith shelve.open('aa') as f:  god = f['class']  god.work()

注意，由于我们使用with open打开，故不用写close语句，此模块是有close函数的，如果不是with方法打开的一定要记得主动close。

以上这篇老生常谈Python序列化和反序列化就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持编程小技巧。

总结

以上是内存溢出为你收集整理的老生常谈Python序列化和反序列化全部内容，希望文章能够帮你解决老生常谈Python序列化和反序列化所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。