Python模块三

collections模块

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

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

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

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

4.OrderedDict: 有序字典

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

namedtuple

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

p = (1, 2)

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

这时，namedtuple就派上了用场：

>>> from collections import namedtuple

>>> Point = namedtuple('Point', ['x', 'y'])

>>> p = Point(1, 2)

>>> p.x

1

>>> p.y

2

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

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

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

deque

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

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

>>> 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：

>>> 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}

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：

>>> from collections import defaultdict

>>> dd = defaultdict(lambda: 'N/A')

>>> dd['key1'] = 'abc'

>>> dd['key1'] # key1存在

'abc'

>>> dd['key2'] # key2不存在，返回默认值

'N/A'

aaarticlea/gif;base64,R0lGODlhAQABAPABAP///wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==" alt="" />

Counter

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

c = Counter('abcdeabcdabcaba')

print c

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

shelve

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

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

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

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

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

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

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

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

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

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

import shelve
f = shelve.open('sss')
f['name'] = [,,,{'':}]
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'] =
# 然后进行添加值
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'] = [,,,{'':}]
print(f['name'])
# 添加后我们就能直接查看了,不在需要多次的dump和load了
f['age'] =
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'] = 'abx'
print(f['name'])
f['name'] = 'meet'
print(f['name'])

运行结果:
宝元
abx

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

这个东西如果没有强烈的要求时,我们就可以使用这种方式来进行序列化,他其实就是基于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')

递归的去拷贝文件夹

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