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

转载于:https://www.cnblogs.com/shuai-aoli/p/11006488.html

序列化，pickle,shelve,json,configparser相关推荐

三十、深入Python中的Pickle和Json模块
@Author: Runsen 听过Python序列化pickle和Json标准库吗? pickle pickle模块是以二进制的形式序列化后保存到文件中(保存文件的后缀为".pkl&quo ...
python中常用的序列化模块_第六章常用模块(5)：python常用模块(序列化模块：pickle，json，shelve，xml)...
6.3.7 序列化模块 (pickle,json,shelve,xml) 文件写入,数据传输时,我们都是以字符串形式写入的(因为字符串可以encode成bytes). 那其他类型(比如字典,列表等)想 ...
json,pickle,shelve序列化和反序列化
1.简介 ● json:用于字符串和 python简单数据类型(list,dict...)间进行转换:字符串<--->python简单数据类型 ● pickle:用于python特有 ...
Python(序列化json,pickle,shelve)
序列化参考:https://www.cnblogs.com/yuanchenqi/articles/5732581.html 1 # dic = str({'1':'111'}) 2 # 3 # f ...
常用模块(json/pickle/shelve/XML)
一.json模块(重点) 一种跨平台的数据格式也属于序列化的一种方式介绍模块之前,三个问题: 序列化是什么? 我们把对象(变量)从内存中变成可存储或传输的过程称之为序列化. 反序列化又是什么? 将 ...
python-常用模块xml、shelve、configparser、hashlib
一.shelve模块 shelve模块也是用来序列化的. 使用方法: 1.open 2.读写 3.close import shelve # 序列化 sl = shelve.open('shlvete ...
Java基础/利用fastjson序列化对象为JSON
利用fastjson序列化对象为JSON 参考博客:http://blog.csdn.net/zeuskingzb/article/details/17468079 Step1:定义实体类 //用户类 ...
包含utf8字符的 pickle 转 json的大坑处理过程
背景:希望将pickle转换为json,由于pickle里有utf8的字符,因此转换失败. 转换代码如下: ''' Convert a pkl file into json file ''' impo ...
Python 序列化 pickle/cPickle模块
Python 序列化 pickle/cPickle模块 2013-10-17 Posted by yeho Python序列化的概念很简单.内存里面有一个数据结构,你希望将它保存下来,重用,或者发送给 ...
fastjson 序列化时指定json的key值
json字符串中的key是下划线例如:foot_dist,而实际实体类中的属性是footDist,添加 @JSONField(name = "foot_dist")即可 packa ...