标签：size elephant pytho 传输数据 参数 不同 操作 接下来 str
一. 什么是序列化
在我们存储数据或者网络传输数据的时候. 需要对我们的对象进行处理.
把对象处理成方便存储和传输的数据格式. 这个过程叫序列化. 不同的序列化, 结果也不同.
但是目的是一样的. 都是为了存储和传输.在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) 不是给人看的.
import pickle
#
class Elephant:
def __init__(self, name, weight, height):
self.name = name
self.weight = weight
self.height = height
def tiaoxi(self):
print(f"{self.name}大象特别喜欢调戏人")
# e = Elephant("宝宝", "185T", "175")
# e.tiaoxi()
#
# # 序列化
# bs = pickle.dumps(e) # 把对象进行序列化
# print(bs)
#
# bs = b‘\x80\x03c__main__\nElephant\nq\x00)\x81q\x01}q\x02(X\x04\x00\x00\x00nameq\x03X\x06\x00\x00\x00\xe5\xae\x9d\xe5\xae\x9dq\x04X\x06\x00\x00\x00weightq\x05X\x04\x00\x00\x00185Tq\x06X\x06\x00\x00\x00heightq\x07X\x03\x00\x00\x00175q\x08ub.‘
# # 发序列化
# dx = pickle.loads(bs) # 发序列化. 得到的是大象
# dx.tiaoxi()
# e1 = Elephant("宝宝", "185T", "175")
# e2 = Elephant("宝贝", "120T", "120")
# f = open("大象", mode="wb")
# # 这也是序列化
# pickle.dump(e1, f) # 没有s的这个方法是把对象打散写入到文件, 序列化的内容不是给人看的
# pickle.dump(e2, f) # 没有s的这个方法是把对象打散写入到文件, 序列化的内容不是给人看的
# f = open("大象", mode="rb")
# while 1:
# try:
# obj = pickle.load(f)
# obj.tiaoxi()
# except Exception:
# break
# e1 = Elephant("宝宝", "185T", "175")
# e2 = Elephant("宝贝", "120T", "120")
#
# lst = [e1, e2]
#
# pickle.dump(lst, open("大象", mode="wb"))
# 读
# lst = pickle.load(open("大象", mode="rb"))
# for dx in lst:
# dx.tiaoxi()
shelve
shelve提供python的持久化操作. 什么叫持久化操作呢? 说白话,就是把数据写到硬盘上.
在操作shelve的时候非常的像操作一个字典. 这个东西到后期. 就像redis差不多.
import shelve
shelf = shelve.open("sylar")
# shelf["jay"] = "周杰伦"
print(shelf[‘jay‘])
shelf.close()
感觉到了么. 这个?东?和字典差不多. 只不过你的字典是?个?件. 接下来, 我们存储
一些复杂的数据
= 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对象简谱.
json(重点中的重点)
json你可以认为是python中的字典. 有一点点的不一样
python: True False None
json: true false null
1. dumps() 把对象序列化成json
2. loads() 把json反序列化成对象
3. dump() 把对象序列化写入文件
4. load() 把文件中的内容反序列化成对象
我们的程序是在python里写的. 但是前端是在JS那边来解析json的. 所以. 我们需要把我们程序产生的字典转化成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()
序列化 pickle(重点) shelve json(重点)
标签：size elephant pytho 传输数据 参数 不同 操作 接下来 str
原文地址：https://www.cnblogs.com/H1050676808/p/10186850.html
