python模块

序列化

 

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

为什么要有序列化模块: 比如，我们在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模块提供了四个功能：dumps、dump、loads、load

dumps 及 loads

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import json
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = json.dumps(dic)  #序列化：将一个字典转换成一个字符串
print(type(str_dic),str_dic)  #<class 'str'> {"k3": "v3", "k1": "v1", "k2": "v2"}
#注意，json转换完的字符串类型的字典中的字符串是由""表示的
​
dic2 = json.loads(str_dic)  #反序列化：将一个字符串格式的字典转换成一个字典
#注意，要用json的loads功能处理的字符串类型的字典中的字符串必须由""表示
print(type(dic2),dic2)  #<class 'dict'> {'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) #<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'}]

dump 及 load

1
2
3
4
5
6
7
8
9
10
import json
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)　

其他参数说明

Serialize obj to a JSON formatted str.(字符串表示的json对象) Skipkeys：默认值是False，如果dict的keys内的数据不是python的基本类型(str,unicode,int,long,float,bool,None)，设置为False时，就会报TypeError的错误。此时设置成True，则会跳过这类key ensure_ascii:，当它为True的时候，所有非ASCII码字符显示为\uXXXX序列，只需在dump时将ensure_ascii设置为False即可，此时存入json的中文即可正常显示。) 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). 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). indent：应该是一个非负的整型，如果是0就是顶格分行显示，如果为空就是一行最紧凑显示，否则会换行且按照indent的数值显示前面的空白分行显示，这样打印出来的json数据也叫pretty-printed json separators：分隔符，实际上是(item_separator, dict_separator)的一个元组，默认的就是(‘,’,’:’)；这表示dictionary内keys之间用“,”隔开，而KEY和value之间用“：”隔开。 default(obj) is a function that should return a serializable version of obj or raise TypeError. The default simply raises TypeError. sort_keys：将数据根据keys的值进行排序。 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.

 

json格式化输出

1
2
3
4
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)

 

pickle模块

用于序列化的两个模块

json，用于字符串 和 python数据类型间进行转换 pickle，用于python特有的类型 和 python的数据类型间进行转换pickle模块提供了四个功能：dumps、dump(序列化，存）、loads（反序列化，读）、load （不仅可以序列化字典，列表...可以把python中任意的数据类型序列化）pickle是python特有的模块.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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)

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

总结:

1
2
3
4
5
6
7
8
9
10
11
12
13
json模块里的dumps是将python的数据结构转换成字符串,loads是将字符串类型转换成python的数据结构
​
    json模块里的dump是将python的数据结构转换成字符串,然后存入到文件当中
​
    json模块里的load是将文件中字符串类型转换成python的数据结构
​
    pickle模块里的dumps是将python的数据结构转换成二进制的文件,loads是将二进制的文件转换成python的
​
        数据结构
​
    pickle模块里的dump是将python的数据结构转换成二进制然后存入到文件中
​
    pickle模块里的load是将文件中的二进制文件转成python的数据结构

 

random 模块

random是一个随机数模块,我们一般用来生成一些没有规则的内容

获取0-1之间的随机小数

1
2
import random
print(random.random())

我们可以获取0到1之间的随机的小数,但是还能够满足你,你想要生成指定的数字内的随机小数怎么办??

1
2
import random
print(random.uniform(1,5))

这样写完后,你就有又想法了,说小数你实现了.整数怎么做到随机呢?老铁别急

1
2
import random
print(random.randint(1,5))

你这样是实现了,我想让你给生成随机的奇数和偶数,怎么样不会了吧??

1
2
3
import random
print(random.randrange(1,5,2))   #随机生成1-5的奇数
print(random.randrange(0,5,2))   #随机生成0-5的偶数

我还真发现了,真有点难不住你了,我现在有一个列表 lst = ['张开','宝元','佩奇','太白'],你给我随机抽一个人出来

1
2
3
import random
lst = ['张开','宝元','佩奇','太白']
print(random.choice(lst))

看来还是有两把刷子的,我在考考你.怎么给我随机抽出两个来　　

1
2
3
import random
lst = ['张开','宝元','佩奇','太白']
print(random.choices(lst,k=2))

差点就被你骗你了,要不是我眼疾手快,发现了你随机出来的两个内容是有重复的,我还就要夸你了,没有满足需求重新实现

1
2
3
import random
lst = ['张开','宝元','佩奇','太白']
print(random.sample(lst,k=2))

可以啊,真是少年有为啊,难不住了,看来事要逼着我使用绝招了.我给你一个列表你给我让他变成随机排序的

1
2
3
4
import random
lst = [1,2,3,4,5,6]
random.shuffle(lst)
print(lst)

看来还是真是不简单啊.老衲服了!

 

os模块

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
<em>#和文件夹相关
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下为"\r\n",Linux下为"\n"
os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
​
# 和执行系统命令相关
os.system("bash command")  运行shell命令，直接显示
os.popen("bash command).read()  运行shell命令，获取执行结果
os.environ  获取系统环境变量
​
#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的大小<br></em>
1
2
3
4
os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname")  改变当前脚本工作目录；相当于shell下cd
os.curdir  返回当前目录: ('.')
os.pardir  获取当前目录的父目录字符串名：('..')

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

1
2
3
4
5
6
7
8
9
10
11
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）是创建时间（详细信息参见平台的文档）。　

 

sys模块

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

1
2
3
4
5
sys.argv           命令行参数List，第一个元素是程序本身路径
sys.exit(n)        退出程序，正常退出时exit(0),错误退出sys.exit(1)
sys.version        获取Python解释程序的版本信息
sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform       返回操作系统平台名称

 

hashlib模块

算法介绍 Python的hashlib提供了常见的摘要算法，如MD5，SHA1等等。

什么是摘要算法呢？摘要算法又称哈希算法、散列算法。它通过一个函数，把任意长度的数据转换为一个长度固定的数据串（通常用16进制的字符串表示）。

摘要算法就是通过摘要函数f()对任意长度的数据data计算出固定长度的摘要digest，目的是为了发现原始数据是否被人篡改过。

摘要算法之所以能指出数据是否被篡改过，就是因为摘要函数是一个单向函数，计算f(data)很容易，但通过digest反推data却非常困难。而且，对原始数据做一个bit的修改，都会导致计算出的摘要完全不同。

我们以常见的摘要算法MD5为例，计算出一个字符串的MD5值：

1
2
3
4
5
6
7
import hashlib
 
md5 = hashlib.md5()
md5.update('how'.encode('utf-8'))
print(md5.hexdigest())
 
结果:db88a0257c220dbfdd2e40f6152d6a8d

如果数据量很大，可以分块多次调用update()，最后计算的结果是一样的：

1
2
3
4
5
6
7
8
9
10
11
12
13
import hashlib
md5 = hashlib.md5()
md5.update('how你好啊,我不好'.encode('utf-8'))
print(md5.hexdigest())
结果:3bfa4bfb7b59a59f27c24ebdd89cd13c
 
 
import hashlib
md5 = hashlib.md5()
md5.update('how'.encode('utf-8'))
md5.update('你好啊,我不好'.encode('utf-8'))
print(md5.hexdigest())
结果:3bfa4bfb7b59a59f27c24ebdd89cd13c

MD5是最常见的摘要算法，速度很快，生成结果是固定的128 bit字节，通常用一个32位的16进制字符串表示。另一种常见的摘要算法是SHA1，调用SHA1和调用MD5完全类似：

1
2
3
4
5
6
7
8
import hashlib
 
sha1 = hashlib.sha1()
sha1.update('how to use sha1 in'.encode('utf-8'))
sha1.update('python hashlib?'.encode('utf-8'))
print(sha1.hexdigest())
 
结果:86e1eae2a08c152d39b55baed085c71a0cc9d10b

SHA1的结果是160 bit字节，通常用一个40位的16进制字符串表示。

SHA1的安全系数比MD5还要高一些,而且摘要的长度要比MD5长一些.

比SHA1更安全的算法是SHA256和SHA512，不过越安全的算法越慢，而且摘要长度更长。

摘要算法应用 任何允许用户登录的网站都会存储用户登录的用户名和口令。如何存储用户名和口令呢？方法是存到数据库表中：

1
2
3
4
5
name    | password
--------+----------
michael | 123456
bob     | abc999
alice   | alice2008

如果以明文保存用户口令，数据库泄露，所有用户的口令就落入黑客的手里就......

此外，网站运维人员是可以访问数据库的，也就是能获取到所有用户的口令。正确的保存口令的方式是不存储用户的明文口令，而是存储用户口令的摘要，比如MD5：

1
2
3
4
5
username | password
---------+---------------------------------
michael  | e10adc3949ba59abbe56e057f20f883e
bob      | 878ef96e86145580c38c87f0410ad153
alice    | 99b1c2188db85afee403b1536010c2c9

考虑这么个情况，很多用户喜欢用123456，888888，password这些简单的口令，于是，黑客可以事先计算出这些常用口令的MD5值，得到一个反推表：

'e10adc3949ba59abbe56e057f20f883e': '123456'
'21218cca77804d2ba1922c33e0151105': '888888'
'5f4dcc3b5aa765d61d8327deb882cf99': 'password'

这样，无需破解，只需要对比数据库的MD5，黑客就获得了使用常用口令的用户账号。

对于用户来讲，当然不要使用过于简单的口令。但是，我们能否在程序设计上对简单口令加强保护呢？

由于常用口令的MD5值很容易被计算出来，所以，要确保存储的用户口令不是那些已经被计算出来的常用口令的MD5，这一方法通过对原始口令加一个复杂字符串来实现，俗称“加盐”：

1
2
3
4
5
6
7
8
9
10
11
12
import hashlib
md5 = hashlib.md5('salt'.encode('utf-8'))  #这是加盐了的
md5.update('how你好啊,我不好'.encode('utf-8'))
print(md5.hexdigest())  
#结果 49f3d086ef5582b12d294c6f1b1c9dea
 
 
import hashlib
md5 = hashlib.md5()
md5.update('how你好啊,我不好'.encode('utf-8'))
print(md5.hexdigest())  
#结果 3bfa4bfb7b59a59f27c24ebdd89cd13c

经过Salt处理的MD5口令，只要Salt不被黑客知道，即使用户输入简单口令，也很难通过MD5反推明文口令。

但是如果有两个用户都使用了相同的简单口令比如123456，在数据库中，将存储两条相同的MD5值，这说明这两个用户的口令是一样的。有没有办法让使用相同口令的用户存储不同的MD5呢？

如果假定用户无法修改登录名，就可以通过把登录名作为Salt的一部分来计算MD5，从而实现相同口令的用户也存储不同的MD5。

摘要算法在很多地方都有广泛的应用。要注意摘要算法不是加密算法，不能用于加密（因为无法通过摘要反推明文），只能用于防篡改，但是它的单向计算特性决定了可以在不存储明文口令的情况下验证用户口令。

 

collections模块

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

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

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

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

4.OrderedDict: 有序字典

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

namedtuple

我们知道tuple可以表示不变集合，例如，一个点的二维坐标就可以表示成：

1
p = (1, 2)

但是，看到(1, 2)，很难看出这个tuple是用来表示一个坐标的。

这时，namedtuple就派上了用场：

1
2
3
4
5
6
7
>>> from collections import namedtuple
>>> Point = namedtuple('Point', ['x', 'y'])
>>> p = Point(1, 2)
>>> p.x
1
>>> p.y
2

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

1
2
namedtuple('名称', [属性list]):
Circle = namedtuple('Circle', ['x', 'y', 'r'])

 

deque

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

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

1
2
3
4
5
6
>>> from collections import deque
>>> q = deque(['a', 'b', 'c'])
>>> q.append('x')
>>> q.appendleft('y')
>>> q
deque(['y', 'a', 'b', 'c', 'x'])

deque除了实现list的append()和pop()外，还支持appendleft()和popleft()，这样就可以非常高效地往头部添加或删除元素。

 

OrderedDict

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

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

1
2
3
4
5
6
7
>>> from collections import OrderedDict
>>> 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)])

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

 

defaultdict

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

即： {'k1': 大于66 , 'k2': 小于66}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
li = [11,22,33,44,55,77,88,99,90]
result = {}
for row in li:
    if row > 66:
        if 'key1' not in result:
            result['key1'] = []
        result['key1'].append(row)
    else:
        if 'key2' not in result:
            result['key2'] = []
        result['key2'].append(row)
print(result)
from collections import defaultdict
​
values = [11, 22, 33,44,55,66,77,88,99,90]
​
my_dict = defaultdict(list)
​
for value in  values:
    if value>66:
        my_dict['k1'].append(value)
    else:
        my_dict['k2'].append(value)

使用dict时，如果引用的Key不存在，就会抛出KeyError。如果希望key不存在时，返回一个默认值，就可以用defaultdict：

1
2
3
4
5
6
7
>>> from collections import defaultdict
>>> dd = defaultdict(lambda: 'N/A')
>>> dd['key1'] = 'abc'
>>> dd['key1'] # key1存在
'abc'
>>> dd['key2'] # key2不存在，返回默认值
'N/A'

 

Counter

Counter类的目的是用来跟踪值出现的次数。它是一个无序的容器类型，以字典的键值对形式存储，其中元素作为key，其计数作为value。计数值可以是任意的Interger（包括0和负数）。Counter类和其他语言的bags或multisets很相似。

1
2
3
c = Counter('abcdeabcdabcaba')
print c
输出：Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1})
 

我们之前学了json和pickle模块 这些都是序列化的模块,咱们进行在讲一个序列化的东西 叫做shelve

你们肯定有个疑问,这个东西和那个类似为什么要讲.是因为这个模块比较简单的,并且你们后期存储数据的时候需要使用数据库,但是当数据较少的时候我们就可以不用通过网络去和数据库进行交互了.直接使用咱们本地的文件就可以了

好了,我们现在来看看这个有多简单.

首先我们要import shelve这个模块,然后就像操作文件一样就可以啦.好我们来试试

import shelve f = shelve.open('sss')

 

这样我们就创建了三个文件,一听三个文件是不是就迷了,别急我们往下看

sss.bak 'name', (0, 28) 这个bak没别的功能就是备份的文件
sss.dat �]q (KKK}qX 1qKse.
sss.dir 'name', (0, 28)

 

纳尼,这些都是些什么啊,你有没在这样想?? 这是我们windows系统下创建文件获取的内容,不用去管它.但是记住一句不要手欠去加个内容

我们刚刚提到了windows下是这三个,那苹果是啥呢,苹果的就是sss.bb,好了这些都是无关紧要的.我们只需知道怎么去用就可以了.

我们只需要向使用字典的方式去操作就行了

import shelve f = shelve.open('sss') f['name'] = [1,2,3,{'1':2}] print(f['name'])

 

以上的操作就是在增加一个键值对,这里的键有个需求是键必须是字符串类型.值就是python类型的数据没有要求

我们现在将一个字典就写到文件中,我们换个py文件值需要打开这个文件就可以使用这字典了.你们会想了.这个和json/pickle有什么区别是在这样的概念下是没有区别,就是将一个对象持久化的存到文件中.

咱们来想想如果我后期需要频繁的增加键值对,要是使用pickle和json来实现的是不是需要一次dump然后在增加

我们先来看看pickle的字典增加键值对

import pickle # 首先我们需要打开一个文件 f = open('ss','wb') dic = {'name':'宝元'} # 将dic字典序列化到这ss文件中 pickle.dump(dic,f) #然后在打开这个文件 f1 = open('ss','rb') # 将这个文件中的内容反序列出来 dics = pickle.load(f1) # 附一个新的变量 print(dics) dics['age'] = 18 # 然后进行添加值 print(dics) f2 = open('ss','wb') # 在把最新的这个字典序列化文件中 dics = pickle.dump(dics,f2) f3 = open('ss','rb') dics = pickle.load(f3) # 最后在反序列回来进行打印这个字典 print(dics)

 

这样写是没有问题,但是咱们来看看shelve是怎么实现的

import shelve f = shelve.open('sss') f['name'] = [1,2,3,{'1':2}] print(f['name']) # 添加后我们就能直接查看了,不在需要多次的dump和load了 f['age'] = 20 print(f['age'])

 

上下一对比,是不是觉得shelve还是挺简单的,这还不算完,其实shelve这个模块就是一个open和字典的操作就可以了

回想一下字典中都有哪些功能,它就有什么功能..

但是不得不说的就是它有它的问题,它的问题就是不能直接查看字典中所的内容,我们想要看这个字典中都有什么功能就

需要循环这个字典了

方式一 import shelve f = shelve.open('sss') for k in f: print(k) 运行结果:name
方式二 import shelve f = shelve.open('sss') for k in f.keys(): print(k) 运行结果:name

和咱们的字典一模一样,我们要是查看f.keys()和咱们预想不一样,这个不能查看只能for循环

有的时候我们想要修改字典中name对应的值,这个时候我们应该怎么操作

import shelve f = shelve.open('sss') f['name'] = '宝元' print(f['name']) f['name'] = 'meet' print(f['name']) 运行结果: 宝元 meet

 

我们现在距离成功只差一步了,差什么呢?? 这个东西在那会用到呢?

这个东西如果没有强烈的要求时,我们就可以使用这种方式来进行序列化,他其实就是基于pickle实现的.

咱们这个shelve模块有个坑你们需要注意的就是文件回写的时候会出现写不成功,你们只需要在open这函数的地方写一个writeback=True 这就是回写.

 

shutil

今天是一个福利日,刚刚告诉你们一个快速使用序列化的模块,在教你们一个模块shutil

这个模块就是针对文件和文件夹在做操作,并且还具有压缩包的功能.废话不多说我们现在把这模块导入进来

import shutil

 

我们就先看看文件有什么操作

import shutil shutil.copyfileobj(open('aa.py','r',encoding='utf-8'),open('as.py','w',encoding='utf-8'))

 

拷贝文件,可以自己指定模式和编码方式

import shutil shutil.copyfile(r'D:\untitled2\a\as.py', 'f2.log') #目标文件必须存在

 

拷贝文件,第一个参数放一个源文件,第二参数放一个要拷贝到那个文件的名字,模式不用管,编码方式默认是utf-8

仅拷贝权限。内容、组、用户均不变

shutil.copymode('f1.log', 'f2.log') #目标文件必须存在

 

仅拷贝状态的信息，包括：mode bits, atime, mtime, flags

shutil.copystat('f1.log', 'f2.log') #目标文件必须存在

 

拷贝文件和权限

import shutil shutil.copy2('f1.log', 'f2.log')

 

递归的去拷贝文件夹

1 import shutil 3 shutil.copytree('folder1', 'folder2', ignore=shutil.ignore_patterns('*.pyc', 'tmp*')) #目标目录不能存在，注意对folder2目录父级目录要有可写权限，ignore的意思是排除

递归的去删除文件

import shutil shutil.rmtree('folder1')

 

递归的去移动文件

import shutil shutil.move('folder1', 'folder3')

 

创建压缩包并返回文件路径，例如：zip、tar

base_name： 压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径， 如 data_bak =>保存至当前路径 如：/tmp/data_bak =>保存至/tmp/ format： 压缩包种类，“zip”, “tar”, “bztar”，“gztar” root_dir： 要压缩的文件夹路径（默认当前目录） owner： 用户，默认当前用户 group： 组，默认当前组 logger： 用于记录日志，通常是logging.Logger对象 #将 /data 下的文件打包放置当前程序目录 import shutil ret = shutil.make_archive("data_bak", 'gztar', root_dir='/data') #将 /data下的文件打包放置 /tmp/目录 import shutil ret = shutil.make_archive("/tmp/data_bak", 'gztar', root_dir='/data')

shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的，详细：
zipfile压缩解压缩

import zipfile # 压缩 z = zipfile.ZipFile('laxi.zip', 'w') z.write('a.log') z.write('data.data') z.close() # 解压 z = zipfile.ZipFile('laxi.zip', 'r') z.extractall(path='.') z.close()

 

tarfile压缩解压缩

import tarfile # 压缩 t=tarfile.open('/tmp/egon.tar','w') t.add('/test1/a.py',arcname='a.bak') t.add('/test1/b.py',arcname='b.bak') t.close() # 解压 t=tarfile.open('/tmp/egon.tar','r') t.extractall('/meet') t.close()

 

posted @ 2019-12-02 17:22  luca-sHi  阅读(212)  评论(0)    收藏  举报