python:序列模块

Posted kakawith

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了python:序列模块相关的知识,希望对你有一定的参考价值。

一,序列化模块

什么叫序列化——将原本的字典、列表等内容转换成一个字符串的过程就叫做序列化

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

序列化的目的

1、以某种存储形式使自定义对象持久性
2、将对象从一个地方传递到另一个地方。
3、使程序更具维护性。

 

1,json模块

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

1)dumps和loads

#json dumps序列化方法 loads反序列化方法
dic = {1:"a",2:\'b\'}
print(type(dic),dic)
import json
str_d = json.dumps(dic)   # 序列化
print(type(str_d),str_d)
# \'{"kkk":"v"}\'#注意:kkk用" "(双引号引起来了)
dic_d = json.loads(str_d) # 反序列化
print(type(dic_d),dic_d)
\'\'\'
<class \'dict\'> {1: \'a\', 2: \'b\'}
<class \'str\'> {"1": "a", "2": "b"}
<class \'dict\'> {\'1\': \'a\', \'2\': \'b\'}
\'\'\'
dumps和loads

dumps是序列化方法,loads反序列化方法

2)dump与load

import json
# json dump load
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)
\'\'\'
<class \'dict\'> {\'2\': \'b\', \'1\': \'a\'}
\'\'\'
dump和load

3)dumps、loads与dump、load的区别

有s的直接在内存操作数据类型,没有s的方法是直接在文件里读写数据类型。 

dump需要需要有文件句柄,load不能进行多次load。

4)ensure_ascii关键字参数

import json
f = open(\'file\',\'w\')
json.dump({\'国籍\':\'中国\'},f)
ret = json.dumps({\'国籍\':\'中国\'})
f.write(ret+\'\\n\')
json.dump({\'国籍\':\'美国\'},f,ensure_ascii=False)
ret = json.dumps({\'国籍\':\'美国\'},ensure_ascii=False)
f.write(ret+\'\\n\')
f.close()
ensure_ascii关键字参数

5)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)
json格式化输出

2,pickle

    #所有的python中的数据类型都可以转化成字符串形式
    #pickle序列化的内容只有python能理解
    #且部分反序列化依赖python代码
    #可以分步dump和分步load
 #序列化与反序列话需要相同的环境
pickle模块提供了四个功能:dumps、dump、loads、load
1)pickle 的dumps和loads
import pickle
dic = {\'k1\':\'v1\',\'k2\':\'v2\',\'k3\':\'v3\'}
str_dic = pickle.dumps(dic)
print(str_dic)  #一串二进制内容

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

2)分步dump与load

dump和load必须用wb和rb打开

import time
struct_time1  = time.localtime(1000000000)
struct_time2  = time.localtime(2000000000)
f = open(\'pickle_file\',\'wb\')
pickle.dump(struct_time1,f)
pickle.dump(struct_time2,f)
f.close()
f = open(\'pickle_file\',\'rb\')
struct_time1 = pickle.load(f)
struct_time2 = pickle.load(f)
print(struct_time1.tm_year)
print(struct_time2.tm_year)
f.close()
分步dump和分步load

3,shelve

    #序列化句柄
    #使用句柄直接操作,非常方便
shelve也是python提供给我们的序列化工具,比pickle用起来更简单一些
shelve只提供给我们一个open方法,open方法获取一个文件句柄,操作和字典类似。是用key来访问的,使用起来和字典类似。
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)

二、模块

1,什么是模块?

一个模块就是一个包含了python定义和声明的文件,文件名就是模块名字加上.py的后缀。

2,import加载的模块分为四个通用类别:

  1 使用python编写的代码(.py文件)

  2 已被编译为共享库或DLL的C或C++扩展

  3 包好一组模块的包

  4 使用C编写并链接到python解释器的内置模块

3,import

1)示例文件:自定义模块my_module.py,文件名my_module.py,模块名my_module

#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
View Code

模块可以包含可执行的语句和函数的定义,这些语句的目的是初始化模块,它们只在模块名第一次遇到导入import语句时才执行(import语句是可以在程序中的任意位置使用的,且针对同一个模块很import多次,为了防止你重复导入,python的优化手段是:第一次导入后就将模块名加载到内存了,后续的import语句仅是对已经加载大内存中的模块对象增加了一次引用,不会重新执行模块内的语句)

#demo.py
import my_module #只在第一次导入时才执行my_module.py内代码,此处的显式效果是只打印一次\'from the my_module.py\',当然其他的顶级代码也都被执行了,只不过没有显示效果.
import my_module
import my_module
import my_module

\'\'\'
执行结果:
from the my_module.py
\'\'\'
#调用了多次但是只打印了一个结果

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

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

#测试一:money与my_module.money不冲突
#demo.py
#my_module中:from the my_module.py
import my_module
money=10
print(my_module.money)

\'\'\'
执行结果:
from the my_module.py
\'\'\'

3)测试二:read1与my_module.read1不冲突

#测试二:read1与my_module.read1不冲突
#demo.py
#my_module:
    #print(\'from the my_module.py\')
    #def read1():
        # print(\'money 1000\')   
import my_module
def read1():
    print(\'========\')
my_module.read1()

\'\'\'
执行结果:
from the my_module.py
my_module->read1->money 1000
\'\'\'                        

4)测试三:执行my_module.change()操作的全局变量money仍然是my_module中的

#测试三:执行my_module.change()操作的全局变量money仍然是my_module中的
#demo.py
import my_module
money=1
my_module.change()
print(money)

\'\'\'
执行结果:
from the my_module.py
\'\'\'

5)

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

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

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

导入模块时到底执行了什么?

事实上函数定义也是“被执行”的语句,模块级别函数定义的执行将函数名放入模块全局名称空间表,用globals()可以查看

3.创建名字my_module来引用该命名空间

1 这个名字和变量名没什么区别,都是‘第一类的’,且使用my_module.名字的方式可以访问my_module.py文件中定义的名字,my_module.名字与test.py中的名字来自两个完全不同的地方。

6)为模块名起别名,相当于m1=1;m2=m1

import my_module as sm
print(sm.money)

示范用法一:

有两中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() 
复制代码

4,from ... import...

from my_module import read1,read2
这样在当前位置直接使用read1和read2就好了,执行时,仍然以my_module.py文件全局名称空间
from demo import money,read
print(money)
read()
money = 200
read()
#测试一:导入的函数read1,执行时仍然回到my_module.py中寻找全局变量money
#demo.py
from my_module import read1
money=1000
read1()
\'\'\'
执行结果:
from the my_module.py
spam->read1->money 1000
\'\'\'

#测试二:导入的函数read2,执行时需要调用read1(),仍然回到my_module.py中找read1()
#demo.py
from my_module import read2
def read1():
    print(\'==========\')
read2()

\'\'\'
执行结果:
from the my_module.py
my_module->read2 calling read1
my_module->read1->money 1000
\'\'\'
这样在当前位置直接使用read1和read2就好了,执行时,仍然以my_module.py文件全局名称空间

如果当前有重名read1或者read2,那么会有覆盖效果

#测试三:导入的函数read1,被当前位置定义的read1覆盖掉了
#demo.py
from my_module import read1
def read1():
    print(\'==========\')
read1()
\'\'\'
执行结果:
from the my_module.py
==========
\'\'\'

需要特别强调的一点是:python中的变量赋值不是一种存储操作,而只是一种绑定关系,如下:

from my_module import money,read1
money=100 #将当前位置的名字money绑定到了100
print(money) #打印当前的名字
read1() #读取my_module.py中的名字money,仍然为1000

\'\'\'
from the my_module.py
my_module->read1->money 1000
\'\'\'

1)as

也支持as

from my_module import read1 as read

2)也支持多行输入

from my_module import (read1,
                  read2,
                 money)

5,把模块当做脚本执行

我们可以通过模块的全局变量__name__来查看模块名:
当做脚本运行:
__name__ 等于\'__main__\'

当做模块导入:
__name__= 模块名

作用:用来控制.py文件在不同的应用场景下执行不同的逻辑
if __name__ == \'__main__\':

def fib(n):   
    a, b = 0, 1
    while b < n:
        print(b, end=\' \')
        a, b = b, a+b
    print()

if __name__ == "__main__":
    print(__name__)
    num = input(\'num :\')
    fib(int(num))

6模块搜索路径

python解释器在启动时会自动加载一些模块,可以使用sys.modules查看

在第一次导入某个模块时(比如my_module),会先检查该模块是否已经被加载到内存中(当前执行文件的名称空间对应的内存),如果有则直接引用

如果没有,解释器则会查找同名的内建模块,如果还没有找到就从sys.path给出的目录列表中依次寻找my_module.py文件。

所以总结模块的查找顺序是:内存中已经加载的模块->内置模块->sys.path路径中包含的模块

需要特别注意的是:我们自定义的模块名不应该与系统内置模块重名。虽然每次都说,但是仍然会有人不停的犯错。

 

模块总结:

1,import和from import都支持as重命名,都支持多名字的导入

2,一个模块被import导入之后,并不会再次被导入。因为sys.mouldes记录了所有被导入的模块

3,sys.path记录了导入模块的时候寻找的所有路径

 4,模块就是一个py文件

 5,__all__必须与*连用

以上是关于python:序列模块的主要内容,如果未能解决你的问题,请参考以下文章

python:序列模块

Python - 模块

python之路 模块,序列化,迭代器,生成器

Python练习册 第 0013 题: 用 Python 写一个爬图片的程序,爬 这个链接里的日本妹子图片 :-),(http://tieba.baidu.com/p/2166231880)(代码片段

python之模块和包

python中的模块