序列化模块

 

模块: 一个py文件就是一个模块.
python开发效率之高:Python的模块非常多,第三方库.
模块分类:
1,内置模块:登录模块,时间模块,sys模块,os模块 等等.
2,扩展模块. itchat 微信有关.爬虫: beautifulsoup
    所有的扩展模块:https://pypi.org/
3,自定义模块.自己写的py文件.
序列化模块.
序列化:创造一个序列.
实例化:创造一个实例(对象).
将一个字典通过网络传输给另一个人.

文件中可以存储:字符串,和bytes.
数据的传输:bytes类型.
什么是序列化:将数据转化成序列化字符串的过程

下面的解决方式不好! eval极度不安全.

dic = {'alex':['women','women','oldwomen']}
ret = str(dic)
# print(ret,type(ret))
b1 = ret.encode('utf-8')
s1 = b1.decode('utf-8')  # "{'alex':['women','women','oldwomen']}"
dic1 = eval(s1)
print(dic1,type(dic1)

那怎么解决?
序列化: 创造一个序列, ---> 特殊处理(序列化的)字符串.
序列化:
        json：
                适用于不同语言之间的，
                但是可支持的数据类型：字符串，数字，列表，字典  bool待定。
        pickle:
            只用于python语言之间的.
            可支持python所有的数据类型.
        shelve(了解):只是python,小工具(文件方面).

json:
数据通过网络发送给别人. json
写入文件 也用到json.

序列化过程: 一个数据类型 ---> 序列化的字符串
反序列化过程: 序列化的字符串  --->  它所对应的数据类型

Json模块提供了四个功能：dumps、dump、loads、load

json 模块:
两对:
dumps  loads
dump  load
dumps  loads 网络的传输

dic = {"alex": ['women','women','老女人'],'p1':True}
dic = {"alex": ('women','women','老女人')}
print(str(dic))  # 基础数据类型str  里面如果有引号就是单引号
ret = json.dumps(dic,ensure_ascii=False) # 序列化过程:数据类型dic---> 序列化的字符串
print(ret,type(ret))
被json序列化的字符串:
1,可以直接通过网络互相传输.
2,可以在各个语言中通用.
dic1 = json.loads(ret)  # 反序列化过程.:将序列化的字符串---> 原有的数据类型.
print(dic1,type(dic1))

被json序列化的字符串:
1,可以直接通过网络互相传输.
2,可以在各个语言中通用.
 序列化过程:数据类型dic---> 序列化的字符串
反序列化过程.:将序列化的字符串---> 原有的数据类型.

import json
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = json.dumps(dic)  #序列化：将一个字典转换成一个字符串
print(type(str_dic),str_dic)  #<class 'str'> {"k3": "v3", "k1": "v1", "k2": "v2"}
#注意，json转换完的字符串类型的字典中的字符串是由""表示的

dic2 = json.loads(str_dic)  #反序列化：将一个字符串格式的字典转换成一个字典
#注意，要用json的loads功能处理的字符串类型的字典中的字符串必须由""表示
print(type(dic2),dic2)  #<class 'dict'> {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}

list_dic = [1,['a','b','c'],3,{'k1':'v1','k2':'v2'}]
str_dic = json.dumps(list_dic) #也可以处理嵌套的数据类型 
print(type(str_dic),str_dic) #<class 'str'> [1, ["a", "b", "c"], 3, {"k1": "v1", "k2": "v2"}]
list_dic2 = json.loads(str_dic)
print(type(list_dic2),list_dic2) #<class 'list'> [1, ['a', 'b', 'c'], 3, {'k1': 'v1', 'k2': 'v2'}]

dump load 有关文件存储:

import json
l1 = ['张三','历史','王五','alex','老土','旭哥']
f = open('json_file',encoding='utf-8',mode='w')
json.dump(l1,f,ensure_ascii=False)  # 将序列化的字符串存储到文件中
f.close()

f = open('json_file',encoding='utf-8')
ret = json.load(f)
print(ret,type(ret))
f.close()

import json
f = open('json_file','w')
dic = {'k1':'v1','k2':'v2','k3':'v3'}
json.dump(dic,f)  #dump方法接收一个文件句柄，直接将字典转换成json字符串写入文件
f.close()

f = open('json_file')
dic2 = json.load(f)  #load方法接收一个文件句柄，直接将文件中的json字符串转换成数据结构返回
f.close()
print(type(dic2),dic2)

有关文件存储的问题?
将多个序列化的字符串写入文件,然后反序列化,就会出错
用 dump load 只能写入和读取文件 一个序列化的字符串
下面的是错误的,没有换行符

f = open('json_files',encoding='utf-8',mode='w')
json.dump(dic,f,ensure_ascii=False)
json.dump(dic2,f,ensure_ascii=False)
json.dump(dic3,f,ensure_ascii=False)
f.close()
f = open('json_files', encoding='utf-8',)
print(json.load(f))
print(json.load(f))
print(json.load(f))
f.close()

多个数据读写一个文件的应用:

dic = {"alex": ('women','women','老女人')}
dic2 = {"alex1": ('women','women','老女人')}
dic3 = {"alex2": ('women','women','老女人')}

with open('json_files',encoding='utf-8',mode='a') as f1:
    s1 = json.dumps(dic,ensure_ascii=False)
    f1.write(s1+'
')
    s2 = json.dumps(dic2,ensure_ascii=False)
    f1.write(s2+'
')
    s3 = json.dumps(dic3,ensure_ascii=False)
    f1.write(s3+'
')

with open('json_files',encoding='utf-8') as f2:
    for line in f2:
        dic = json.loads(line)
        print(dic,type(dic))

dic = {"alex": ('women','women','老女人')}
ret = "
"+json.dumps(dic)
print(ret)

其他参数:
json的格式化输出:

import json
data = {'username':['李华','二愣子'],'sex':'male','age':16,'A':666}
json_dic2 = json.dumps(data,sort_keys=True,indent=2,separators=(',',':'),ensure_ascii=False)
print(json_dic2)

print(json.loads(json_dic2)) # 如果改了:separators=('|','*')反序列化不行了
sort_keys=True 字典键的首字母的ascii码排序
ensure_ascii=False 显示中文
indent=2 key 缩进

dic = {(1,2,3):'alex',1:[1,2,3]}
ret = json.dumps(dic)
print(ret)  # TypeError: keys must be a string

python 可以json序列化的数据类型有:dict,list,tuple,str,int,float,bool,None
json字符串,和python str 到底差在什么地方?

json 字符串 在数据最外面始终是单引号引起来的.
'{"name": "taibai"}'
json 字符串 如果数据是容器类的数据类型,且里面有字符串,则字符串一定双引号.
'{"name": "taibai"}'
而 python的是 "{'name': 'taibai'}"
对于单独的字符串:
python 显示:  'alex'
json 显示是  '"alex"'
额外:
ss = 'alex'
print(json.loads(ss))
ss1 = '"alex"'
print(json.loads(ss1))
i = '1'
print(json.loads(i),type(json.loads(i)))
思考题? 如果直接在文件中写一个 "alex"
我要是用load 可不可以?

pickle
class A :
     def __init__(self,name,age):
         self.name = name
         self.age = age

a1 = A('alex',1000)
import pickle

游戏的存档,读挡
with open('存储对象',mode='wb') as f1:
    pickle.dump(a1,f1)
with open('存储对象',mode='rb') as f1:
    ret = pickle.load(f1)
print(ret)
print(ret.name)

pickle   模块:
用于序列化的两个模块
json，用于字符串 和 python数据类型间进行转换
pickle，用于python特有的类型 和 python的数据类型间进行转换
pickle模块提供了四个功能：dumps、dump(序列化，存）、loads（反序列化，读）、load  （不仅可以序列化字典，列表...可以把python中任意的数据类型序列化）
pickle 序列化模块,python语言网络交互使用的,他支持所有的python数据类型.
两对 四个方法

dumps  loads  网络传输:

dic = {1:True,(2,3):[1,2,3,4],False:{1,2,3}}
import pickle
ret = pickle.dumps(dic)  # bytes类型无法识别内容

dic1 = pickle.loads(ret)
print(dic1,type(dic1))

dump  load 文件操作:

dic = {1:True,(2,3):[1,2,3,4],False:{1,2,3}}

import pickle
with open('pickle_file',mode='wb') as f1:
    pickle.dump(dic,f1)

with open('pickle_file',mode='rb') as f2:
    print(pickle.load(f2))

多个数据存储到一个文件:

dic = {"alex": ('women','women','老女人')}
dic2 = {"alex1": ('women','women','老女人')}
dic3 = {"alex2": ('women','women','老女人')}

import pickle
with open('pickle_files',mode='wb') as f1:
    pickle.dump(dic,f1)
    pickle.dump(dic2,f1)
    pickle.dump(dic3,f1)
    pickle.dump(dic3,f1)


with open('pickle_files',mode='rb') as f1:
    while True:
        try:
            print(pickle.load(f1))
        except EOFError:
            break

shelve模块:
shelve  与文件相关.:

import shelve
f = shelve.open('shelve_file')
f['key'] = {'int':10, 'float':9.5, 'string':'Sample data'}  #直接对文件句柄操作，就可以存入数据
f.close()

import shelve
f1 = shelve.open('shelve_file')
existing = f1['key']  #取出数据的时候也只需要直接用key获取即可，但是如果key不存在会报错
f1.close()
print(existing)

import shelve
f = shelve.open('shelve_file', flag='r')
# existing = f['key']
f['key'] = [11,22,33]
f.close()
# print(existing)

f = shelve.open('shelve_file', flag='r')
ex = f['key']
print(ex)
f.close()

f['key'] = {'int':10, 'float':9.5, 'string':'Sample data','new_value': 'this was not here before'}
import shelve
f1 = shelve.open('shelve_file')
print(f1['key'])
f1['key']['new_value'] = 'this was not here before'
print(f1['key'])
f1.close()

f2 = shelve.open('shelve_file',writeback=True)
print(f2['key'])
f2['key']['new_value'] = 'this was not here before'
print(f2['key'])
f2.close()

import shelve
f1 = shelve.open('shelve_file')
f1['key'] = {'int':10, 'float':9.5, 'string':'Sample data'}
print(f1['key'])
f1.close()
添加了一个键值对,主要是添加了一个值 {'int':10, 'float':9.5, 'string':'Sample data'}

总结:
序列化模块:
为了将数据用于网络传输
文件的读写操作
序列化:将数据转化成序列化字符串
反序列化:将序列化字符串转化成原数据
json:
优点;不同语言的数据传输
缺点:只支持str,int,list,dict,bool,float,None,tuple
老男孩官网 有微信支付功能.
两对 四个方法:
dumps  loads: 用于网络传输,多个数据读写一个文件.
import json
dic1 = {'name':'alex'}
s1 = json.dumps(dic1)  序列化过程
dic = json.loads(s1)  反序列化过程
dump load: 单个数据读写一个文件.
多个数据读写一个文件的应用:
代码 02 序列化模块.py中
其他参数...
pickle:
优点:支持python所有的数据类型
缺点:只能在python语言中进行数据传输
两对 四个方法:
dumps  loads: 用于网络传输,多个数据读写一个文件.
import pickle
dic1 = {'name':'alex'}
s1 = pickle.dumps(dic1)  序列化过程
dic = pickle.loads(s1)  反序列化过程
dump load: 单个数据读写一个文件.
多个数据读写一个文件的应用:
代码 02 序列化模块.py中
循环,try ....
shelve:pass(了解.)

序列化模块：
用于序列化的两个模块
 json，用于字符串 和 python数据类型间进行转换
pickle，用于python特有的类型 和 python的数据类型间进行转换
 pickle模块提供了四个功能：dumps、dump(序列化，存）、loads（反序列化，读）、load  （不仅可以序列化字典，列表...可以把python中任意的数据类型序列化）
支持所有数据类型只在python语言中流通
序列:有序的排列  （列表 元组  字符串  bytes)
序列化:
字符串
将普通的数据类型转换成字符串/bytes的过程
数据结构？
容器类型
为什么要用序列化呢？
要固态的存储一个数据结构
要在网络上传输一个数据结构

import json
# 序列化 dict/list---> str
dic = {'k':'v'}   #dic
print(dic,type(dic))
print(json.dumps(dic))   #json
ret = json.dumps(dic)
print(ret,type(ret))   #str
# 反序列化  str--->dict/list
res = json.loads(ret)
print(res,type(res))
import json
lst = [1,2,3]  #list
print(lst,type(lst))
ret = json.dumps(lst)
print(ret,type(ret))
反序列化  str---> dict/list
res = json.loads(ret)
print(res,type(res))

import json
tup = (1,2,3)
print(tup,type(tup))
ret = json.dumps(tup)
print(ret,type(ret))
反序列化， str--->dict/list
res = json.loads(ret)
print(res,type(res))

import json    #报错。
se = {1,2,3}    #集合的对象不是JSON序列化
print(se,type(se))
ret = json.dumps(se)
print(ret,type(ret))
#反序列化 str--->dict/list
res = json.loads(ret)
print(res,type(res))
java js-->json

所有的语言都通用的一种数据结构
数字  字符串  列表  字典
元组和list非常像
元组是作为一个列表被序列化的，所以在转回来的过程中也只能转换成一个列表
json
其他特定的数据类型-->str 序列化  dumps
str-->其他特定的数据类型  反序列化 loads

import json
dic = {'k':'v'}
ret = json.dumps(dic)
with open('json_demo','w')as f:
    f.write(ret)
with open('json_demo')as f:
    str_dic = f.read()
d = json.loads(str_dic)
print(d)

dic = {'k':'v'}
with open('json_demo2','w')as f:json.dumps(dic,f)
with open('json_demo2')as f:print(json.load(f))

dumps / loads 内存中 数据类型<-->str
dump / load 文件和内存之间  数据类型<-->str
json的问题
{1:'v'}-->str -->{'1':'v'} json 的key必须是一个字符串
有限的数据类型  数字 字符串 元组 列表 字典
不能连续的load
三个模块
json:
json  所有语言通用
支持的数据类型很少：str lst dict tuple {}的key必须是str
json的结果可以看懂
pickle:
pickle —— 只能python
几乎可以处理所有的数据类型只在python语言中流通
pickle的结果bytes
可以连续向文件中dump或load
json & pickle:
dum/load  --> 和文件打交道
json 不能连续load
pickle 可以多次dump,连续load
dumps/loads -->和内存打交道
shelve ：
shelve —— 简单 不全面
obj = open()
obj['key'] = {' '}
obj.close()

import pickle#能够处理所有数据类型 只能在python中使用
dic = {'k':'v',(1,2,3):{'a','b','c'}}
res = pickle.dumps(dic)
print(res)     #bytes类型
d = pickle.loads(res)
print(d)#{'k': 'v', (1, 2, 3): {'b', 'a', 'c'}}
import pickle
dic = {'k':'v',(1,2,3):{'a','b','c'}}
with open('pickle_demo1','wb')as f:
    pickle.dump(dic,f)
    pickle.dump(dic,f)
    pickle.dump(dic, f)
with open('pickle_demo1','rb') as f:
     d = pickle.load(f)
     print(d)
     d = pickle.load(f)
     print(d)
     d = pickle.load(f)
     print(d)


import shelve
f = shelve.open('shelve_file')
f['key'] = {'int':10,'float':9.5,'string':'Sample data'}
f.close()
f1 = shelve.open('shelve_file')
existing = f1['key'] #
f1.close()
print(existing)