Python附带一个模块，它包含许多容器数据类型，名字叫作collections。我们将讨论它的作用和用法。
我们将讨论的是：
- defaultdict
- OrderedDict
- Counter
- deque
- namedtuple
- enum.Enum (包含在Python 3.4以上)
1 defaultdict
defaultdict与dict类型不同，你不需要检查key是否存在，所以我们能这样做：
from collections import defaultdict
colours = (
('Ali', 'Yellow'),
('Ali', 'Blue'),
('Baidu', 'Green'),
('Google', 'Black'),
('Sina', 'Red'),
('Tesla', 'Silver'),
)
favourite_colours = defaultdict(list)
for name, colour in colours:
favourite_colours[name].append(colour)
print(favourite_colours)
# 输出为：defaultdict(<type 'list'>, {'Baidu': ['Green'], 'Sina': ['Red'],
'Google': ['Black'], 'Tesla': ['Silver'], 'Ali': ['Yellow', 'Blue']})
另一种重要的是例子就是：当你在一个字典中对一个键进行嵌套赋值时，如果这个键不存在，会触发keyError异常。
defaultdict允许我们用一个聪明的方式绕过这个问题。首先给出一个使用dict触发KeyError的例子，然后提供一个使用defaultdict的解决方案。
问题：
some_dict = {}
some_dict['colours']['favourite'] = "yellow"
# 异常输出：KeyError: 'colours'
解决方案：
from collections import defaultdict
tree = lambda: defaultdict(tree)
some_dict = tree()
some_dict['colours']['favourite'] = "yellow"
# 运行正常，不会出现任何错误提示
可以用json.dumps打印出some_dict，例如：
import json
print(json.dumps(some_dict))
# 输出: {"colours": {"favourite": "yellow"}}
2 OrderedDict
要控制字典中元素的顺序，可以使用collections模块中的OrderedDict类。当对字典做迭代时，它会严格按照元素初始添加的顺序进行。
colours = {"Red" : 180, "Green" : 170, "Blue" : 160}
for key, value in colours.items():
print(key, value)
# 输出为：
Green 170
Blue 160
Red 180
迭代普通字典时，输出结果不会按照插入顺序的进行输出，只是随机输出。
from collections import OrderedDict
colours = OrderedDict([("Red", 180), ("Green", 160), ("Blue", 170)])
for key, value in colours.items():
print(key, value)
# 输出为：
Red 180
Green 160
Blue 170
可以看出，OrderedDict的输出会按照插入的顺序，进行输出的。
OrderedDict内部维护了一个双向链表，它会根据元素加入的顺序来排列键的位置。第一个新加入的元素被放置在链表的末尾，接下来对已存在的键做重新赋值不会改变键的顺序。
注意OrderedDict的大小是普通字典的2倍多，这是由于它额外创建的链表所致。
3 Counter
Counter是一个计数器，它可以帮助我们针对某项数据进行计数。
from collections import Counter
colours = (
('Ali', 'Yellow'),
('Ali', 'Blue'),
('Baidu', 'Green'),
('Google', 'Black'),
('Sina', 'Red'),
('Tesla', 'Silver'),
)
favs = Counter(name for name, colour in colours)
print(favs)
# 输出为：
Counter({'Ali': 2, 'Baidu': 1, 'Sina': 1, 'Google': 1, 'Tesla': 1})
我们也可以利用它统计一个文件，例如：
with open('filename', 'rb') as f:
line_count = Counter(f)
print(line_count)
4 deque
deque提供了一个双端队列，你可以从头/尾两端添加或删除元素。要想使用它，首先我们要从collections中导入deque模块：
from collections import deque
d = deque()
d.append('1')
d.append('2')
d.append('3')
print(len(d)) # output: 3
print(d[0]) # output: '1'
print(d[-1]) # output: '3'
deque的用法就像python的list，并且提供了类似的方法。
from collections import deque
d = deque(range(5))
print(len(d)) # output: 5
d.popleft() # output: 0
d.pop() # output: 4
print(d) # output: deque([1, 2, 3])
我们也可以限制这个列表的大小，当超出你设定的限制时，数据会从对队列另一端被挤出去(pop)。
d = deque(maxlen=30)
现在当你插入30条数据时，最左边一端的数据将从队列中删除。
你还可以从任一端扩展这个队列中的数据：
from collections import deque
d = deque([1,2,3,4,5])
d.extendleft([0])
d.extend([6,7,8])
print(d) # output: deque([0, 1, 2, 3, 4, 5, 6, 7, 8])
5 namedtuple
一个元组是一个不可变的列表，你可以存储一个数据的序列，它和命名元组(namedtuples)非常像，但有几个关键的不同。
主要相似点是都不像列表，你不能修改元组中的数据。为了获取元组中的数据，你需要使用整数作为索引：
man = ('Ali', 30)
print(man[0]) # output: Ali
嗯，那namedtuple是什么呢？它把元组变成一个针对简单任务的容器。你不必使用整数索引来访问一个namedtuple的数据。你可以像字典（dict）一样访问namedtuple，但namedtuple是不可变的。
from collections import namedtuple
Animal = namedtuple('Animal', 'name age type')
jack = Animal(name="Jack", age=3, type="dog")
print(jack) # output: Animal(name='Jack', age=3, type='dog')
print(jack.name) # output: 'Jack'
现在可以看到，我们可以用名字来访问namedtuple中的数据。我们再继续分析它。一个命名元组（namedtuple）有两个必需的参数：元组名称和字段名称。
在上面的例子中，我们的元组名称是Animal，字段名称是'name'，'age'和'type'。
namedtuple让你的元组变得容易理解，知道代码是做什么的。你也不必使用整数索引来访问一个命名元组，这让你的代码更易于维护。
而且，namedtuple的每个实例没有对象字典，所以它们很轻量，与普通的元组比，并不需要更多的内存。这使得它们比字典更快。
然而，要记住它是一个元组，属性值在namedtuple中是不可变的，所以下面的代码不能工作：
from collections import namedtuple
Animal = namedtuple('Animal', 'name age type')
jack = Animal(name="Jack", age=3, type="dog")
jack.age = 4
# 输出为：
AttributeError Traceback (most recent call last)
<ipython-input-12-bb0587b5d87f> in <module>()
3 Animal = namedtuple('Animal', 'name age type')
4 jack = Animal(name="Jack", age=3, type="dog")
----> 5 jack.age = 4
AttributeError: can't set attribute
命名元组向后兼容于普通的元组，这意味着可以既使用整数索引，也可以使用名称来访问namedtuple：
from collections import namedtuple
Animal = namedtuple('Animal', 'name age type')
jack = Animal(name="Jack", age=3, type="dog")
print(jack[0]) # output: Jack
最后，你可以将一个命名元组转换为字典，方法如下：
from collections import namedtuple
Animal = namedtuple('Animal', 'name age type')
jack = Animal(name="Jack", age=3, type="dog")
print(jack._asdict())
# output:
OrderedDict([('name', 'Jack'), ('age', 3), ('type', 'dog')])
6 enum.Enum （Python 3.4+）
另一个有用的容器是枚举对象，它属于enum模块，存在于Python 3.4以上版本中。Enums（枚举类型）基本上是一种组织各种东西的方式。
让我们回顾一下上一个'Animal'命名元组的例子。它有一个type字段，问题是，type是一个字符串。那么问题来了，万一程序员输入了Cat，因为他按到了Shift键，或者输入了'CAT'，甚至'kitten'？
枚举可以帮助我们避免这个问题，通过不使用字符串。考虑以下这个例子：
from collections import namedtuple
from enum import Enum
class Species(Enum):
cat = 1
dog = 2
horse = 3
aardvark = 4
butterfly = 5
owl = 6
platypus = 7
dragon = 8
unicorn = 9
# 依次类推
# 但我们并不想关心同一物种的年龄，所以我们可以使用一个别名
kitten = 1
puppy = 2
Animal = namedtuple('Animal', 'name age type')
perry = Animal(name="Perry", age=3, type=Species.cat)
drogon = Animal(name="Drogon", age=4, type=Species.dragon)
tom = Animal(name="Tom", age=7, type=Species.cat)
charlie = Animal(name="Charlie", age=2, type=Species.kitten)
现在，我们进行一些测试：
>>> charlie.type == tom.type
True
>>> charlie.type
<Species.kitten: 1>
这样就没那么容易错误，我们必须更明确，而且我们应该只使用定义后的枚举类型。
有三种方法访问枚举数据，例如以下方法都可以获取到'cat'的值：
Species(1) # output: <Species.kitten: 1>
Species['cat'] # output: <Species.kitten: 1>
Species.cat # output: <Species.kitten: 1>
