23_pikle/shevel/json

一、序列化

 

    存储数据或者传输数据时，需要把对象进行处理，把对象处理成方便存储和传输的数据格式。不同的序列化，结果也不同。

    序列化方式：

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

        (2) shelve 简单另类的一种序列化的?案. 有点类似以后学到的redis. 可以作为一种小型的数据库来使用

        (3) json 将python中常见的字典, 列表转化成字符串. 是目前后端数据交互使用频率最高的一种数据格式

 

二、pickle

 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() # 猫依然是猫. 还可以抓老鼠

把对象写入文件

 f = open("cat", mode="wb")
 pickle.dump(c, f) # 写入到文件中
 f.close()

 f = open("cat", mode="rb")
 cc = pickle.load(f) # 从文件中读取对象
 cc.catchMouse()

多对象写入

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

三、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", writeback=True)     # writeback=True可以动态的把我们修改的信息写入到文件中
 s['jay']['name'] = "胡辣汤" # 尝试改变字典中的数据
 s.close()
 s = shelve.open("sylar")
 print(s['jay']) # 改变了.
 s.close()

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

四、json（重点）

 

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

程序是在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"}    # 由于json中默认支持ASCII

解决\u问题（把字典——>json字符串）

 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)

写入文件

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

读出

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

五、configparser模块

 

    该模块适用于配置文件的格式与windows ini文件类似，可以包含一个或多个节(section)每个节可以有多个参数(键=值).

 [DEFAULT] [DEFAULT]
 ServerAliveInterval = 45
 Compression = yes
 CompressionLevel = 9
 ForwardX11 = yes
 [[bitbucket.org]]
 User = hg
 [[topsecret.server.com]]
 Port = 50022
 ForwardX11 = no

 

    ⽤configparser就可以对这样的⽂件进⾏处理.⾸先, 是初始化

 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": "",
 "u_name": "root",
 "u_pwd": ""
 }
 config['168-DB'] = {
 "db_ip": "152.163.18.168",
 "port": "",
 "u_name": "root",
 "u_pwd": ""
 }
 config['173-DB'] = {
 "db_ip": "152.163.18.173",
 "port": "",
 "u_name": "root",
 "u_pwd": ""
 }
 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.168")

 # 删除章节
 config.remove_section("173-DB")

 # 删除元素信息
 config.remove_option("168-DB", "u_name")

 # 写回文件
 config.write(open("db.ini", mode="w"))