collections模塊提供更加高級的容器數據類型，替代Python的內置dict，list， set，和tuple

Counter對象

提供計數器，支持方便和快速的計數。返回的是一個以元素為鍵，出現次數為值的字典

cnt = Counter()    #創建一個Counter對象
lst =[‘red‘, ‘blue‘, ‘red‘, ‘green‘, ‘blue‘, ‘blue‘]
for word in lst:
　　cnt[word] += 1
print cnt          # 輸出：Counter({‘blue‘: 3, ‘red‘: 2, ‘green‘: 1})

c1 = Counter(‘
 
gallahad‘)             #輸出：Counter({‘a‘: 3, ‘l‘: 2, ‘h‘: 1, ‘g‘: 1, ‘d‘: 1})
c2 = Counter({‘red‘: 4, ‘blue‘: 2})  #輸出：Counter({‘red‘: 4, ‘blue‘: 2})
c3 = Counter(cats=4, dogs=8)         #輸出：Counter({‘dogs‘: 8, ‘cats‘: 4})
c4 = Counter([‘eggs‘, ‘ham‘])        #輸出：Counter({‘eggs‘: 1, ‘ham‘: 1})

使用：Counter對象除了支持用於字典的所有方法（fromkeys和update除外）

elements()

返回一個叠代器，重復每個重復次數的元素，計數小於1的被忽略。

c = Counter(a=4, b=2, c=0, d=-2)
i = c.elements()       #返回一個叠代器
list(i)                #輸出：[‘a‘, ‘a‘, ‘a‘, ‘a‘, ‘b‘, ‘b‘]

most_common([n])

返回n個最常見元素及其計數的列表，從最常見到最少排序。

c = Counter(‘abracadabra‘)
c.most_common(3)        #輸出：[(‘a‘, 5), (‘r‘, 2), (‘b‘, 2)]
 

subtract([可叠代或映射])

從叠代或從另一個映射（或計數器）中減去元素。輸入和輸出都可以為零或負數

c = Counter(a=4, b=2, c=0, d=-2)
d = Counter(a=1, b=2, c=3, d=4)
c.subtract(d)
print c               輸出：Counter({‘a‘: 3, ‘b‘: 0, ‘c‘: -3, ‘d‘: -6})

Counter常見用法

c = Counter(a=4, b=2, c=0, d=-2)
sum(c.values())                 # 計算value值的和，輸出：4
c.clear()                       # 清除所有鍵值，c的值為Counter()
list(c)                         # 返回鍵的列表，輸出：[‘a‘, ‘b‘, ‘c‘, ‘d‘]
set(c)                          # 返回鍵的集合， 輸出：set([‘a‘, ‘b‘, ‘c‘, ‘d‘])
dict(c)                         # 返回鍵值對的字典，輸出：{‘a‘: 4, ‘b‘: 2, ‘c‘: 0, ‘d‘: -2}
c.items()                       # 返回鍵值對的元組的列表，輸出：[(‘a‘, 4), (‘c‘, 0), (‘b‘, 2), (‘d‘, -2)]
Counter(dict([(‘a‘,2),(‘b‘,3),(‘c‘,4)]))    # 返回Counter對象，輸出：Counter({‘c‘: 4, ‘b‘: 3, ‘a‘: 2}
c.most_common()[:-n-1:-1]       # 列表切片
+c                              #移除值為0和負數的鍵值對（2.7版本沒有該功能）

c = Counter(a=3, b=1)
d = Counter(a=1, b=2)
c + d                       #輸出：Counter({‘a‘: 4, ‘b‘: 3})
c - d                       #輸出：Counter({‘a‘: 2})
c & d                       #相當於min(c[x], d[x])，輸出：Counter({‘a‘: 1, ‘b‘: 1})
c | d                       #相當於max(c[x], d[x])，輸出：Counter({‘a‘: 3, ‘b‘: 2})

deque對象

雙向隊列。

支持以下方法：

append(x)  #將x添加到隊列的右側。

appendleft(x)  #將x添加到隊列的左側。

clear()  #刪除所有元素。

copy()  #隊列的淺復制。版本3.5中的新功能。

count(x)  #計算隊列中元素等於x的數量。版本3.2中的新功能。

extend(iterable)  #將iterable可叠代對象追加到隊列的右側。

extendleft(iterable)  #將iterable對象插入到隊列的左側。註意，叠代對象的元素會反轉順序。

index(x， start， stop)  #返回隊列中第一個x的位置（在start和stop之間）。未找到則引發ValueError。版本3.5中的新功能。

insert(i，x)  #將x插入到隊列的下標為i的位置。如果插入會導致有界雙端超過maxlen，則會引發IndexError。版本3.5中的新功能。

pop()  #從隊列的右側移除並返回一個元素。如果沒有元素，則引發一個IndexError。

popleft()  #從隊列的左側移除並返回一個元素。如果沒有元素，則引發一個IndexError。

remove(value)  刪除第一次出現的value。如果沒有找到，則引發一個ValueError。

reverse()  #反轉隊列。版本3.2中的新功能。

rotate(n = 1)  #向右旋轉隊列n步。如果n為負數，則向左旋轉。當雙端隊列不為空時，向右d.appendleft(d.pop())旋轉一步相當於，向左旋轉一步相當於d.append(d.popleft())。

創建一個雙向隊列

d = deque(‘ghi‘)     # 返回一個雙向隊列對象：deque([‘g‘, ‘h‘, ‘i‘])

defaultdict對象

類字典對象。具有標準dict的操作（還有__missing__和default_factory方法）。

用法：

d = defaultdict(attr) #返回一個新的類字典對象，第一個參數attr提供default_factory的屬性值，默認為None

#用list作為default_factory的屬性，類似於dict.setdedault，將一系列鍵值對分組到列表字典中
s = [(‘yellow‘, 1), (‘blue‘, 2), (‘yellow‘, 3), (‘blue‘, 4), (‘red‘, 1)]
d = defaultdict(list)  # 創建一個list屬性的defaultdict對象
for k, v in s:
     d[k].append(v)
# d的輸出為：defaultdict(<type ‘list‘>, {‘blue‘: [2, 4], ‘red‘: [1], ‘yellow‘: [1, 3]})

sorted(d.items())  #輸出：[(‘blue‘, [2, 4]), (‘red‘, [1]), (‘yellow‘, [1, 3])]

#使用dict.setdefault方法實現：
d = {}
for k, v in s:
　　d.setdefault(k, []).append(v)

sorted(d.items())  #輸出：[(‘blue‘, [2, 4]), (‘red‘, [1]), (‘yellow‘, [1, 3])]

#用int作為default_factory的屬性，對單個元素計數
s = ‘mississippi‘  
d = defaultdict(int)  #創建一個int屬性的defaultdict對象
for k in s:
   d[k] += 1
# d的輸出為：defaultdict(<type ‘int‘>, {‘i‘: 4, ‘p‘: 2, ‘s‘: 4, ‘m‘: 1})

sorted(d.items())  #輸出：[(‘i‘, 4), (‘m‘, 1), (‘p‘, 2), (‘s‘, 4)]

#用set作為default_factory的屬性，構建集合字典

s = [(‘red‘, 1), (‘blue‘, 2), (‘red‘, 3), (‘blue‘, 4), (‘red‘, 1), (‘blue‘, 4)]
d = defaultdict(set)
for k, v in s:
   d[k].add(v)
# d的輸出為：defaultdict(<type ‘set‘>, {‘blue‘: set([2, 4]), ‘red‘: set([1, 3])})

sorted(d.items())  #輸出：[(‘blue‘, {2, 4}), (‘red‘, {1, 3})]

namedtuple對象

可以命名的元組。

Point = namedtuple(‘Point‘, [‘x‘, ‘y‘])  #創建一個命名元組
p = Point(11, y=22)     #賦值給元組，輸出：Point(x=11, y=22)
p[0] + p[1]             #元組元素相加，輸出：33
x, y = p                #將元素賦值給x, y，
x, y                    #輸出：(11, 22), 單個x或y輸出為:11或22p.x + p.y               #元組元素相加，輸出：33

除了繼承元組的方法外，還支持以下三個方法和兩個屬性：

_make()：把序列變成命名元組對象

t = [11, 22]
Point._make(t)  #輸出：Point(x=11, y=22)

_asdict()：返回一個新的OrderedDict映射鍵值對

p = Point(x=11, y=22)
p._asdict()     #輸出：OrderedDict([(‘x‘, 11), (‘y‘, 22)])

_replace(**kwargs)：替換命名元組指定鍵的值

p = Point(x=11, y=22)
p._replace(x=33)   #輸出：Point(x=33, y=22)

_fields：返回命名元組的鍵

p = Point(x=11, y=22)
p._fields         #輸出：(‘x‘, ‘y‘)

Color = namedtuple(‘Color‘, ‘red green blue‘)
Pixel = namedtuple(‘Pixel‘, Point._fields + Color._fields)
Pixel(11, 22, 128, 255, 0)  #輸出：Pixel(x=11, y=22, red=128, green=255, blue=0)

_fields_defaults：將字段名稱映射到默認值，返回一個字典

Account = namedtuple(‘Account‘, [‘type‘, ‘balance‘], defaults=[0])
Account._fields_defaults
{‘balance‘: 0}
Account(‘premium‘)   #輸出：Account(type=‘premium‘, balance=0)

OrderedDict對象

有序字典。按鍵的插入順序排序

d = OrderedDict.fromkeys(‘abcde‘)  #創建一個有序字典對象，輸出：OrderedDict([(‘a‘, None), (‘b‘, None), (‘c‘, None), (‘d‘, None), (‘e‘, None)])

除了具有字典dict的方法之外，還有以下兩種方法：

popitem(last=True)：刪除並返回鍵值對。如果last為true，則刪除並返回右端的鍵值對，如果為false，則刪除並返回左端的鍵值對。

d：   OrderedDict([(‘a‘, None), (‘b‘, None), (‘c‘, None), (‘d‘, None), (‘e‘, None)])
d.popitem(last=True)  #返回(‘e‘, None)
d：   OrderedDict([(‘a‘, None), (‘b‘, None), (‘c‘, None), (‘d‘, None)])
d.popitem(last=False)  #返回(‘a‘, None)
d：   OrderedDict([(‘b‘, None), (‘c‘, None), (‘d‘, None)])

move_to_end(key, last=true)：將key鍵移動到有序字典的前端或後端。如果last是true（默認），則移動到右端，last為false，移動到左端

d.move_to_end(‘b‘)
s = ‘‘.join(d.keys())   #輸出：‘acdeb‘
d.move_to_end(‘b‘, last=False)
w = ‘‘.join(d.keys())   #輸出：‘bacde‘

UserDict對象

UserList對象

UserString對象

Python高級數據類型模塊collections