Python中的基本数据结构有list，dict，tuple，set。Python还有一个功能比较强大的包collections，可以处理并维护一个有序的dict，可以提高程序的运行效率。

1、collections中defaultdict的使用

defaultdict在字典dict的基础之上添加一个参数default_factory（default_factory可以指定为list，set，int）
例子1：将下面的list转换成一个dict，其中key对应的value是一个list

>>from collections import defaultdict
>>l=[('a',2),('b',3),('a',1),('b',4),('a',3),('a',1),('b',3)]
>>d=defaultdict(list)
>>for key,value in l:
      d[key].append(value)
>>d
defaultdict(<class 'list'>,{'a':[2,1,3,1],'b':[3,4,3]}

例子2：例1中value中包含重复元素，如果我们不想要value中的元素重复，可以用defaultdict(set)来解决这个问题，set与list不同之处就是set中不允许存在相同的元素。

>>d = defaultdict(set)
>>for key,value in s:
      d[key].add(value)
>>d
defaultdict(<class 'set'>, {'a': {2,1,3}, 'b': {3,4}})

例子3：如果要统计一个字符串中每个字符出现的次数，可以使用defaultdict(int)

>sen='hello world'
>d=defaultdict(int)
>for key,value in sen:
     d[key]+=1
>d
defaultdict(<class 'int'>, {'o': 2, 'h': 1, 'w': 1, 'l': 3, ' ': 1, 'd': 1, 'e': 1, 'r': 1})

2、collections中OrdereDict的使用

字典dict是无序的，如果我们想要有序的dict，可以使用OrdereDict 。

例子1：

在讲例1之前先讲一下sorted函数的概念。
sorted(iterable,key,reverse)，sorted一共有iterable,key,reverse这三个参数。其中iterable表示可以迭代的对象，例如可以是dict.items()、dict.keys()等，key是一个函数，用来选取参与比较的元素，reverse则是用来指定排序是倒序还是顺序，reverse=true则是倒序，reverse=false时则是顺序，默认时reverse=false。

下面我们利用sorted函数按key，value值对字典排序

>from collections import OrderedDic
>d={'b':3,'a':4,'c':2,'d':1}
# 将d按照key来排序
>OrderedDic(sorted(d.items(),key=lambda t:t[0]))
OrderedDic([('a',4),('b',3),('c',2),('d',1)])
# 按照value来排序
>OrderedDict(sorted(d.items(),key=lambda t:t[1]))
OrderedDic([('d',1),('c',2),('b',3),('a',4)])
# 按照key的长度来排序
>OrderedDic(sorted(d.items(),key=lambda t:len(t[0])))

这里的d.items()实际上是将d转换为可迭代对象，迭代对象的元素为（‘b’,3）、（‘a’,3）、（‘c’,2）、（‘d’,1），items()方法将字典的元素转化为了元组，而这里key参数对应的lambda表达式的意思则是选取元组中的第二个元素作为比较参数（如果写作key=lambda item:item[0]的话则是选取第一个元素作为比较对象，也就是key值作为比较对象。lambda x:y中x表示输出参数，y表示lambda函数的返回值），所以采用这种方法可以对字典的value进行排序。注意排序后的返回值是一个list，而原字典中的名值对被转换为了list中的元组。

例子2：例1中已经按照key排序的dict，使用使用popitem()方法来移除最后一个key-value对.如果我们要删除dict中的key-value,popitem(last=True)按照先进后出的顺序删除dict中的key-value，popitem(last=False)按照先进先出的规则删除dict中的key-value.

>d.popitem()
('d',1)
# 使用popitem(last=False)
>d.popitem(last=False)
('a',4)

例子3：如果我们想要改变有序的OrderedDict对象的key-value顺序，可以使用move_to_end(key,last=True)

>d = OrderedDict.fromkeys('abcde')
OrderedDict([('a', None), ('b', None), ('c', None), ('d', None), ('e', None)])
# 将key为c的key-value移动到最后
>d.move_to_end('c')
# 将key为c的key-value移动到最前面
>d.move_to_end('c',last=False)
>''.join(d.keys())
cabde

3、collections中deque的使用

deque是为了向list中删除和插入的效率更高，用法与list相似，而list自带的append和pop方法（尾部插入和删除）速度慢

4、collections中ChainMap的使用

ChainMap可以合并多个dict，而且效率很高

>from collections import ChainMap
> a = {'a': 4, 'c': 2}
> b = {'b': 3, 'c': 1}
> c=ChainMap(a,b)
ChainMap({'a': 4, 'c': 2}, {'b': 3, 'c': 1})
# 将c变成一个list
>c.maps
[{'a': 4, 'c': 2}, {'b': 3, 'c': 1}]

5、collections中Counter的使用

例子1：若想统计相关元素出现的次数，可以使用Counter

>from collections import Counter
>cnt=Counter()
>for w in ['a','b','a','a','a','r','b']:
    cnt[w]+=1
Counter({'a': 4, 'b': 2, 'r': 1})
# 统计字符串出现的次数 前面有统计sen='hello world'，用defaultdict(int)
>cnt = Counter()
> for ch in 'hello':
    cnt[ch] = cnt[ch] + 1
Counter({'l': 2, 'o': 1, 'h': 1, 'e': 1})

例子2：elements()方法按照元素的出现次数返回一个iterator(迭代器)，元素以任意的顺序返回，如果元素的计数小于1，将忽略它。

>c = Counter(a=4, b=3, c=1, d=-4,e=0)
Counter({'a': 4, 'b': 3, 'c': 1, 'd': -4, 'e':0})
>sorted(c.elements())
['a', 'a', 'a', 'a', 'b', 'b','b','c']
# most_common(n)返回一个list, list中包含Counter对象中出现最多前n个元素。
>c = Counter('abracadabra')
Counter({'a': 5, 'b': 2, 'r': 2, 'd': 1, 'c': 1})
>c.most_common(3)
[('a', 5), ('b', 2), ('r', 2)]

6、collections中namedtuple的使用

命名tuple中的元素，使用namedtuple(typename,field_names)

>from collections import namedtuple
>nm=namedtuple('helloworld',['x','y'])
>n=nm(1,2)
>n__class__.__name__
'helloworld'
>n.x
1
>n.y
2