序列化，pickle,shelve,json,configparser

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",))#增删改完成后，要重写文件