collections模块

在内置数据类型（dict、list、set、tuple）的基础上，collections模块还提供了几个额外的数据类型：Counter、deque、defaultdict、namedtuple和OrderedDict等。

1.namedtuple: 生成可以使用名字来访问元素内容的tuple

2.deque: 双端队列，可以快速的从另外一侧追加和推出对象

3.Counter: 计数器，主要用来计数 

4.OrderedDict: 有序字典 

5.defaultdict: 带有默认值的字典

namedtuple

我们知道tuple可以表示不变集合，例如，一个点的二维坐标就可以表示成：

 >>> p = (1, 2)

但是，看到(1, 2)，很难看出这个tuple是用来表示一个坐标的。

这时，namedtuple就派上了用场：

类似的，如果要用坐标和半径表示一个圆，也可以用namedtuple定义：

 #namedtuple('名称', [属性list]):

Circle = namedtuple('Circle', ['x', 'y', 'r'])

 

import collections
Card = collections.namedtuple('Card',['rank','suit'])
class FrenchDeck:#创建扑克牌的类
    ranks = [str(n) for n in range(2,11)] + list('JQKA') # 2 - 10 JQKA
    suits = 'spades diamonds clubs hearts'.split() #花色
    def __init__(self):
        self._cards = [Card(rank,suit) for suit in self.suits for rank in self.ranks] #数字和花色组成扑克牌
    def __len__(self):
        return  len(self._cards) #组成多少个就有几张
    def __getitem__(self, item):
        return  self._cards[item]

been_card = Card('7','diamonds') #构建了一张扑克牌
print(been_card)

deck = FrenchDeck()
print(deck[-1]) #数字从2 开始 'A'在最后

#随机挑选一张纸牌
from random import choice

print(choice(deck))

# 因为__getitem__方法把[]操作交给了self.cards列表，所以deck类自动支持切片
print(deck[:3]) #deck[]调用__getitem__方法 所以可以切片

print(deck[12::13])
# 迭代
for d in deck:
    print(d)

# 反向迭代
for card in reversed(deck):
    print(card)

print(Card('Q','hearts') in deck) # in 运算符 xxx是否在xxx中

#排序 2最小 A最大 黑桃最大 红桃次之 方块再次 梅花最小
suit_values = dict(spades=3,hearts=2,diamonds=1,clubs=0)
# print(suit_values) # {'clubs': 0, 'diamonds': 1, 'spades': 3, 'hearts': 2}
def spades_high(card):
    rank_value = FrenchDeck.ranks.index(card.rank)
    # print('-----%s ---- %s'%(rank_value,card.rank))  扑克牌数字列表中'2'下标为0 '3'下标为1 '4'下标为2
    return rank_value * len(suit_values) + suit_values[card.suit] #数字下标*4+花色下标
for card in sorted(deck,key=spades_high):
    print(card)

l = [1,2,3,4]
print(len(l)) # 返回PyVarObject中的ob_size属性

nametuple实例 - 纸牌

deque

使用list存储数据时，按索引访问元素很快，但是插入和删除元素就很慢了，因为list是线性存储，数据量大的时候，插入和删除效率很低。

deque是为了高效实现插入和删除操作的双向列表，适合用于队列和栈：

>>> from collections import deque
>>> q = deque(['a', 'b', 'c'])
>>> q.append('x')
>>> q.appendleft('y')
>>> q
deque(['y', 'a', 'b', 'c', 'x'])

deque除了实现list的append()和pop()外，还支持appendleft()和popleft()，这样就可以非常高效地往头部添加或删除元素。

OrderedDict

使用dict时，Key是无序的。在对dict做迭代时，我们无法确定Key的顺序。

如果要保持Key的顺序，可以用OrderedDict：

注意，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}

# 原生字典解决办法
values = [11, 22, 33,44,55,66,77,88,99,90]

my_dict = {}

for value in  values:
    if value>66:
        if my_dict.has_key('k1'):
            my_dict['k1'].append(value)
        else:
            my_dict['k1'] = [value]
    else:
        if my_dict.has_key('k2'):
            my_dict['k2'].append(value)
        else:
            my_dict['k2'] = [value]

# defaultdict 字典解决办法
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})