第一章：数据结构

目录

1. collections模块
2. heapq

---

1. Collections模块

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

Counter对象是一个使用哈希计算的字典子类，该对象也是无序存储，计算的values值可以是0也可以是负数。

他进行统计的是一个可以迭代的元素或者其他的映射

c = Counter()                  #创建一个新的Counter对象
c = Counter('gallahad')    # 将字符串（迭代元素）转换为Counter对象
c = Counter({'red': 4, 'blue':2})    # 将一个Mapping转换为Counter对象
c = Counter(cats=4, dogs=8)        #将关键字转换为Counter对象

如果Counter对象中没有该Keys，那么就会返回0，但是将某个Keys对应的values赋值为0，不会删除该元素，使用del删除某元素

In [15]: c = Counter(['egg', 'ham'])

In [23]: c
Out[23]: Counter({'egg': 1, 'ham': 1})

In [16]: c['bacon']
Out[16]: 0

In [18]: c['egg'] = 0

In [19]: c
Out[19]: Counter({'egg': 0, 'ham': 1})

In [24]: del c['egg']

In [25]: c
Out[25]: Counter({'ham': 1})

In [26]: c['ham'] = -1

In [27]: c
Out[27]: Counter({'ham': -1})

Counter方法

In [2]: c = Counter(a=4, b=2, c=0, d=-2)

In [3]: c
Out[3]: Counter({'a': 4, 'b': 2, 'c': 0, 'd': -2})
 
In [4]: list(c.elements())
Out[4]: ['b', 'b', 'a', 'a', 'a', 'a']
 
In [5]: c.most_common()
Out[5]: [('a', 4), ('b', 2), ('c', 0), ('d', -2)]
 
In [6]: c.most_common(1)
Out[6]: [('a', 4)]

In [7]: d = Counter(d=2)

In [8]: c.update(d)

In [9]: c
Out[9]: Counter({'a': 4, 'b': 2, 'c': 0, 'd': 0})

In [10]: c = Counter(a=4, b=2, c=0, d=-2)

In [11]: d = Counter(a=1, b=2, c=3, d=4)

In [12]: c.subtract(d)

In [13]: c
Out[13]: Counter({'a': 3, 'b': 0, 'c': -3, 'd': -6})

对Counter对象的常用操作方式

sum(c.values())                    #统计所有数值
c.clear()                                #清空c
list(c)                                    #将Counter对象转换为list
set(c)                                    #将Counter对象转换为set
dict(c)                                    #将Counter对象转换为dict
c.items()                     #将Counter对象转换为list，返回是（elem，cnt）
Counter(dict([]))                #将dict对象转换为Counter
c.most_common()[:-n-1:-1]        #返回c中值最小的n个元素
+c                                        #去除c中的0值和负值

 两个Counter对象可以使用‘+’、‘-’来进行value值的加减（注意：得出的结果只有正数，0和负数都不会返回的）

In [2]: c = Counter(a=3, b=1)

In [3]: d = Counter(a=1, b=2)

In [4]: c + d
Out[4]: Counter({'a': 4, 'b': 3})

In [5]: c - d
Out[5]: Counter({'a': 2})

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