《Python》常用模块之collections模块

内置的数据类型：

　　int  float  complex

　　str  list  tuple

　　dict  set

基础数据类型：

　　int  float  complex

　　str  list  tuple

　　dict

collections模块：

　　根据基础数据类型又做了一些扩展

　　　　1、OrderdDict：有序字典　　Python3.6以后自动有序　　　

　　　　2、defaultdict：默认字典

　　　　3、Counter： 计数器

　　　　4、namedtuple：可命名元祖

　　　　5、deque：双端队列

1、OrderdDict：（有序字典）

　　　　在Python3.6之前使用dict，key是无序的。在对dict做迭代时，我们无法确定key的顺序。

　　　　如果要保持key的顺序，key用OrderdDict：

from collections import OrderedDict
d = dict([('a', 1), ('b', 2), ('c', 3)])
print(d)    # {'a': 1, 'c': 3, 'b': 2}  dict的key是无序的
od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
print(od)   # OrderedDict([('a', 1), ('b', 2), ('c', 3)])   OrderedDict的Key是有序的

from collections import OrderedDict
dd = OrderedDict([('a', 1), ('k1', 'v1')])
print(dd)   # OrderedDict([('a', 1), ('k1', 'v1')])
for k in dd:
    print(k, dd[k])  # a 1      k1 v1
dd['k2'] = 'v2'
print(dd)   # OrderedDict([('a', 1), ('k1', 'v1'), ('k2', 'v2')])

2、defaultdict：（默认字典）

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

即：{‘k1’：大于66，‘k2’：小于66}

lst = [11, 22, 33, 44, 55, 66, 77, 88, 99 ,90]
dic = {}
for i in lst:
    if i > 66:
        if dic.get('k1'):
            dic['k1'].append(i)
        else:
            dic['k1'] = [i]
    elif i < 66:
        if dic.get('k2'):
            dic['k2'].append(i)
        else:
            dic['k2'] = [i]
print(dic)  # {'k2': [11, 22, 33, 44, 55], 'k1': [77, 88, 99, 90]}

原生字典解决方法

from collections import defaultdict
lst = [11, 22, 33, 44, 55, 66, 77, 88, 99 ,90]
dic = defaultdict(list)
for i in lst:
    if i > 66:
        dic['v1'].append(i)
    elif i < 66:
        dic['v2'].append(i)
print(dic)  # defaultdict(<class 'list'>, {'v2': [11, 22, 33, 44, 55], 'v1': [77, 88, 99, 90]})
print(dic['v1'])    # [77, 88, 99, 90]
print(dic['v2'])    # [11, 22, 33, 44, 55]

defaultdict解决方法

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

from collections import defaultdict
d = defaultdict(lambda : 'default')
print(d)   # defaultdict(<function <lambda> at 0x01368D68>, {})
print(d['k1'])    # k1不存在，使用默认值：default
print(d['k2'])    # k2不存在，使用默认值：default
d['k3'] = 'vvvvv'  # k3自定义值
print(d)   # defaultdict(<function <lambda> at 0x00798D68>, {'k1': 'default', 'k2': 'default', 'k3': 'vvvvv'})

d = defaultdict(list)
print(d['k1'])  # []
d['k2'].append(123)
print(d)    # defaultdict(<class 'list'>, {'k1': [], 'k2': [123]})

3、Counter（计数器）

　　Counter类的目的是用来跟踪值出现的次数。它是一个无序的容器类型，以字典的键值对形式存储，其中元素作为key，其计数作为value。

from collections import Counter
c = Counter('sdghjasihgaosjdoiasfsfas')
print(c)    # Counter({'s': 6, 'a': 4, 'd': 2, 'g': 2, 'h': 2, 'j': 2, 'i': 2, 'o': 2, 'f': 2})
# 删除一个值
del c['a']
print(c)    # Counter({'s': 6, 'd': 2, 'g': 2, 'h': 2, 'j': 2, 'i': 2, 'o': 2, 'f': 2})

4、namedtuple：（可命名元祖）

　　　时间模块中的结构化时间用的就是可命名元祖　

from collections import namedtuple

birth = namedtuple('Struct_time', ['year', 'month', 'day'])
b1 = birth(2018, 9, 5)
print(type(b1)) # <class '__main__.Struct_time'>
print(b1.year)  #
print(b1.month) #
print(b1.day)   #
print(b1)   # Struct_time(year=2018, month=9, day=5)
'''
可命名元组非常类似一个只有属性没有方法的类
['year','month','day']是对象属性名
Struct_time是类 的名字
这个类最大的特点就是一旦实例化 不能修改属性的值
'''

5、deque：双端队列　　　

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

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

from collections import deque

dq = deque()
dq.append(1)
dq.append(2)
dq.append(3)
dq.appendleft(4)
print(dq)   # deque([4, 1, 2, 3])
print(dq.pop()) #
print(dq)   # deque([4, 1, 2])
print(dq.popleft()) #
print(dq)   # deque([1, 2])

import queue

q = queue.Queue()    #队列
q.put(1)
q.put(2)
q.put('aaa')
q.put([1, 2, 3])
q.put({'k1':1, 'k2':2})
print(q)    # <queue.Queue object at 0x004BE490>
print(q.get())  #
print(q.get())  #
print(q.get())  # aaa
# 一个个添加，一个个取值，先进先出