collections模块
功能: 给我们提供了一些python的数据类型,比较特殊的数据类型.出奇制胜的是效果.
有五个额外的数据类型
-1. namedtuple: 生成可以使用名字来访问元素内容的tuple
-2. deque: 双端队列, 可以快速的从另外一侧追加和推出对象.
-3. Counter: 计数器,主要用来计数.
-4: OrderedDict: 有序字典.
-5: defaultdict: 带有默认值的字典
namedtuple 命名元组
我们知道tuple可以表示不变集合，例如，一个点的二维坐标就可以表示成：
p = (1, 2)
但是，看到(1, 2)，很难看出这个tuple是用来表示一个坐标的。
这时，namedtuple就派上了用场：
from collections import namedtuple
# namedtuple()方法中第一个参数为: 类型名(typename),第二个参数为一个字段集(field_names)
point = namedtuple('point', ['x', 'y'])
n_tuple = point(10, 20)
print(type(n_tuple)) # <class '__main__.point'> 其中的point是namedtuple()方法的第一个参数的值
# dsb = namedtuple('dsb', ['x', 'y'])
# d = dsb(x=1, y=2)
# print(type(d)) # <class '__main__.dsb'>
# 可以根据命名元组的索引来取值
print(n_tuple[0] + n_tuple[1]) # 10 + 20 = 30
# 也可以通过字段名来取
print(n_tuple.y + n_tuple.x) # 20 + 10 = 30
x, y = n_tuple
print(x, y) # 10 20
dic = n_tuple._asdict() # 将命名元组变为一个字典(有序)
print(type(dic)) # <class 'collections.OrderedDict'> 转成的是一个有序字典
print(dic) # OrderedDict([('x', 10), ('y', 20)])
print([i for i in dic])
print(point(**dic)) # point(x=10, y=20) 转回了point对象了
# 可以通过._replace() 方法来改变里面的字段的值
print(n_tuple._replace(x=100)) # point(x=100, y=20)
# 但是该改变不会影响到原来的命名元组
print(n_tuple) # point(x=10, y=20)
"""
复习一下time模块, 看02xxx.py
"""
复习time模块中的
from collections import namedtuple
import time
time_tuple = time.strptime('2021-3-3', "%Y-%m-%d")
print(type(time_tuple)) # print(type(time_tuple)) 和namedtuple一样
# time.struct_time(tm_year=2021, tm_mon=3, tm_mday=3, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=2, tm_yday=62, tm_isdst=-1)
print(time_tuple)
# 调用里面的值也可以使用索引来获取
print(time_tuple[0], time_tuple[1]) # 2021 3
print(time_tuple.tm_year, time_tuple.tm_mon) # 2021 3
# 我们用 collections模块中的namedtuple 模拟这个time.strptime() 方法
tmp = namedtuple('struct_time', ["tm_year", "tm_mon", "tm_mday", "tm_hour"])
time_tuple1 = tmp(2021, 3, 3, 0)
print(type(time_tuple1)) # <class '__main__.struct_time'>
print(time_tuple1[0], time_tuple1[1], time_tuple1[2]) # 2021 3 3
print(time_tuple1.tm_year, time_tuple1.tm_mon, time_tuple1.tm_mday) # 2021 3 3
deque 双向列表
是一种类似于列表的一种容器型数据,插入元素和删除元素效率高
使用list存储数据时,按索引访问元素很快,但是插入和删除元素就很慢了,因为list是线性存储,数据量大的时候,插入和删除效率很低.
deque 是为了高效实现插入和删除操作的双向列表,适合用于队列和栈.
一般用于淘宝的限量买卖.
案例:
from collections import deque
# deque([iterable[, maxlen]]) --> deque object
li = [1, 2, 3, 4, 5, 6, 7, 8, 9]
q = deque(li, 100) # 第一个参数为可迭代对象, 第二个参数为队列中最大存放的个数,返回的是一个deque 对象
print(type(q)) # <class 'collections.deque'>
print(q) # deque([1, 2, 3, 4, 5, 6, 7, 8, 9], maxlen=100)
# 和列表的使用方法类似,但是比列表多了俩个方法 appendleft()和popleft()
q.append(10)
print(q) # deque([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], maxlen=100)
q.appendleft(0)
print(q) # deque([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10], maxlen=100)
q.pop()
print(q) # deque([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], maxlen=100)
q.popleft()
print(q) # deque([1, 2, 3, 4, 5, 6, 7, 8, 9], maxlen=100)
# 以下列表中也一样使用
# 根据索引删
del q[0]
print(q) # deque([2, 3, 4, 5, 6, 7, 8, 9], maxlen=100)
# insert()增
q.insert(0, 1)
print(q) # deque([1, 2, 3, 4, 5, 6, 7, 8, 9], maxlen=100)
注意: 相对于普通的列表,增加和删除元素更快!!!!
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本身排序：
>>> 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的值中。
即： {'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'
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})