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

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

2，何时使用序列化html

  • 数据存储
  • 网络上传输的时候
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  不能分次往文件里写java

# 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  能够实现：分次往文件里写，分次往文件外读python

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

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+'\n')
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 的格式化输出mysql

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
sql

# 用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
文件名：my_module.py 
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，关于导入模块的名称空间
　　　　每一个模块都是一个独立的名称空间，定义在这个模块中的函数，把这个模块的名称空间当作全局名称空间，这样咱们在编写本身的模块时，就不用担忧咱们定义在本身模块中全局变量会在被导入时，与使用者的全局变量冲突
 测试一:money与my_module.money不冲突
 测试二：read1与my_module.read1不冲突
 测试三：执行my_module.change()操做的全局变量money仍然是my_module中的

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

　　　　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，根据用户的输入，选择不一样的sqloracle

#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__ == '__被导入模块名__'
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程