018_序列化模块_什么是模块

1，序列化模块
　　什么叫序列化——将原本的字典、列表等内容转换成一个字符串的过程就叫做序列化。
　　比如，我们在python代码中计算的一个数据需要给另外一段程序使用，那我们怎么给？现在我们能想到的方法就是存在文件里，然后另一个python程序再从文件里读出来。但是我们都知道，对于文件来说是没有字典这个概念的，所以我们只能将数据转换成字符串放到文件中。你一定会问，将字典转换成一个字符串很简单，就是str(dic)就可以办到了，为什么我们还要学习序列化模块呢？没错序列化的过程就是从dic 变成str(dic)的过程。现在你可以通过str(dic)，将一个名为dic的字典转换成一个字符串，但是你要怎么把一个字符串转换成字典呢？
　　聪明的你肯定想到了eval()，如果我们将一个字符串类型的字典str_dic传给eval，就会得到一个返回的字典类型了。eval()函数十分强大，但是eval是做什么的？官方demo解释为：将字符串str当成有效的表达式来求值并返回计算结果。ＢＵＴ！强大的函数有代价。安全性是其最大的缺点。想象一下，如果我们从文件中读出的不是一个数据结构，而是一句"删除文件"类似的破坏性语句，那么后果实在不堪设设想。而使用eval就要担这个风险。所以，我们并不推荐用eval方法来进行反序列化操作(将str转换成python中的数据结构)

2，什么时候使用序列化

• 数据存储
• 网络上传输的时候

3，两种模块

• json
• pickle
• shelve（2.x有效，3.x无效）

4

• json  # 数字 字符串 列表 字典 元组

　　　　　通用的序列化格式
　　　　   只有很少的一部分数据类型能够通过json转化成字符串

• pickle

   　　　　 所有的python中的数据类型都可以转化成字符串形式
    　　　　pickle序列化的内容只有python能理解
    　　　　且部分反序列化依赖python代码

• shelve（2.x有效，3.x无效）

    　　　　序列化句柄
    　　　　使用句柄直接操作，非常方便

5，json

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

　　5.1，json
　　　dumps序列化方法  loads反序列化方法　　直接对内存中的数据进行操作，操作后还在内存里

dic = {"k1":'v1'}
print(type(dic),dic)
# <class 'dict'> {'k1': 'v1'}

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

dic_d = json.loads(str_d)   #反序列化
print(type(dic_d),dic_d)
# <class 'dict'> {'k1': 'v1'}
#注意，要用json的loads功能处理的字符串类型的字典中的字符串必须由""表示

　　

#也可以处理嵌套的数据类型 
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'}]

　　5.2，json

　　　　dump    load 对文件进行操作的

import json
dic = {1:"a",2:'b'}
f = open('fff','w',encoding='utf-8')
json.dump(dic,f)
f.close()

f = open('fff')
res = json.load(f)
f.close()
print(type(res),res)

　　5.3，在文件中写入中文序列化

import json
dic = {1:"中国",2:'b'}
f = open('F:临时文件\fff.txt','w',encoding='utf-8')
json.dump(dic,f,ensure_ascii=False)   
f.close()
# 要加入ensure_ascii=False，不然会写入bytes类型
# 也可以不加，不影响load的结果

f = open('F:临时文件\fff.txt',encoding='utf-8')
res = json.load(f)
f.close()
print(type(res),res)

　　5.4，dump  load  不能分次往文件里写

# import json
# dic = {1:"中国",2:'b'}

# f = open('F:临时文件\fff.txt','w',encoding='utf-8')
# json.dump(dic,f,ensure_ascii=False)
# json.dump(dic,f,ensure_ascii=False)
# f.close()

# f = open('F:临时文件\fff.txt',encoding='utf-8')
# res1 = json.load(f)
# res2 = json.load(f)
# f.close()
# print(type(res1),res1)
# print(type(res2),res2)

　　5.4，dumps  loads  可以实现：分次往文件里写，分次往文件外读

# json
# dumps {} -- >为了分次写将其写入成一行一行的dumps '{}
'
# 一行一行的读

l = [{'k':'111'},{'k2':'111'},{'k3':'111'}]
f = open('F:临时文件\fff.txt','w')

import json
for dic in l:
    str_dic = json.dumps(dic)
    f.write(str_dic+'
')
f.close()
f = open('F:临时文件\fff.txt')

import json
l = []
for line in f:
    dic = json.loads(line.strip())
    l.append(dic)
f.close() 
print(l)

　　5.5，

<1> Serialize obj to a JSON formatted str.(将obj序列化为json格式的str) 
<2> Skipkeys：默认值是False，如果dict的keys内的数据不是python的基本类型(str,unicode,int,long,float,bool,None)，设置为False时，就会报TypeError的错误。此时设置成True，则会跳过这类key 
<3> ensure_ascii：当它为True的时候，所有非ASCII码字符显示为uXXXX序列，只需在dump时将ensure_ascii设置为False即可，此时存入json的中文即可正常显示。
<4> If check_circular is false, then the circular reference check for container types will be skipped and a circular reference will result in an OverflowError (or worse). 
<5> If allow_nan is false, then it will be a ValueError to serialize out of range float values (nan, inf, -inf) in strict compliance of the JSON specification, instead of using the JavaScript equivalents (NaN, Infinity, -Infinity). 
<6> indent：应该是一个非负的整型，如果是0就是顶格分行显示，如果为空就是一行最紧凑显示，否则会换行且按照indent的数值显示前面的空白分行显示，这样打印出来的json数据也叫pretty-printed json 
<7> separators：分隔符，实际上是(item_separator, dict_separator)的一个元组，默认的就是(‘,’,’:’)；这表示dictionary内keys之间用“,”隔开，而KEY和value之间用“：”隔开。 
<8> default(obj) is a function that should return a serializable version of obj or raise TypeError. The default simply raises TypeError. 
<9> sort_keys：将数据根据keys的值进行排序。 
<10> To use a custom JSONEncoder subclass (e.g. one that overrides the .default() method to serialize additional types), specify it with the cls kwarg; otherwise JSONEncoder is used.

　　5.6，json 的格式化输出

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

6，pickle

# 用pickle dump的序列化是bytes类型的
##
这时候机智的你又要说了，既然pickle如此强大，为什么还要学json呢？
这里我们要说明一下，json是一种所有的语言都可以识别的数据结构。
如果我们将一个字典或者序列化成了一个json存在文件里，那么java代码或者js代码也可以拿来用。
但是如果我们用pickle进行序列化，其他语言就不能读懂这是什么了～
所以，如果你序列化的内容是列表或者字典，我们非常推荐你使用json模块
但如果出于某种原因你不得不序列化其他的数据类型，而未来你还会用python对这个数据进行反序列化的话，那么就可以使用pickle

 

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

　　6.1,

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

　　6.2,
　　　　(下面的程序，只有pickle能这样写，json不能。)
　　　　# pickle支持分次load，json不支持而是直接load
　　　　# pickle与文件打交道时，文件的模式要加b,即文件模式要是bytes数据类型的

import time
struct_time1  = time.localtime(1000000000)
struct_time2  = time.localtime(2000000000)
import pickle

f = open('Fpickle_file','wb')
pickle.dump(struct_time1,f) # dump 第一个
pickle.dump(struct_time2,f) # dump 第二个
f.close()

f = open('pickle_file','rb')
struct_time1 = pickle.load(f) # 加载dump的第一个
struct_time2 = pickle.load(f) # 加载dump的第二个
print(struct_time1.tm_year)
print(struct_time2.tm_year)
f.close()

7, shelve ( 在2.7版本有效，3.x版本无效)

　　详情点：shelve

　　#使用时会创建三个文件

　　7.1，

　　　　路径为文件夹，不是文件

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)

7.2，由于shelve在默认情况下时不会记录任何修改的，
     所以我们在sheleve.open()时候需要修改默认参数writeback=True才会保存修改。
     否则对象的修改是不会保存的。

import shelve
#修改不会保存
f1 = shelve.open('shelve_file')
print(f1['key'])
f1['key']['new_value'] = 'this was not here before'
f1.close()
#修改会保存
f2 = shelve.open('shelve_file', writeback=True)
print(f2['key'])
f2['key']['new_value'] = 'this was not here before'
f2.close()

 

8，模块
　　　什么是模块？
   　　常见的场景：一个模块就是一个包含了python定义和声明的文件，文件名就是模块名字加上.py的后缀。
  　　 但其实import加载的模块分为四个通用类别：　
　　　　1 使用python编写的代码（.py文件）
　　　　2 已被编译为共享库或DLL的C或C++扩展
　　　　3 包好一组模块的包
　　　　4 使用C编写并链接到python解释器的内置模块

9，import
　　9.1，导入模块
   　　1，自己写的程序文件，可以在另一个程序文件中通过“import 文件名”导入。

　　　注意：第一次导入时就立即执行了被导入的程序文件，并将模块名加载到内存中，但是重复导入只是引用，不会执行导入的文件。
   　　2，要调用被导入程序文件中的函数，要通过“模块名.函数名”执行。

   3，我们可以从sys.modules中找到当前已经加载的模块，sys.modules是一个字典，内部包含模块名与模块对象的映射，该字典决定了导入模块时是否需要重新导入。

# 文件名：my_module.py
print('from the my_module.py')

money=1000

def read1():
    print('my_module->read1->money',money)

def read2():
    print('my_module->read2 calling read1')
    read1()

def change():
    global money
    money=0

import my_modul
# 第一次导入时，执行被导入文件
# 结果：from the my_module.py

import my_module
import my_module
import my_module
# 重复导入，只第一次执行
# 结果：from the my_module.p

　　9.2，导入的过程
　　　　1，先从sys.modules里查看是否已经被导入如果没有被导入，就依据sys.path路径去寻找模块，找到了就导入
　　　　2，创建这个模块的命名空间
　　　　3，执行文件，把文件中的名字都放到命名空间里

import sys
print(sys.modules.keys())
print(sys.path)

　　9.3，关于导入模块的名称空间

　　　　每个模块都是一个独立的名称空间，定义在这个模块中的函数，把这个模块的名称空间当做全局名称空间，这样我们在编写自己的模块时，就不用担心我们定义在自己模块中全局变量会在被导入时，与使用者的全局变量冲突

 

 

 

　　总结：首次导入模块my_module时会做三件事：

　　　　1.为源文件(my_module模块)创建新的名称空间，在my_module中定义的函数和方法若是使用到了global时访问的就是这个名称空间。

　　　　2.在新创建的命名空间中执行模块中包含的代码，见初始导入import my_module

　　　　3.创建名字my_module来引用该命名空间（即不同的模块是单独的名称空间，通过 模块名.名称 的方式引用）

　　9.4，给模块起别名

import time as t   #将time模块命名为t
print(t.time())

　　起别名的作用：
 　　　　导入的不同模块，如有相同的方法，可以将两个模块命名成同样的别名。　　　

　　有两中sql模块mysql和oracle，根据用户的输入，选择不同的sql

#mysql.py
def sqlparse():
    print('from mysql sqlparse')
#oracle.py
def sqlparse():
    print('from oracle sqlparse')

#test.py
db_type=input('>>: ')
if db_type == 'mysql':
    import mysql as db
elif db_type == 'oracle':
    import oracle as db

db.sqlparse() 

　　9.5，导入模块要在程序文件前导入，为了方便查看使用了什么模块，
 　　　　　　导入顺序：内置的，扩展的，自定义的

　　　　在一行导入多个模块

import sys,os,re

 

10，from...import...

　　10.1，导入模块中的某个具体的方法，用

from my_module import read1,read2

10.2，不同于导入整个模块，单独导入一个模块中的方法时，导入的方法的名字就属于本程序文件全局变量名的范围了，在当前名称空间中，直接使用名字就可以调用该导入函数。

　　因此，如果再定义一个和导入的方法一样的变量名时，导入的就会被覆盖。

　　但执行被导入的函数时，仍然是以被导入模块文件为全局名称空间（即执行read1，read2时，使用到的变量，函数等，仍然是到my_module.py文件全局名称空间去寻找，与本程序文件全局变量名的范围无关）

from demo import read
def read():
    print('my read')
read()

　　10.3，可以使用 from demo import * 导入所有不是以下划线方法。

• 但要注意：当被导入模块中，前面用语句： __all__ = ['变量名','方法名’]   则只能导入限定的这几个变量或方法；
• 不同于“import 模块”本程序不会对其有影响，而这种方法导入，即是将其变量名，方法名归入本程序全局空间中
• 大部分情况下我们的python程序不应该使用这种导入方式，因为*你不知道你导入什么名字，很有可能会覆盖掉你之前已经定义的名字

　　10.4，支持 as

from my_module import read1 as read

　　10.5，支持多行导入

from my_module import (read1,
                  read2,
                  money)

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

if __name__ == '__main__'
   pass

　　　　#如果在本在这句话所在的程序中执行程序，该程序会执行pass
　　　　#如果该模块被导入到其他模块，当等于被导入模块名时才执行
　　　　if __name__ == '__被导入模块名__'