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": }, {"b": },
f = open("test.json", mode="utf-8"
for el in lst:
  json.dump(el, f)
f.close()
完成后的结果是:{"a": }{"b": }{"c": } 这是一行内容,是无法正常读取的
那如何解决呢?方案一. 把所有的内容准备好统一进行写入和读取,这样处理,数据量小还好
数据量多的话就不够友好了,
方案二
不用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()

--------------------------------------------------------------------------------------------
那可以把自定义对象转化为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"))

day21 pickle json shelve configpaser 模块的更多相关文章

  1. 常用模块之 os,json,shelve,xml模块

    os 即操作系统 在 os 中提供了很多关于文件,文件夹,路径处理的函数 这是我们学习的重点 os.path 是os模块下专门用于处理路径相关的 python是一门跨平台语言,由于每个平台路径规则不同 ...

  2. python模块--pickle&json&shelve

    使用file文件处理时,写入的必须是str ,否则会报错. 例如:要把一个字典写入文件,写入时会报错 ,就算转换成str格式写入,读取的时候也不能按照dict格式读. >>> inf ...

  3. python3之序列化(pickle&json&shelve)

    1.pickle模块 python持久化的存储数据: python程序运行中得到了一些字符串,列表,字典等数据,想要长久的保存下来,方便以后使用,而不是简单的放入内存中关机断电就丢失数据.python ...

  4. 第二十二天- 序列化 pickle json shelve

    # 序列化:存储或传输数据时,把对象处理成方便存储和传输的数据格式,这个过程即为序列化# Python中序列化的三种方案:# 1.pickle python任意数据——>bytes写入⽂件:写好 ...

  5. python序列化之pickle,json,shelve

    模块 支持方法 说明 json dumps/dump loads/load 只能处理基本数据类型: 用于多种语言间的数据传输: pickle dumps/dump loads/load 支持pytho ...

  6. 序列化 pickle & json & shelve

    把内存数据转成字符,叫序列化,dump,dumps 把字符转成内存数据类型,叫反序列化load,loads dumps:仅转成字符串 dump不仅能把对象转换成str,还能直接存到文件内 json.d ...

  7. python模块之pickle、shelve、json

    一 什么是序列化 序列化指的是将内存中的数据结构转化为一种中间格式,并存储到硬盘上. (反序列化:将硬盘上存储的中间格式数据再还原为内存中的数据结构) 二 为什么要序列化 持久保持状态 需知一个软件/ ...

  8. 20,序列化模块 json,pickle,shelve

    序列化模块 什么叫序列化? 将原本的字典,列表等内容转换成一个字符串的过程叫做序列化. 序列化的目的? 数据结构 通过序列化 转成 str. str 通过反序列化 转化成数据结构. json: jso ...

  9. python常用模块:pickle、shelve、json、xml、configparser

    今日内容主要有: 一.pickle模块二.shelve模块三.json模块四.json练习五.xml模块 六.xml练习七.configparser模块 一.pickle模块 #pickle是一个用来 ...

随机推荐

  1. 使用Get进行Http通信

    --------------siwuxie095 有道翻译官网:http://fanyi.youdao.com/ 找到官网页面下方的 有道翻译API,选择 调用数据接口,申请一个 key (申请内容可 ...

  2. 序列化+fastjson和java各种数据对象相互转化

    序列化的定义 序列化就是一种用来处理对象流的机制 所谓对象流也就是将对象的内容进行流化.可以对流化后的对象进行读写操作,也可将流化后的对象传输于网络之间. 序列化是将对象转换为容易传输的格式的过程 例 ...

  3. Gym - 100792C Colder-Hotter(三分交互)

    Colder-Hotter Statements This is an interactive problem. Egor and Petr are playing a game called «Co ...

  4. 符合条件中用where 1=1影响效率以及having和where的区别

    想当初我自己想出来用where 1=1的时候还高兴了一小会,毕竟把代码简化了许多.今天看到的书里面说会影响性能.摘要如下: 低效的“WHERE 1=1” 网上有不少人提出过类似的问题:“看到有人写了W ...

  5. 【C#】EF学习<二> DbFirst (先创建数据库,表及其关联关系)

    工程压缩文件放到百度云盘---20181019001文件夹 1. 创建表的脚本 create table Teacher ( TID char(12) primary key, Tname char( ...

  6. JavaFx 实现画图工具

    制作一款类似于Windows画图工具程序 功能需求: (1)在画布上绘制直线.曲线.矩形.椭圆等图形 (2)实现输入文字,橡皮擦 (3)可以绘制填充图形以及设置画笔的颜色和粗细 (4)实现撤销操作.保 ...

  7. 用ES6的class模仿Vue写一个双向绑定

    原文地址:用ES6的class模仿Vue写一个双向绑定 点击在线尝试一下 最终效果如下: 构造器(constructor) 构造一个TinyVue对象,包含基本的el,data,methods cla ...

  8. C#静态类 转载:(原文:http://www.cnblogs.com/chenlulouis/ )

    静态类是不能实例化的,我们直接使用它的属性与方法,静态类最大的特点就是共享. 探究 public static class StaticTestClass{    public static int ...

  9. jmeter+Jenkins性能测试自动化搭建

    一.安装java.ant.maven 1.官网下载tar.gz包 2.解压相应的tar包 3.配置/etc/profile路径 4.source /etc/profile 使配置生效. 二.安装Jen ...

  10. NOIP后省选集训前文化课划水记

    划水划了一个多月,文化课没啥长进还他妈累死了...--ghj1222 11.11(NOIP Day2) 师傅开车开得很快,晚上8:00多就到了二狱 晚上听毒瘤班主任swh讲了半节语文,我:黑人问号.j ...