collections模块

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