我心中的王者：Python-第9章 字典(Dict)
列表(list)与元组(tuple)是依序排列可称是序列数据结构，只要知道元素的特定位置，即可使用索引观念取得元素内容。这一章的重点是介绍字典(dict)，它并不是依序排列的数据结构，通常可称是非序列数据结构，所以无法使用类似列表的数值(0, 1, … n)索引观念取得元素内容。
9-1 字典基本操作
9-1-1 定义字典
字典也是一个列表型的数据结构，但是它的元素是用“键-值”方式配对存储，在操作时是用键(key)取得值(value)的内容。定义字典时，是将键-值放在大括号“{ }”内，字典的语法格式如下：
name_dict = { 键1:值1, … , 键n:值n } # name_dict是字典变量名称
字典的值(value)可以是任何Python的对象，所以可以是数值、字符串、列表等。
程序实例ch9_1.py：以水果行和面店为例定义一个字典，同时列出字典。下列字典是设定水果一斤的价格、面一碗的价格，最后使用type( )列出字典数据类型。
# ch9_1.py
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设计打斗游戏时，玩家通常扮演英雄的角色，敌军可以用字典方式存储，例如，可以用不同颜色的标记设定敌军的小兵，每一个敌军的小兵给予一个分数，这样可以由打死敌军数量再统计游戏得分，可以用下列方式定义字典内容。
程序实例ch9_2.py：定义soldier0字典tag和score是键，red和3是值。
# ch9_2.py
soldier0 = {'tag':'red', 'score':3}
print(soldier0)
执行结果
{'tag': 'red', 'score': 3}
上述是定义红色(red)小兵，分数是3分，玩家打死红色小兵得3分。
9-1-2 列出字典元素的值
字典的元素是“键-值”配对设定，如果想要取得元素的值，可以将键当作是索引方式处理，因此字典内的元素不可有重复的键，可参考下列实例ch9_3.py的第4行，例如，下列可传回fruits字典水蜜桃键的值。
fruits[‘水蜜桃'] # 用字典变量[‘键']取得值
下列是完整实例。
程序实例ch9_3.py：分别列出ch9_1.py中水果店水蜜桃一斤的价格和面店牛肉面一碗的价格。
# ch9_3.py
fruits = {'西瓜':15, '香蕉':20, '水蜜桃':25}
noodles = {'牛肉面':100, '肉丝面':80, '阳春面':60}
print("水蜜桃一斤 = ", fruits['水蜜桃'], "元")
print("牛肉面一碗 = ", noodles['牛肉面'], "元")
执行结果
水蜜桃一斤 = 25 元
牛肉面一碗 = 100 元
程序实例ch9_4.py：分别列出ch9_2.py小兵字典的tag和score键的值。
# ch9_4.py
soldier0 = {'tag':'red', 'score':3}
print("你刚打死标记 %s 小兵" % soldier0['tag'])
print("可以得到 ", soldier0['score'], " 分")
执行结果
你刚打死标记 red 小兵
可以得到 3 分
9-1-3 增加字典元素
可使用下列语法格式增加字典元素：
name_dict[键] = 值 # name_dict是字典变量
程序设计ch9_5.py：为fruits字典增加橘子一斤18元。
# ch9_5.py
fruits = {'西瓜':15, '香蕉':20, '水蜜桃':25}
fruits['橘子'] = 18
print(fruits)
print("橘子一斤 = ", fruits['橘子'], "元")
执行结果
{'西瓜': 15, '香蕉': 20, '水蜜桃': 25, '橘子': 18}
橘子一斤 = 18 元
在设计打斗游戏时，我们可以使用屏幕坐标标记小兵的位置，下列实例是用xpos/ypos标记小兵的x坐标/y坐标。
程序实例ch9_6.py：为soldier0字典增加x,y轴坐标(xpos,ypos)和移动速度(speed)元素，同时列出结果做验证。
# ch9_6.py
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 更改字典元素内容
市面上的水果价格是浮动的，如果发生价格异动可以使用本节观念更改。
程序实例ch9_7.py：将fruits字典的香蕉一斤改成12元。
# ch9_7.py
fruits = {'西瓜':15, '香蕉':20, '水蜜桃':25}
print("旧价格香蕉一斤 = ", fruits['香蕉'], "元")
fruits['香蕉'] = 12
print("新价格香蕉一斤 = ", fruits['香蕉'], "元")
执行结果
旧价格香蕉一斤 = 20 元
新价格香蕉一斤 = 12 元
在设计打斗游戏时，我们需要时刻移动小兵的位置，此时可以使用本节介绍的方法来更改小兵位置。
程序实例ch9_8.py：依照soldier字典speed键的值移动小兵位置。
# ch9_8.py
soldier0 = {'tag':'red', 'score':3, 'xpos':100,
'ypos':30, 'speed':'slow' }
print("小兵的 x,y 旧坐标 = ", soldier0['xpos'], ",", soldier0['xpos'] )
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 , 100
小兵的 x,y 新坐标 = 101 , 30
上述程序将小兵移动速度分成3个等级，slow是每次xpos移动1单位(5和6行)，medium是每次xpos移动3单位(7和8行)，另一等级则是每次xpos移动5单位(9和10行)。第11行是执行小兵移动，为了简化条件y轴暂不移动。所以可以得到上述小兵x轴位置由100移到101。
9-1-5 删除字典特定元素
如果想要删除字典的特定元素，它的语法格式如下：
del name_dict[键] # 可删除特定键的元素
程序实例ch9_9.py：删除fruits字典的西瓜元素。
# ch9_9.py
fruits = {'西瓜':15, '香蕉':20, '水蜜桃':25}
print("旧fruits字典内容:", fruits)
del fruits['西瓜']
print("新fruits字典内容:", fruits)
执行结果
旧fruits字典内容: {'西瓜': 15, '香蕉': 20, '水蜜桃': 25}
新fruits字典内容: {'香蕉': 20, '水蜜桃': 25}
9-1-6 删除字典所有元素
Python有提供方法clear( )可以将字典的所有元素删除，此时字典仍然存在，不过将变成空的字典。
程序实例ch9_10.py：使用clear( )方法删除fruits字典的所有元素。
# ch9_10.py
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 # 可删除字典name_dict
程序实例ch9_11.py：删除字典的测试，这个程序前4行是没有任何问题，第5行尝试打印已经被删除了的字典，所以产生错误，错误原因是没有定义fruits字典。
# ch9_11.py
fruits = {'西瓜':15, '香蕉':20, '水蜜桃':25}
print("旧fruits字典内容:", fruits)
del fruits
print("新fruits字典内容:", fruits) # 错误! 错误!
执行结果
旧fruits字典内容: {'西瓜': 15, '香蕉': 20, '水蜜桃': 25}
Traceback (most recent call last):
File "e:\桌面Desktop\Python王者归来\代码\ch9\ch9_11.py", line 5, in <module>
print("新fruits字典内容:", fruits) # 错误! 错误!
^^^^^^
NameError: name 'fruits' is not defined
9-1-8 建立一个空字典
在程序设计时，也允许先建立一个空字典，建立空字典的语法如下：
name_dict = { } # name_dict是字典名称
上述建立完成后，可以用9-1-3节增加字典元素的方式为空字典建立元素。
程序实例ch9_12.py：建立一个小兵的空字典，然后为小兵建立元素。
# ch9_12
soldier0 = {} # 建立空字典
print("空小兵字典", soldier0)
soldier0['tag'] = 'red'
soldier0['score'] = 3
print("新小兵字典", soldier0)
执行结果
空小兵字典 {}
新小兵字典 {'tag': 'red', 'score': 3}
9-1-9 字典的复制
在大型程序开发过程，有时为了要保护原先字典内容，所以常会需要将字典复制，此时可以使用此方法。
new_dict = name_dict.copy( ) # name_dict会被复制至new_dict
上述所复制的字典是独立存在新地址的字典。
程序实例ch9_13.py：复制字典的应用，同时列出新字典所在地址，如此可以验证新字典与旧字典是不同的字典。
# ch9_13.py
fruits = {'西瓜':15, '香蕉':20, '水蜜桃':25, '苹果':18}
cfruits = fruits.copy( )
print("地址 = ", id(fruits), " fruits元素 = ", fruits)
print("地址 = ", id(cfruits), " fruits元素 = ", cfruits)
执行结果
地址 = 2649559370176 fruits元素 = {'西瓜': 15, '香蕉': 20, '水蜜桃': 25, '苹果': 18}
地址 = 2649560281600 fruits元素 = {'西瓜': 15, '香蕉': 20, '水蜜桃': 25, '苹果': 18}
9-1-10 取得字典元素数量
在列表(list)或元组(tuple)使用的方法len( )也可以应用在字典，它的语法如下：
length = len(name_dict) # 将返回name_dict字典的元素数量给length
程序实例ch9_14.py：列出空字典和一般字典的元素数量，本程序第4行由于是建立空字典，所以第7行印出元素数量是0。
# ch9_14.py
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 # 可验证键元素是否存在
程序实例ch9_15.py：这个程序会要求输入键-值，然后判断此元素是否在fruits字典，如果不在此字典则将此键-值加入字典。
# ch9_15.py
fruits = {'西瓜':15, '香蕉':20, '水蜜桃':25}
key = input("请输入键(key) = ")
value = input("请输入值(value) = ")
if key in fruits:
print("%s已经在字典了" % key)
else:
fruits[key] = value
print("新的fruits字典内容 = ", fruits)
执行结果
请输入键(key) = 黄瓜
请输入值(value) = 11
新的fruits字典内容 = {'西瓜': 15, '香蕉': 20, '水蜜桃': 25, '黄瓜': '11'}
9-1-12 设计字典的可读性技巧
设计大型程序时，字典的元素内容很可能是由长字符串所组成，碰上这类情况建议从新的一行开始安置每一个元素，如此可以大大增加字典内容的可读性。例如，有一个players字典，元素是由键（球员名字）-值（球队名称）所组成。如果，我们使用传统方式设计，将让整个字典定义变得很复杂，如下所示：
碰上这类字典，建议是一行定义一个元素，如下所示：
程序实例ch9_16.py：字典元素是长字符串的应用。
# ch9_16.py
players = {'Stephen Curry':'Golden State Warriors',
'Kevin Durant':'Golden State Warriors',
'Lebron James':'Cleveland Cavaliers',
'James Harden':'Houston Rockets',
'Paul Gasol':'San Antonio Spurs'}
print("Stephen Curry是 %s 的球员" % players['Stephen Curry'])
print("Kevin Durant是 %s 的球员" % players['Kevin Durant'])
print("Paul Gasol是 %s 的球员" % players['Paul Gasol'])
执行结果
Stephen Curry是 Golden State Warriors 的球员
Kevin Durant是 Golden State Warriors 的球员
Paul Gasol是 San Antonio Spurs 的球员
9-2 遍历字典
大型程序设计中，字典用久了会产生相当数量的元素，也许是几千个或几十万个或更多。本节将说明如何遍历字典的键-值对、键或值。
9-2-1 遍历字典的键-值
Python有提供方法items( )，可以让我们取得字典键-值配对的元素，若是以ch9_16.py的players字典为实例，可以使用for循环加上items( )方法，如下所示：
上述只要尚未完成遍历字典，for循环将持续进行，如此就可以完成遍历字典，同时传回所有的键-值。
程序实例ch9_17.py：列出players字典所有元素，相当于所有球员数据。
# ch9_17.py
players = {'Stephen Curry':'Golden State Warriors',
'Kevin Durant':'Golden State Warriors',
'Lebron James':'Cleveland Cavaliers',
'James Harden':'Houston Rockets',
'Paul Gasol':'San Antonio Spurs'}
for name, team in players.items( ):
print("\n姓名: ", name)
print("队名: ", team)
执行结果
姓名: Stephen Curry
队名: Golden State Warriors
姓名: Kevin Durant
队名: Golden State Warriors
姓名: Lebron James
队名: Cleveland Cavaliers
姓名: James Harden
队名: Houston Rockets
姓名: Paul Gasol
队名: San Antonio Spurs
上述实例的执行结果中虽然元素出现顺序与程序第2行到第6行的顺序相同，不过读者须了解Python的直译器并不保证未来一定会保持相同顺序，因为字典(dict)是一个无序的数据结构，Python只会保持键-值，不会关注元素的排列顺序。
9-2-2 遍历字典的键
有时候我们不想要取得字典的值(value)，只想要键(keys)，Python有提供方法keys( )，可以让我们取得字典的键内容，若是以ch9_16.py的players字典为实例，可以使用for循环加上keys( )方法，如下所示：
上述for循环会依次将players字典的键传回。
程序实例ch9_18.py：列出players字典所有的键(keys)，此例是所有球员名字。
# ch9_18.py
players = {'Stephen Curry':'Golden State Warriors',
'Kevin Durant':'Golden State Warriors',
'Lebron James':'Cleveland Cavaliers',
'James Harden':'Houston Rockets',
'Paul Gasol':'San Antonio Spurs'}
for name in players.keys( ):
print("姓名: ", name)
执行结果
姓名: Stephen Curry
姓名: Kevin Durant
姓名: Lebron James
姓名: James Harden
姓名: Paul Gasol
其实上述实例第7行也可以省略keys( )方法，而获得一样的结果，未来各位设计程序是否使用keys( )，可自行决定，细节可参考ch9_19.py的第7行。
程序实例ch9_19.py：重新设计ch9_18.py，此程序省略了keys( )方法，但增加一些输出问候语句。
# ch9_19.py
players = {'Stephen Curry':'Golden State Warriors',
'Kevin Durant':'Golden State Warriors',
'Lebron James':'Cleveland Cavaliers',
'James Harden':'Houston Rockets',
'Paul Gasol':'San Antonio Spurs'}
for name in players:
print(name)
print("Hi! %s 我喜欢看你在 %s 的表现" % (name, players[name]))
执行结果
Stephen Curry
Hi! Stephen Curry 我喜欢看你在 Golden State Warriors 的表现
Kevin Durant
Hi! Kevin Durant 我喜欢看你在 Golden State Warriors 的表现
Lebron James
Hi! Lebron James 我喜欢看你在 Cleveland Cavaliers 的表现
James Harden
Hi! James Harden 我喜欢看你在 Houston Rockets 的表现
Paul Gasol
Hi! Paul Gasol 我喜欢看你在 San Antonio Spurs 的表现
9-2-3 排序与遍历字典
Python的字典功能并不会处理排序，如果想要遍历字典同时列出排序结果，可以使用方法sorted( )。
程序实例ch9_20.py：重新设计程序实例ch9_19.py，但是名字将以排序方式列出结果，这个程序的重点是第7行。
# ch9_20.py
players = {'Stephen Curry':'Golden State Warriors',
'Kevin Durant':'Golden State Warriors',
'Lebron James':'Cleveland Cavaliers',
'James Harden':'Houston Rockets',
'Paul Gasol':'San Antonio Spurs'}
for name in sorted(players.keys( )):
print(name)
print("Hi! %s 我喜欢看你在 %s 的表现" % (name, players[name]))
执行结果
James Harden
Hi! James Harden 我喜欢看你在 Houston Rockets 的表现
Kevin Durant
Hi! Kevin Durant 我喜欢看你在 Golden State Warriors 的表现
Lebron James
Hi! Lebron James 我喜欢看你在 Cleveland Cavaliers 的表现
Paul Gasol
Hi! Paul Gasol 我喜欢看你在 San Antonio Spurs 的表现
Stephen Curry
Hi! Stephen Curry 我喜欢看你在 Golden State Warriors 的表现
9-2-4 遍历字典的值
Python有提供方法values( )，可以让我们取得字典值列表，若是以ch9_16.py的players字典为实例，可以使用for循环加上values( )方法，如下所示：
程序实例ch9_21.py：列出players字典的值列表。
# ch9_21.py
players = {'Stephen Curry':'Golden State Warriors',
'Kevin Durant':'Golden State Warriors',
'Lebron James':'Cleveland Cavaliers',
'James Harden':'Houston Rockets',
'Paul Gasol':'San Antonio Spurs'}
for team in players.values( ):
print(team)
执行结果
Golden State Warriors
Golden State Warriors
Cleveland Cavaliers
Houston Rockets
San Antonio Spurs
上述Golden State Warriors重复出现，在字典的应用中键不可有重复，值是可以重复，如果你希望所列出的值不要重复，可以使用集合(set)观念使用set( )函数，例如将第7行改为下列所示即可，这个实例放在ch9_21_1.py，读者可自行参考。这是下一章的主题，更多细节将在下一章解说。
# ch9_21_1.py
players = {'Stephen Curry':'Golden State Warriors',
'Kevin Durant':'Golden State Warriors',
'Lebron James':'Cleveland Cavaliers',
'James Harden':'Houston Rockets',
'Paul Gasol':'San Antonio Spurs'}
for team in set(players.values( )):
print(team)
下列是执行结果，可以发现Golden State Warriors不重复了。
Golden State Warriors
San Antonio Spurs
Cleveland Cavaliers
Houston Rockets
9-3 建立字典列表
读者可以思考一下程序实例ch9_2.py，我们建立了小兵soldier0字典，在真实的游戏设计中为了让玩家展现雄风，玩家将面对数十、数百或更多个小兵所组成的敌军，为了管理这些小兵，可以将每个小兵当作一个字典，字典内则有小兵的各种信息，然后将这些小兵字典放入列表(list)内。
程序实例ch9_22.py：建立3个小兵字典，然后将小兵组成列表(list)。
# ch9_22.py
soldier0 = {'tag':'red', 'score':3, 'speed':'slow'} # 建立小兵
soldier1 = {'tag':'blue', 'score':5, 'speed':'medium'}
soldier2 = {'tag':'green', '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': 'green', 'score': 10, 'speed': 'fast'}
程序设计中如果每个小兵皆要个别设计这样太没效率了，我们可以使用7-2节的range( )函数处理这类的问题。
程序实例ch9_23.py：使用range( )建立50个小兵，tag是red、score是3、speed是slow。
# ch9_23.py
armys = [] # 建立小兵空列表
# 建立50个小兵
for soldier_number in range(50):
soldier = {'tag':'red', 'score':3, 'speed':'slow'}
armys.append(soldier)
# 打印前3个小兵
for soldier in armys[: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循环处理。
程序实例ch9_24.py：重新设计ch9_23.py，建立50个小兵，但是将编号第36到38名的小兵改成tag是blue、score是5、speed是medium。
# ch9_24.py
armys = [] # 建立小兵空列表
# 建立50个小兵
for soldier_number in range(50):
soldier = {'tag':'red', 'score':3, 'speed':'slow'}
armys.append(soldier)
# 打印前3个小兵
print("前3名小兵资料")
for soldier in armys[:3]:
print(soldier)
# 更改编号36到38的小兵
for soldier in armys[35:38]:
if soldier['tag'] == 'red':
soldier['tag'] = 'blue'
soldier['score'] = 5
soldier['speed'] = 'medium'
# 打印编号35到40的小兵
print("打印编号35到40小兵数据")
for soldier in armys[34:40]:
print(soldier)
执行结果
前3名小兵资料
{'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字典内含3个键-值配对元素，其中值的部分皆是列表。程序设计时外层循环配合items( )方法，设计如下：
上述设计后，键内容会传给name变量，值内容会传给favorite_sport变量，所以第8行将打印键内容。内层循环主要是将favorite_sport列表内容拆解，它的设计如下：
上述列表内容会随循环传给sport变量，所以第11行可以列出结果。
程序实例ch9_25.py：字典内含列表元素的应用，本程序会先定义内含字符串的字典，然后再拆解打印。
# ch9_25.py
# 建立内含字符串的字典
sports = {'Curry':['篮球', '美式足球'],
'Durant':['棒球'],
'James':['美式足球', '棒球', '篮球']}
# 打印key名字 + 字符串'喜欢的运动'
for name, favorite_sport in sports.items( ):
print("%s 喜欢的运动是: " % name)
# 打印value,这是列表
for sport in favorite_sport:
print(" ", sport)
执行结果
Curry 喜欢的运动是:
篮球
美式足球
Durant 喜欢的运动是:
棒球
James 喜欢的运动是:
美式足球
棒球
篮球
9-5 字典内含字典
在Python的应用中也允许将字典放在字典内，这时字典将是字典某键的值。假设微信(wechat_account)账号是用字典存储，键有2个值是由另外字典组成，这个内部字典另有3个键，分别是last_name、first_name和city，下列是设计实例。
至于打印方式一样需使用items( )函数，可参考下列实例。
程序实例ch9_26.py：列出字典内含字典的内容。
# ch9_26.py
# 建立内含字典的字典
wechat_account = {'cshung':{
'last_name':'洪',
'first_name':'锦魁',
'city':'台北'},
'kevin':{
'last_name':'郑',
'first_name':'义盟',
'city':'北京'}}
# 打印内含字典的字典
for account, account_info in wechat_account.items( ):
print("使用者账号 = ", account) # 打印键(key)
name = account_info['last_name'] + " " + account_info['first_name']
print("姓名 = ", name) # 打印值(value)
print("城市 = ", account_info['city']) # 打印值(value)
执行结果
使用者账号 = cshung
姓名 = 洪 锦魁
城市 = 台北
使用者账号 = kevin
姓名 = 郑 义盟
城市 = 北京
9-6 while循环在字典的应用
这一节的内容主要是将while循环应用在字典上。
程序实例ch9_27.py：这是一个市场梦幻旅游地点调查的实例，此程序会要求输入名字以及梦幻旅游地点，然后存入survey_dict字典，其中键是name，值是travel_location。输入完后程序会询问是否有人要输入，y表示有，n表示没有则程序结束，程序结束前会输出市场调查结果。
# ch9_27.py
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': # 不是输入y,则离开while循环
market_survey = False
# 市场调查结束
print("\n\n以下是市场调查的结果")
for user, location in survey_dict.items( ):
print(user, "梦幻旅游景点: ", location)
执行结果
请输入姓名 : 晓波
梦幻旅游景点: 宜昌
是否有人要参加市场调查?(y/n) y
请输入姓名 : 子均
梦幻旅游景点: 武汉
是否有人要参加市场调查?(y/n) n
以下是市场调查的结果
晓波 梦幻旅游景点: 宜昌
子均 梦幻旅游景点: 武汉
有时候设计一个较长的程序时，若是适度空行则整个程序的可读性会更佳，上述笔者分别在第9、12和17行空一行的目的就是如此。
9-7 字典常用的函数和方法
9-7-1 len( )
可以列出字典元素的个数。
程序实例ch9_28：列出字典以及字典内的字典元素的个数。
# ch9_28.py
# 建立内含字典的字典
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当字典键的值。
程序实例ch9_29.py：分别使用列表和元组建立字典。
# ch9_29.py
# 将列表转成字典
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）。
程序实例ch9_30.py：get( )方法的应用。
# ch9_30.py
fruits = {'Apple':20, 'Orange':25}
ret_value1 = fruits.get('Orange')
print("Value = ", ret_value1)
ret_value2 = fruits.get('Grape')
print("Value = ", ret_value2)
ret_value3 = fruits.get('Grape', 10)
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]) # dict是欲搜寻的字典
程序实例ch9_31.py：setdefault( )方法，键在字典内的应用。
# ch9_31.py
# key在字典內
fruits = {'Apple':20, 'Orange':25}
ret_value1 = fruits.setdefault('Orange')
print("Value = ", ret_value1)
print("fruits字典", fruits)
执行结果
Value = 25
fruits字典 {'Apple': 20, 'Orange': 25}
程序实例ch9_32.py：setdefault( )方法，键不在字典内的应用。
# ch9_32.py
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]) # dict是欲删除元素的字典
上述key是要搜寻删除的元素的键，找到时就将该元素从字典内删除，同时将删除键的值回传。当找不到key时则传回default设定的内容，如果没有设定则传回KeyError。
程序实例ch9_33.py：使用pop( )删除元素，同时元素存在的应用。
# ch9_33.py
fruits = {'apple':20, 'banana':15, 'orange':22}
ret_value = fruits.pop('orange')
print("传回删除元素的值", ret_value)
print("删除后的字典内容", fruits)
执行结果
传回删除元素的值 22
删除后的字典内容 {'apple': 20, 'banana': 15}
程序实例ch9_34.py：使用pop( )删除元素，同时元素不存在的应用。
# ch9_34.py
fruits = {'apple':20, 'banana':15, 'orange':22}
ret_value = fruits.pop('grape', 'does not exist')
print("传回删除元素的值", ret_value)
print("删除后的字典内容", fruits)
执行结果
传回删除元素的值 does not exist
删除后的字典内容 {'apple': 20, 'banana': 15, 'orange': 22}
