迄今为止，我们已经为大家介绍了Python中的三种容器型数据类型，但是这些数据类型还不足以帮助我们解决所有的问题。例如，我们要保存一个人的信息，包括姓名、年龄、体重、单位地址、家庭住址、本人手机号、紧急联系人手机号等信息，你会发现我们之前学过的列表、元组和集合都不是最理想的选择。

  1. person1 = ['王大锤', 55, 60, '科华北路62号', '中同仁路8号', '13122334455', '13800998877']
  2. person2 = ('王大锤', 55, 60, '科华北路62号', '中同仁路8号', '13122334455', '13800998877')
  3. person3 = {'王大锤', 55, 60, '科华北路62号', '中同仁路8号', '13122334455', '13800998877'}

集合肯定是最不合适的，因为集合有去重特性，如果一个人的年龄和体重相同，那么集合中就会少一项信息；同理，如果这个人的家庭住址和单位地址是相同的，那么集合中又会少一项信息。另一方面，虽然列表和元组可以把一个人的所有信息都保存下来，但是当你想要获取这个人的手机号时，你得先知道他的手机号是列表或元组中的第6个还是第7个元素；当你想获取一个人的家庭住址时，你还得知道家庭住址是列表或元组中的第几项。总之，在遇到上述的场景时，列表、元组、字典都不是最合适的选择，我们还需字典（dictionary）类型，这种数据类型最适合把相关联的信息组装到一起，并且可以帮助我们解决程序中为真实事物建模的问题。

Python程序中的字典跟现实生活中的字典很像，它以键值对（键和值的组合）的方式把数据组织到一起，我们可以通过键找到与之对应的值并进行操作。就像《新华字典》中，每个字（键）都有与它对应的解释（值）一样，每个字和它的解释合在一起就是字典中的一个条目，而字典中通常包含了很多个这样的条目。

创建和使用字典

在Python中创建字典可以使用{}字面量语法，这一点跟上一节课讲的集合是一样的。但是字典的{}中的元素是以键值对的形式存在的，每个元素由:分隔的两个值构成，:前面是键，:后面是值，代码如下所示。

  1. xinhua = {
  2.     '麓': '山脚下', 
  3.     '路': '道，往来通行的地方；方面，地区：南～货，外～货；种类：他俩是一～人',
  4.     '蕗': '甘草的别名', 
  5.     '潞': '潞水，水名，即今山西省的浊漳河；潞江，水名，即云南省的怒江'
  6. }
  7. print(xinhua)
  8. person = {
  9.     'name': '王大锤', 'age': 55, 'weight': 60, 'office': '科华北路62号', 
  10.     'home': '中同仁路8号', 'tel': '13122334455', 'econtact': '13800998877'
  11. }
  12. print(person)

通过上面的代码，相信大家已经看出来了，用字典来保存一个人的信息远远优于使用列表或元组，因为我们可以用:前面的键来表示条目的含义，而:后面就是这个条目所对应的值。

当然，如果愿意，我们也可以使用内置函数dict或者是字典的生成式语法来创建字典，代码如下所示。

  1. # dict函数(构造器)中的每一组参数就是字典中的一组键值对
  2. person = dict(name='王大锤', age=55, weight=60, home='中同仁路8号')
  3. print(person)    # {'name': '王大锤', 'age': 55, 'weight': 60, 'home': '中同仁路8号'}
  5. # 可以通过Python内置函数zip压缩两个序列并创建字典
  6. items1 = dict(zip('ABCDE', '12345'))
  7. print(items1)    # {'A': '1', 'B': '2', 'C': '3', 'D': '4', 'E': '5'}
  8. items2 = dict(zip('ABCDE', range(1, 10)))
  9. print(items2)    # {'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 5}
  11. # 用字典生成式语法创建字典
  12. items3 = {x: x ** 3 for x in range(1, 6)}
  13. print(items3)     # {1: 1, 2: 8, 3: 27, 4: 64, 5: 125}

想知道字典中一共有多少组键值对，仍然是使用len函数；如果想对字典进行遍历，可以用for循环，但是需要注意，for循环只是对字典的键进行了遍历，不过没关系，在讲完字典的运算后，我们可以通过字典的键获取到和这个键对应的值。

  1. person = {'name': '王大锤', 'age': 55, 'weight': 60, 'office': '科华北路62号'}
  2. print(len(person))    # 4
  3. for key in person:
  4.     print(key)

字典的运算

对于字典类型来说，成员运算和索引运算肯定是最为重要的，前者可以判定指定的键在不在字典中，后者可以通过键获取对应的值或者向字典中加入新的键值对。值得注意的是，字典的索引不同于列表的索引，列表中的元素因为有属于自己有序号，所以列表的索引是一个整数；字典中因为保存的是键值对，所以字典的索引是键值对中的键，通过索引操作可以修改原来的值或者向字典中存入新的键值对。需要特别提醒大家注意的是，字典中的键必须是不可变类型，例如整数（int）、浮点数（float）、字符串（str）、元组（tuple）等类型的值；显然，列表（list）和集合（set）是不能作为字典中的键的，当然字典类型本身也不能再作为字典中的键，因为字典也是可变类型，但是字典可以作为字典中的值。关于可变类型不能作为字典中的键的原因，我们在后面的课程中再为大家详细说明。这里，我们先看看下面的代码，了解一下字典的成员运算和索引运算。

  1. person = {'name': '王大锤', 'age': 55, 'weight': 60, 'office': '科华北路62号'}
  2. # 检查name和tel两个键在不在person字典中
  3. print('name' in person, 'tel' in person)    # True False
  4. # 通过age修将person字典中对应的值修改为25
  5. if 'age' in person:
  6.     person['age'] = 25
  7. # 通过索引操作向person字典中存入新的键值对
  8. person['tel'] = '13122334455'
  9. person['signature'] = '你的男朋友是一个盖世垃圾，他会踏着五彩祥云去赢取你的闺蜜'
  10. print('name' in person, 'tel' in person)    # True True
  11. # 检查person字典中键值对的数量
  12. print(len(person))    # 6
  13. # 对字典的键进行循环并通索引运算获取键对应的值
  14. for key in person:
  15.     print(f'{key}: {person[key]}')

注意：在通过索引运算获取字典中的值时，如指定的键没有在字典中，将会引发KeyError异常。

字典的方法

字典类型的方法基本上都跟字典的键值对操作相关，可以通过下面的例子来了解这些方法的使用。例如，我们要用一个字典来保存学生的信息，我们可以使用学生的学号作为字典中的键，通过学号做索引运算就可以得到对应的学生；我们可以把字典中键对应的值也做成一个字典，这样就可以用多组键值对分别存储学生的姓名、性别、年龄、籍贯等信息，代码如下所示。

  1. # 字典中的值又是一个字典(嵌套的字典)
  2. students = {
  3.     1001: {'name': '狄仁杰', 'sex': True, 'age': 22, 'place': '山西大同'},
  4.     1002: {'name': '李元芳', 'sex': True, 'age': 23, 'place': '河北保定'},
  5.     1003: {'name': '武则天', 'sex': False, 'age': 20, 'place': '四川广元'}
  6. }
  8. # 使用get方法通过键获取对应的值，如果取不到不会引发KeyError异常而是返回None或设定的默认值
  9. print(students.get(1002))    # {'name': '白元芳', 'sex': True, 'age': 23, 'place': '河北保定'}
  10. print(students.get(1005))    # None
  11. print(students.get(1005, {'name': '无名氏'}))    # {'name': '无名氏'}
  13. # 获取字典中所有的键
  14. print(students.keys())      # dict_keys([1001, 1002, 1003])
  15. # 获取字典中所有的值
  16. print(students.values())    # dict_values([{...}, {...}, {...}])
  17. # 获取字典中所有的键值对
  18. print(students.items())     # dict_items([(1001, {...}), (1002, {....}), (1003, {...})])
  20. # 对字典中所有的键值对进行循环遍历
  21. for key, value in students.items():
  22.     print(key, '--->', value)
  24. # 使用pop方法通过键删除对应的键值对并返回该值
  25. stu1 = students.pop(1002)
  26. print(stu1)             # {'name': '白元芳', 'sex': True, 'age': 23, 'place': '河北保定'}
  27. print(len(students))    # 2
  28. # stu2 = students.pop(1005)    # KeyError: 1005
  29. stu2 = students.pop(1005, {})
  30. print(stu2)             # {}
  32. # 使用popitem方法删除字典中最后一组键值对并返回对应的二元组
  33. # 如果字典中没有元素，调用该方法将引发KeyError异常
  34. key, value = students.popitem()
  35. print(key, value)    # 1003 {'name': '武则天', 'sex': False, 'age': 20, 'place': '四川广元'}
  37. # setdefault方法的第一个参数是键，第二个参数是键对应的值
  38. # 如果键不存在于字典中，将会添加该键并将default的值设为该键的默认值
  39. # 如果键存在于字典中，将读出该键原来对应的值，default的值不会覆盖原来已经存在的键的值
  40. person = {'name': '王大锤', 'age': 25, 'sex': True}
  41. result = person.setdefault('name', '刘星')
  42. print(result)   # 王大锤
  43. print(person)   # {'name': '王大锤', 'age': 25, 'sex': True}
  44. result2 = person.setdefault('place', '成都')
  45. print(result2)  # 成都
  46. print(person)   # {'name': '王大锤', 'age': 25, 'sex': True, 'place': '成都'}
  48. # 使用update更新字典元素，相同的键会用新值覆盖掉旧值，不同的键会添加到字典中
  49. others = {
  50.     1005: {'name': '乔峰', 'sex': True, 'age': 32, 'place': '北京大兴'},
  51.     1010: {'name': '王语嫣', 'sex': False, 'age': 19},
  52.     1008: {'name': '钟灵', 'sex': False}
  53. }
  54. students.update(others)
  55. print(students)      # {1001: {...}, 1005: {...}, 1010: {...}, 1008: {...}}

跟列表一样，从字典中删除元素也可以使用del关键字，在删除元素的时候如果指定的键索引不到对应的值，一样会引发KeyError异常，具体的做法如下所示。

  1. person = {'name': '王大锤', 'age': 25, 'sex': True}
  2. del person['age']
  3. print(person)    # {'name': '王大锤', 'sex': True}

字典的应用

我们通过几个简单的例子来讲解字典的应用。
例子1：输入一段话，统计每个英文字母出现的次数。

  1. """
  2. 输入一句话统计每个字母出现的次数
  3. """
  4. sentence = input('请输入一句话：')
  5. counter = {}
  6. for ch in sentence:
  7.     counter[ch] = counter.get(ch, 0) + 1
  8. for key, value in counter.items():
  9.     print(f'字母{key}出现了{value}次')

例子2：在一个字典中保存了股票的代码和价格，找出股价大于100元的股票并创建一个新的字典。

说明：可以用字典的生成式语法来创建这个新字典。

  1. """
  2. 找出股价大于100元的股票并创建一个新的字典
  3. """
  4. stocks = {
  5.     'AAPL': 191.88,
  6.     'GOOG': 1186.96,
  7.     'IBM': 149.24,
  8.     'ORCL': 48.44,
  9.     'ACN': 166.89,
  10.     'FB': 208.09,
  11.     'SYMC': 21.29
  12. }
  13. stocks2 = {key: value for key, value in stocks.items() if value > 100}
  14. print(stocks2)

例3：井字棋游戏

```python “”” 井字棋游戏 “”” import os

def print_board(board): print(board[‘TL’] + ‘|’ + board[‘TM’] + ‘|’ + board[‘TR’]) print(‘——-‘) print(board[‘ML’] + ‘|’ + board[‘MM’] + ‘|’ + board[‘MR’]) print(‘——-‘) print(board[‘BL’] + ‘|’ + board[‘BM’] + ‘|’ + board[‘BR’])

def main(): init_board = { ‘TL’: ‘ ‘, ‘TM’: ‘ ‘, ‘TR’: ‘ ‘, ‘ML’: ‘ ‘, ‘MM’: ‘ ‘, ‘MR’: ‘ ‘, ‘BL’: ‘ ‘, ‘BM’: ‘ ‘, ‘BR’: ‘ ‘ } begin = True while begin: curr_board = init_board.copy() begin = False turn = ‘X’ counter = 0 os.system(‘cls’) print_board(curr_board) while counter < 9: move = input(f’轮到{turn}走棋，请输入位置: ‘) if curr_board[move] == ‘ ‘: counter += 1 curr_board[move] = turn if turn == ‘X’: turn = ‘O’ else: turn = ‘X’ os.system(‘cls’) print_board(curr_board) choice = input(‘再玩一局（yes|no）’) begin = choice == ‘yes’

if name == ‘main‘: main() ```

说明： 最后这个案例来自《Python编程快速上手:让繁琐工作自动化》一书（这本书对有编程基础想迅速使用Python将日常工作自动化的人来说还是不错的选择），对代码做了一点点的调整。