字典

字典类似于你通过联系人名字查找地址和联系人详细情况的地址簿，即，我们把键（名字）和值（详细情况）联系在一起。注意，键必须是唯一的，就像如果有两个人恰巧同名的话，你无法找到正确的信息。
注意，你只能使用不可变的对象（比如字符串）来作为字典的键，但是你可以把不可变或可变的对象作为字典的值。基本说来就是，你应该只使用简单的对象作为键。
键值对在字典中以这样的方式标记：d = key1 : value1, key2 : value2 。注意它们的键/值对用冒号分割，而各个对用逗号分割，所有这些都包括在花括号中。
记住字典中的键/值对是没有顺序的。如果你想要一个特定的顺序，那么你应该在使用前自己对它们排序。
字典是 dict 类的实例/对象。
其实字典可以简单的用以下说明：

字典是一个key value结构
字典的value可以是任意值
字典的key必须是可hash的值
字典的key是唯一的

字典的定义

In [1]: d1 = dict()

In [2]: type(d1)
Out[2]: dict

In [3]: d2 = {}

In [4]: type(d2)
Out[4]: dict

In [5]: d3 = {'a':1,'b':2}

In [6]: type(d3)
Out[6]: dict

字典元素

In [8]: d
Out[8]: {'a': 1, 'b': 2}

In [9]: d['a']
Out[9]: 1

In [11]: d['a']=11

In [12]: d
Out[12]: {'a': 11, 'b': 2}

In [15]: d['c']=3

In [16]: d
Out[16]: {'a': 11, 'b': 2, 'c': 3}

增加、修改

update

In [16]: d
Out[16]: {'a': 11, 'b': 2, 'c': 3}

In [18]: d.update({'d':4,'e':5})

In [19]: d
Out[19]: {'a': 11, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

In [20]: d.update([('f',6),('g',7)])

In [21]: d
Out[21]: {'a': 11, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6, 'g': 7}

In [22]: d.update(h=8)

In [23]: d
Out[23]: {'a': 11, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6, 'g': 7, 'h': 8}

update 的参数可以是以下几种情况：

字典
由二元组构成的可迭代对象
关键字参数
字典元素的修改：

In [24]: d.update(b=22)

In [25]: d
Out[25]: {'a': 11, 'b': 22, 'c': 3, 'd': 4, 'e': 5, 'f': 6, 'g': 7, 'h': 8}

In [27]: d.update([('c',33),('d',44)])

In [28]: d
Out[28]: {'a': 11, 'b': 22, 'c': 33, 'd': 44, 'e': 5, 'f': 6, 'g': 7, 'h': 8}

In [30]: d.update({'e':55,'f':66})

In [31]: d
Out[31]: {'a': 11, 'b': 22, 'c': 33, 'd': 44, 'e': 55, 'f': 66, 'g': 7, 'h': 8}

update时，如果key相同，会覆盖原来的value，这样就可以修改字典中的元素。

删除

pop
popitem
clear

在Python中字典是用pop方法进行删除指定的键值的。

In [31]: d
Out[31]: {'a': 11, 'b': 22, 'c': 33, 'd': 44, 'e': 55, 'f': 66, 'g': 7, 'h': 8}

In [32]: d.pop('h')
Out[32]: 8

In [33]: d
Out[33]: {'a': 11, 'b': 22, 'c': 33, 'd': 44, 'e': 55, 'f': 66, 'g': 7}

上面删除的是我们知道的键，若我们删除没有定义的键则会报KeyError的错误，若不想让Python报错我们可以指定返回的值。

In [35]: d
Out[35]: {'a': 11, 'b': 22, 'c': 33, 'd': 44, 'e': 55, 'f': 66, 'g': 7}

In [36]: d.pop('i',-1)
Out[36]: -1

同时Python还提供了一个随机删除键值的方法popitem。

In [37]: d
Out[37]: {'a': 11, 'b': 22, 'c': 33, 'd': 44, 'e': 55, 'f': 66, 'g': 7}

In [38]: d.popitem()
Out[38]: ('d', 44)

In [39]: d
Out[39]: {'a': 11, 'b': 22, 'c': 33, 'e': 55, 'f': 66, 'g': 7}

最后清空一个字典可以用clear方法。

In [39]: d
Out[39]: {'a': 11, 'b': 22, 'c': 33, 'e': 55, 'f': 66, 'g': 7}

In [40]: d.clear()

In [41]: d
Out[41]: {}

访问

前面查看Python中的元素是通过下标的方法，而Python提供了get方法来查看字典中的元素。

In [43]: d
Out[43]: {'a': 11, 'b': 22, 'c': 33, 'e': 55, 'f': 66, 'g': 7}

In [44]: d['b']
Out[44]: 22

In [46]: d.get('a')
Out[46]: 11

In [47]: d.get('i')

上面我们可以通过字典中的键来查看其对应的值，也可以使用get方法通过键来查看值。两者中get方法在Python中若查看的键没有定义值则会输出None，而使用下标的方法则会报KeyError的异常。若不想输出None则可以指定输出的值。

In [47]: d.get('i')

In [48]: d.get('i',-1)
Out[48]: -1

在Python中可以使用setdefault方法来定义若字典中有该键则返回改键对应的值，而若字典中没有该键则添加setdefault方法所定义该键的默认值。

In [63]: d
Out[63]: {'a': 11, 'b': 22, 'c': 33, 'd': 44, 'e': 55, 'f': 66, 'g': 7}

In [64]: d.get('i')

In [65]: d.setdefault('i',-1)
Out[65]: -1

In [66]: d
Out[66]: {'a': 11, 'b': 22, 'c': 33, 'd': 44, 'e': 55, 'f': 66, 'g': 7, 'i': -1}

In [67]: d.setdefault('a',-1)
Out[67]: 11

In [68]: d
Out[68]: {'a': 11, 'b': 22, 'c': 33, 'd': 44, 'e': 55, 'f': 66, 'g': 7, 'i': -1}

defaultdict

这里的defaultdict(function_factory)构建的是一个类似dictionary的对象，其中keys的值，自行确定赋值，但是values的类型，是function_factory的类实例，而且具有默认值。比如default(int)则创建一个类似dictionary对象，里面任何的values都是int的实例，而且就算是一个不存在的key, d[key] 也有一个默认值，这个默认值是int()的默认值0.

In [4]: from collections import defaultdict

In [5]: dd = defaultdict(list)

In [6]: dd.get('x')

In [7]: dd['x']
Out[7]: []

In [8]: dd['f']
Out[8]: []

In [9]: dd.update({'a':1})

In [10]: dd
Out[10]: defaultdict(list, {'a': 1, 'f': [], 'x': []})

In [11]: dd.update({'f':7})

In [12]: dd
Out[12]: defaultdict(list, {'a': 1, 'f': 7, 'x': []})

In [15]: dd.update({'x':[1,2,3]})

In [16]: dd
Out[16]: defaultdict(list, {'a': 1, 'f': 7, 'x': [1, 2, 3]})

遍历

keys
values
items
keys方法返回一个包含字典中键的列表。

In [20]: d={'a': 11, 'b': 22, 'c': 33}

In [21]: d.keys()
Out[21]: dict_keys(['a', 'b', 'c'])

In [25]: for i in d.keys():
   ....:     print('{} => {}'.format(i,d[i]))
   ....:     
a => 11
b => 22
c => 33

keys的集合运算：

In [27]: d.keys()
Out[27]: dict_keys(['a', 'b', 'c'])

In [28]: dk=d.keys()

In [29]: dk | {'d','a'}
Out[29]: {'a', 'b', 'c', 'd'}

In [30]: dk & {'d','a'}
Out[30]: {'a'}

In [31]: dk - {'d','a'}
Out[31]: {'b', 'c'}

In [32]: dk ^ {'d','a'}
Out[32]: {'b', 'c', 'd'}

注意：字典的keys只能做集合的运算符重载操作，而不能使用集合的方法。

values方法返回一个包含字典中所有值的列表。

In [33]: d
Out[33]: {'a': 11, 'b': 22, 'c': 33}

In [34]: d.values()
Out[34]: dict_values([11, 22, 33])

items方法返回一个包含字典中键、值对元组的列表。

In [35]: d.items()
Out[35]: dict_items([('a', 11), ('b', 22), ('c', 33)])

In [36]: for k,v in d.items():
   ....:     print('{} => {}'.format(k,v))
   ....:     
a => 11
b => 22
c => 33

enumerate函数
enumerate 函数用于遍历序列中的元素以及它们的下标：

In [38]: d
Out[38]: {'a': 11, 'b': 22, 'c': 33}

In [39]: for k in d:
   ....:     print(k)
   ....:     
a
b
c

In [41]: for k,v in enumerate(d):
   ....:     print('{} => {}'.format(k,v))
   ....:     
0 => a
1 => b
2 => c

OrderedDict有序字典
OrderedDict是dict的子类，它记住了内容添加的顺序。

In [44]: od = OrderedDict()

In [45]: od['c'] = 3

In [46]: od['b'] = 2

In [47]: od['a'] = 1

In [48]: od
Out[48]: OrderedDict([('c', 3), ('b', 2), ('a', 1)])

In [49]: od.keys()
Out[49]: odict_keys(['c', 'b', 'a'])

In [50]: for k,v in od.items():
   ....:     print('{} => {}'.format(k,v))
   ....:     
c => 3
b => 2
a => 1

其他方法

fromkeys(seq,val=None)
fromkeys方法创建并返回一个新字典，以seq中的元素做该字典的键，val做该字典中所有键对应的初始值（如果不提供此值，则默认是None）

In [51]: d1=dict()

In [52]: d1.fromkeys([1,2,3])
Out[52]: {1: None, 2: None, 3: None}

In [61]: d1.fromkeys(['a','b','c'],1)
Out[61]: {'a': 1, 'b': 1, 'c': 1}