# 一个简单的字典
"""
来看一个包含外星人的游戏，这些外星人的颜色和分数各不相同。下面是一个简单的
字典，存储了有关特定外星人的信息：
"""
alien_0 = {'color': 'green', 'points': 5}
print(alien_0['color'])
print(alien_0['points'])
print()
# 使用字典
"""
字典（dictionary）是一系列键值对。每个键都与一个值关联，可以使用
键来访问与之关联的值。与键相关联的值可以是数、字符串、列表乃至字典。事实
上，可将任意 Python 对象用作字典中的值。
"""
# 在 Python 中，字典用放在花括号（{}）中的一系列键值对表示：
alien_0 = {'color': 'green', 'points': 5}
print(alien_0)
"""
键值对包含两个相互关联的值。当你指定键时，Python 将返回与之关联的值。键和值
之间用冒号分隔，而键值对之间用逗号分隔。在字典中，你想存储多少个键值对都可
以。
"""
# 最简单的字典只有一个键值对，如下述修改后的字典 alien_0 所示：
alien_0 = {'color': 'green'}
print(alien_0)
"""
这个字典只存储了一项有关 alien_0 的信息，具体地说是这个外星人的颜色。在这个
字典中，字符串 'color' 是一个键，与之关联的值为 'green'。
"""
# 访问字典中的值
# 要获取与键关联的值，可指定字典名并把键放在后面的方括号内，如下所示：
alien_2 = {'color': 'green'}
print(alien_2['color'])
# 字典中可包含任意数量的键值对。例如，最初的字典 alien_0 就包含两个键值对：
alien_0 = {'color': 'red', 'points': 5}
print(alien_0)
# 添加键值对
# 字典是一种动态结构，可随时在其中添加键值对。要添加键值对，可依次指定字典名、用方括号括起来的键和与该键关联的值。
'''
下面来在字典 alien_0 中添加两项信息：外星人的 x 坐标和 y 坐标，以便在屏幕的特
定位置上显示该外星人。我们将这个外星人放在屏幕左边缘上，距离屏幕上边缘 25 像
素。由于屏幕坐标系的原点通常在左上角，因此要将该外星人放在屏幕左边缘，可将 x
坐标设置为 0；要将该外星人放在距离屏幕上边缘 25 像素的地方，可将 y 坐标设置为
25，如下所示：
'''
alien_0 = {'color': 'red', 'points': 5}
print(alien_0)
alien_0['x_position'] = 0
alien_0['y_position'] = 25
print(alien_0)
"""
字典会保留定义时的元素排列顺序。如果将字典打印出来或遍历其元素，将发现元素
的排列顺序与其添加顺序相同。
"""
# 从创建一个空字典开始
# 示例：
alien_0 = {}
alien_0['color'] = 'green'
alien_0['points'] = 5
print(alien_0)
print()
# 首先定义空字典 alien_0，再在其中添加颜色和分数，得到前述示例一直在使用的字典
"""
如果要使用字典来存储用户提供的数据或者编写能自动生成大量键值对的代码，通常
需要先定义一个空字典。
"""
# 修改字典中的值
'''
要修改字典中的值，可依次指定字典名、用方括号括起来的键和与该键关联的新值。
假设随着游戏的进行，需要将一个外星人从绿色改为蓝色：
'''
alien_0 = {'color': 'green'}
print(f"The alien is {alien_0['color']}.")
alien_0['color'] = 'blue'
print(f"The alien is now {alien_0['color']}.")
print()
'''
对一个能够以不同速度移动的外星人进行位置跟踪。为此，
存储该外星人的当前速度，并据此确定该外星人应该向右移动多远：
'''
alien_0 = {'x_position': 0, 'y_position': 25, 'speed': 'medium'}
print(f"Original position: {alien_0['x_position'],alien_0['y_position']}")
# 向右移动外星人
# 根据当前速度确定将外星人向右移动多远
if alien_0['speed'] == 'slow':
    x_increment = 1
elif alien_0['speed'] == 'medium':
    x_increment = 2
else:
    # 这个外星人的移动速度肯定很快
    x_increment = 3
# 新位置为旧位置加上移动距离
alien_0['x_position'] = alien_0['x_position'] + x_increment
print(f"New position: {alien_0['x_position'],alien_0['y_position']}")
# 例如，要将这个速度中等的外星人变成速度很快的外星人，可添加如下代码行：
alien_0['speed'] = 'fast'
print()
# 删除键值对
"""
对于字典中不再需要的信息，可使用 del 语句将相应的键值对彻底删除。在使用 del
语句时，必须指定字典名和要删除的键。
"""
# 例如，下面的代码从字典 alien_0 中删除键 'points' 及其值：
alien_0 = {'color': 'green', 'points': 5}
print(alien_0)
del alien_0['points']
print(alien_0)
# 注意：删除的键值对永远消失了
print()
# 由类似的对象组成的字典
"""
字典存储的是一个对象（游戏中的一个外星人）的多种信息，但也
可以使用字典来存储众多对象的同一种信息。假设你要调查很多人，询问他们喜欢的
编程语言，可使用一个字典来存储这种简单调查的结果，如下所示：
"""
favorite_languages = {
 'jen': 'python',
 'sarah': 'c',
 'edward': 'rust',
 'phil': 'python',
 }
"""
注意：对于较长的列表和字典，大多数编辑器提供了以类似方式设置格式的功
能。对于较长的字典，还有其他一些可行的格式设置方式，因此在你的编辑器或
其他源代码中，你可能会看到稍微不同的格式设置方式。
"""
language = favorite_languages['sarah'].title()
print(f"Sarah's favorite language is {language}.")

# 使用 get() 来访问值
'''
使用放在方括号内的键从字典中获取感兴趣的值，可能会引发问题：如果指定的键不
存在，就将出错。
如果你要求获取外星人的分数，而这个外星人没有分数，结果将如何呢？下面来看一
看：
'''
"""
alien_0 = {'color': 'green', 'speed': 'slow'}
print(alien_0['points'])
Traceback (most recent call last):
  File "G:\Python\Python_program\Python3\第6章\字典.py", line 139, in <module>
    print(alien_0['points'])
KeyError: 'points'
"""
"""
就字典而言，为避免出现这样的错误，可使用 get() 方法在指定的键不存在时返回一个默认值。
get() 方法的第一个参数用于指定键，是必不可少的；第
二个参数为当指定的键不存在时要返回的值，是可选的：
"""
point_value = alien_0.get('point','No point value assigned.') # 没有指定第二个参数，返回值为None
# None 只是一个表示所需值不存在的特殊值
print(point_value)
# 如果指定的键有可能不存在，应考虑使用 get() 方法，而不要使用方括号表示法。

# 遍历所有的键值对
user_0 = {
 'username': 'efermi',
 'first': 'enrico',
 'last': 'fermi',
 }
for key,value in user_0.items():
    print(f"正在配置 {key} -> {value}")
print()

favorite_languages = {
 'jen': 'python',
 'sarah': 'c',
 'edward': 'rust',
 'phil': 'python',
 }
for name,language in favorite_languages.items(): # 少了items()方法，会报异常：ValueError: too many values to unpack (expected 2)
    print(f"{name.title()}'s favorite language is {language.title()}.")
print()

# 遍历字典中的所有键
favorite_languages = {
 'jen': 'python',
 'sarah': 'c',
 'edward': 'rust',
 'phil': 'python',
 }
for name in favorite_languages.keys():
    print(name.title())
print()
# for name in favorite_languages: 输出将不变。
'''
在这种循环中，可使用当前的键来访问与之关联的值。下面来打印两条消息，指出两
个朋友喜欢的编程语言。我们像前面一样遍历字典中的名字，但在名字为指定朋友的
名字时，打印一条消息，指出其喜欢的语言：
'''
friends = ['phil', 'sarah']
for name in favorite_languages.keys():
    print(f"Hi {name.title()}.")
    if name in friends:
        language = favorite_languages[name].title()
        print(f"\t{name.title()}, I see you love {language}!")
if 'erin' not in favorite_languages.keys():
    print("Erin, please take our poll!")
# keys() 方法并非只能用于遍历：实际上，它会返回一个列表，其中包含字典中的所有键
print()
# 按特定的顺序遍历字典中的所有键
# 遍历字典时将按插入元素的顺序返回其中的元素，但是在一些情况下，你可能要按与此不同的顺序遍历字典。
'''
要以特定的顺序返回元素，一种办法是在 for 循环中对返回的键进行排序。为此，可
使用 sorted() 函数来获得按特定顺序排列的键列表的副本：
'''
favorite_languages = {
 'jen': 'python',
 'sarah': 'c',
 'edward': 'rust',
 'phil': 'python',
 }
for name in sorted(favorite_languages.keys()):
    print(f"{name.title()}, thank you for taking the poll.")
print()
# 遍历字典中的所有值
'''
如果你感兴趣的是字典包含的值，可使用 values() 方法。它会返回一个值列表，不
包含任何键。如果想获得一个只包含被调查者选择的各种语言，而不包含被调查者名
字的列表，可以这样做：
'''
favorite_languages = {
 'jen': 'python',
 'sarah': 'c',
 'edward': 'rust',
 'phil': 'python',
 }
print("The following languages have been mentioned:")
for language in favorite_languages.values():
    print(language.title())
print()
"""
这种做法提取字典中所有的值，而没有考虑值是否有重复。当涉及的值很少时，这也
许不是问题，但如果被调查者很多，最终的列表可能包含大量的重复项。为剔除重复
项，可使用集合（set）。集合中的每个元素都必须是独一无二的：
"""
print("The following languages have been mentioned:")
for language in set(favorite_languages.values()):
    print(language.title())
# 注意：可以使用一对花括号直接创建集合，并在其中用逗号分隔元素：
languages = {'python', 'rust', 'python', 'c'}
print(languages)
print()
# 嵌套：将多个字典存储在列表中或将列表作为值存储在字典中，这称为嵌套。
# 可以在列表中嵌套字典，在字典中嵌套列表，甚至在字典中嵌套字典
# 字典列表
'''
字典 alien_0 包含一个外星人的各种信息，但无法存储第二个外星人的信息，更别说
屏幕上全部外星人的信息了。如何管理成群结队的外星人呢？一种办法是创建一个外
星人列表，其中每个外星人都是一个字典，包含有关该外星人的各种信息。例如，下
面的代码创建一个包含三个外星人的列表：
'''
alien_0 = {'color': 'green', 'points': 5}
alien_1 = {'color': 'yellow', 'points': 10}
alien_2 = {'color': 'red', 'points': 15}
aliens = [alien_0, alien_1, alien_2]
for alien in aliens:
    print(alien)
print()
'''
更符合现实的情形是，外星人不止三个，而且每个外星人都是用代码自动生成的。在
下面的示例中，使用 range() 生成了 30 个外星人：
'''
# 创建一个用于存储外星人的空列表
aliens = []
# 创建 30 个绿色的外星人
for alien_numbers in range(30):
    new_alien = {'color': 'green', 'points': 5, 'speed': 'slow'}
    aliens.append(new_alien)
# 显示前 5 个外星人
for alien in aliens[:5]:
    print(alien)
print("...")
# 显示创建了多少个外星人
print(f"Total number of aliens: {len(aliens)}")
print()
'''
在什么情况下需要处理成群结队的外星人呢？想象一下，随着游戏的进行，有些外星
人会变色且加快移动速度。在必要时，可使用 for 循环和 if 语句来修改某些外形人
的颜色。例如，要将前三个外星人修改为黄色、速度中等且值 10 分，可这样做：
'''
# 创建一个用于存储外星人的空列表
aliens = []
# 创建 30 个绿色的外星人
for alien_numbers in range(30):
    new_alien = {'color': 'green', 'points': 5, 'speed': 'slow'}
    aliens.append(new_alien)
for alien in aliens[:3]:
    if alien.get('color') == 'green':
        alien['color'] = 'yellow'
        alien['speed'] = 'medium'
        alien['points'] = 10
# 显示前 5 个外星人
for alien in aliens[:5]:
    print(alien)
print("...")
print()
'''
可进一步扩展这个循环，在其中添加一个 elif 代码块，将黄色外星人改为移动速度
快且值 15 分的红色外星人，如下所示：
'''
aliens = []
# 创建 30 个绿色的外星人
for alien_numbers in range(5):
    new_alien = {'color': 'yellow', 'points': 5, 'speed': 'slow'}
    aliens.append(new_alien)
for alien_numbers in range(25):
    new_alien = {'color': 'green', 'points': 5, 'speed': 'slow'}
    aliens.append(new_alien)
for alien in aliens[:15]:
    if alien['color'] == 'green':
        alien['color'] = 'yellow'
        alien['speed'] = 'medium'
        alien['points'] = 10
    elif alien['color'] == 'yellow':
        alien['color'] = 'red'
        alien['speed'] = 'fast'
        alien['points'] = 15
# 显示前 10 个外星人
for alien in aliens[:10]:
    print(alien)
print("...")
print()
# 在字典中存储列表
'''
有时候，需要将列表存储在字典中，而不是将字典存储在列表中。例如，如何描述顾
客点的比萨呢？如果使用列表，只能存储要添加的比萨配料；但如果使用字典，其中
的配料列表就只是用来描述比萨的一个方面。
'''
'''
在下面的示例中，存储了比萨两个方面的信息：外皮类型和配料列表。配料列表是一
个与键 'toppings' 关联的值。要访问该列表，我们使用字典名和键
'toppings'，就像访问字典中的其他值一样。这将返回一个配料列表，而不是单个
值：
'''
# 存储顾客所点比萨的信息
pizza = {
    'crust': 'thick',
    'toppings': ['mushrooms', 'extra cheese'],
}
# 概述顾客点的比萨
print(f"You ordered a {pizza['crust']}-crust pizza "
 "with the following toppings:")
for topping in pizza['toppings']:
    print(f"\t{topping}")
print()
'''
每当需要在字典中将一个键关联到多个值时，都可以在字典中嵌套一个列表。在本章
前面有关喜欢的编程语言的示例中，如果将每个人的回答都存储在一个列表中，被调
查者就可以选择多种喜欢的语言。在这种情况下，当我们遍历字典时，与每个被调查
者关联的都是一个语言列表，而不是一种语言。因此，在遍历该字典的 for 循环中，
需要再使用一个 for 循环来遍历与被调查者关联的语言列表：
'''
favorite_languages = {
 'jen': ['python', 'rust'],
 'sarah': ['c'],
 'edward': ['rust', 'go'],
 'phil': ['python', 'haskell'],
 }
for name, languages in favorite_languages.items():
    print(f"\n{name.title()}'s favorite languages are:")
    for language in languages:
        print(f"\t{language.title()}")
print("-----")
# 在字典中存储字典
'''
可以在字典中嵌套字典，但这样可能会让代码很快变得非常复杂。如果有一网站有多
个用户，每个用户都有独特的用户名，可在字典中将用户名作为键，然后将每个用户
的信息存储在一个字典中，并将该字典作为与用户名关联的值。在下面的程序中，存
储每个用户的三项信息：名、姓和居住地。为了访问这些信息，我们遍历所有的用户
名，并访问与每个用户名关联的信息字典：
'''
users = {
 'aeinstein': {
 'first': 'albert',
 'last': 'einstein',
 'location': 'princeton',
 },
 'mcurie': {
 'first': 'marie',
 'last': 'curie',
 'location': 'paris',
 },
 }
for username, user_info in users.items():
    print(f"\nUsername: {username}")
    full_name = f"{user_info['first']} {user_info['last']}"
    location = user_info['location']
    print(f"\tFull name: {full_name.title()}")
    print(f"\tLocation: {location.title()}")

"""
使用一个字典来存储一个人的信息，包括名、姓、年龄和居住的城
市。该字典应包含键 first_name、last_name、age 和 city。将存储在该字
典中的每项信息都打印出来。
"""
person = {
    'first_name': '鸣人',
    'last_name': '旋涡',
    'age': 18,
    'city': '木叶村',
}
print(person['first_name'])
print(person['last_name'])
print(person['age'])
print(person['city'])
print()
"""
使用一个字典来存储一些人喜欢的数。请想出 5 个人的名
字，并将这些名字用作字典中的键。再想出每个人喜欢的一个数，并将这些数作
为值存储在字典中。打印每个人的名字和喜欢的数。为了让这个程序更有趣，通
过询问朋友确保数据是真实的。
"""
favorite_numbers = {
    '小明': 7,
    '李华': 3,
    '张伟': 42,
    '王芳': 13,
    '赵敏': 28
}
# 打印结果
print("【朋友喜欢的数字】")
for name,number in favorite_numbers.items():
    print(f"{name} 喜欢的数字是 {number}")
print()
"""
在 Python 中，items() 是字典（dict）对象的内置方法，用于返回一个包含字典所有键值对的视图对象（view object）。
这个视图对象以可遍历的 (键, 值) 元组形式存在，常用于同时访问字典的键和值。
核心作用
1、遍历键值对：在 for 循环中同时获取字典的键（key）和值（value）
2、动态视图：返回的视图会实时反映字典的修改（与 Python 3 的行为一致）
3、数据转换：可轻松将字典转换为列表、元组或其他数据结构
"""
# ------------补充：
# 创建一个字典
person = {"name": "Alice", "age": 30, "city": "New York"}

# 使用 items() 方法
items_view = person.items()
print(items_view)  # 输出：dict_items([('name', 'Alice'), ('age', 30), ('city', 'New York')])

# 遍历键值对
for key, value in person.items():
    print(f"{key}: {value}")
# 进阶用法
# 1. 转换为其他数据结构
# 转换为列表
items_list = list(person.items())
print(items_list)
# 结果：[('name', 'Alice'), ('age', 30), ('city', 'New York')]

# 转换为元组
items_tuple = tuple(person.items())
print(items_tuple)

# 2. 字典推导式配合使用
# 将值转换为字符串格式
new_dict = {k: str(v) for k, v in person.items()}
print(new_dict)
# 结果：{'name': 'Alice', 'age': '30', 'city': 'New York'}

# 3. 检查键值对是否存在
if ('age', 30) in person.items():
    print("包含年龄30的记录")  # 会执行

# 修改字典时的行为：
person = {"a": 1, "b": 2,}
items = person.items()
print(items)
person["c"] = 3  # 修改字典
print(items)      # 输出包含 ('c', 3)

# 实际应用场景
# 数据遍历：
config = {"host": "localhost", "port": 8080, "debug": True}
for param, value in config.items():
    print(f"正在配置 {param} -> {value}")
# API 数据处理：
"""
response = {"status": 200, "data": {"user_id": 123}, "error": None}
for key, val in response.items():
    if key == "data" and val:
        process_user_data(val)
"""
# 字典转换工具：
"""
def dict_to_table(data):
    headers = data.keys()
    rows = data.values()
    # 生成表格代码...
"""
print()
#  动手试一试
"""
Python 字典可用于模拟现实生活中的字典。为避免混淆，我
们将后者称为词汇表。
1、想出你在前面学过的 5 个编程术语，将它们用作词汇表中的键，并将它们的
含义作为值存储在词汇表中。
2、以整洁的方式打印每个术语及其含义。为此，既可以先打印术语，在它后面
加上一个冒号，再打印其含义；也可以先在一行里打印术语，再使用换行符
（\n）插入一个空行，然后在下一行里以缩进的方式打印其含义。
"""
glossary = {
 'string': 'A series of characters.',
 'comment': 'A note in a program that the Python interpreter ignores.',
 'list': 'A collection of items in a particular order.',
 'loop': 'Work through a collection of items, one at a time.',
 'dictionary': "A collection of key-value pairs.",
 }
word = 'string'
print(f"\n{word.title()}: {glossary[word]}")
word = 'comment'
print(f"\n{word.title()}: {glossary[word]}")
word = 'list'
print(f"\n{word.title()}: {glossary[word]}")
word = 'loop'
print(f"\n{word.title()}: {glossary[word]}")
word = 'dictionary'
print(f"\n{word.title()}: {glossary[word]}")
print()
'''
现在你知道了如何遍历字典，请整理你为上面练习 编写的代
码，将其中的一系列函数调用 print() 替换为一个遍历字典中键和值的循环。确
保该循环正确无误后，再在词汇表中添加 5 个 Python 术语。当你再次运行这个程
序时，这些新术语及其含义将自动包含在输出中。
'''
glossary = {
 'string': 'A series of characters.',
 'comment': 'A note in a program that the Python interpreter ignores.',
 'list': 'A collection of items in a particular order.',
 'loop': 'Work through a collection of items, one at a time.',
 'dictionary': "A collection of key-value pairs.",
 'key': 'The first item in a key-value pair in a dictionary.',
 'value': 'An item associated with a key in a dictionary.',
 'conditional test': 'A comparison between two values.',
 'float': 'A numerical value with a decimal component.',
 'boolean expression': 'An expression that evaluates to True or False.',
 }
for word, definition in glossary.items():
    print(f"\n{word.title()}: {definition}")
print()
'''
创建一个字典，在其中存储三条河流及其流经的国家。例如，一
个键值对可能是 'nile': 'egypt'。
使用循环为每条河流打印一条消息，如下所示。
The Nile runs through Egypt.
使用循环将该字典中每条河流的名字打印出来。
使用循环将该字典包含的每个国家的名字打印出来。
'''
# 创建河流字典
rivers = {
    'nile': 'egypt',
    'amazon': 'brazil',
    'yangtze': 'china'
}
# 打印河流流经国家信息
print("【河流与流经国家】")
for river, country in rivers.items():
    print(f"The {river.title()} runs through {country.title()}.")
# 打印所有河流名称
print("\n【河流名称列表】")
for river in rivers.keys():
    print(river.title())
# 打印所有国家名称
print("\n【国家名称列表】")
for country in rivers.values():
    print(country.title())
# 扩展
# 添加多国家支持（使用列表存储多个国家）
rivers_advanced = {
    'nile': ['egypt', 'sudan', 'uganda'],
    'amazon': ['brazil', 'peru', 'colombia'],
    'danube': ['germany', 'austria', 'hungary']
}
print("\n【河流流经多国家】")
for river, countries in rivers_advanced.items():
    countries_str = ', '.join(country.title() for country in countries)
    print(f"The {river.title()} flows through: {countries_str}")
print()
'''
在 6.3.1 节编写的程序 favorite_languages.py 中执行以下操作。
创建一个应该会接受调查的人的名单，其中有些人已在字典中，而其他人不
在字典中。
遍历这个名单。对于已参与调查的人，打印一条消息表示感谢；对于还未参
与调查的人，打印一条邀请参加调查的消息。
'''
favorite_languages = {
 'jen': 'python',
 'sarah': 'c',
 'edward': 'ruby',
 'phil': 'python',
 }
for name, language in favorite_languages.items():
 print(f"{name.title()}'s favorite language is {language.title()}.")
print()
coders = ['phil', 'josh', 'david', 'becca', 'sarah', 'matt', 'danielle']
for coder in coders:
 if coder in favorite_languages.keys():
    print(f"Thank you for taking the poll, {coder.title()}!")
 else:
    print(f"{coder.title()}, what's your favorite programming language?")
print()

'''
在为练习 6.1 编写的程序中，再创建两个表示人的字典，然后将
这三个字典都存储在一个名为 people 的列表中。遍历这个列表，将其中每个人
的所有信息都打印出来。
'''
# 创建一个用于存储人的空列表
people = []
# 定义一些人并将他们添加到前述列表中。
person = {
    'first_name': 'eric',
    'last_name': 'mattes',
    'age': 46,
    'city': 'sitka',
 }
people.append(person)
person = {
    'first_name': 'lemmy',
    'last_name': 'mattes',
    'age': 2,
    'city': 'sitka',
 }
people.append(person)
person = {
    'first_name': 'willie',
    'last_name': 'mattes',
    'age': 11,
    'city': 'sitka',
 }
people.append(person)
# 显示列表包含的每个字典中的信息。
for person in people:
    name = f"{person['first_name'].title()} {person['last_name']}"
    age = person['age']
    city = person['city'].title()
    print(f"{name}, of {city}, is {age} years old.")
'''
创建多个表示宠物的字典，每个字典都包含宠物的类型及其主人
的名字。将这些字典存储在一个名为 pets 的列表中，再遍历该列表，并将有关
每个宠物的所有信息打印出来。
'''
# 创建一个用于存储宠物的空列表。
pets = []
# 定义各个宠物并将其存储到列表中。
pet = {
    'animal type': 'python',
    'name': 'john',
    'owner': 'guido',
    'weight': 43,
    'eats': 'bugs',
}
pets.append(pet)
pet = {
    'animal type': 'chicken',
    'name': 'clarence',
    'owner': 'tiffany',
    'weight': 2,
    'eats': 'seeds',
}
pets.append(pet)
pet = {
    'animal type': 'dog',
    'name': 'peso',
    'owner': 'eric',
    'weight': 37,
    'eats': 'shoes',
}
pets.append(pet)
# 显示每个宠物的信息。
for pet in pets:
    print(f"\nHere's what I know about {pet['name'].title()}:")
    for key,value in pet.items():
        print(f"\t{key}: {value}")
'''
创建一个名为 favorite_places 的字典。在这个字典
中，将三个人的名字用作键，并存储每个人喜欢的 1～3 个地方。为让这个练习更
有趣些，让一些朋友说出他们喜欢的几个地方。遍历这个字典，并将其中每个人
的名字及其喜欢的地方打印出来。
'''
favorite_places = {
 'eric': ['bear mountain', 'death valley', 'tierra del fuego'],
 'erin': ['hawaii', 'iceland'],
 'willie': ['mt. verstovia', 'the playground', 'new hampshire']
 }
for name,places in favorite_places.items():
    print(f"\n{name.title()} likes the following places:")
    for place in places:
        print(f"- {place.title()}")
print()
'''
修改为练习 6.2 编写的程序，让每个人都可以有多个喜欢
的数字，然后将每个人的名字及其喜欢的数打印出来。
'''
favorite_numbers = {
 'mandy': [42, 17],
 'micah': [42, 39, 56],
 'gus': [7, 12],
 }
for name,numbers in favorite_numbers.items():
    print(f"\n{name.title()} likes the following numbers:")
    for number in numbers:
        print(f" {number}")
print()
'''
创建一个名为 cities 的字典，将三个城市名用作键。对于每
座城市，都创建一个字典，并在其中包含该城市所属的国家、人口约数以及一个
有关该城市的事实。表示每座城市的字典都应包含 country、population 和
fact 等键。将每座城市的名字以及相关信息都打印出来。
'''
# 创建包含三个中国城市的字典
cities = {
    'Beijing': {
        'country': 'China',
        'population': 21_500_000,
        'fact': 'Capital of China and home to the Forbidden City.'
    },
    'Shanghai': {
        'country': 'China',
        'population': 24_870_000,
        'fact': 'A global financial center with the iconic Oriental Pearl Tower.'
    },
    'Guangzhou': {
        'country': 'China',
        'population': 18_670_000,
        'fact': 'Famous for Cantonese cuisine and the annual Canton Fair.'
    }
}
# 遍历字典并打印信息
for city,info in cities.items():
    print(f"\nCity: {city}")
    print(f"  Country: {info['country']}")
    print(f"  Population: {info['population']:,}")  # 使用逗号格式化人口数字
    print(f"  Fact: {info['fact']}")
# ------------------- 补充：
# {info['population']:,} 的语法含义是：
'''
冒号后的 `:,` 是格式规范（format specifier）
{变量:格式规则}
'''
# 具体解释
# 1、, 的作用
'''
在数字中添加千位分隔符（如 21,500,000），使大数字更易读。

这是 Python 中一种标准化的数字格式化方式。
'''
# 2、语法细节
value = 21500000
print(f"{value:,}")  # 输出 "21,500,000"
"""
value 必须是整数或浮点数，否则会报错。
默认使用逗号分隔，但本地化设置可能会影响符号（如某些语言环境用 . 或空格）。
"""
money = 1234567.89
print(f"{money:,.2f}")  # 输出 "1,234,567.89"
print()