day21 pickle json shelve configpaser 模块

1. 序列化:我们在网络传输的时候,需要我们对对象进行处理,把对象处理成方便存储和传输的格式,这个过程就叫序列化
   序列化的方法不一定一样,三十目的都是为了方便储存和传输.
   在python中有三种序列化方案:
   1. pickle  可以将我们python中任意数据类型转化为bytes写入文件中,同样也可以把文件中写好的bytes
    转换回我们的python数据,这个过程成为反序列化.
   2.shelve 简单另类的一种序列化方案,有点类似后面会学的redis,可以做为一种小型数据库使用
   3.json 将python常见的字典,列表转化成字符串.是目前前后端交互使用频率最高的一种的一种数据格式,

2.  pickle
 把python对象写入文件中的一种方法,写入的格式是bytes类型,所以pickle的结果是给机器识别而不
是给人看的.
例:

import pickle
class Cat:
    def __init__(self,name,color):
        self.name=name
        self.color=color
    def chi(self):
        print("%s吃老鼠"%self.name)

c=Cat("波斯","绿色") 
c.chi()              #造了一个对象,执行chi()这个动作

bs=pickle.dumps(c)    #序列化一个对象,把对象转化成bytes类型
print(bs)             #查看效果  是一堆二进制东西,看不懂

cc=pickle.loads(bs)     #反序列化
print(cc)               #还是原来那只猫
cc.chi()               #也能执行chi()这个动作
print(cc.name)           #也能查看他的属性
print(cc.color)

#总的来说:pickle中的dumps可以序列化一个对象. loads可以反序列化一个对象.

------------------------------------------------------------
#那怎么把序列化之后的数据写入到文件当中呢?

c1=Cat("英短","蓝白")                       #造一直英短蓝白的猫
pickle.dump(c1,open("cat.db",mode="wb"))   #把一个对象写入文件cat.db

c111=pickle.load(open("cat.db",mode="rb"))   #从文件中把一个对象从cat.db文件中读取出来 
c111.chi()                                  #解读出来的还是能执行chi()
print(c111.color)                              #也可查看其属性
print(c111.name)

---------------------------------------------------------------
#那怎么把多个文件序列化后写入文件当中呢?

c1=Cat("英短1","蓝白")                #造出多个对象,很多只猫
c2=Cat("英短2","蓝白")
c3=Cat("英短3","蓝白")
c4=Cat("英短4","蓝白")
c5=Cat("英短5","蓝白")

lst=[c1,c2,c3,c4,c5]            #为了方便,把猫装进列表里面
f=open("cats.db",mode="wb")     #打开(创建)一个cats.db文件
pickle.dump(lst,f)              #把整个列表写入文件中
f.close()                      #关闭文件


f1=open("cats.db",mode="rb")  #打开cats.db文件
lis=pickle.load(f1)           #把读取出来的列表赋值给新的列表
for i in lis:                 #把列表的元素一个一个拿出来
    i.chi()
f1.close()                     #关闭文件

-----------------------------------------------------------------------

注意
 1.单单序列化都是不带s的,而序列化后写入文件是要带s的
 2.在文件中读写是是wb,rb模式,所以在打开文件的时候不需要设置encoding
 3.pickle序列化的内容是⼆进制的内容(bytes) 不是给人看的 

例.2
import pickle
class User:
    def __init__(self,username,password):
        self.username=username
        self.password=password
class Client:
    def register(self):
        usn=input("请输入你的用户名")                #注册程序
        psw=input("请输入你的密码")
        u=User(usn,psw)                          #用注册的信息造出一个对象
        pickle.dump(u,open("userinfo",mode="ab")) #把对象写入到userin文件当中, 模式是ab
        print("注册成功")
    def login(self):
        usern=input("请输入你的用户名")                 #登录程序
        psword=input("请输入你的密码")
        f=open("userinfo",mode="rb")            
        while 1:                          #把用户输入的和userinfo的信息进行一一比对
            try:
                u=pickle.load(f)
                if u.username==usern and u.password==psword:
                    print("登录成功")
                    break
            except Exception as e:             #当userifo里面的信息比对完了,就报错
                print("登录失败")
                break
c=Client()
c.register()
c.register()
c.register()c.register()

c.login()

3.  shelve 提供持久化操作,想歪了没有?其实是把数据写到硬盘上面,而且shelve的操作很像字典,你可以把他认为是字典
例.1

import shelve
--------------------------------------------------------------------
d=shelve.open("漂亮")       #文件型字典
d["wf"]="汪峰"            # 创建字典,往里面写东西
d["小三"]="汪峰老婆"
d.close()

d=shelve.open("漂亮")
print(d["wf"])            #对里面的内容进行查看,可以看到上面写的内容
print(d["小三"])
d.close()
----------------------------------------------------------------------

d=shelve.open("漂亮")          #当"key"存在的时候就是对他"value"值进行修改
d["小三"]="国际章"             #对里面已经存在的进行修改
d.close()

d=shelve.open("漂亮")
print(d["小三"])                #修改完成后看我们的修改是否成功
d.close()                      #修改成功
-------------------------------------------------------------------
#那对于多层嵌套的字典操作是不是也是这样呢?

d=shelve.open("多层嵌套的字典")                        #字典不存在就创建
d["wf"]={"name":"汪峰 ","wf":{"name":"国际章","hobby":"换男人"}    }
d.close()

d=shelve.open("多层嵌套的字典")                  #对多层嵌套字典进行查看
print(d["wf"])
d.close()

d=shelve.open("多层嵌套的字典")
d["wf"]["wf"]["name"]="小三"         #对多层嵌套的字典比较里面的内容进行修改
d.close()

d=shelve.open("多层嵌套的字典")     #再次查看多层嵌套字典,查看修改是否成功
print(d["wf"]["wf"]["name"])    #发现还是原来的名字-->国际章,并没有修改
d.close()                 #原因是只是把读出来在内存上的内容修改了,并没有返写到硬盘上面

#解决方法      writeback=True

d=shelve.open("多层嵌套的字典",writeback=True)
d["wf"]["wf"]["name"]="小三"                       #对多层嵌套的字典进行修改
d.close()

d=shelve.open("多层嵌套的字典")
print(d["wf"]["wf"]["name"])    #再看一下,修改成功了
d.close()

-----------------------------------------------------------------------------
注:对于多层嵌套的字典叫底层的东西进行修改只是在读取出来的内存中修改,并没有修改硬盘上面的内容,所以对里层的内容修改的时候要记得
把返写 writeback=True写进去
writeback=True可以动态的把我们修改的信息写入到文件中. 而且这个鬼东西还可以删
除数据. 就像字典一样. 上一波操作 

s = shelve.open("sylar", writeback=True)
del s['jay']             #删除一个对象,记得返写
s.close()

s = shelve.open("sylar")
print(s['jay']) # 报错了, 没有了
s.close()

s = shelve.open("sylar", writeback=True)
s['jay'] = "周杰伦"
s['wlj'] = "王力宏"
s.close()

s = shelve.open("sylar")
for k in s:         # 像字典一样遍历
　　print(k)
print(s.keys()) # 拿到所有key的集合

for k in s.keys():
　　print(k) 
for k, v in s.items(): # 像字典一样操作
　　print(k, v)
s.close() 

4.  json
    json是我们前后端交互的枢纽. 相当于编程界的普通话. 大家沟通都用json. 
    为什么这样呢? 因为json的语法格式可以完美的表示出一个对象
    那什么是json: json全称javascript object notation. 翻译过来叫js对象简谱.

   json的用法:
       前端是在JS那边来解析json的. 所以, 我们需要把我们程序产生的字典
       转化成json格式的json串(字符串). 然后网络络传输. 那边接收到了之后.
       它爱怎么处理是它的事情,那如何把字典转化成我们的json格式的字符串?
例.1

import json

#在python中可以把字典和列表直接转化为jason
dic={"a":"小萝莉","b":"大妈","c":"十八水","d":"管式服务","e":False,"f":None}  #创建字典
s=json.dumps(dic,ensure_ascii=False)    #把字典转化为json串 处理中文的时候就得把默认的ascii码关掉
print(s)         #{"a": "小萝莉", "b": "大妈", "c": "十八水", "d": "管式服务", "e": false, "f": null}
print(type(s))    #<class 'str'>

a='{"a": "小萝莉", "b": "大妈", "c": "十八水", "d": "管式服务", "e": false, "f": null}'    #json串
b=json.loads(a)   #把json串转化为字典
print(b)          #{'a': '小萝莉', 'b': '大妈', 'c': '十八水', 'd': '管式服务', 'e': False, 'f': None}
print(type(b))    #<class 'dict'>

--------------------------------------------------------------------------------------------------
那json可以像pickle那样把json串写入文件吗?哪是肯定的

#把json写入文件

dic={"a":"小萝莉","b":"大妈","c":"十八水","d":"管式服务","e":False,"f":None,"wf":{"name":"汪峰","hobby":"皮裤"}}
f=open("json文件",mode="w",encoding="utf-8")    #把对象打散成json写入文件中
json.dump(dic,f,ensure_ascii=False,indent=4)   #indent=缩进,4个缩进为一个空格 把ascii码默认为false

f=open("json文件",mode="r",encoding="utf-8")  
d=json.load(f)                       #对写入文件的内容进行读取
print(d)                             #dump load和pickle的用法一样,带s是不写入文件的,写入文件的不带s

json串是字符串,时予以这边的文件打开的编码格式要设置为encoding="utf-8"
-------------------------------------------------------------------------
这边要注意的是:我们可以向同一个文件中写入多个json串. 但是读不行
import json
lst = [{"a": 1}, {"b": 2},
f = open("test.json", mode="utf-8"
for el in lst:
　　json.dump(el, f)
f.close() 
完成后的结果是:{"a": 1}{"b": 2}{"c": 3} 这是一行内容,是无法正常读取的
那如何解决呢?方案一. 把所有的内容准备好统一进行写入和读取,这样处理,数据量小还好
数据量多的话就不够友好了,
方案二 
不用dump. 改用dumps和loads. 对每一条数据分别进行处理. 
例:
import json
lst = [{"a": 1}, {"b": 2}, {"c": 3}]
# 写入
f = open("test.json", mode="w", encoding="utf-8")
for el in lst:
　　s = json.dumps(el, ensure_ascii=True) + "
"
　　f.write(s)
　　f.close()
# 读取
f = open("test.json", mode="r", encoding="utf-8")
for line in f:
　　dic = json.loads(line.strip())
　　print(dic)
f.close() 

--------------------------------------------------------------------------------------------
那可以把自定义对象转化为json串再写入文件吗?可以的,就是步骤麻烦了一点

class Person:                              #新建一个类
    def __init__(self,firstname,lastname):
        self.firstname=firstname
        self.lastname=lastname
p=Person("日天","一辈子")                 #用类创建一个对象


-----------------------------------------------------------------------------------------

#方案一:

# s=json.dumps(p.__dict__,ensure_ascii=False)    #直接转化会报错,没办法动态转化
# print(s)                                       #直接用字典形式获取里面所有的信息在进行转化 转的是字典

-------------------------------------------------------------------------------------------
#方案二

def func(obj):
    return {
        "firstname":obj.firstname,
        "lastname":obj.lastname
    }

s=json.dumps(p,default=func,ensure_ascii=False)
print(s)



#怎么把json还原为对象

def func(dic):
    return Person(dic["firstname"],dic["lastname"])

s='{"firstname": "日天", "lastname": "一辈子"}'  #json格式的
p=json.loads(s,object_hook=func)
print(p.firstname,p.lastname)

-------------------------------------------------------------------

5.  configpatser模块
   该模块适用于配置文件的格式与windows ini文件类似，可以包含一个或多个节(section)每个节
   可以有多个参数(键=值).
例.
import configparser
config = configparser.ConfigParser()
config['DEFAULT'] = { 
"sleep": 1000,
"session-time-out": 30,
"user-alive": 999999
}

config['TEST-DB'] = {
"db_ip": "192.168.17.189",
"port": "3306",
"u_name": "root",
"u_pwd": "123456"
}

config['168-DB'] = {
"db_ip": "152.163.18.168",
"port": "3306",
"u_name": "root",
"u_pwd": "123456"
}

config['173-DB'] = {
"db_ip": "152.163.18.173",
"port": "3306",
"u_name": "root",
"u_pwd": "123456"
}

f = open("db.ini", mode="w")
config.write(f) # 写⼊⽂件
f.flush()
f.close() 

#读取文件
config = configparser.ConfigParser()
config.read("db.ini") # 读取⽂件
print(config.sections()) # 获取到section. 章节...DEFAULT是给每个章节都配备的信
print(config.get("DEFAULT", "SESSION-TIME-OUT")) # 从xxx章节中读取到xxx信息
# 也可以像字典⼀样操作
print(config["TEST-DB"]['DB_IP'])
print(config["173-DB"]["db_ip"])
for k in config['168-DB']:
　　print(k)
for k, v in config["168-DB"].items():
　　print(k, v)
print(config.options('168-DB')) # 同for循环,找到'168-DB'下所有键
print(config.items('168-DB')) #找到'168-DB'下所有键值对 
print(config.get('168-DB','db_ip')) # 152.163.18.168 get⽅法Section下的
key对应的value 

# 先读取. 然后修改. 最后写回⽂件
config = configparser.ConfigParser()
config.read("db.ini") # 读取⽂件
# 添加⼀个章节
# config.add_section("189-DB")
# config["189-DB"] = {
# "db_ip": "167.76.22.189",
# "port": "3306",
# "u_name": "root",
# "u_pwd": "123456"
# }
# 修改信息
config.set("168-DB", "db_ip", "10.10.10.
# 删除章节
config.remove_section("173-DB")
# 删除元素信息
config.remove_option("168-DB", "u_name")
# 写回⽂件
config.write(open("db.ini", mode="w"))