用{ }创建，逗号进行键值对分割。

In [3]:  d1 = {'a' : 'some value', 'b' : [1, 2, 3, 4]}

In [4]: d1
Out[4]: {'a': 'some value', 'b': [1, 2, 3, 4]}

In [5]: d1[7] = 'an integer'

In [6]: d1
Out[6]: {'a': 'some value', 'b': [1, 2, 3, 4], 7: 'an integer'}

In [7]: d1['b']
Out[7]: [1, 2, 3, 4]

In [8]: 'b' in d1
Out[8]: True

In [9]: d1[5] = 'some value'

In [10]: d1
Out[10]: {'a': 'some value', 'b': [1, 2, 3, 4], 7: 'an integer', 5: 'some value'}

In [11]: d1['dummy'] = 'another value'

In [12]: d1
Out[12]:
{'a': 'some value',
 'b': [1, 2, 3, 4],
 7: 'an integer',
 5: 'some value',
 'dummy': 'another value'}

In [13]: del d1[5]

In [14]: d1
Out[14]:
{'a': 'some value',
 'b': [1, 2, 3, 4],
 7: 'an integer',
 'dummy': 'another value'}

In [15]: ret = d1.pop('dummy')

In [16]: ret
Out[16]: 'another value'

In [17]: d1
Out[17]: {'a': 'some value', 'b': [1, 2, 3, 4], 7: 'an integer'}

keys方法和values方法提供字典键、值的迭代器。

In [18]: list(d1.keys())
Out[18]: ['a', 'b', 7]

In [19]: list(d1.values())
Out[19]: ['some value', [1, 2, 3, 4], 'an integer']

update 方法将两个字典合并。

In [20]: d1.update({'b' : 'foo', 'c' : 12})

In [21]: d1
Out[21]: {'a': 'some value', 'b': 'foo', 7: 'an integer', 'c': 12}

从序列生成字典。两个序列想要在字典中按元素配对。

In [22]: mapping = dict(zip(range(5), reversed(range(5))))

In [23]: mapping
Out[23]: {0: 4, 1: 3, 2: 2, 3: 1, 4: 0}

默认值

这样的代码逻辑：

if key in some_dict:
    value = some_dict[key]
else:
    value = default_value

可写为：

value = some_dict.get(key, default_value)

带有默认值的 get 方法在 key 不是键时，返回None

字典中的集合通过设置，成为另一种集合。

In [1]: words = ['apple', 'bat', 'bar', 'atom', 'book']

In [2]: by_letter = {}

In [3]: for word in words:
   ...:     letter = word[0]
   ...:     if letter not in by_letter:
   ...:         by_letter[letter] = [word]
   ...:     else:
   ...:         by_letter[letter].append(word)
   ...:

In [4]: by_letter
Out[4]: {'a': ['apple', 'atom'], 'b': ['bat', 'bar', 'book']}

字典中的 setdefault 方法可以更简单的实现。

In [5]: for word in words:
   ...:     letter = word[0]
   ...:     by_letter.setdefault(letter, []).append(word)
   ...:

In [6]: by_letter
Out[6]:
{'a': ['apple', 'atom', 'apple', 'atom'],
 'b': ['bat', 'bar', 'book', 'bat', 'bar', 'book']}

内建集合模块的很有用的类，defaultdict.

In [7]: from collections import defaultdict

In [8]: by_letter = defaultdict(list)

In [9]: for word in words:
   ...:     by_letter[word[0]].append(word)
   ...:

In [10]: by_letter
Out[10]: defaultdict(list, {'a': ['apple', 'atom'], 'b': ['bat', 'bar', 'book']})

有效的字典类型

字典的值可以使 Python 任何对象，但键必须是不可变对象。如：标量类型（整数、浮点数、字符串）或元组（元组内对象也必须是不可变对象）。通过 hash 函数可以检查一个对象是否可以哈希化（是否可以作为字典的键）。

In [14]: hash('string')
Out[14]: 5543969717919855119

In [15]: hash((1, 2, (2, 3)))
Out[15]: 1097636502276347782

In [16]: hash((1, 2, [2, 3]))
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-16-8ffc25aff872> in <module>
----> 1 hash((1, 2, [2, 3]))

TypeError: unhashable type: 'list'

In [17]: d = {}

In [18]: d[tuple([1, 2, 3])] = 5

In [19]: d
Out[19]: {(1, 2, 3): 5}