collections 模块

python内置数据类型
int float complex
str list tuple
dict set

collections 模块提供了：
   根据基础数据类型又做了一些扩展，就是添加了一些功能
   有序字典（3.6后所有字典都有序了）
   默认字典
   可命名元组（stuct time）
   counter
   双端队列
   iterable
   iterator

counter: 计数器，统计字符出现的次数
from collections import Counter
c = Counter('ababddfgasdfdff')
print(c)  # Counter({'d': 4, 'f': 4, 'a': 3, 'b': 2, 'g': 1, 's': 1})

b = Counter('kd9f8298487t5o3rkhsdf5df6566565')
print(b)  # Counter({'5': 5, '6': 4, 'd': 3, 'f': 3, '8': 3, 'k': 2, '9': 2, '2': 1, '4': 1, '7': 1, 't': 1, 'o': 1, '3': 1, 'r': 1, 'h': 1, 's': 1})

c = Counter('which')
c.update('witch')
print(c['h'])  # 3

d = Counter('watch')
c.update(d)
print(c['h'])  # 4 更新的次数已经记下来了

OrderedDict  3.6前字典都是无序的，使用key时，key是无序的，在对dict迭代是，无法确定key的顺序
如果要保持key的顺序，可以用OrderedDict:

from collections import OrderedDict
d = dict({('a', 1), ('b', 2), ('c', 3)})  # 初始化字典
print(d)  # {'b': 2, 'a': 1, 'c': 3}  无序的
od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
print(od)  # OrderedDict([('a', 1), ('b', 2), ('c', 3)])  有序的
for k in od:
    print(k, od[k])  # 可以按键的顺序循环了
>>>
a 1
b 2
c 3
Order
od['k2'] = 'v3'
print(od)  # 增加到了最后 #  OrderedDict([('a', 1), ('b', 2), ('c', 3), ('k2', 'v3')])


from collections import defaultdict

values = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90]

my_dict = defaultdict(list)  # 默认字典，有值就加，没有就不加
print(my_dict)  # defaultdict(<class 'list'>, {})  # 空字典 defaultdict类型
print(my_dict['b'])  # []  直接增加了‘b’键，并且值为空列表
my_dict['a'].append(1)  # 增加了‘a’键， 值为空列表并增加了1
print(my_dict)  # defaultdict(<class 'list'>, {'b': [], 'a': [1]})
for value in values:
    if value > 66:
        my_dict['k1'].append(value)
    else:
        my_dict['k2'].append(value)

print(my_dict)
defaultdict(<class 'list'>, {'b': [], 'a': [1], 'k2': [11, 22, 33, 44, 55, 66], 'k1': [77, 88, 99, 90]})


d = defaultdict(dict)  # defaultdict括号里面的类型可以自定义，list，dict，tuple 都是可调用的的（加括号就看执行）
print(d)
print(d['a'])

a = defaultdict(tuple)
print(a)
a['nn'] = (2, 4)
print(a)

>>>
defaultdict(<class 'dict'>, {})
{}
defaultdict(<class 'tuple'>, {})
defaultdict(<class 'tuple'>, {'nn': (2, 4)})

d = defaultdict(lambda :'default')  # 括号里面的应该是可调用的数据类型，如果要放一个字符串，可以用匿名函数，因为匿名函数是可调用的。
print(d['kk'])  # default
print(d['i'])  # default  # 如果没有设置就调用函数默认返回值
d['aa'] = 'jjjj'
print(d['aa'])  # jjjj  # 如果设置了值就返回设置的值


可命名元组
from collections import namedtuple
元组中的每个值都有特定的意义，你希望以特定的格式来描述时，就可以用可命名元组，
维持了元组的特点：不可变，
当元组有很多值，希望用户看到每个值的含义，能看的这个值表示什么东西
和元组没有多大的交集，不b1[0]的方式访问，只能通过名字的形式访问他
birth = namedtuple('struct_time', ['year', 'month', 'day'])
b1 = birth(2018, 9, 5)
print(b1.year)  # 2018
print(b1.month)  # 9
print(b1.day)  # 5
print(b1)  # struct_time(year=2018, month=9, day=5)
namedtuple就像一个只有属性而没有方法的一个类的对象，year，month 都像一个属性的值，而b1
像对象，所以当定义一个类，类的属性永远不变时且不可变时，且没有其他方法，提高安全性，并可以用元组里面的
名字访问属性值。

class A:
     pass
print(type(A))  # <class 'type'> 类的type就是type
B = A
a = A()
print(type(a))  # <class '__main__.A'>  A对象的type就是A
b = B()
print(type(b))  # <class '__main__.A'> 因为在类命名时已经定了

一旦实例化，不能修改属性的值了，实际就是一个类
from collections import namedtuple
birth = namedtuple('Struct_time', ['year', 'month', 'day'])  # struct是类名，把类里面的空间赋值给birth了，但是类的名字始终叫Struct_timem这三个属性都是类stuct_time的对象
b1 = birth(2018, 9, 5)
print(type(b1))  # <class '__main__.Struct_time'>

双端队列：
可以弥补list的缺点
双端队列是在列表内存中随便找一个内存插进去，有几个值就有几个内存，而列表是一个列表一个内存，如果要插入值的话是整个列表
都会移动，所以如果要在列表中执行插入的操作，直接用双端队列。
队列：
是一个数据类型，不在collections模块里面，在模块queue
import queue
q = queue.Queue()  # 维持一个队列，严格先进先出,里面的值看不到，列表不一样，可以从中间取值
q.put(1)
q.put(2)
q.put('aaa')
q.put([1, 2, 3])
q.put({'k', 'v'})
print(q.get())  # 取出一个值就没了
print(q.get())
print(q.get())
from collections import deque
dq = deque()
dq.append(1)
dq.append(2)
dq.appendleft(3)
dq.appendleft(7)
print(dq)  # deque([7, 3, 1, 2])
print(dq.pop())  # 2
print(dq.popleft())  # 7