第九章 python 字典（Dict）

9-1 字典基本操作

列表与元组是依序排列可称是序列数据结构，只要知道元素的特定位置，即可使用索引观念取得元素内容，这一章的重点是介绍了字典，它并不是依序排列的数据结构，通常可称是非序列数据结构，所以无法使用类似列表的数值（0、1、… n ）索引观念取得元素内容。

9-1-1 字义字典

字典也是一个列表型的数据结构，但是它的元素是用 “ 键 - 值 ” 方式配对存储存，在操作时是用键取得值的内容。定义字典时，是将 “ 键 - 值 ” 放大 “ { } ” 内，字典的语法格式如下：
- name_dict = { 键1：值1，…，键n：值n } # name_dict 是字典变量名称
字典的值可以是任何 python 的对象，所以可以是数值、字符串、列表等。

例：以水果行和面店为例定义一个字典，同时列出字典。下列字典是设定水果一斤的价格、面一碗的价格，最后使用 type() 列出字典数据类型。

fruits = {'西瓜':15,'香蕉':20,'水蜜桃':25}
noodles = {'牛肉面':100,'肉丝面':80,'阳春面':60}
print(fruits)
print(noodles)
print("字典 fruits 的数据类型是",type(fruits))#输出结果
{'西瓜': 15, '香蕉': 20, '水蜜桃': 25}
{'牛肉面': 100, '肉丝面': 80, '阳春面': 60}
字典 fruits 的数据类型是 <class 'dict'>

例：在使用 python 设计打斗游戏时，玩家通常扮演英雄的角色，敌军可以用字典方式储存，例如，可以用不同颜色的标记设定敌军的小兵，每一个敌军的小兵予一个分数，这样可以由打死敌军数量再统计游戏得分，可以用下列方式定义字典内容。

例：定义 soldier0 字典 tag 和 score 是键，red 和 3 是值。

soldier0 = {'tag':'red','score':3}
print(soldier0)#输出结果
{'tag': 'red', 'score': 3}

9-1-2 列出字典元素的值

字典的元素是 “ 键 - 值 ” 配对设定，如果想要取得元素的值，可以将键当作是索引方式处理，因此字典内的元素不可有重复的键，可参考下列实例第 4 行，例如，下列可传回 fruits 字典水蜜桃的值
- fruits [ ’ 水蜜桃 ’ ]

例：分别列出水果店水蜜栎一斤的价格和面店年肉面一碗的价格。

fruits = {'西瓜':15,'香蕉':20,'水蜜桃':25}
noodles = {'牛肉面':100,'肉丝面':80,'阳春面':60}
print("水蜜桃一斤：",fruits["水蜜桃"],"元")
print("牛肉面一碗：",noodles["牛肉面"],"元")#输出结果
水蜜桃一斤： 25 元
牛肉面一碗： 100 元

例：分别列出小兵字典的 tag 和 score 键的值。

soldier0 = {'tag':'red','score':3}
print("tag 键的值：",soldier0['tag'])
print("score 键的值：",soldier0["score"])#输出结果
tag 键的值： red
score 键的值： 3

9-1-3 增加字典元素

可使用下列语法格式增加字典元素。
- name_dict [ 键 ] = 值

例：为 fruits 字典增加橘子一斤 18 元

fruits = {'西瓜':15,'香蕉':20,'水蜜桃':25}
fruits['橘子'] = 18
print(fruits)
print('橘子一斤：',fruits['橘子'],"元")#输出结果
{'西瓜': 15, '香蕉': 20, '水蜜桃': 25, '橘子': 18}
橘子一斤： 18 元

在设计打斗游戏时，我们可以使用屏幕坐标标记小兵的位置，下列实例是用 xpos/ypos 标记小兵的 x 坐标，y 坐标

soldier0 = {'tag':'red','score':3}
soldier0['xpos'] = 100
soldier0['ypos'] = 30
soldier0['speed'] = 'slow'
print("小兵的 x 坐标：",soldier0['xpos'])
print("小兵的 y 坐标：",soldier0['ypos'])
print("小兵的移动速度：",soldier0['speed'])#输出结果
小兵的 x 坐标： 100
小兵的 y 坐标： 30
小兵的移动速度： slow

9-1-4 更改字典元素内容

市面上的水果价格是浮动的，如果发生价格异动可以使用本节观念更改

例：将 fruits 字典的香蕉一斤改成 12 元

fruits = {'西瓜':15,'香蕉':20,'水蜜桃':25}
print("旧香蕉的价格一斤：",fruits['香蕉'],'元')
fruits['香蕉'] = 12
print("香蕉的价格一斤：",fruits['香蕉'],'元')#输出结果
旧香蕉的价格一斤： 20 元
香蕉的价格一斤： 12 元

在设计打斗游戏时，我们需要时刻移动小兵的位置，此时可以使用本节的方法来更改小兵位置

soldier0 = {'tag':'red','score':3,'xpos':100,'ypos':30,'speed':'slow'}
print("小兵旧的 x，y 坐标：",soldier0['xpos'],soldier0['ypos'])
if soldier0['speed'] == 'slow':         #慢x_move = 1
elif soldier0['speed'] == 'medium':     #中x_move = 3
else:x_move = 5                           #快
soldier0['xpos'] += x_move
print("小兵新的 x，y 坐标：",soldier0['xpos'],soldier0['ypos'])#输出结果
小兵旧的 x，y 坐标： 100 30
小兵新的 x，y 坐标： 101 30

9-1-5 删除字典特定元素

如果想要删除字典特定元素，它的语法格式如下：
- del name_dict[ 键 ]

例：删除 fruits 字典的西瓜元素

fruits = {'西瓜':15,'香蕉':20,'水蜜桃':25}
print("旧的 fruits 内容：",fruits)
del fruits['西瓜']
print("新的 fruits 内容：",fruits)#输出结果
旧的 fruits 内容： {'西瓜': 15, '香蕉': 20, '水蜜桃': 25}
新的 fruits 内容： {'香蕉': 20, '水蜜桃': 25}

9-1-6 删除字典所有元素

python 有提供方法 clear() 可以将字典的所有元素删除，此时字典仍然存在，不过将变成空的字典

例：使用 clear() 方法删除 fruits 字典的所有元素

fruits = {'西瓜':15,'香蕉':20,'水蜜桃':25}
print("旧的 fruits 内容：",fruits)
fruits.clear()
print("新的 fruits 内容：",fruits)#输出结果
旧的 fruits 内容： {'西瓜': 15, '香蕉': 20, '水蜜桃': 25}
新的 fruits 内容： {}

9-1-7 删除字典

python 也有提供 del 指令可以将整个字典删除，字典一经删除就不再存在。它的语法格式如下：
- del name_dict

例：删除字典的测试，错语原因是没有定议 fruits 字典

fruits = {'西瓜':15,'香蕉':20,'水蜜桃':25}
print("旧的 fruits 内容：",fruits)
del fruits
print("新的 fruits 内容：",fruits)#输出结果
旧的 fruits 内容： {'西瓜': 15, '香蕉': 20, '水蜜桃': 25}
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-11-437b22deaee0> in <module>2 print("旧的 fruits 内容：",fruits)3 del fruits
----> 4 print("新的 fruits 内容：",fruits)NameError: name 'fruits' is not defined

建立一个空字典

在程序设计时，也允许先建立一个空字典，建立空字典的语法如下：
name_dict = ( )

例：建立一个小兵的空字典，然后为小兵建立元素

soldier0 = {}
print("空小兵的字典",soldier0)
soldier0['tag'] = 'red'
soldier0 ['score'] = 3
print("新小兵字典",soldier0)#输出结果

空小兵的字典 {}
新小兵字典 {'tag': 'red', 'score': 3}#输出结果
空小兵的字典 {}
新小兵字典 {'tag': 'red', 'score': 3}

9-1-9 字典的复制

大型程序开发过程，有时为了要保护字典原先的内容，所以常会需要字复制，此时可以使用此方法

fruits = {'西瓜':15,'香蕉':20,'水蜜桃':25,'苹果':18}
cfruits = fruits.copy()
print("地址：",id(fruits),"fruits 元素：",fruits)
print("地址：",id(cfruits),"cfruits 元素",cfruits)#输出结果
地址： 135882856 fruits 元素： {'西瓜': 15, '香蕉': 20, '水蜜桃': 25, '苹果': 18}
地址： 135881976 cfruits 元素 {'西瓜': 15, '香蕉': 20, '水蜜桃': 25, '苹果': 18}

9-1-10 取得字典元素数量

在列表或元组使用的方法 len() 也可以应用在字典，它的语法如下：
- length = len ( name_dict )

例：列出空字典和一般字典的元素数量，本程序第 3 行由于是建立空字典，所以第 6 行印出元素数量是 0

fruits = {'西瓜':15,'香蕉':20,'水蜜桃':25,'苹果':18}
noodles = {'牛肉面':100,'肉丝面':80,'阳春面':60}
empty_dict = {}
print("fruits 字典元素数量：    ",len(fruits))
print("noodles 字典元素数量：   ",len(noodles))
print("empty_dict 字典元素数量：",len(empty_dict))#输出结果
fruits 字典元素数量：     4
noodles 字典元素数量：    3
empty_dict 字典元素数量： 0

9-1-11 验证元素是否存在

可以用下列语法验证元素是否存在
- 键 in name_dict

例：这个程序会要求输入 “ 键 - 值 “，然后判断此元素是否在 fruits 字典，如果不在此字典则将此键 - 值加入字典

fruits = {'西瓜':15,'香蕉':20,'水蜜桃':25}
key = input("请输入键（key）：")
value = input("请输入值（value）：")
if key in fruits:print("%s 已经在字典了"% key)
else:fruits[key] = valueprint("新的 fruits 字典内容",fruits)#输出结果1
请输入键（key）：苹果
请输入值（value）：18
新的 fruits 字典内容 {'西瓜': 15, '香蕉': 20, '水蜜桃': 25, '苹果': '18'}#输出结果2
请输入键（key）：西瓜
请输入值（value）：20
西瓜 已经在字典了

9-2 遍历字典#

大型程序设计中，字典用久了会产生相当数量的元素，也许是几千个或几十万个或更多，本节将说明如何遍历字典的 “ 键 - 值 ” 对，键或值

9-2-1 遍历字典的 “ 键 - 值 ”

python 有提供方法，可以让我们取得字典 “ 键 - 值 ” 配对的元素，可以使用 for 循环加 items() 方法。
例：列出 players 字典所有元素，相当于所有球员数据。
```
players = { '王三':'A队','李四':'A队','张五':'B队','林六':'C队','刘七':'D队'}
for name,team in players.items():print("\n姓名：",name)print("队名：",team)#输出结果姓名： 王三
队名： A队姓名： 李四
队名： A队姓名： 张五
队名： B队姓名： 林六
队名： C队姓名： 刘七
队名： D队
```
- 上述实例的执行结果虽然元素出现顺序与程序第 2 行到第 6 行的顺序相同，不过读者须了解 python 的直译器并不保证未来一定会保持相同顺序，因为字典是一个无序的数据结构，python 只会保持 “ 键 - 值 ”，不会关注元素的排序顺序。

9-2-2 遍历字典的键

有时假我们不想要取得字典的值，只想要键，python 有提供方法 keys() ，可以让我们取得字典的键的内容，可以使用 for 循环加上 keys() 方法

例：列出 players 字典所有的键，此例是所有球员名字。

players = { '王三':'A队','李四':'A队','张五':'B队','林六':'C队','刘七':'D队'}
for name in players.keys():print("姓名：",name)#输出结果
姓名： 王三
姓名： 李四
姓名： 张五
姓名： 林六
姓名： 刘七

其实上述实例第 7 行也可以省略 keys() 方法，而获得一样的结果，未来各位设计程序是否使用 keys()，可自行决定

例：此程序省略了 keys() 方法，但增加一些输出问候语句。

players = { '王三':'A队','李四':'A队','张五':'B队','林六':'C队','刘七':'D队'}
for name in players:print(name)print("%s 我喜欢看你在 %s 的表现" %(name,players[name]))#输出结果
王三
王三 我喜欢看你在 A队 的表现
李四
李四 我喜欢看你在 A队 的表现
张五
张五 我喜欢看你在 B队 的表现
林六
林六 我喜欢看你在 C队 的表现
刘七
刘七 我喜欢看你在 D队 的表现

9-2-3 排序与遍历字典

python 的字典功能并不会处理排序，如果想要遍历字典同时列出排序结果，可以使用方法 sorted()。

例：以名字将以排序方式列出结果

players = { '1王三':'A队','4李四':'A队','2张五':'B队','5林六':'C队','4刘七':'D队'}
for name in sorted(players.keys()):print(name)print("%s 我喜欢看你在 %s 的表现" %(name,players[name]))#输出结果
1王三
1王三 我喜欢看你在 A队 的表现
2张五
2张五 我喜欢看你在 B队 的表现
4刘七
4刘七 我喜欢看你在 D队 的表现
4李四
4李四 我喜欢看你在 A队 的表现
5林六
5林六 我喜欢看你在 C队 的表现

9-2-4 遍历字典的值

python 有提供方法 values()，可以让我们取得字典值列表，可以使用 for 循环加上 values() 方法，如下所示：

players = { '1王三':'A队','4李四':'A队','2张五':'B队','5林六':'C队','4刘七':'D队'}
for team in players.values():print(team)#输出结果
A队
A队
B队
C队
D队

上述 A 队重复出现，在字典的应用中键不可有重复，值是可以重复，如果你希望所列出的值不要重复，可以使用集合（set）观念作用 set() 函数，如下所示
```
players = { '1王三':'A队','4李四':'A队','2张五':'B队','5林六':'C队','4刘七':'D队'}
for team in set(players.values()):print(team)#输出结果
A队
D队
B队
C队
```

9-3 字典内含列表

我们建立了小兵 soldier0 字典，在真实的游戏设计中为了让玩家展现雄风，玩家将面对数十、数百或更多个小兵所组成的敌军，为了管理这些小表，可以将每个小兵当作一个字典，字典内则有小兵的各种信息，然后将这些小兵字典放入列表内。

例：建立 3 个小兵字典，然后将小兵组成列表

soldier0 = {'tag':'red','score':3,'speed':'slow'}
soldier1 = {'tag':'blue','score':5,'speed':'medium'}
soldier2 = {'tag':'greem','score':10,'speed':'fast'}
armys = [soldier0,soldier1,soldier2]
for army in armys:print(army)#输出结果
{'tag': 'red', 'score': 3, 'speed': 'slow'}
{'tag': 'blue', 'score': 5, 'speed': 'medium'}
{'tag': 'greem', 'score': 10, 'speed': 'fast'}

程序设计中如果每个小兵皆要个别设计这样太没效率，我们可以使用 7 - 2 节的 range() 函数处理这类的问题。

例：例用 range() 键立 50 个小兵，tag 是red、score 是 3、speed 是 slow。

armys = []
for soldier_name in range(50):soldier = {'tag':'red','score':3,'speed':'slow'}armys.append(soldier)
for soldier in armys[:3]:    #打印前 3 个小兵print(soldier)
print("小兵数量：",len(armys))#输出结果
{'tag': 'red', 'score': 3, 'speed': 'slow'}
{'tag': 'red', 'score': 3, 'speed': 'slow'}
{'tag': 'red', 'score': 3, 'speed': 'slow'}
小兵数量： 50

读者可能会想，上述小兵各种特征皆相同，用处可能不大，其实对 python 而言，虽然 50 个特征相同的小兵入在列表内，但每个小兵皆是独立，可用索引方式存取。通常可以在游戏过程中使用 if 语句和 for 循环处理。

例：建立 50 个小兵，但是将编号第 36 到 38 的小兵改成 tag 是 blue、score 是 5、speed 是 medium。

armys = []
for soldier_name in range(50):soldier = {'tag':'red','score':3,'speed':'slow'}armys.append(soldier)
for soldier in armys[:3]:    #打印前 3 个小兵print(soldier)
#更改编号 36 到 38 的小兵
for soldier in armys[35:38]:if soldier['tag'] == 'red':soldier['tag'] = 'blue'soldier['score'] = 5soldier['speed'] = 'medium'
#打印编号 35 到 40 的小兵
print("打印编号 35 到 40 小兵数据")
for soldier in armys[34:40]:print(soldier)#输出结果
{'tag': 'red', 'score': 3, 'speed': 'slow'}
{'tag': 'red', 'score': 3, 'speed': 'slow'}
{'tag': 'red', 'score': 3, 'speed': 'slow'}
打印编号 35 到 40 小兵数据
{'tag': 'red', 'score': 3, 'speed': 'slow'}
{'tag': 'blue', 'score': 5, 'speed': 'medium'}
{'tag': 'blue', 'score': 5, 'speed': 'medium'}
{'tag': 'blue', 'score': 5, 'speed': 'medium'}
{'tag': 'red', 'score': 3, 'speed': 'slow'}
{'tag': 'red', 'score': 3, 'speed': 'slow'}

9-4 字典内含列表元素

在 python 的应用中也允许将列表放在字典内，这时列表将是字典某键的值。如果想要遍历这类数据结构，需要使用嵌套循环和字典的方法 items()，外层循环是取得字典的键，内层循环则是将含列表的值拆解。下列是定义 sports 字典的实例：

sports = {'Curry':['篮球','美式足球'],'Durant':['棒球'],'James':['美式足球','棒球','篮球']}
for name,favorite_sport in sports.items():print("%s 喜欢的运动是：" % name)for sport in favorite_sport:print("  ",sport)#输出结果
Curry 喜欢的运动是：篮球美式足球
Durant 喜欢的运动是：棒球
James 喜欢的运动是：美式足球棒球篮球

9-5 字典内含字典

在 python 的应用中也允许将字典放在字典内，这时字典将是字典某键的值。假设微信账号是用字典存储，键有 2 个值是由另外字典组成，这个内部字典另有 3 个键，分别是 last_name、first_name 和 city，下列是设计实例：

wechat_account = {'cshung':{'last_name':'洪','first_name':'锦魁','city':'台北'},'kevin':{'last_name':'郑','first_name':'义盟','city':'北京'},}
#打印内含 字典的字典
for account,account_info in wechat_account.items():print("使用者账号：",account)name = account_info['last_name'] + " " + account_info['first_name']print("姓名      ：",name)print("城市      ：",account_info['city'])#输出结果
使用者账号： cshung
姓名      ： 洪 锦魁
城市      ： 台北
使用者账号： kevin
姓名      ： 郑 义盟
城市      ： 北京

9-6 while 循环在字典的应用

这一节的内容主要是将 while 循环应用在字典上。

例：这是一个市场梦幻旅游地点调查的实例，此程序会要求输入名字以及梦幻旅游地点，然后存入 surver_dict 字典，其中键是 name，值是 travel_location。输入完后程序会询问是否有人要输入，y 表是有，n 表示没有则程序结束，程序结束前会输出市场调查结果。

survey_dict = {}        #建立制场空字典
market_survey = True   #设定循环布尔值#读取参加市场调查者姓名和梦幻旅游景点
while market_survey:name = input("\n请输入性名：")travel_location = input("梦幻旅游景点：")#将输入存入 survey_dict 字典survey_dict[name] = travel_location#可由此决定是否离开市场调查repeat = input("是否有人要参加市场调查？（y/n）")if repeat != 'y':market_survey = False#市场调查结束
print("\n\n以下是市场调查结果")
for user,location in survey_dict.items():print(user,"梦幻旅游景点：",location)#输出结果请输入性名：张三
梦幻旅游景点：长沙
是否有人要参加市场调查？（y/n）y请输入性名：李四
梦幻旅游景点：西湖
是否有人要参加市场调查？（y/n）n以下是市场调查结果
张三 梦幻旅游景点： 长沙
李四 梦幻旅游景点： 西湖

有时候设计一个较长的程序时，若是适度空行整个程序的可读性会更佳，上述笔者就适当用空行将各个小程序分开

9-7 字典常用的函数和方法

9-7-1 len()

可以列出字典元素的个数

例：列出字典以及字典内的字典元素的个数

wechat_account = {'cshung':{'last_name':'洪','first_name':'锦魁','city':'台北'},'kevin':{'last_name':'郑','first_name':'义盟','city':'北京'},}
#打印字典元素个数
print("wechat_account 字典元素个数        ：",len(wechat_account))
print("wechat_account['cshung'] 元素个数  ：",len(wechat_account['cshung']))
print("wechat_account['kevin'] 元素个数   ：",len(wechat_account['kevin']))#输出结果
wechat_account 字典元素个数        ： 2
wechat_account['cshung'] 元素个数  ： 3
wechat_account['kevin'] 元素个数   ： 3

9-7-2 fromkeys()

这是建立字典的一个方法，它的语法格式如下：
- name_dict = dict . fromkeys ( seq [ , value ] ) #使用 seq 序列建立字典
上述会使用 seq 序列建立字典，序列内容将是字典的键，如果没有设定 value 则用 None 当字典键的值。

例：分别使用列表和元组建立字典

#将列表转成字典
seq1 = ['name','city']
list_dict1 = dict.fromkeys(seq1)
print("字典1：",list_dict1)
list_dict2 = dict.fromkeys(seq1,'Chicago')
print("字典2：",list_dict2)#将元组转成字典
seq2 = ('name','city')
tup_dict1 = dict.fromkeys(seq2)
print("字典3：",tup_dict1)
tup_dict2 = dict.fromkeys(seq2,"New York")
print("字典4",tup_dict2)#输出结果
字典1： {'name': None, 'city': None}
字典2： {'name': 'Chicago', 'city': 'Chicago'}
字典3： {'name': None, 'city': None}
字典4 {'name': 'New York', 'city': 'New York'}

9-7-3 get()

搜寻字典的键，如果键存在则传回该键，如果不存在则传回默认值。
- ret_value = dict.get ( key [ , default = none ] ) #dict 是欲搜寻的字典
- key 是要搜寻的键，如果找不到 key 则传回 default 的值（如果没有设就传回 None）。

例：get() 方法的应用

fruits = {'Apple':20,'Orange':25}
ret_value1 = fruits.get('Orange')  # 找到键就返回此键的值
print("Value = ",ret_value1)
ret_value2 = fruits.get("Grang")   # 找不到键就返回 None
print("Value = ",ret_value2)
ret_value3 = fruits.get("Grape",10) # 找不到键就返回第2个参数，即默认值
print("Value = ",ret_value3)#输出结果
Value =  25
Value =  None
Value =  10

9-7-4 setdefault()

这个方法基本上与 get() 相同，不同之处在于 get() 方法不会改变字典内容。使用 setdefault() 方法时若所搜寻的键不在，会将 “ 键 - 值 ” 加入字典，如果有设定默认值则将键：默认值加入字典，如果没有设定默认值则将 None 加入字典。
ret_value = dict.setdefault ( key [ , default = none ] )

例：setdefault() 方法，键在字典的内应用

fruits = {'Apple':20,'Orange':25}
ret_value1 = fruits.setdefault('Orange') # 找到键就返回此键的值
print("Value = ",ret_value1)
print("fruits字典：",fruits)#输出结果
Value =  25
fruits字典： {'Apple': 20, 'Orange': 25}

sedefault() 方法，键不在字典内的应用

person = {'name':'John'}
print("原先字典内容：",person)#'age'键不存在
age = person.setdefault('age')
print("增加 age 键",person)
print("age = ",age)#'sex'键不存在
sex = person.setdefault('sex','Male')
print("增加 sex 键",person)
print("sex = ",sex)#输出结果
原先字典内容： {'name': 'John'}
增加 age 键 {'name': 'John', 'age': None}
age =  None
增加 sex 键 {'name': 'John', 'age': None, 'sex': 'Male'}
sex =  Male

9-7-5 pop()

这个方法可以删除字典元素，它的语法格式如下：
- ret_value = dict . pop ( key [ , default ] )
上述 key 是要搜寻删除的元素的键，找到时就将该元素从字典内删除，同时将删键的值回传。当找不到 key 时则传回 default 设定的内容，如果没有设定则传回 KeyError。

例：使用 pop() 删除元素，同时元素存在的应用。

fruits = {'apple':20,'banana':15,'orange':22}
ret_value = fruits.pop('orange')
print("传回删除元素的值：",ret_value)
print("删除后的字典内容",fruits)#输出结果
传回删除元素的值： 22
删除后的字典内容 {'apple': 20, 'banana': 15}

例：使用 pop() 删除元素，同时元素不存在的应用

fruits = {'apple':20,'banana':15,'orange':22}
ret_value = fruits.pop('grape','要删除的元素不存在')
print("传回删除元素的值：",ret_value)
print("删除后的字典内容",fruits)#输出结果
传回删除元素的值： 要删除的元素不存在
删除后的字典内容 {'apple': 20, 'banana': 15, 'orange': 22}