day 20 - 1 序列化模块，模块的导入

序列化模块

首先我们来看一个序列：'sdfs45sfsgerg4454287789sfsf&*0'

序列 —— 就是字符串
序列化 —— 从数据类型 --> 字符串的过程
反序列化 —— 从字符串 --> 数据类型的过程

首先要了解到的是：一般没事不会把一个其他数据类型转化为字符串，因为这样功能就变少了，如：字典，列表...

序列化模块
json *****（非常重要）
pickle ****
shelve ***

json
　　数字 字符串 列表 字典 元组
　　通用的序列化格式（语言界的英语）
　　只有很少的一部分数据类型能够通过 json 转化成字符串
pickle
　　所有的 python 中的数据类型都可以转化成字符串形式
　　pickle 序列化的内容只有 python 能理解
　　且部分反序列化依赖 python 代码
　　比如：用于游戏中
shelve
　　序列化句柄（shelve 句柄）
　　使用句柄直接操作，非常方便

 

json 序列化

json   （dumps  loads）
　　dumps（序列化方法）、loads（反序列化方法），这两个直接对内存中的数据进行操作
　　json 本身是单引号的，内部原本是字符串元素要用双引号

json.dumps

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

sort_keys=True 　　 排序
indent 　　　　　　  整齐打印，填充物为空格
separators=()  　　   紧凑编码
ensure_ascii=False   输出为中文，（中文显示默认为 ascii 码）

dic = {"k":'v'}
print(type(dic),dic)     #输出结果：<class 'dict'> {'k': 'v'}
str_d = json.dumps(dic)   #序列化
print(type(str_d),str_d)  #输出结果：<class 'str'> {"k": "v"}

 

json.loads

#接上面的例子中 str_d
dic_d = json.loads(str_d) #反序列化
print(type(dic_d),dic_d)  #输出结果：<class 'dict'> {'k': 'v'}

 

元组也可以序列化（但被当做列表处理了）

dic = (1,2,3)
print(type(dic),dic)

str_d = json.dumps(dic)
print(type(str_d),str_d)

dic_d = json.loads(str_d)
print(type(dic_d),dic_d)

#输出结果如下
#<class 'tuple'> (1, 2, 3)
#<class 'str'> [1, 2, 3]
#<class 'list'> [1, 2, 3]

 

dump（序列化方法）、load（反序列化方法），这两个是对文件相关的操作
dump load 一次性写入 一次性读出

import json
dic = {1:"a",2:"b"}

f = open('D:/py/file.txt','w',encoding='utf-8')
ret = json.dump(dic,f)
f.close()
print(type(ret),ret)    #输出结果：<class 'NoneType'> None

f = open('D:/py/file.txt',encoding='utf-8')
res = json.load(f)
f.close()
print(type(res),res)    #输出结果：<class 'dict'> {'2': 'b', '1': 'a'}

with open('D:/py/file.txt','w',encoding='utf-8')as f:
    ret = json.dump(dic,f)
    print(type(ret),ret) 

with open('D:/py/file.txt',encoding='utf-8')as f:
    res = json.load(f)
    print(type(res),res)

#文件中的结果：{"1": "a", "2": "b"}

 

改写为中文字符：ensure_ascii=False

import json
dic = {1:"雷诺",2:"诺娃"}

with open('D:/py/file.txt','w',encoding='utf-8')as f:
    ##ret = json.dump(dic,f)
    ret = json.dump(dic,f,separators=(',',':'),ensure_ascii=False)
    print(type(ret),ret)    #输出结果：<class 'NoneType'> None

with open('D:/py/file.txt',encoding='utf-8')as f:
    res = json.load(f)
    print(type(res),res)    #输出结果：<class 'dict'> {'1': '雷诺', '2': '诺娃'}

##文件中的结果：{"1": "\u96f7\u8bfa", "2": "\u8bfa\u5a03"}
#文件中的结果：{"1":"雷诺","2":"诺娃"}

 

pickle 序列化模块

pickle 模块提供了四个功能：dumps、dump(序列化，存）、loads（反序列化，读）、load  （不仅可以序列化字典，列表...可以把 python 中任意的数据类型序列化）

import pickle
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = pickle.dumps(dic)
print(str_dic)  #一串二进制内容

dic2 = pickle.loads(str_dic)
print(dic2)    #字典

import time
struct_time  = time.localtime(1000000000)
print(struct_time)
f = open('pickle_file','wb')
pickle.dump(struct_time,f)
f.close()

f = open('pickle_file','rb')
struct_time2 = pickle.load(f)
print(struct_time2.tm_year)

 

 

模块的导入

模块导入的流程
　　先从sys.modules里查看是否已经被导入，即：模块不会被重复导入
　　如果没有被导入，就依据sys.path路径取寻找模块
　　找到了就导入
　　创建这个模块的命名空间
　　执行文件，把文件中的名字都放到命名空间里
　　import sys
　　print(sys.modules.keys())
　　print(sys.path)

导入 demo 及其中的函数

import demo
demo.reads()
#输出结果：还是这个模块

 

函数的别名

设置别名后，只有别名可以用，原来的函数名已经是过去式了

import time as t
print(t.time())
print(time.time())  #NameError: name 'time' is not defined

模块的集体调用

#模块的导入要写在文件的最开始导入
#先导入内置模块——再导入扩展模块——之后是自定义的（这样分为三行写）
import time，sys，os  #不推荐这样写 不利于可读性和加大的修改成本
import time
import sys
import os

 

from ... import ...

当使用改种方法时，times 函数就变为了全局函数
如果在自己的文件中在 创建一个 times()，则 demo 中的 times 会被覆盖掉
使用改种的优点是节省内存，只把自己需要的函数名拿过来，直接使用 import 是把被调用的文件中的函数名都拿来了

from demo import times
print(times())

from demo import times,reads  #使用逗号隔开 调用多个
from demo import *  #相当于调用 demo 中的所有（不安全，尽量不要用）

第四种
form demo import * 与 __all__ = [''] 的关联使用

#当使用这种模式调用模块时： form demo import * 与 __all__ = ['']
#此时就只能调用 __all__ 对应列表中的函数
from demo import *  #__all__ = ['times']
print(times())
reads()  #报错  NameError: name 'reads' is not defined

小结：

所有的模块导入都应该尽量往上写（顺序如下）
　　内置模块
　　扩展模块
　　自定义模块
模块不会重复被导入 ： sys.moudles
从哪儿导入模块 : sys.path

import
　　import 模块名
　　模块名.变量名 和本文件中的变量名完全不冲突
　　import 模块名 as 重命名的模块名 ： 提高代码的兼容性
　　import 模块1，模块2（不推荐使用）

from ... import ...
　　from 模块名 import 变量名
　　直接使用 变量名 就可以完成操作
　　如果本文件中有相同的变量名会发生冲突

from 模块名 import 变量名字 as 重命名变量名
　　from 模块名 import 变量名1，变量名2
　　from 模块名 import *
　　将模块中的所有变量名都放到内存中
　　如果本文件中有相同的变量名会发生冲突

from 模块名 import * 和 __all__ 是一对
　　没有这个变量，就会导入所有的名字
　　如果有 all 只导入 all 列表中的名字

__name__
　　在模块中 有一个变量 __name__
　　当我们直接执行这个模块的时候，__name__ == '__main__'
　　当我们执行其他模块，在其他模块中引用这个模块的时候，这个模块中的__name__ == '模块的名字'