欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

序列化,pickle,shelve,json,configparser

程序员文章站 2022-04-10 20:37:28
1,序列化 2,pickle pickle 能把Python的任何数据类型转换成bytes类型 pickle方法 dump ,将对象序列化成bytes,并写入文件 load ,将bytes类型的反序列化为对象,在文件中操作 dumps,将对象序列化成bytes loads ,将bytes类型的反序列 ......

1,序列化

序列化:
把对象打散成bytes和字符串,方便存储和传输

反序列化:
把bytes和字符串转化为对象
python中提供的序列化方法,pickle,shelve,json

2,pickle

  pickle

  能把python的任何数据类型转换成bytes类型

  pickle方法

  • dump ,将对象序列化成bytes,并写入文件
  • load  ,将bytes类型的反序列化为对象,在文件中操作
  • dumps,将对象序列化成bytes
  • loads  ,将bytes类型的反序列化为对象

只是序列化dumps,loads

 1 import pickle
 2 
 3 class cat:
 4     def __init__(self,name,age):
 5         self.name = name
 6         self.age = age
 7     def catchmouse(self):
 8         print(self.name,self.age,"抓老鼠")
 9 
10 c = cat("jerry",18)
11 
12 #dumps 把对象转化成bytes, 序列化
13 bs = pickle.dumps(c)
14 
15 #把bytes转换回对象 ,反序列化
16 h = pickle.loads(bs)

 

 将序列化的东西写入文件dump,load

 1 import pickle
 2 
 3 class cat:
 4     def __init__(self,name,age):
 5         self.name = name
 6         self.age = age
 7     def catchmouse(self):
 8         print(self.name,self.age,"抓老鼠")
 9 
10 c = cat("jerry",18)
11 
12 #把对象转成bytes写入文件中
13 f = open("pickle.txt","wb")
14 pickle.dump(c,f)
15 
16 #把文件中的bytes读出来
17 f = open("pickle.txt","rb")
18 c = pickle.load(f)

 

 序列化一堆文件时,如果文件量不大,可以一次性写入,一次性读取,方便

 1 #实例化一堆猫
 2 lst = [cat("cat1",10),cat("cat2",10),cat("cat3",10),cat("cat4",10),cat("cat5",10)]
 3 
 4 #文件量不大的时候,一次存入
 5 f = open("pickle.txt","wb")
 6 pickle.dump(lst,f)
 7 f.flush()
 8 f.close()
 9 #一次读出来
10 f = open("pickle.txt","rb")
11 j = pickle.load(f)

 

如果文件量大,可以分多次写入,循环多次读取,并处理异常

 1 #文件量大的时候,一次一次写入
 2 f = open("pickle.txt","wb")
 3 for el in lst:
 4     pickle.dump(el,f)
 5 f.flush()
 6 f.close()
 7 #读的时候多次读取
 8 f = open("pickle.txt","rb")
 9 while 1:
10     try:
11         d = pickle.load(f)
12         print(d)
13     except eoferror as e:
14         break
15 f.close()

 

 

3,shelve模块

shelve
shelve提供python的持久化操作,把内存的数据写到硬盘上,操作shelve的时候
非常像一个字典,更redis像
 1 import shelve
 2 
 3 #打开一个文件,像操作字典一样去操作文件
 4 f = shelve.open("shelve.txt")
 5 f["jay"] = "周杰伦"
 6 print(f["jay"])
 7 f.close()
 8 
 9 
10 #一个字典的嵌套
11 f = shelve.open("shelve.txt")
12 f["kd"] = {"name":"杜兰特","age":30,"aihao":"喝洗澡水"}
13 print(f["kd"]["aihao"])#喝洗澡水
14 f.close()
15 
16 #更改,需要加上writeback,写回文件
17 f = shelve.open("shelve.txt",writeback=true)
18 f["kd"] = {"name":"杜兰特","age":30,"aihao":"喝洗澡水"}
19 print(f["kd"]["aihao"])#喝洗澡水
20 f["kd"]["aihao"]="逛夜店"
21 print(f["kd"]["aihao"])#逛夜店
22 f.close()
23 
24 #得到所有的key
25 f = shelve.open("shelve.txt")
26 f["1"] = "a"
27 f["2"] = "b"
28 f["3"] = "c"
29 f["4"] = "d"
30 
31 for i in f.keys():
32     print(i)
33 
34 #得到所有的key,value
35 
36 for k,v in f.items():
37     print(k,v)

 

4,json模块

前后端数据交互的通用数据格式,只是将数据转换成字符串格式
处理中文要加上ensure_ascii = false

 

json中,使用只有两种情况,将字典,列表转换成字符串,再将字符串转换成字典,列表

 1 import json
 2 
 3 #把字典转成字符串
 4 dic = {"a":1,"c":"帅奥立","c":"lixiang"}
 5 s=json.dumps(dic,ensure_ascii=false)#干掉ascii码
 6 print(s,type(s))
 7 print(repr(s),type(s))#repr打印出字符串带引号
 8 
 9 # #把字符串转成字典
10 dic1 = json.loads(s)
11 print(dic1,type(dic1))

 

 

将转换之后的字符串写入到文件中,从文件中读取字符串再装换  dump,load

#把字典转成字符串写入文件中
s = open("waimai.json","w",encoding="utf-8")
json.dump(dic,s,ensure_ascii=false)
s.close()

文件中读,并将字符串转换
w = open("waimai.json","r",encoding="utf-8")
s = json.load(w)

 

把文件读出,json读数据的时候,要一行一行的读
通过dump写的时候,是把多个数据写入同一行
所以,不提倡使用dump,load写和读

 1 #写入的时候
 2 #循环
 3 #用dumps把字典转换成字符串,然后在后面加换行符/n
 4 #写入
 5 
 6 #字典
 7 dic = [{"shuai":"aoli"},{"deng":"xiangxinag","haung":"zishi"},{"zhang":"zifneg"}]
 8 #打开文件
 9 f = open("p.json","w",encoding="utf-8")
10 for i in dic:
11     s = json.dumps(i,ensure_ascii=false) + '\n'
12     #json.dump(s,f,ensure_ascii=false)
13     f.write(s)
14 f.close()
15 
16 
17 #读取的时候
18 #for line in f:
19 #strip() 去掉每一行的空白/n
20 #loads()变成字典
21 
22 f = open("p.json","r",encoding="utf-8")
23 for line in f:
24     line = line.strip()
25     s=json.loads(line)
26     print(s)
27 f.close()

 

5,configparser

configparser
处理配置文件,把配置文件作为一个大的字典来处理,能进行创建,增删改查

创建一个配置文件
 1 import configparser
 2 
 3 
 4 #写配置到文件
 5 conf = configparser.configparser()
 6 conf["default"] = {
 7     "session-time-out":30,
 8     "user-alive":60,
 9     "connect-alive":10
10 }
11 
12 conf["189-db"] = {
13     "ip":"192.168.2.189",
14     "port":3306,
15     "uname":"root",
16     "password":"root"
17 }
18 conf["186-db"] = {
19     "ip":"192.168.2.186",
20     "port":3306,
21     "uname":"root",
22     "password":"root"
23 }
24 f = open("db.ini",mode="w")
25 conf.write(f)
26 
27 
28 
29 
30 运行结果
31 db.ini
32 
33 
34 [default]
35 session-time-out = 30
36 user-alive = 60
37 connect-alive = 10
38 
39 [189-db]
40 ip = 192.168.2.189
41 port = 3306
42 uname = shuai
43 password = root
44 
45 [186-db]
46 ip = 192.168.2.186
47 port = 3306
48 uname = root
49 password = root

 

 

前面说。它像一个字典一样,就能用字典类似的方式来操作

 1 #读取内容
 2 conf= configparser.configparser()
 3 conf.read("db.ini")
 4 #读取章节
 5 print(conf.sections())
 6 #章节可以向字典一样操作
 7 print(conf["189-db"]["ip"])
 8 
 9 #遍历章节
10 for key in conf["189-db"]:
11     print(key)
12 
13 for k,v in conf["189-db"].items():
14     print(k,v)

 

增删改都需要将文件从写,最开始读文件(conf.read())的时候,是将全部读到内存中去

1 #增删改,改完之后在写回文件
2 conf= configparser.configparser()
3 conf.read("db.ini")#在这里,是把db,ini文件全读到内存中去了
4 conf["189-db"]["uname"] = "shuai" #改
5 #del conf["189-db"]["password"]#删除
6 conf.set("189-db","max-connect","1024")#189-db章节中增加一个max-connect属性值为1024
7 conf.add_section("130-db")#增加一个章节
8 conf.write(open("db.ini","w",))#增删改完成后,要重写文件