python中collections模块的使用

官方API链接

namedtuple

collections.namedtuple(typename, field_names, *, rename=False, defaults=None, module=None)

namedtuple是一个函数，它用来创建一个自定义的tuple对象，并且规定了tuple元素的个数，并可以用属性而不仅仅是索引来引用tuple的某个元素。

>>> # Basic example
>>> from collections import namedtuple
>>> Point = namedtuple('Point', ['x', 'y'])
>>> p = Point(11, y=22)     # instantiate with positional or keyword arguments
>>> p[0] + p[1]             # indexable like the plain tuple (11, 22)
33
>>> x, y = p                # unpack like a regular tuple
>>> x, y
(11, 22)
>>> p.x + p.y               # fields also accessible by name
33
>>> p                       # readable __repr__ with a name=value style
Point(x=11, y=22)

namedtuple类的几种扩展方法：

方法	描述
somenamedtuple._make(iterable)	存在的序列或迭代实例创建一个新实例。
somenamedtuple._replace(**kwargs)	返回一个新的命名元组实例，并将指定域替换为新的值
somenamedtuple._asdict()	返回一个新的 dict ，它将字段名称映射到它们对应的值

Point = namedtuple('Point', ['x', 'y'])
t = [11, 2]
p = Point._make(t)     
print((p.x,p.y))
p = p._replace(x=33)     
print((p.x,p.y))
p_dict = p._asdict()     
print(p_dict)

#输出
(11, 2)
(33, 2)
{'x': 33, 'y': 2}

其他

#1.获取名字域的值的三种办法
print(p[0])
print(p.x)
print(getattr(p, 'x'))

#输出
33
33
33

#2.转换一个字典到命名元组，使用 ** 两星操作符
d = {'x': 11, 'y': 50}
p2 = Point(**d)
getattr(p2,'y')

#输出
50

Counter

class collections.Counter([iterable-or-mapping])

一个更简便的计数器，在NLP里面统计词频十分方便

from collections import Counter

c = Counter('gallahad')                 
print(c)
c = Counter({'red': 4, 'blue': 2})     
print(c)
c = Counter(cats=4, dogs=8)
print(c)

#输出

Counter({'a': 3, 'l': 2, 'g': 1, 'h': 1, 'd': 1})
Counter({'red': 4, 'blue': 2})
Counter({'dogs': 8, 'cats': 4})

Counter对象有一个字典接口，如果引用的键没有任何记录，就返回一个0，而不是弹出一个 KeyError :

c = Counter(['eggs', 'ham'])
c['bacon']                              # count of a missing element is zero
#输出
0

计数器对象除了字典方法以外，还提供了几个其他的方法：

elements()
返回一个迭代器，其中每个元素将重复出现计数值所指定次。 元素会按首次出现的顺序返回。 如果一个元素的计数值小于一，elements() 将会忽略它。

c = Counter(a=4, b=2, c=0, d=-2)
sorted(c.elements())

输出： ['a', 'a', 'a', 'a', 'b', 'b']

most_common([n])
返回一个列表，其中包含 n 个最常见的元素及出现次数，按常见程度由高到低排序。 如果 n 被省略或为 None，most_common() 将返回计数器中的 所有 元素。 计数值相等的元素按首次出现的顺序排序：

Counter('abracadabra').most_common(3)

输出：[('a', 5), ('b', 2), ('r', 2)]

Counter 提供了几个数学操作，可以结合 Counter 对象，以生产 multisets (计数器中大于0的元素）。 加和减，结合计数器，通过加上或者减去元素的相应计数。交集和并集返回相应计数的最小或最大值。每种操作都可以接受带符号的计数，但是输出会忽略掉结果为零或者小于零的计数。

c = Counter(a=3, b=1)
d = Counter(a=1, b=2)
c + d                       # add two counters together:  c[x] + d[x]
输出：Counter({'a': 4, 'b': 3})
c - d                       # subtract (keeping only positive counts)
输出：Counter({'a': 2})
c & d                       # intersection:  min(c[x], d[x]) 
输出：Counter({'a': 1, 'b': 1})
c | d                       # union:  max(c[x], d[x])
输出：Counter({'a': 3, 'b': 2})

deque

class collections.deque([iterable[, maxlen]])

list按索引访问元素很快，但是插入和删除元素很慢，deque是为了高效实现插入和删除操作的双向列表，适用于队列和栈。

方法	描述
append(x)	添加 x 到右端
appendleft(x)	添加 x 到左端
extend(iterable)	扩展deque的右侧，通过添加iterable参数中的元素
extendleft(iterable)	扩展deque的左侧，通过添加iterable参数中的元素。注意，左添加时，在结果中iterable参数中的顺序将被反过来添加。
pop()	移去并且返回一个元素，deque 最右侧的那一个。 如果没有元素的话，就引发一个 IndexError。
popleft()	移去并且返回一个元素，deque 最左侧的那一个。 如果没有元素的话，就引发 IndexError。
clear()	移除所有元素，使其长度为0.
copy()	创建一份浅拷贝
count(x)	计算 deque 中元素等于 x 的个数
index(x[, start[, stop]])	返回 x 在 deque 中的位置（在索引 start 之后，索引 stop 之前）。 返回第一个匹配项，如果未找到则引发 ValueError。
insert(i, x)	在位置 i 插入 x 。如果插入会导致一个限长 deque 超出长度 maxlen 的话，就引发一个 IndexError。
remove(value)	移除找到的第一个 value。 如果没有的话就引发 ValueError。
reverse()	将deque逆序排列。返回 None
rotate(n=1)	向右循环移动 n 步。 如果 n 是负数，就向左循环。如果deque不是空的，向右循环移动一步就等价于 d.appendleft(d.pop()) ， 向左循环一步就等价于 d.append(d.popleft())

defaultdict

class collections.defaultdict([default_factory[, …]])

使用dict时，如果引用的key不存在，就会抛出keyerror。如果希望key不存在时，返回一个默认值，就可以使用defaultdict。除了在key不存在时返回默认值，defaultdict的其他行为跟dict是完全一样的。

from collections import defaultdict
dd = defaultdict(lambda:'nan')
dd['key1'] = 'abc'
print(dd['key2'])
#输出
'nan'

#items为list
s1 = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
d1 = defaultdict(list)
for k, v in s1:
    d1[k].append(v)
print(d1)
print(d1.keys())
print(d1.items())
print(d1['blue'])

#输出
defaultdict(<class 'list'>, {'yellow': [1, 3], 'blue': [2, 4], 'red': [1]})
dict_keys(['yellow', 'blue', 'red'])
dict_items([('yellow', [1, 3]), ('blue', [2, 4]), ('red', [1])])
[2, 4]

#计数功能
s2 = 'mississippi'
d2 = defaultdict(int)
for k in s2:
    d2[k] += 1
    
print(d2)
print(d2.keys())
print(d2.items())
print(d2['s'])

#输出
defaultdict(<class 'int'>, {'m': 1, 'i': 4, 's': 4, 'p': 2})
dict_keys(['m', 'i', 's', 'p'])
dict_items([('m', 1), ('i', 4), ('s', 4), ('p', 2)])
4

##items为set
s3 = [('red', 1), ('blue', 2), ('red', 3), ('blue', 4), ('red', 1), ('blue', 4)]
d3 = defaultdict(set)
for k, v in s3:
    d3[k].add(v)
    
print(d3)
print(d3.keys())
print(d3.items())
print(d3['gray'])

#输出
defaultdict(<class 'set'>, {'red': {1, 3}, 'blue': {2, 4}})
dict_keys(['red', 'blue'])
dict_items([('red', {1, 3}), ('blue', {2, 4})])
set()

OrderedDict

class collections.OrderedDict([items])

dict的key是无序的，通过OrderedDict的key会按照插入的顺序排序

from collections import OrderedDict
od = OrderedDict()
od['z'] = 3
od['a'] = 2
od['b'] = 1
print(od)

输出：OrderedDict([('z', 3), ('a', 2), ('b', 1)])

OrderedDict提供了**move_to_end(key, last=True)**方法：
将现有 key 移动到有序字典的任一端。 如果 last 为真值（默认）则将元素移至末尾；如果 last 为假值则将元素移至开头。如果 key 不存在则会触发 KeyError:

>>> d = OrderedDict.fromkeys('abcde')
>>> d.move_to_end('b')
>>> ''.join(d.keys())
'acdeb'
>>> d.move_to_end('b', last=False)
>>> ''.join(d.keys())
'bacde'

OrderedDict对实现LRU结构提供很方便的构造方式，在leetcode中，就是希望我们不用OrderedDict来实现使用OrderedDict构造的LRU相同的功能：lc.146: LRU缓存机制

class LRU(OrderedDict):
    'Limit size, evicting the least recently looked-up key when full'

    def __init__(self, maxsize=128, /, *args, **kwds):
        self.maxsize = maxsize
        super().__init__(*args, **kwds)

    def __getitem__(self, key):
        value = super().__getitem__(key)
        self.move_to_end(key)
        return value

    def __setitem__(self, key, value):
        if key in self:
            self.move_to_end(key)
        super().__setitem__(key, value)
        if len(self) > self.maxsize:
            oldest = next(iter(self))
            del self[oldest]