通过将对象序列化可以将其存储在变量或者文件中,可以保存当时对象的状态,实现其生命周期的延长。并且需要时可以再次将这个对象读取出来。Python中有几个常用模块可实现这一功能。
pickle模块
存储在变量中
dumps(obj)返回存入的字节
1
2
3
4
|
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函数就行了。
1
2
|
obj = pickle.loads(byte_data)
print (obj)
|
存储在文件中
也可以存在文件中,使得对象持久化。使用的是dump和load函数,注意和上面的区别,少了s。由于pickle写入的是二进制数据,所以打开方式需要以wb和rb的模式。
1
2
3
4
5
6
7
8
9
|
# 序列化
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
1
2
3
4
5
6
7
8
|
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当然也能写入,不仅可以写入类本身,也能写入它的一个实例。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
# 将实例存储在变量中,当然也能存在文件中
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' , 23 , '6' )
aa.work()
|
json模块
pickle可以很方便地序列化所有对象。不过json作为更为标准的格式,具有更好的可读性(pickle是二进制数据)和跨平台性。是个不错的选择。
json使用的四个函数名和pickle一致。
序列化为字符串
1
2
3
4
5
6
7
8
|
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文件中
1
2
3
4
5
6
7
|
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对象。如果直接序列化会报错
1
2
3
|
aa = Person( 'Bob' , 23 , 'Student' )
with open ( 'abc.json' , 'w' , encoding = 'utf-8' ) as f:
json.dump(aa, f) # 报错
|
Object of type 'Person' is not JSON serializable此时dump函数里传一个参default就可以了,这个参数接受一个函数,这个函数可以将对象转换为字典。
写一个就是了
1
2
3
4
|
def person2dict(person):
return { 'name' : person.name,
'age' : person.age,
'job' : person.job}
|
这样返回的就是一个字典了,对象实例有个方法可以简化这一过程。直接调用实例的__dict__。例如
1
|
print (aa.__dict) # {'name': 'Bob', 'age': 23, 'job': 'Student'}
|
很方便。
同时在读取的时候load出来的是一个字典,再转回对象就可,同样需要一个object_hook参数,该参数接收一个函数,用于将字典转为对象。
1
2
|
def dict2person(dic):
return Person(dic[ 'name' ], dic[ 'age' ], dic[ 'job' ])
|
于是完整的程序应该写成下面这样
1
2
3
4
5
6
7
|
with open ( 'abc.json' , 'w' , encoding = 'utf-8' ) as f:
json.dump(aa, 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函数简化。
1
2
|
with open ( 'abc.json' , 'w' , encoding = 'utf-8' ) as f:
json.dump(aa, f, default = lambda obj: obj.__dict__)
|
以上是存储到文件,存储到变量也是类似操作。
不过就我现在所学,不知道如何像pickle一样方便的将我们自定义的类本身使用json序列化,或许要用到其他扩展函数。以后用到了再说。
shelve模块
还有一个模块,不太常用,通常使用一个open就好。shelve以键值对的形式存储数据。
1
2
3
4
5
6
7
8
9
10
|
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文件是可以查看的(貌似两个文件内容一样)在下面这个例子中生成这样的数据。
1
2
|
'person' , ( 0 , 44 )
'numbers' , ( 512 , 28 )
|
允许写回--writeback
有个细节,我们读取键person时候,发现age还是23岁,f['person']['age'] = 44后并没有变成44。下面的写法
1
2
3
4
5
|
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对象
1
2
3
4
5
6
7
8
|
with shelve. open ( 'aa' ) as f:
f[ 'class' ] = Person
# 写入类本身
with shelve. open ( 'aa' ) as f:
Person = f[ 'class' ]
a = Person( 'Bob' , 23 , 'Student' )
a.work()
|
上面的例子说明shelve也可以序列化类本身。当然序列化实例肯定可以。
1
2
3
4
5
6
7
|
with shelve. open ( 'aa' ) as f:
a = Person( 'God' , 100 , 'watch' )
f[ 'class' ] = a
with shelve. open ( 'aa' ) as f:
god = f[ 'class' ]
god.work()
|
注意,由于我们使用with open打开,故不用写close语句,此模块是有close函数的,如果不是with方法打开的一定要记得主动close。
以上这篇老生常谈Python序列化和反序列化就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持服务器之家。