常用模块2

本节主要内容
1. 什么是序列化
2. pickle(重点)
3. shelve
4. json(重点)
5. configparser模块

⼀. 什么是序列化
　　在我们存储数据或者⽹络传输数据的时候. 需要对我们的对象进⾏处理. 把对象处理成
⽅便存储和传输的数据格式. 这个过程叫序列化. 不同的序列化, 结果也不同. 但是⽬的是⼀
样的. 都是为了存储和传输.

　　在python中存在三种序列化的方案。

　　1.pickle. 可以将我们python中的任意数据类型转化成bytes并写入到⽂件中. 同样也
　　可以把⽂件中写好的bytes转换回我们python的数据. 这个过程被称为反序列化。

　　2. shelve. 简单另类的⼀种序列化的⽅案. 有点⼉类似后⾯我们学到的redis. 可以作为
　　⼀种⼩型的数据库来使⽤。

　　3. json. 将python中常⻅的字典, 列表转化成字符串. 是⽬前前后端数据交互使⽤频率
　　最⾼的⼀种数据格式.

⼆. pickle(重点)
　　pickle⽤起来很简单. 说⽩了. 就是把我们的python对象写入到⽂件中的⼀种解决⽅案.
　　但是写入到⽂件的是bytes. 所以这东⻄不是给⼈看的. 是给机器看的.

import pickle
class Cat:
     def __init__(self, name, age):
         self.name = name
         self.age = age
     def catchMouse(self):
         print(self.name, "抓⽼⿏")
c = Cat("jerry", 18)
bs = pickle.dumps(c) # 序列化⼀个对象.
print(bs) #  ⼀堆⼆进制. 看不懂
cc = pickle.loads(bs) # 把⼆进制反序列化成我们的对象
cc.catchMouse() # 猫依然是猫. 还可以抓⽼⿏

　　pickle中的dumps可以序列化⼀个对象. loads可以反序列化⼀个对象. 我们使⽤dump
还可以直接 把⼀个对象写入到⽂件中

# f = open("cat", mode="wb")
# pickle.dump(c, f) # 写⼊到⽂件中
# f.close()
f = open("cat", mode="rb")
cc = pickle.load(f) # 从⽂件中读取对象
cc.catchMouse()

　　pickle还支持多个对象的写出。

lst = [Cat("jerry", 19), Cat("tommy", 20), Cat("alpha", 21)]
f = open("cat", mode="wb")
for el in lst:
     pickle.dump(el, f) # 写⼊到⽂件中
f.close()
f = open("cat", mode="rb")
for i in range(len(lst)):
     cc = pickle.load(f) # 从⽂件中读取对象
     cc.catchMouse()

　　但是这样写并不够好，因为读的时候。并不能知道有多少对象要读。这里记住不能一行一行的读

　　那要写入或者读取多个内容怎么办？很简单。装list里，然后读取和写入都用list

lst = [Cat("jerry", 19), Cat("tommy", 20), Cat("alpha", 21)]
f = open("cat", mode="wb")
pickle.dump(lst, f)
f = open("cat", mode="rb")
ll = pickle.load(f)
for el in ll:
     el.catchMouse()

　　记住⼀点, pickle序列化的内容是⼆进制的内容(bytes) 不是给⼈看的. 

三. shelve
　　shelve提供python的持久化操作. 什么叫持久化操作呢? 说⽩话,就是把数据写到硬盘上.
　　在操作shelve的时候非常的像操作⼀个字典. 这个东⻄到后期. 就像redis差不多.

import shelve
shelf = shelve.open("sylar")
# shelf["jay"] = "周杰伦"
print(shelf['jay'])
shelf.close()

　　这鬼东西和字典差不多。只不过你的字典是一个文件。下面储存一些复杂的数据。

s = shelve.open("sylar")
# s["jay"] = {"name":"周杰伦", "age":18, "hobby":"哄⼩孩"}
print(s['jay'])
s.close()

　　但是这里有坑

s = shelve.open("sylar")
s['jay']['name'] = "胡辣汤" # 尝试改变字典中的数据
s.close()
s = shelve.open("sylar")
print(s['jay']) # 并没有改变
s.close()

　　解决方案

s = shelve.open("sylar", writeback=True)
s['jay']['name'] = "胡辣汤" # 尝试改变字典中的数据
s.close()
s = shelve.open("sylar")
print(s['jay']) # 改变了.
s.close()

　　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()

　　综上shelve就当字典来用就行了，它比redis还简单。。。。

四. json(重点)
　　终于到json了. json是我们前后端交互的枢纽. 相当于编程界的普通话. ⼤家沟通都⽤
json. 为什么这样呢? 因为json的语法格式可以完美的表⽰出⼀个对象. 那什么是json: json全
称javascript object notation. 翻译过来叫js对象简谱. 很复杂是吧? 来上⼀段我们认识的代
码:

wf = {
         "name":"汪峰",
         "age":18,
         "hobby":"上头条",
         "wife":{
                 "name":'⼦怡',
                 "age":19,
                 "hobby":["唱歌", "跳舞", "演戏"]
         }
}    

　　你会发现这玩意儿不就是字典嘛，对的！在python中这东西就叫字典。但在JavaScript中这东西

　　叫json，我们发现用这样的数据结构可以完美的表示出任何对象。并且可以完整的把对象表示出

　　来。只要代码格式比较好。那可读性也很强的。所以大家公认用这样一种数据结构作为数据交互

　　的格式。那这玩意儿之前是什么呢？是xml。。来看这个：

<?xml version="1.0" encoding="utf-8" ?>
<wf>
         <name>汪峰</name>
         <age>18</age>
         <hobby>上头条</hobby>
         <wife>
                 <name>⼦怡</name>
                 <age>18</age>
                 <hobbies>
                         <hobby>唱歌</hobby>
                         <hobby>跳舞</hobby>
                         <hobby>演戏</hobby>
                 </hobbies>
         </wife>
 
</wf>

　　远古程序员都是用这样的数据进行传输的，其他的不说。主要这玩意需要解析，那酸爽简直了，相死的心都有！太难解析以前的项目几乎没有用ajax的。

　　那好既然json这么的牛逼。那怎么用呢？我们的程序是在python中写的。但是前端是在js那边来解析

　　的。所以，我们需要把我们的程序产生的字典转化成json格式的json串（字符串）。然后网络传输

　　那我们如何把字典转成我们的json格式的字符串呢？很简单，上代码：

import json
dic = {"a": "⼥王", "b": "萝莉", "c": "⼩清新"}
s = json.dumps(dic) # 把字典转化成json字符串
print(s) # {"a": "\u5973\u738b", "b": "\u841d\u8389", "c":
"\u5c0f\u6e05\u65b0"}

　　但是结果很不友好啊。中文该如何处理呢？在dumps的时候给出另外一个参数就可以了

　　ensure_ascii = False就可以了

import json
dic = {"a": "⼥王", "b": "萝莉", "c": "⼩清新"}
s = json.dumps(dic, ensure_ascii=False) # 把字典转化成json字符串
print(s) # {"a": "⼥王", "b": "萝莉", "c": "⼩清新"}

　　前端给你传递信息了。你要把前端传递过来的json字符串转化成字典。

import json
s = '{"a": "⼥王", "b": "萝莉", "c": "⼩清新"}'
dic = json.loads(s)
print(type(dic), dic)

　　json也可以像pickle一样把序列化的结果写入到文件中。

dic = {"a": "⼥王", "b": "萝莉", "c": "⼩清新"}
f = open("test.json", mode="w", encoding="utf-8")
json.dump(dic, f, ensure_ascii=False) # 把对象打散成json写⼊到⽂件中
f.close()

　　同样也可以从文件中读取一个json

f = open("test.json", mode="r", encoding="utf-8")
dic = json.load(f)
f.close()
print(dic)

　　我们可以向同一个文件中写入多个json串。但是读不行。

import json
lst = [{"a": 1}, {"b": 2}, {"c": 3}]
f = open("test.json", mode="w", encoding="utf-8")
for el in lst:
     json.dump(el, f)
f.close()

　　注意！此时文件中的内容是一行内容。

　　那么要如何解决呢？有两种方案：

　　方案一：

　　　　　　把所有的内容准备好统一进行写入和读取。但是这样的话数据量小还好如果数据量很大

　　　　　　就很不友好了。

　　方案二：
　　　　　　不用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) + "\n"
     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()