7. 数据类型 —— 字典

字典属于容器存储、可变、映射访问的数据类型。相对于列表等数据类型，字典中的元素是通过键来进行存取，而不是通过偏移量 —— 或者可以理解为列表等数据类型的键即为偏移量，而字典的键可以为任意值。并且在字典中元素是没有特定顺序的，Python 将字典中的元素从左到右随机排序，以便快速查找。

1. 创建字典

字典使用 { } 来定义，字典元素的语法格式为 Key: Value，不同的元素使用 , 分隔。将字典直接赋值给变量即可创建一个新的字典

>>> dict = {}                                                   # 一对 {} 可以创建一个空字典
>>> dict
{}
>>> dict = {"name": "ybian", "year": 2015}                      # 字典的键-值可以是任意数据类型，且可以嵌套
>>> dict
{"name": "ybian", "year": 2015}

除此之外还可以使用 dict() 方法创建字典

>>> a = dict(one=1, two=2, three=3)                             # 使用 dict 方法创建字典，如果输入为一个映射对象，则直接进行浅复制
>>> a
{'three': 3, 'two': 2, 'one': 1}
>>> b = dict([('one', 1), ('two', 2), ('three', 3)])            # 如果输入为可迭代的，则可迭代元素必须成对出现，在每个值对中第一个元素为键，第二个为值 
>>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))

使用 fromkeys() 方法创建字典

>>> a = {}.fromkeys(('x', 'y'), 1)                              # 使用 fromkeys 创建一个新的字典，且元素具有相同的值
>>> a
{'y': 1, 'x': 1}
>>> a = {}.fromkeys(('x', 'y'))                                 # 如果没有指定值时，默认为 None
>>> a
{'y': None, 'x': None}

2. 字典的基本操作

• 访问字典中的元素

  字典为映射访问的数据类型，只需指定键即可访问字典的元素值

>>> a = {'one': 1, 'two': 2， 'three': 3}
>>> a['one']                                                   # 指定要查找元素的键即可访问字典中的元素
1
>>> a['four']                                                  # 如果指定的键在字典中不存在，会引发一个 KeyError 异常
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'four'

• 判断字典中是否存在某个键

  使用 in、 not in 即可判断一个键是否存在于字典中

>>> 'one' in a                                                # 判断键 one 是否在字典 a 中 
True
>>> 'four' in a 
False

• 修改字典中某个键的值

  直接将要修改的数据赋值给键即可

>>> a['one'] = 0                                             # 修改字典中键为 one 的元素的值
>>> a
{'three': 3, 'two': 2, 'one': 0}

• 删除字典中的元素

  使用 del 删除字典指定的键-值

>>> del a['one']                                            # 删除字典中键为 one 的元素
>>> a
{'three': 3, 'two': 2}
>>> a.clear()                                               # 清空字典中的所有元素 
>>> a
{}

3. 字典内建函数

• len()

  len() 函数返回字典中的键-值的数目

>>> len(a)
3

• keys() 、 values() 、 items()

  这三个方法在需要对字典中的键或值进行遍历时十分有效

>>>a.keys()                                                # 返回一个由字典的键组成的列表 
['three', 'two', 'one']
>>> a.values()                                             # 返回一个由字典的值组成的列表
[3, 2, 1]
>>> a.items()                                              # 返回一个由所有（键-值）元组组成的列表
[('three', 3), ('two', 2), ('one', 1)]

• get()

  使用 get() 方法可以避免由于键的缺失而引起的异常

>>> a.get('one')                                         # 使用 get 方法可以获取指定键的值
1
>>> print a.get('four')                                  # 当指定的键在字典中不存在时返回 None 或指定的默认值
None

• update()

  update 方法可以将两个字典合并，当遇到相同的键时会直接覆盖

>>> b = {'one':0, 'four':4}
>>> a.update(b)                                          # 将 a 和 b 合并，并将 b 中的 'one' 对应的值覆盖 a 中 'one' 对应的值
>>> a
{'four': 4, 'three': 3, 'two': 2, 'one': 0}

• setdefault()

  检查字典中是否存在某个键，如果存在获取该键对应的值，否则进行赋值并返回值

>>> a.setdefault('one',0)                                # 由于 a 中存在 'one'，返回对应值不做任何操作
1
>>> a.setdefault('four',4)                               # a 中不存在 'four'，设置 four: 4 并返回值 
4
>>> a
{'four': 4, 'three': 3, 'two': 2, 'one': 1}

• pop()

  类似于列表中的 pop() 函数，删除对应键并返回值

>>> a.pop('four')
4
>>> a
{'three': 3, 'two': 2, 'one': 1}

4. 字典注意事项

• 每个键只能对应一个值，当键发生冲突时直接覆盖值

>>> a = {'one':1, 'one':0}
>>> a
{'one': 0}

• 键必须是可哈希的

  所有不可变的数据类型都是可哈希的（对于数字而言，值相等数字表示同一个键，即 1 和 1.0 为同一个键）。使用 hash() 函数可以判断一个数据是否是可哈希的

>>> hash('one')                                        # 如果参数是可哈希则会返回其哈希值
4135046628013640463
>>> hash([1, 2])                                       # 如果参数是不可哈希的会引发异常 
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

• 序列运算对字典无效

  字典是无序的数据类型，因此所有序列运算对字典无效且会引发异常

参考
Dict