python功能选择模块_Python一些常用模块

阅读目录

九：uuid

十：importlib

collections模块

常用模块连接:http://www.cnblogs.com/Eva-J/articles/7228075.html#_labelTop

在内置数据类型(dict、list、set、tuple)的基础上，collections模块还提供了几个额外的数据类型：Counter、deque、defaultdict、namedtuple和OrderedDict等。

1.namedtuple: 生成可以使用名字来访问元素内容的tuple

2.deque: 双端队列，可以快速的从另外一侧追加和推出对象

3.Counter: 计数器，主要用来计数

4.OrderedDict: 有序字典

5.defaultdict: 带有默认值的字典

namedtuple

from collections importnamedtuple

l1= namedtuple('foo',['zhou','jun','hao']) #第一个参数随便起个名字

l2 = l1(520,123,1314)print(l2.hao)#1314

print(l2.jun)#123

print(l2.hao)#1314

类似的，如果要用坐标和半径表示一个圆，也可以用namedtuple定义：

#namedtuple('名称', [属性list]):

Circle = namedtuple('Circle', ['x', 'y', 'r'])

yuan= Circle(1,2,3)print(yuan.x) #1

print(yuan.y) #2

print(yuan.r) #3

deque 双端队列,可以从两边增加删除值

使用list存储数据时，按索引访问元素很快，但是插入和删除元素就很慢了，因为list是线性存储，数据量大的时候，插入和删除效率很低。

deque是为了高效实现插入和删除操作的双向列表，适合用于队列和栈：

from collections importdeque

new_list= deque([1,2,3,4,5,6,7]) #变成一个双端队列

new_list.appendleft('x') #往队列左边添加元素

new_list.append('y') #队列右边添加元素

print(new_list) #deque(['x', 1, 2, 3, 4, 5, 6, 7, 'y'])

ret = new_list.popleft() #从左边弹出一个值

print(ret) #x

OrderedDict  有序字典

使用dict时，Key是无序的。在对dict做迭代时，我们无法确定Key的顺序。

如果要保持Key的顺序，可以用OrderedDict：

>>> from collections importOrderedDict>>> d = dict([('a', 1), ('b', 2), ('c', 3)]) #可以这样创建一个字典

>>> d #dict的Key是无序的

{'a': 1, 'c': 3, 'b': 2}>>> od = OrderedDict([('a', 1), ('b', 2), ('c', 3)]) #创建一个有序系字典

>>> od #OrderedDict的Key是有序的

OrderedDict([('a', 1), ('b', 2), ('c', 3)])

from collections import OrderedDict

dic2 = {'a':1,'b':2}

dic = OrderedDict(dic2)

print(dic) #OrderedDict([('a', 1), ('b', 2)])

注意，OrderedDict的Key会按照插入的顺序排列，不是Key本身排序：

>>> od =OrderedDict()>>> od['z'] = 1

>>> od['y'] = 2

>>> od['x'] = 3

>>> od.keys() #按照插入的Key的顺序返回

['z', 'y', 'x']

defaultdict  带有默认值的字典

有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于66 的值保存至字典的第一个key中，将小于66 的值保存至第二个key的值中。

time  时间模块

#常用方法

import time

1.time.sleep(secs)

(线程)推迟指定的时间运行。单位为秒。

2.time.time()

获取当前时间戳

表示时间的三种方式

在Python中，通常有这三种方式来表示时间：时间戳、元组(struct_time)、格式化的时间字符串：

(1)时间戳(timestamp) ：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型。

(2)格式化的时间字符串(Format String)： ‘1999-12-06’  time.strftime('%c')

%y 两位数的年份表示(00-99)%Y 四位数的年份表示(000-9999)%m 月份(01-12)%d 月内中的一天(0-31)%H 24小时制小时数(0-23)%I 12小时制小时数(01-12)%M 分钟数(00=59)%S 秒(00-59)%a 本地简化星期名称%A 本地完整星期名称%b 本地简化的月份名称%B 本地完整的月份名称%c 本地相应的日期表示和时间表示%j 年内的一天(001-366)%p 本地A.M.或P.M.的等价符%U 一年中的星期数(00-53)星期天为星期的开始%w 星期(0-6)，星期天为星期的开始%W 一年中的星期数(00-53)星期一为星期的开始%x 本地相应的日期表示%X 本地相应的时间表示%Z 当前时区的名称%% %号本身

python中时间日期格式化符号：

python中时间日期格式化符号：

(3)元组(struct_time) ：struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天等)time.localtime()

索引(Index)属性(Attribute)值(Values)

0

tm_year(年)

比如2011

1

tm_mon(月)

1 - 12

2

tm_mday(日)

1 - 31

3

tm_hour(时)

0 - 23

4

tm_min(分)

0 - 59

5

tm_sec(秒)

0 - 61

6

tm_wday(weekday)

0 - 6(0表示周日)

7

tm_yday(一年中的第几天)

1 - 366

8

tm_isdst(是否是夏令时)

默认为-1

首先，我们先导入time模块，来认识一下python中表示时间的几种格式：

#导入时间模块

>>>importtime#时间戳

>>>time.time()1500875844.800804

#时间字符串

>>>time.strftime("%Y-%m-%d %X")'2017-07-24 13:54:37'

>>>time.strftime("%Y-%m-%d %H-%M-%S")'2017-07-24 13-55-04'

#时间元组:localtime将一个时间戳转换为当前时区的struct_time

time.localtime()

time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24,

tm_hour=13, tm_min=59, tm_sec=37,

tm_wday=0, tm_yday=205, tm_isdst=0)

View Code

小结：时间戳是计算机能够识别的时间；时间字符串是人能够看懂的时间；元组则是用来操作时间的

几种格式之间的转换

#时间戳-->结构化时间#time.gmtime(时间戳) #UTC时间，与英国伦敦当地时间一致#time.localtime(时间戳) #当地时间。例如我们现在在北京执行这个方法：与UTC时间相差8小时，UTC时间+8小时 = 北京时间

>>>time.gmtime(1500000000)

time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=2, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0)>>>time.localtime(1500000000)

time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=10, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0)#结构化时间-->时间戳#time.mktime(结构化时间)

>>>time_tuple = time.localtime(1500000000)>>>time.mktime(time_tuple)1500000000.0

#结构化时间 --> %a %b %d %H:%M:%S %Y串#time.asctime(结构化时间) 如果不传参数，直接返回当前时间的格式化串

>>>time.asctime(time.localtime(1500000000))'Fri Jul 14 10:40:00 2017'

>>>time.asctime()'Mon Jul 24 15:18:33 2017'

#%a %d %d %H:%M:%S %Y串 --> 结构化时间#time.ctime(时间戳) 如果不传参数，直接返回当前时间的格式化串

>>>time.ctime()'Mon Jul 24 15:19:07 2017'

>>>time.ctime(1500000000)'Fri Jul 14 10:40:00 2017'

计算时间差

importtime

true_time=time.mktime(time.strptime('2017-09-11 08:30:00','%Y-%m-%d %H:%M:%S'))

time_now=time.mktime(time.strptime('2017-09-12 11:00:00','%Y-%m-%d %H:%M:%S'))

dif_time=time_now-true_time

struct_time=time.gmtime(dif_time)print('过去了%d年%d月%d天%d小时%d分钟%d秒'%(struct_time.tm_year-1970,struct_time.tm_mon-1,

struct_time.tm_mday-1,struct_time.tm_hour,

struct_time.tm_min,struct_time.tm_sec))

计算时间差

时间差

补充：

import time

#--------------------------我们先以当前时间为准,让大家快速认识三种形式的时间

print(time.time()) # 时间戳:1487130156.419527

print(time.strftime("%Y-%m-%d %X")) #格式化的时间字符串:'2017-02-15 11:40:53'

print(time.localtime()) #本地时区的struct_time

print(time.gmtime()) #UTC时区的struct_time

#--------------------------按图1转换时间

# localtime([secs])

# 将一个时间戳转换为当前时区的struct_time。secs参数未提供，则以当前时间为准。

time.localtime()

time.localtime(1473525444.037215)

# gmtime([secs]) 和localtime()方法类似，gmtime()方法是将一个时间戳转换为UTC时区(0时区)的struct_time。

# mktime(t) : 将一个struct_time转化为时间戳。

print(time.mktime(time.localtime()))#1473525749.0

# strftime(format[, t]) : 把一个代表时间的元组或者struct_time(如由time.localtime()和

# time.gmtime()返回)转化为格式化的时间字符串。如果t未指定，将传入time.localtime()。如果元组中任何一个

# 元素越界，ValueError的错误将会被抛出。

print(time.strftime("%Y-%m-%d %X", time.localtime()))#2016-09-11 00:49:56

# time.strptime(string[, format])

# 把一个格式化时间字符串转化为struct_time。实际上它和strftime()是逆操作。

print(time.strptime('2011-05-05 16:37:06', '%Y-%m-%d %X'))

#time.struct_time(tm_year=2011, tm_mon=5, tm_mday=5, tm_hour=16, tm_min=37, tm_sec=6,

# tm_wday=3, tm_yday=125, tm_isdst=-1)

#在这个函数中，format默认为："%a %b %d %H:%M:%S %Y"。

#--------------------------按图2转换时间

# asctime([t]) : 把一个表示时间的元组或者struct_time表示为这种形式：'Sun Jun 20 23:21:05 1993'。

# 如果没有参数，将会将time.localtime()作为参数传入。

print(time.asctime())#Sun Sep 11 00:43:43 2016

# ctime([secs]) : 把一个时间戳(按秒计算的浮点数)转化为time.asctime()的形式。如果参数未给或者为

# None的时候，将会默认time.time()为参数。它的作用相当于time.asctime(time.localtime(secs))。

print(time.ctime()) # Sun Sep 11 00:46:38 2016

print(time.ctime(time.time())) # Sun Sep 11 00:46:38 2016

datetime模块

#时间加减

import datetime

# print(datetime.datetime.now()) #返回 2016-08-19 12:47:03.941925

#print(datetime.date.fromtimestamp(time.time()) ) # 时间戳直接转成日期格式 2016-08-19

# print(datetime.datetime.now() )

# print(datetime.datetime.now() + datetime.timedelta(3)) #当前时间+3天

# print(datetime.datetime.now() + datetime.timedelta(-3)) #当前时间-3天

# print(datetime.datetime.now() + datetime.timedelta(hours=3)) #当前时间+3小时

# print(datetime.datetime.now() + datetime.timedelta(minutes=30)) #当前时间+30分

#

# c_time = datetime.datetime.now()

# print(c_time.replace(minute=3,hour=2)) #时间替换

>>> from datetime import datetime

>>> dt = datetime(2015, 4, 19, 12, 20) # 用指定日期时间创建datetime

>>> print(dt)

2015-04-19 12:20:00

>>> from datetime import datetime

>>> dt = datetime(2015, 4, 19, 12, 20) # 用指定日期时间创建datetime

>>> dt.timestamp() # 把datetime转换为timestamp

1429417200.0

>>> from datetime import datetime

>>> t = 1429417200.0

>>> print(datetime.fromtimestamp(t))

2015-04-19 12:20:00

random模块  随机模块

>>> importrandom#随机小数

>>> random.random() #大于0且小于1之间的小数

0.7664338663654585

>>> random.uniform(1,3) #大于1小于3的小数

1.6270147180533838

#随机整数

>>> random.randint(1,5) #大于等于1且小于等于5之间的整数

>>> random.randrange(1,10,2) #大于等于1且小于10之间的奇数

#随机选择一个返回

>>> random.choice([1,'23',[4,5]]) ##1或者23或者[4,5]#随机选择多个返回，返回的个数为函数的第二个参数

>>> random.sample([1,'23',[4,5]],2) ##列表元素任意2个组合

[[4, 5], '23']#打乱列表顺序

>>> item=[1,3,5,7,9]>>> random.shuffle(item) #打乱次序

>>>item

[5, 1, 3, 7, 9]>>>random.shuffle(item)>>>item

[5, 9, 7, 1, 3]

随机生成数字大小写字母组合的验证码

importrandomdeffunc(n):

ret= ''

for i inrange(n):

num= random.randint(0,9) #0到9随机生成一个整数

ALPHA = chr(random.randint(65,90)) #随机生成一个大写字母

alpha = chr(random.randint(97,122)) #随机生成一个小写字母

value = random.choice([str(num),ALPHA,alpha]) #注意,数字要转成字符串格式,choice参数传一个列表

ret +=valuereturnretprint(func(8))print(func(7))print(func(6))

os模块

os模块是与操作系统交互的一个接口

1.和文件夹相关的

2.和路径相关的

3.和文件相关的

4.和操作系统相关的

5.系统执行命令相关的

'''os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径

os.chdir("dirname") 改变当前脚本工作目录；相当于shell下cd #绝对路径

os.curdir 返回当前目录: ('.')

os.pardir 获取当前目录的父目录字符串名：('..')

os.makedirs('dirname1/dirname2') 可生成多层递归目录

os.removedirs('dirname1') 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推

os.mkdir('dirname') 生成单级目录；相当于shell中mkdir dirname

os.rmdir('dirname') 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname

os.listdir('dirname') 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印

os.remove() 删除一个文件

os.rename("oldname","newname") 重命名文件/目录

os.stat('path/filename') 获取文件/目录信息

os.sep 输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"

os.linesep 输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"

os.pathsep 输出用于分割文件路径的字符串 win下为;,Linux下为:

os.name 输出字符串指示当前使用平台。win->'nt'; Linux->'posix'

os.system("bash command") 运行shell命令，直接显示

os.popen("bash command) 运行shell命令，获取执行结果

os.environ 获取系统环境变量

os.path

os.path.abspath(path) 返回path规范化的绝对路径 os.path.split(path) 将path分割成目录和文件名二元组返回 os.path.dirname(path)

返回path的目录。其实就是os.path.split(path)的第一个元素 os.path.basename(path) 返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。

即os.path.split(path)的第二个元素

os.path.exists(path) 如果path存在，返回True；如果path不存在，返回False

os.path.isabs(path) 如果path是绝对路径，返回True

os.path.isfile(path) 如果path是一个存在的文件，返回True。否则返回False

os.path.isdir(path) 如果path是一个存在的目录，则返回True。否则返回False

os.path.join(path1[, path2[, ...]]) 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略

os.path.getatime(path) 返回path所指向的文件或者目录的最后访问时间

os.path.getmtime(path) 返回path所指向的文件或者目录的最后修改时间

os.path.getsize(path) 返回path的大小

os.path.abspath(path) #返回绝对路径

os.path.basename(path) #返回文件名

os.path.commonprefix(list) #返回list(多个路径)中，所有path共有的最长的路径。

os.path.dirname(path) #返回文件路径

os.path.exists(path)  #路径存在则返回True,路径损坏返回False

os.path.lexists  #路径存在则返回True,路径损坏也返回True

os.path.expanduser(path)  #把path中包含的"~"和"~user"转换成用户目录

os.path.expandvars(path)  #根据环境变量的值替换path中包含的”$name”和”${name}”

os.path.getatime(path)  #返回最后一次进入此path的时间。

os.path.getmtime(path)  #返回在此path下最后一次修改的时间。

os.path.getctime(path)  #返回path的大小

os.path.getsize(path)  #返回文件大小，如果文件不存在就返回错误

os.path.isabs(path)  #判断是否为绝对路径

os.path.isfile(path)  #判断路径是否为文件

os.path.isdir(path)  #判断路径是否为目录

os.path.islink(path)  #判断路径是否为链接

os.path.ismount(path)  #判断路径是否为挂载点()

os.path.join(path1[, path2[, ...]])  #把目录和文件名合成一个路径

os.path.normcase(path)  #转换path的大小写和斜杠

os.path.normpath(path)  #规范path字符串形式

os.path.realpath(path)  #返回path的真实路径

os.path.relpath(path[, start])  #从start开始计算相对路径

os.path.samefile(path1, path2)  #判断目录或文件是否相同

os.path.sameopenfile(fp1, fp2)  #判断fp1和fp2是否指向同一文件

os.path.samestat(stat1, stat2)  #判断stat tuple stat1和stat2是否指向同一个文件

os.path.split(path)  #把路径分割成dirname和basename，返回一个元组

os.path.splitdrive(path)   #一般用在windows下，返回驱动器名和路径组成的元组

os.path.splitext(path)  #分割路径，返回路径名和文件扩展名的元组

os.path.splitunc(path)  #把路径分割为加载点与文件

os.path.walk(path, visit, arg)  #遍历path，进入每个目录都调用visit函数，visit函数必须有

3个参数(arg, dirname, names)，dirname表示当前目录的目录名，names代表当前目录下的所有

文件名，args则为walk的第三个参数

os.path.supports_unicode_filenames  #设置是否支持unicode路径名

'''

注意：os.stat('path/filename') 获取文件/目录信息的结构说明

stat 结构:

st_mode: inode 保护模式

st_ino: inode 节点号。

st_dev: inode 驻留的设备。

st_nlink: inode 的链接数。

st_uid: 所有者的用户ID。

st_gid: 所有者的组ID。

st_size: 普通文件以字节为单位的大小；包含等待某些特殊文件的数据。

st_atime: 上次访问的时间。

st_mtime: 最后一次修改的时间。

st_ctime: 由操作系统报告的"ctime"。在某些系统上(如Unix)是最新的元数据更改的时间，在其它系统上(如Windows)是创建时间(详细信息参见平台的文档)。

stat 结构

stat 结构

sys模块 和python解释器交互

sys模块是与python解释器交互的一个接口

sys.argv 命令行参数List，第一个元素是程序本身路径

sys.exit(n) 退出程序，正常退出时exit(0),错误退出sys.exit(1)

sys.version 获取Python解释程序的版本信息

sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值

sys.platform 返回操作系统平台名称

importsystry:

sys.exit(1)exceptSystemExit as e:print(e)

异常处理和status

import sys #和解释器交互

if sys.argv[1] == 'alex' and sys.argv[2] == 'somebody':print('登录成功')else:print('登录失败')if sys.version.startswith('2'):'不支持'sys.exit()

实例

序列化模块 json pickle shelve

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

比如，我们在python代码中计算的一个数据需要给另外一段程序使用，那我们怎么给？

现在我们能想到的方法就是存在文件里，然后另一个python程序再从文件里读出来。

但是我们都知道，对于文件来说是没有字典这个概念的，所以我们只能将数据转换成字典放到文件中。

你一定会问，将字典转换成一个字符串很简单，就是str(dic)就可以办到了，为什么我们还要学习序列化模块呢？

没错序列化的过程就是从dic 变成str(dic)的过程。现在你可以通过str(dic)，将一个名为dic的字典转换成一个字符串，

但是你要怎么把一个字符串转换成字典呢？

聪明的你肯定想到了eval()，如果我们将一个字符串类型的字典str_dic传给eval，就会得到一个返回的字典类型了。

eval()函数十分强大，但是eval是做什么的？e官方demo解释为：将字符串str当成有效的表达式来求值并返回计算结果。

ＢＵＴ！强大的函数有代价。安全性是其最大的缺点。

想象一下，如果我们从文件中读出的不是一个数据结构，而是一句"删除文件"类似的破坏性语句，那么后果实在不堪设设想。

而使用eval就要担这个风险。

所以，我们并不推荐用eval方法来进行反序列化操作(将str转换成python中的数据结构)

为什么要有序列化模块

我为什么要有序列化模块

序列化的目的

1、以某种存储形式使自定义对象持久化；

2、将对象从一个地方传递到另一个地方。

3、使程序更具维护性。

json

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

importjson

dic= {'k1':'v1','k2':'v2','k3':'v3'}

str_dic= json.dumps(dic) #序列化：将一个字典转换成一个字符串

print(type(str_dic),str_dic) # {"k3": "v3", "k1": "v1", "k2": "v2"}#注意，json转换完的字符串类型的字典中的字符串是由""表示的

dic2= json.loads(str_dic) #反序列化：将一个字符串格式的字典转换成一个字典#注意，要用json的loads功能处理的字符串类型的字典中的字符串必须由""表示

print(type(dic2),dic2) # {'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) # [1, ["a", "b", "c"], 3, {"k1": "v1", "k2": "v2"}]

list_dic2 =json.loads(str_dic)print(type(list_dic2),list_dic2) # [1, ['a', 'b', 'c'], 3, {'k1': 'v1', 'k2': 'v2'}]

loads和dumps

dumps和loads

importjson

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)

load和dump

dump,load

importjson

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关键字参数

ensure_ascii关键字参数

pickle

#pickle 可以序列化一些自定义的数据类型 只能是python,其他语言不支持 游戏

#json 是所有编程语言通用的一种数据类型 列表,字典,数字 网络编程

json & pickle 模块

用于序列化的两个模块

json，用于字符串 和 python数据类型间进行转换

pickle，用于python特有的类型 和 python的数据类型间进行转换

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

importpickle

dic= {'k1':'v1','k2':'v2','k3':'v3'}

str_dic=pickle.dumps(dic)print(str_dic) #一串二进制内容

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

importtime

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)

pickle

pickle

如果你序列化的内容是列表或者字典，我们非常推荐你使用json模块

但如果出于某种原因你不得不序列化其他的数据类型，而未来你还会用python对这个数据进行反序列化的话，那么就可以使用pickle

shelve

shelve也是python提供给我们的序列化工具，比pickle用起来更简单一些。

shelve只提供给我们一个open方法，是用key来访问的，使用起来和字典类似。

importshelve

f= shelve.open('shelve_file')

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

f.close()importshelve

f1= shelve.open('shelve_file')

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

f1.close()print(existing)

shelve

shelve

这个模块有个限制，它不支持多个应用同一时间往同一个DB进行写操作。所以当我们知道我们的应用如果只进行读操作，我们可以让shelve通过只读方式打开DB

importshelve

f= shelve.open('shelve_file', flag='r')

existing= f['key']

f.close()print(existing)

只读

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

importshelve

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()

设置writeback

View Code

writeback方式有优点也有缺点。优点是减少了我们出错的概率，并且让对象的持久化对用户更加的透明了；但这种方式并不是所有的情况下都需要，首先，使用writeback以后，

shelf在open()的时候会增加额外的内存消耗，并且当DB在close()的时候会将缓存中的每一个对象都写入到DB，这也会带来额外的等待时间。因为shelve没有办法知道缓存中哪些对象修改了，

哪些对象没有修改，因此所有的对象都会被写入。

uuid  生成随机字符串，唯一标识

import uuid

print(str(uuid.uuid4()))

# 9b0d52cb-f2e7-4949-975f-7f8546db22b7

import importlib

importlib.import_module()