1 篇博文含有标签「python」

Python编程：从入门到实践(第3版)

2025年7月24日 · 阅读需 45 分钟

Hanbin Che

Front End Engineer

简介

"Python 三剑客"之一，豆瓣评分 9.3；另外两剑客为《Python 编程快速上手 —— 让繁琐工作自动化》和《Python 极客项目编程》第二版

书名：《Python 编程：从入门到实践》
作者：[美]埃里克·马瑟斯
时间：2023-05-01
出版社：人民邮电出版社

第一部分基础知识

第 1 章起步

第 2 章变量和简单的数据类型

第 3 章列表简介

第 4 章操作列表

4.1 遍历整个列表

for 循环语法

for item in items:
  operation_1
  operation_2
  ...
  operation_n

冒号后面的每一行缩进语句都是 for 循环每次执行的代码

使用循环打印魔术师的名字

magicians.py

magicians = ["alice", "david", "carolina"]
for magician in magicians:
    print(f"{magician.title()}, that was a great trick!.")
    print(f"I cat't wait to see your next trick, {magician.title()}\n")

4.1.1 深入研究循环

magicians.py

magicians = ["alice", "david", "carolina"]
for magician in magicians:
    print(f"{magician.title()}, that was a great trick!.")

4.1.2 在 for 循环中执行更多操作

for 循环中每个缩进行都是循环的一部分，将在每次循环时都执行一次

magicians.py

magicians = ["alice", "david", "carolina"]
for magician in magicians:
    print(f"{magician.title()}, that was a great trick!.")
    print(f"I cat't wait to see your next trick, {magician.title()}\n")

4.1.3 在 for 循环结束之后执行一些操作

for 循环后，没有缩进的代码不属于循环的一部分，只执行一次，可作为循环结束后的逻辑。

magicians = ["alice", "david", "carolina"]
for magician in magicians:
    print(f"{magician.title()}, that was a great trick!")
    print(f"I can't wait to see your next trick, {magician.title()}.\n")
print("Thank you, everyone. That was a great magic show!")

4.2 避免缩进错误

Python 根据缩进来判断代码行与程序其他部分的关系。

4.2.1 忘记缩进

位于 for 语句后面且属于循环组成部分的代码行，一定要缩进。

4.2.2 忘记缩进额外的代码行

有时候循环可以正常执行，但结果出人意料。当试图在循环中执行多项操作时，却忘记缩进其中一些操作，就会出现这种情况。

magicians = ['alice', 'david', 'carolina']
for magician in magicians:
    print(f"{magician.title()}, that was great trick!")
print(f"I cant't wait to see your next trick, {magician.title()}.\n")

第二个 print 原本需要缩进，但是 Python 发现 for 语句后面有一行代码是缩进的，因此没有报错。最终结果是如下，只有最后一个魔术师收到了消息"I can't wait to see your next trick":

Alice, that was great trick!
David, that was great trick!
Carolina, that was great trick!
I cant't wait to see your next trick, Carolina.

这是一个逻辑错误。

4.2.3 不必要的缩进

如果不小心缩进了无须缩进的代码行，Python 将指出这一点：

message = "Hello Python World!"
    print(message)

调用 print 无须缩进，因为它并非循环的一部分，因此 Python 将指出这种错误：

  File "hello_world.py", line 2
    print(message)
IndentationError: unexpected indent

4.2.4 循环后不必要的缩进

如果不小心缩进了在循环结束后执行的代码，这些代码将在每个循环重复执行。也会造成逻辑错误。

magicians = ['alice', 'david', 'carolina']
for magician in magicians:
    print(f"{magician.title()}, that was great trick!")
    print(f"I cant't wait to see your next trick, {magician.title()}.\n")
    print("Thank you everyone, that was a great magic show!")

由于最后一行也缩进了，它将针对列表中的每位魔术师执行一次：

Alice, that was great trick!
I cant't wait to see your next trick, Alice.

Thank you everyone, that was a great magic show!
David, that was great trick!
I cant't wait to see your next trick, David.

Thank you everyone, that was a great magic show!
Carolina, that was great trick!
I cant't wait to see your next trick, Carolina.

Thank you everyone, that was a great magic show!

这也是一个逻辑错误。

4.2.5 遗漏冒号

for 语句末尾的冒号告诉 Python，下一行是循环的第一行。

magicians = ['alice', 'david', 'carolina']
for magician in magicians
    print(magician)

如果不小心漏了冒号，将导致 Python 语法错误。

  File "magicians.py", line 2
    for magician in magicians
                             ^
SyntaxError: expected ':'

4.2.6 动手试一试

# 练习4.1：比萨　想出至少三种你喜欢的比萨，将其名称存储在一个列表中，再使用for循环将每种比萨的名称打印出来。
# • 修改这个for循环，使其打印包含比萨名称的句子，而不仅仅是比萨的名称。对于每种比萨都显示一行输出，如下所示。I like pepperoni pizza.
# • 在程序末尾添加一行代码（不包含在for循环中）​，指出你有多喜欢比萨。输出应包含针对每种比萨的消息，还有一个总结性的句子，如下所示。I really love pizza!

# pizzas = ['Margherita', 'Pepperoni', 'BBQ Chicken']
# for pizza in pizzas:
#     print(f"I like {pizza} pizza")
# print("I really love pizza!")

# 练习4.2：动物　想出至少三种有共同特征的动物，将其名称存储在一个列表中，再使用for循环将每种动物的名称打印出来
# • 修改这个程序，使其针对每种动物都打印一个句子，如下所示。A dog would make a great pet.
# • 在程序末尾添加一行代码，指出这些动物的共同之处，如打印下面这样的句子。Any of these animals would make a great pet!
animals = ['dog', 'peg', 'cat', 'bird']
for animal in animals:
    print(f"A {animal.title()} would make a great pet.")
print("Any of these animals would make a great pet!")

4.3 创建数值列表

列表非常适合存储数据集合，Python 给我们提供了很多高效的工具处理数值列表。

4.3.1 使用 range()函数

可以像下面这用使用 range() 函数来打印一些列的数：

for value in range(1, 5):
    print(value)

上述代码打印 1~4 之间的数字，不包含 5。在调用 range 函数时，也可以只指定一个参数，这样它将从 0 开始生成对应参数的整数列表。

for value in range(6):
  print(value)

上述返回 0~5 （含）之间的整数列表。

4.3.2 使用 range() 创建数值列表

要创建数值列表，可使用 list()函数将 range()函数的结果直接转换成数值列表。如果将 range()函数的结果作为 list()函数的参数，输出将是一个数值列表。

numbers = list(range(1, 6))
print(numbers)

创建 1~10 之间整数的平方列表

values = []
for value in range(1, 11):
    values.append(value ** 2)
print(values)

4.3.3 对数值列表执行简单的统计计算

最大值、最小值和求和

values = []
for value in range(1, 11):
    values.append(value ** 2)

print(values)
print(f"The max number of values is: {max(values)}")
print(f"The sum of values is: {sum(values)}")
print(f"The min number of values is: {min(values)}")

4.3.4 列表推导式

列表推导式将 for 循环和创建新元素的代码合并成一行。

# 列表推导式：将for循环和列表生成结合成一句话，生成列表

squares = [value ** 2 for value in range(2, 11, 2)]
print(squares)

4.3.5 动手练一练

# # 练习4.3：数到20　使用一个for循环打印数1～20（含）​。
# values = list(range(1, 21))
# for value in values:
#     print(value)

# # 练习4.4: 100万　创建一个包含数1～1 000 000的列表，再使用一个for循环将这些数打印出来。​（如果输出的时间太长，按Ctrl + C停止输出，或关闭输出窗口。​）
# values = range(1, 1_000_001)
# for value in values:
#     print(value)

# # 练习4.5: 100万求和　创建一个包含数1～1 000 000的列表，再使用min()和max()核实该列表确实是从1开始、到1 000 000结束的。另外，对这个列表调用函数sum()，看看Python将100万个数相加需要多长时间。
# values = range(1, 1_000_001)
# print(min(values))
# print(max(values))
# print(sum(values))

# # 练习4.6：奇数　通过给range()函数指定第三个参数来创建一个列表，其中包含1～20的奇数；再使用一个for循环将这些数打印出来。
# odds = range(1, 20, 1)
# for odd in odds:
#     print(odd)

# # 练习4.7: 3的倍数　创建一个列表，其中包含3～30内能被3整除的数，再使用一个for循环将这个列表中的数打印出来。
# values = range(3, 31, 3)
# for value in values:
#     print(value)

# # 练习4.8：立方　将同一个数乘三次称为立方。例如，在Python中，2的立方用2**3表示。创建一个列表，其中包含前10个整数(1～10)的立方，再使用一个for循环将这些立方数打印出来。
# values = []
# for value in range(1, 11):
#     num = value ** 3
#     values.append(num)
#     print(num)

# # 练习4.9：立方推导式　使用列表推导式生成一个列表，其中包含前10个整数的立方。
# values = [value ** 3 for value in range(1, 11)]
# for value in values:
#     print(value)

4.4 使用列表的一部分

在 Python 中，我们可以处理列表的部分元素，在 Python 中列表的部分元素称为切片

4.4.1 切片

要创建切片，可指定要获取切片范围的第一个参数和最后一个参数的索引。与 range 函数相似，Python 在到达指定的第二个索引之前的元素时就停止了。

players = ["charles", "martina", "michael", "florence", "eli"]
# 获取前三个元素
print(players[0: 3])

我们可以生成列表的任意子集。

players = ["charles", "martina", "michael", "florence", "eli"]
# 获取第二、三、四索引对应的元素
print(players[1:4])

如果没有指定第一个索引，Python 将自动从列表开头开始提取：

players = ["charles", "martina", "michael", "florence", "eli"]
print(players[:4])

也可省略第二个索引，Python 将从第一个索引开始，直接到列表的结尾。

players = ["charles", "martina", "michael", "florence", "eli"]
# 将取第三个元素到结尾之间的元素
print(players[2:])

参数可以为负数，负数表示从结尾倒数的索引

players = ["charles", "martina", "michael", "florence", "eli"]
# 从倒数第三个开始到结尾之间的元素
print(players[-3:])

还可在切片的中括号内指定第三个参数，指定切片在指定范围内的步长，每相隔多少个元素取一个作为切片的元素。

players = ["charles", "martina", "michael", "florence", "eli"]
# 可以指定切片的第三个参数，表示指定范围切片每相隔几个元素取下一个元素
print(players[0::2])

# 输出
# ['charles', 'michael', 'eli']

4.4.2 遍历切片

可使用 for 循环遍历切片。

players = ["charles", "martina", "michael", "florence", "eli"]
print("Here are the first three players on my team:")
for player in players[:3]:
    print(player.title())

4.4.3 复制列表

要复制列表，可以创建一个包含整个列表的切片，方法是同时省略起始和终止索引（[:]）。

my_foods = ["pizza", "falafel", "carrot cake"]
friend_foods = my_foods[:]

print(f"My favorite foods are: \n{my_foods}\n")
print(f"My friend favorite foods are: \n{friend_foods}")

为了核实确实是两个独立的列表，我们在每个列表中添加一个食品：

my_foods = ["pizza", "falafel", "carrot cake"]
friend_foods = my_foods[:]

my_foods.append("cannoli")
friend_foods.append("ice cream")

print(f"My favorite foods are: \n{my_foods}\n")
print(f"My friend favorite foods are: \n{friend_foods}")

输出：

My favorite foods are:
['pizza', 'falafel', 'carrot cake', 'cannoli']

My friend favorite foods are:
['pizza', 'falafel', 'carrot cake', 'ice cream']

4.4.4 动手试一试

# 练习4.10：切片　选择你在本章编写的一个程序，在末尾添加几行代码，以完成如下任务。
# • 打印消息“The first three items in the list are:”​，再使用切片来打印列表的前三个元素。
# • 打印消息“Three items from the middle of the list are:”​，再使用切片来打印列表中间的三个元素。
# • 打印消息“The last three items in the list are:”​，再使用切片来打印列表末尾的三个元素。

available_toppings = ['mushrooms', 'olives', 'green peppers', 'pepperoni', 'pineapple' ]

print(f"The first three items in the list are: {available_toppings[:3]}")
print(f"Three items from the middle of the list are: {available_toppings[2:5]}")
print(f"The last three items in the list are: {available_toppings[-3:]}")


# 练习4.11：你的比萨，我的比萨　在你为练习4.1编写的程序中，创建比萨列表的副本，并将其赋给变量friend_pizzas，再完成如下任务。
# • 在原来的比萨列表中添加一种比萨。
# • 在列表friend_pizzas中添加另一种比萨。
# • 核实有两个不同的列表。为此，打印消息“My favorite pizzas are:”​，再使用一个for循环来打印第一个列表；打印消息“My friend's favorite pizzas are:”​，再使用一个for循环来打印第二个列表。核实新增的比萨被添加到了正确的列表中。


# 练习4.12：使用多个循环　在本节中，为节省篇幅，程序foods.py的每个版本都没有使用for循环来打印列表。请选择一个版本的foods.py，在其中编写两个for循环，将各个食品列表都打印出来。

4.5 元组

列表非常适合存储在运行期间可能变化的数据集。列表是可以修改的。然后，有时候需要创建一组不可修改的数据集，元组可满足这种需求。

4.5.1 定义元组

元组看起来和列表很像，但是使用圆括号而不是方括号来标识。定义元组后，就可以使用索引访问其元素，就行访问列表一样。

# 定义一个元组存储矩形的长宽
dimensions = (200, 50)
print(dimensions[0])
print(dimensions[1])

下面尝试修改元组的元素：

dimensions[0] = 300

如果尝试修改元组中元素的值，将导致 Python 返回类型错误的消息。

200
50
Traceback (most recent call last):
  File "dimensions.py", line 5, in <module>
    dimensions[0] = 300
    ~~~~~~~~~~^^^
TypeError: 'tuple' object does not support item assignment

注意：严格地说，元组是由逗号标识的，圆括号只是让元组看起来更整洁、更清晰。如果你要定义只包含一个元素的元组，必须在这个元素后面加上逗号:

my_t = (3,)

创建只包含一个元素的元组通常没有意义，但自动生成的元组有可能只有一个元素。

4.5.2 便利元组中的所有值

像列表一样，也可以使用 for 循环来遍历元组中的所有值：

dimensions = (200, 50)
for dimension in dimensions:
    print(dimension)

就像遍历列表时一样，Python 返回元组中的所有元素：

200
50

4.5.3 修改元组变量

虽然不能修改元组的元素，但是可以给表示元组的变量重新赋值。例如，要修改前述矩形的尺寸，可重新定义整个元组：

dimensions = (200, 50)
print("Original dimensions:")
for dimension in dimensions:
    print(dimension)
dimensions = (400, 100)
print("\nModified dimensions:")
for dimension in dimensions:
    print(dimension)

输出：

Original dimensions:
200
50

Modified dimensions:
400
100

相比列表，元组是更简单的数据结构。如果需要存储一组在程序生命周期内都不可变的集合，就可以使用元组。

4.5.4 动手试一试

# 练习4.13：自助餐　有一家自助式餐馆，只提供5种简单的食品。请想出5种简单的食品，并将其存储在一个元组中。
# • 使用一个for循环将该餐馆提供的5种食品都打印出来。
# • 尝试修改其中的一个元素，核实Python确实会拒绝你这样做。
# • 餐馆调整菜单，替换了两种食品。请编写一行给元组变量赋值的代码，并使用一个for循环将新元组的每个元素都打印出来。

foods = ("Grilled Chicken","Caesar Salad","Spaghetti Bolognese","Beef Burger","French Fries")
print("Original foods:")
for food in foods:
    print(food)

# # 尝试修改食谱，将 烤鸡肉 修改为 红烧鱼
# foods[0] = 'Soy-Braised Fish'

foods = ("Soy-Braised Fish","Rice Noodles","Spaghetti Bolognese","Beef Burger","French Fries")
print("\nImproved foods:")
for food in foods:
    print(food)

第 5 章 if 语句

在 Python 中，if 语句能够让我们检查程序的当前状态，并采取相应的措施。

5.1 一个简单的示例

cars = ['audi', 'bmw', 'subaru', 'toyota']

for car in cars:
    if car == 'bmw':
        print(car.upper())
    else:
        print(car.title())

5.2 条件测试

每条 if 语句的核心都是一个值为 True 或 False 的表达式，这种表达式称为条件测试。Python 根据条件测试的值是 True 或 False 来决定是否执行 if 语句中的代码。如果条件测试的值为 True，Python 就会执行紧跟在 if 语句后面的代码；否则就会忽略这些代码。

5.2.1 检查是否相等

car = 'Audi'
car == 'Audi'
# True

5.2.2 如何在检查是否相等是忽略大小写

car = 'Audi'
car.lower() == 'audi'
# True

5.2.3 检查是否不等

request_topping = 'mushrooms'
if request_topping != 'anchovies':
    print('Hold the anchovies!')

5.2.4 数值比较

answer = 17
if answer != 42:
    print("That is not the correct answer. Please try again!")

5.2.5 检查多个条件

使用 and 检查多个条件

age_0 = 22
age_1 = 18
(age_0 >= 21) and (age_1 >= 21)
# False
age_1 = 22
age_0 >= 21 and age_1 >= 21
# True

使用 or 检查多个条件

age_0 = 22
age_1 = 18
age_0 >= 21 or age_1 >= 21
# True
age_0 = 18
age_0 >= 21 or age_1 >= 21
# False

5.2.6 检查特定的值是否在列表中

requested_toppings = ['mushrooms', 'onions', 'pineapple']
'mushrooms' in requested_toppings
# True
'pepperoni' in requested_toppings
# False

5.2.7 检查特定的值是否不在列表中

banned_users = ['andrew', 'carolina', 'david']
user = 'marie'

if user not in banned_users:
    print(f"{user.title()}, you can post a response if you wish.")

5.2.8 布尔表达式

game_active = True
can_edit = False

5.2.9 动手试一试

# 练习5.1：条件测试　编写一系列条件测试，将每个条件测试以及你对其结果的预测和实际结果都打印出来。你编写的代码应类似于下面这样：
# car = 'subaru'
# print("Is car == 'subaru'? I predict True.")
# print(car == 'subaru')
# print("\nIs car == 'audi'? I predict False.")
# print(car == 'audi')
# • 详细研究实际结果，直到你明白它为何为True或False。
# • 创建至少10个条件测试，而且结果为True和False的条件测试分别至少有5个。

# 练习5.2：更多条件测试　你并非只能创建10个条件测试。如果想尝试做更多的比较，可再编写一些条件测试，并将它们加入conditional_tests.py。对于下面列出的各种情况，至少编写两个条件测试，结果分别为True和False。
# • 检查两个字符串是否相等和不等。
# • 使用lower()方法的条件测试。
# • 涉及相等、不等、大于、小于、大于等于和小于等于的数值比较。
# • 使用关键字and和or的条件测试。
# • 测试特定的值是否在列表中。
# • 测试特定的值是否不在列表中。

5.3 if 语句

5.3.1 简单的 if 语句

age = 19
vote = 18
if age >= vote:
    print("You are old enough to vote!")
print("Have you registered to vote yet?")

5.3.2 if-else 语句

age = 19
vote = 18
if age >= vote:
    print("You are old enough to vote!")
    print("Have you registered to vote yet?")
else:
    print("Sorry, you are too young to vote.")
    print("Please register to vote as soon as you turn 18!")

5.3.3 if- elif-else 语句

游乐场根据年龄段收费：

4 岁以下免费。
4（含）～ 18 岁收费 25 美元。
年满 18 岁收费 40 美元。

age = 12
if age < 4:
    print("Your admission cost is $0.")
elif age < 18:
    print("Your admission cost is $25")
else:
    print("Your admission cost is $40.")

优化版：

age = 12
if age < 4:
    price = 0
elif age < 18:
    price = 25
else:
    price = 40
print(f"Your admission cost is ${price}.")

5.3.4 使用多个 elif 代码块

修改游乐场收费规则，新增 65 岁以上人员 20$。

age = 12
if age < 4:
    price = 0
elif age < 18:
    price = 25
elif age < 65:
    price = 40
else:
    price = 20
print(f"Your admission cost is ${price}.")

5.3.5 省略 else 代码块

Python 没有要求 if-elif结构后面必须有 else 代码结构。有时候使用 elif 逻辑更清晰：

age = 12
if age < 4:
    price = 0
elif age < 18:
    price = 25
elif age < 65:
    price = 40
elif age >= 65:
    price = 20
print(f"Your admission cost is ${price}.")

5.3.6 测试多个条件

requested_toppings = ['mushrooms', 'extra_cheese']
if 'mushrooms' in requested_toppings:
    print("Add mushrooms.")
if 'pepperoni' in requested_toppings:
    print("Add pepperoni.")
if 'extra_cheese' in requested_toppings:
    print("Add extra_cheese.")
print("\nFinished making your pizza!")

5.3.7 动手试一试

# 练习5.3：外星人颜色1　假设玩家在游戏中消灭了一个外星人，请创建一个名为alien_color的变量，并将其赋值为'green'、'yellow'或'red'。
# • 编写一条if语句，测试外星人是否是绿色的。如果是，就打印一条消息，指出玩家获得了5分。
# • 编写这个程序的两个版本，上述条件测试在其中的一个版本中通过，在另一个版本中未通过（未通过条件测试时没有输出）​。
# alien_color = 'red'
# if alien_color == 'green':
#     print("You get 5")
# elif alien_color == 'yellow':
#     print("You get 10")
# elif alien_color == 'red':
#     print("You get 15")

# 练习5.4：外星人颜色2　像练习5.3那样设置外星人的颜色，并编写一个if-else结构。
# • 如果外星人是绿色的，就打印一条消息，指出玩家因消灭该外星人获得了5分。
# • 如果外星人不是绿色的，就打印一条消息，指出玩家获得了10分。
# • 编写这个程序的两个版本，在一个版本中将执行if代码块，在另一个版本中将执行else代码块。

# 练习5.5：外星人颜色3　将练习5.4中的if-else结构改为if-elif-else结构。
# • 如果外星人是绿色的，就打印一条消息，指出玩家获得了5分。
# • 如果外星人是黄色的，就打印一条消息，指出玩家获得了10分。
# • 如果外星人是红色的，就打印一条消息，指出玩家获得了15分。
# • 编写这个程序的三个版本，分别在外星人为绿色、黄色和红色时打印一条消息。

# 练习5.6：人生的不同阶段　设置变量age的值，再编写一个if-elif-else结构，根据age的值判断这个人处于人生的哪个阶段。
# • 如果年龄小于2岁，就打印一条消息，指出这个人是婴儿。
# • 如果年龄为2（含）～4岁，就打印一条消息，指出这个人是幼儿。
# • 如果年龄为4（含）～13岁，就打印一条消息，指出这个人是儿童。
# • 如果年龄为13（含）～18岁，就打印一条消息，指出这个人是少年。
# • 如果年龄为18（含）～65岁，就打印一条消息，指出这个人是中青年人。
# • 如果年龄达到65岁，就打印一条消息，指出这个人是老年人。

# age = 29
# if age < 2:
#     age_type = 'infant'
# elif age < 4:
#     age_type = 'toddler'
# elif age < 13:
#     age_type = 'child'
# elif age < 18:
#     age_type = 'juvenile'
# elif age < 65:
#     age_type = 'middle-age and young'
# elif age >= 65:
#     age_type = 'old age'
# print(f"You are {age_type}.")

# 练习5.7：喜欢的水果　创建一个列表，其中包含你喜欢的水果，再编写一系列独立的if语句，检查列表中是否包含特定的水果。
# • 将该列表命名为favorite_fruits，并让其包含三种水果。
# • 编写5条if语句，每条都检查某种水果是否在列表中。如果是，就打印一条像下面这样的消息。You really like bananas!

favorite_fruits = ['apple', 'banana', 'pear', 'watermelon', 'lichee', 'peach']
if 'banana' in favorite_fruits:
    print("You really like banana!")
if 'watermelon' in favorite_fruits:
    print(f"You really like {'watermelon'}!")
if 'lichee' in favorite_fruits:
    print("You really like lichee!")

5.4 使用 if 语句处理列表

5.4.1 检查特殊元素

requested_toppings = ['mushrooms', 'green peppers', 'extra cheese']

for requested_topping in requested_toppings:
    if requested_topping == 'green peppers':
        print("Sorry, we are out of green peppers right now.")
    else:
        print(f"Add {requested_topping}")

5.4.2 确定列表非空

requested_toppings = []
if requested_toppings:
    for requested_topping in requested_toppings:
        print(f"Add {requested_topping}")
else:
    print("Are you sure you want to a plain pizza.")

5.4.3 使用多个列表

available_toppings = ['mushrooms', 'olives', 'green peppers', 'pepperoni', 'pineapple', 'extra cheese']

requested_toppings = ['mushrooms', 'french fires', 'extra cheese']

for requested_topping in requested_toppings:
    if requested_topping not in available_toppings:
        print(f"Sorry, we don't have {requested_topping}")
    else:
        print(f"Add {requested_topping}")
print("\nFinished making your pizza.")

5.4.4 动手练一练

# 练习5.8：以特殊方式跟管理员打招呼　创建一个至少包含5个用户名的列表，并且其中一个用户名为'admin'。想象你要编写代码，在每个用户登录网站后都打印一条问候消息。遍历用户名列表，向每个用户打印一条问候消息。
# • 如果用户名为'admin'，就打印一条特殊的问候消息，如下所示。Hello admin, would you like to see a status report?
# • 否则，打印一条普通的问候消息，如下所示。Hello Jaden, thank you for logging in again.


# users = ['admin', 'tom', 'alice', 'bob', 'jack']
# for user in users:
#     if user == 'admin':
#         print("Hello admin, would you like to see a status report?")
#     else:
#         print(f"Hello {user.title()}, thank you for logging in again.")

# 练习5.9：处理没有用户的情形　在为练习5.8编写的程序中，添加一条if语句，检查用户名列表是否为空。
# • 如果为空，就打印如下消息。We need to find some users!
# • 删除列表中的所有用户名，确认将打印正确的消息。

# # users = ['admin', 'tom', 'alice', 'bob', 'jack']
# users = []
# if users:
#     for user in users:
#         if user == 'admin':
#             print("Hello admin, would you like to see a status report?")
#         else:
#             print(f"Hello {user.title()}, thank you for logging in again.")
# else:
#     print("We need to find some users!")

# 练习5.10：检查用户名　按照下面的说明编写一个程序，模拟网站如何确保每个用户的用户名都独一无二。
# • 创建一个至少包含5个用户名的列表，并将其命名为current_users。
# • 再创建一个包含5个用户名的列表，将其命名为new_users，并确保其中有一两个用户名也在列表current_users中。
# • 遍历列表new_users，检查其中的每个用户名是否已被使用。如果是，就打印一条消息，指出需要输入别的用户名；否则，打印一条消息，指出这个用户名未被使用。
# • 确保比较时不区分大小写。换句话说，如果用户名'John'已被使用，应拒绝用户名'JOHN'。​（为此，需要创建列表current_users的副本，其中包含当前所有用户名的全小写版本。​）

# current_users = ['Admin', 'tom', 'alice', 'bob', 'jack']
# # 使用列表推导式将 current_users 转换成对应的全小写列表
# current_users = [user.lower() for user in current_users]
# new_users = ['TOM', 'jackson', 'Alice', 'lucy', 'lulu']

# for new_user in new_users:
#     if new_user.lower() in current_users:
#         print(f"The username {new_user} is already in use, please change it to a different username.")
#     else:
#         print(f"{new_user}, the username is not used.")


# 练习5.11：序数　序数表示顺序位置，如1st和2nd。序数大多以th结尾，只有1st、2nd、3rd例外。
# • 在一个列表中存储数字1～9。• 遍历这个列表。
# • 在循环中使用一个if-elif-else结构，打印每个数字对应的序数。输出内容应为"1st 2nd 3rd 4th 5th 6th 7th 8th 9th"，每个序数都独占一行。

# order_list = ['1st', '2nd', '3rd', '4th', '5th', '6th', '7th', '8th', '9th']
order_list = list(range(1, 10))
for order in order_list:
    if order == 1:
        print('1st')
    elif order == 2:
        print('2nd')
    elif order == 3:
        print('3rd')
    else:
        print(f"{order}th")

5.5 设置 if 语句的格式

本章的每个示例都展示了良好的格式设置习惯。在条件测试的格式设置方面，PEP 8 提供的唯一建议是：在诸如==、>=和<=等比较运算符两边各添加一个空格。例如：

if age < 4:

要比

if age<4:

好。

这样的空格不会影响 Python 对代码的解读，只是让代码阅读起来更容易。

5.5.1 动手练一练

# 练习5.12：设置if语句的格式　审核你在本章编写的程序，确保正确地设置了条件测试的格式。
# 练习5.13：自己的想法　与刚拿起本书时相比，现在你是一名能力更强的程序员了。鉴于你对如何在程序中模拟现实情形有了更深入的认识，可以考虑使用程序来解决一些问题了。随着编程技能不断提高，你可能想解决一些问题，请将这方面的想法记录下来。想想你可能想编写的游戏，想研究的数据集，以及想创建的Web应用程序。

第 6 章字典

6.1 一个简单的字典

alien_0 = {
    "color": 'red',
    'points': 5
}

print(alien_0['color'])
print(alien_0['points'])

Python 字典字面量 key 必须使用引号包裹，否则会导致 Python 报错。

Traceback (most recent call last):
  File "chapter-06\alien.py", line 3, in <module>
    color: 'red',
    ^^^^^
NameError: name 'color' is not defined

没用引号包裹的 key，Python 认为是一个变量。访问也一样，

6.2 使用字典

在 Python 中，字典是一系列键值对。每个键都一个值关联，可以使用键访问与之关联的值。与键相关联的值可以是数值、字符串、列表甚至是字典。事实上，可以将任意 Python 对象用作字典的值。

在 Python 中字典用放在花括号()中的一系列键值对表示，如前面的示例所在：

aline_0 = {'color': 'green', 'points': 5}

键值之间使用冒号分隔，键值对之间使用逗号分隔，在字典中可以存储多少键值对都可以。

6.2.1 访问字典中的值

要获取字典中与键关联的值，可指定字典名并把键放在字典后面的方括号内，如下所示：

alien_0 = {'color': 'green', 'points': 5}
new_points = alien_0['points']
print(f"You just earned {new_points} points!")

6.2.2 添加键值对

字典是一种动态结构，可随时在其中添加键值对。要添加键值对，可依次指定字典名、用方括号括起来的键和与键对应的值。

alien_0 = {
    "color": 'red',
    'points': 5
}
print(alien_0)
alien_0['x_position'] = 0
alien_0['y_position'] = 25
print(alien_0)

字典会保留字典定义时的元素排列顺序。

6.2.3 从创建一个空字典开始

alien_0 = {}
alien_0['color'] = 'red'
alien_0['points'] = 5
print(alien_0)

6.2.4 修改字典中的值

要修改字典中的值，可依次指定字典名、用方括号括起来的键和与该键关联的新值。

alien_0 = {
    'color': 'red'
}
print(f"The alien is {alien_0['color']}")
alien_0['color'] = 'yellow'
print(f"The alien is {alien_0['color']}")

alien_0 = {
    "x_position": 0,
    'y_position': 25,
    "speed": 'medium'
}
print(f"Original position: {alien_0['x_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'] += x_increment
print(f"New position: {alien_0['x_position']}")

6.2.5 删除键值对

对于字典中不需要的信息，可使用 del 语句将相应的键值对彻底删除。在使用 del 语句时，务必指定字典名和要删除的键。

alien_0 = {
    'color': 'red',
    'points': 5
}
print(alien_0)
del alien_0['points']
print(alien_0)

被删除的键值对将永远从字典中消失了。

6.2.6 由类似的对象组成的字典

favorite_languages = {
    'jen': 'python',
    'sarah': 'c',
    'edward': 'rust',
    'phil': 'python'
}
favorite_language = favorite_languages['sarah'].title()
print(f"Sarah's favorite language is {favorite_language}.")

6.2.7 使用 get() 来访问值

alien_0 = {
    'color': 'green',
    'speed': 'slow'
}
print(alien_0['points'])

这将导致 Python 显示 traceback，指出存在键值错误(KeyError)

Traceback (most recent call last):
  File "chapter-06\alien_no_points.py", line 5, in <module>
    print(alien_0['points'])
          ~~~~~~~^^^^^^^^^^
KeyError: 'points'

就字典而言，为避免出现这样的错误，可使用 get() 方法在指定的键不存在时返回一个默认值。get()方法的第一个参数用于指定键，是必需要的；第二个参数为当指定的键不存在时要返回的值，是可选的：

alien_0 = {
    'color': 'green',
    'speed': 'slow'
}
print(alien_0.get('points', 'No point value assigned.'))

不会引发错误：

No point value assigned.

如果没有指定可选的默认值，则 get()方法返回 None

如果指定的键有可能不存在，应考虑使用 get()方法，而不要使用方括号表示法。

注意：在调用 get()时，如果没有指定第二个参数且指定的键不存在，Python 将返回值 None，这个特殊的值表示没有相应的值。这并非错误，None 只是一个表示所需值不存在的特殊值，第 8 章将介绍它的其他用途。

6.2.8 动手试一试

# 练习6.1：人　使用一个字典来存储一个人的信息，包括名、姓、年龄和居住的城市。该字典应包含键first_name、last_name、age和city。将存储在该字典中的每项信息都打印出来。
# person_info = {
#     'first_name': 'Robin',
#     'last_name': 'Che',
#     'age': 29,
#     'city': 'Wuhan'
# }
# print(person_info)

# 练习6.2：喜欢的数1　使用一个字典来存储一些人喜欢的数。请想出5个人的名字，并将这些名字用作字典中的键。再想出每个人喜欢的一个数，并将这些数作为值存储在字典中。打印每个人的名字和喜欢的数。为了让这个程序更有趣，通过询问朋友确保数据是真实的。
# favorite_nums = {
#     'Jack': 9,
#     'Tom': 5,
#     "Alice": 8,
#     'Lucy': 1,
#     'Bob': 6
# }
# print(f"Jack's favorite number is {favorite_nums['Jack']}")
# print(f"Tom's favorite number is {favorite_nums['Tom']}")
# print(f"Alice's favorite number is {favorite_nums['Alice']}")
# print(f"Lucy's favorite number is {favorite_nums['Lucy']}")
# print(f"Bob's favorite number is {favorite_nums['Bob']}")

# 练习6.3：词汇表1　Python字典可用于模拟现实生活中的字典。为避免混淆，我们将后者称为词汇表。
# • 想出你在前面学过的5个编程术语，将它们用作词汇表中的键，并将它们的含义作为值存储在词汇表中。
# • 以整洁的方式打印每个术语及其含义。为此，既可以先打印术语，在它后面加上一个冒号，再打印其含义；也可以先在一行里打印术语，再使用换行符(\n)插入一个空行，然后在下一行里以缩进的方式打印其含义。
word_list = {
    '==': 'equality operator: returns True if the values of two operands are equal',
    'in': 'membership operator: returns True if a value is found in a sequence (string, list, tuple, dict, set, etc.)',
    'not in': 'negated membership operator: returns True if a value is NOT found in a sequence',
    'and': 'logical AND operator: returns True only if both operands are truthy',
    'or' : 'logical OR operator: returns True if at least one operand is truthy'
}
print(f"The mean of '==' is: {word_list['==']}")
print(f"The mean of 'in' is: {word_list['in']}")
print(f"The mean of 'not in' is: {word_list['not in']}")
print(f"The mean of 'and' is: {word_list['and']}")
print(f"The mean of 'or' is: {word_list['or']}")

6.3 遍历字典

6.3.1 遍历所有的键值对

user_0 = {
    'username': 'efermi',
    'first': 'enrico',
    'last': 'fermi'
}
for key, value in user_0.items():
    print(f"{key}'value is {value}")

可使用 for 循环遍历字典，需要声明两个变量，分别存储键值对中的键和值。for 语句的第二部分包含字典名和方法 items()，这个方法返回一个键值对列表。接下来使用 for 循环依次将每个键值对赋给指定的两个变量。

重写 favorite_language 示例：

favorite_languages = {
    'jen': 'python',
    'sarah': 'c',
    'edward': 'rust',
    'phil': 'python'
}
# favorite_language = favorite_languages['sarah'].title()
# print(f"Sarah's favorite language is {favorite_language}.")
for name, language in favorite_languages.items():
    print(f"{name.title()}'s favorite language is {language}")

6.3.2 遍历字典中的所有键

在不需要使用字典的值时，keys()方法可以只遍历字典的键。

favorite_languages = {
    'jen': 'python',
    'sarah': 'c',
    'edward': 'rust',
    'phil': 'python'
}

for name in favorite_languages.keys():
    print(name.title())

favorite_languages = {
    'jen': 'python',
    'sarah': 'c',
    'edward': 'rust',
    'phil': 'python'
}
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}!")

6.3.3 按特定的顺序遍历字典中的值

要以一种特定的顺序返回元素，一种方法是在 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 talking the poll.")

6.3.4 遍历字典中的所有值

可使用 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())

输出：

The following languages have been mentioned:
Python
C
Rust
Python

为剔除重复项，可使用集合 set()。集合中的每个元素是独一无二的：

favorite_languages = {
    'jen': 'python',
    'sarah': 'c',
    'edward': 'rust',
    'phil': 'python'
}
print("The following languages have been mentioned:")
for language in set(favorite_languages.values()):
    print(language.title())

输出：

The following languages have been mentioned:
Python
Rust
C

可以使用一对花括号直接创建集合，并在其中使用逗号分隔元素：

languages = {'python', 'rust', 'python', 'c'}
# {'python', 'rust', 'c'}

集合和字典很容易混淆，因为它们都是用一对花括号定义的。当花括号内没有键值对时，定义的很可能是集合。不同于列表和字典，集合不会以特定的顺序存储元素。

6.3.5 动手练一练

# 练习6.4：词汇表2　现在你知道了如何遍历字典，请整理你为练习6.3编写的代码，将其中的一系列函数调用print()替换为一个遍历字典中键和值的循环。确保该循环正确无误后，再在词汇表中添加5个Python术语。当你再次运行这个程序时，这些新术语及其含义将自动包含在输出中。
# word_list = {
#     '==': 'equality operator: returns True if the values of two operands are equal',
#     'in': 'membership operator: returns True if a value is found in a sequence (string, list, tuple, dict, set, etc.)',
#     'not in': 'negated membership operator: returns True if a value is NOT found in a sequence',
#     'and': 'logical AND operator: returns True only if both operands are truthy',
#     'or' : 'logical OR operator: returns True if at least one operand is truthy'
# }
# for op in word_list.keys():
#     print(f"The mean of '{op}' is: {word_list[op]}")

# 练习6.5：河流　创建一个字典，在其中存储三条河流及其流经的国家。例如，一个键值对可能是'nile': 'egypt'。
# • 使用循环为每条河流打印一条消息，如下所示。The Nile runs through Egypt.
# • 使用循环将该字典中每条河流的名字打印出来。
# • 使用循环将该字典包含的每个国家的名字打印出来。
# rivers = {
#     'Amazon': 'Brazil',      # 亚马孙河流经巴西
#     'Nile': 'Egypt',         # 尼罗河流经埃及
#     'Yangtze': 'China'       # 长江流经中国
# }
# for river, country in rivers.items():
#     print(f"The {river} runs through {country}")
# for river in rivers.keys():
#     print(river)
# for country in set(rivers.values()):
#     print(country)

# 练习6.6：调查　在6.3.1节编写的程序favorite_languages.py中执行以下操作。
# • 创建一个应该会接受调查的人的名单，其中有些人已在字典中，而其他人不在字典中。
# • 遍历这个名单。对于已参与调查的人，打印一条消息表示感谢；对于还未参与调查的人，打印一条邀请参加调查的消息。
# favorite_languages = {
#     'jen': 'python',
#     'sarah': 'c',
#     'edward': 'rust',
#     'phil': 'python'
# }
# current_users = favorite_languages.keys()
# users = ['sarah', 'phil', 'tom', 'alice']
# for user in users:
#     if user in current_users:
#         print(f'Thank you, {user.title()}')
#     else:
#         print(f"Hi {user.title()}, would you want to join?")

6.4 嵌套

有时候，需要将多个字典存储在列表中或将列表作为值存储在字典中，这称为嵌套。可以在列表中嵌套字典，在字典中嵌套列表，甚至在字典中嵌套字典。

6.4.1 字典列表

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)

# 创建一个用于存储外星人的列表
aliens = []

# 创建30个绿色的外星人
for alien_number 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)}")

# 创建一个用于存储外星人的列表
aliens = []

# 创建30个绿色的外星人
for alien_number in range(30):
    new_alien = {'color': 'green', 'points': 5, 'speed': 'slow'}
    aliens.append(new_alien)

# 修改前三个外星人的颜色、速度、得分
for alien in aliens[:3]:
    if alien['color'] == 'green':
        alien['color'] = 'yellow'
        alien['speed'] = 'medium'
        alien['points'] = 10
    elif alien['color'] == 'red':
        alien['color'] = 'red'
        alien['speed'] = 'fast'
        alien['points'] = 15

# 显示前5个外星人
for alien in aliens[:5]:
    print(alien)
print("...")

6.4.2 在字典中存储列表

# 存储顾客所点披萨的信息
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}")

favorite_languages = {
    'jen': ['python', 'rust'],
    'sarah': ['c'],
    'edward': ['rust', 'go'],
    'phil': ['python', 'haskell']
}
for name, languages in favorite_languages.items():
    print(f"{name.title()}'s favorite language are: ")
    for language in languages:
        print(f"\t{language}")

注意：列表和字典的嵌套层级不应太多。如果嵌套层级比前面的示例多得多，很可能有更简单的解决方案。

6.4.3 在字典中存储字典

users = {
    'aeinstein': {
        'first': 'albert',
        'last': 'einstein',
        'location': 'princeton'
    },
    'mcurie': {
        'first': 'marie',
        'last': "curie",
        'location': "paris"
    }
}
for username, info in users.items():
    print(f"\nUsername: {username.title()}")
    full_name = f"{info['last']} {info['first']}"
    location = info['location']
    print(f"\tFull name: {full_name.title()}")
    print(f"\tLocation: {location.title()}")

6.4.4 动手试一试

# 练习6.7：人们　在为练习6.1编写的程序中，再创建两个表示人的字典，然后将这三个字典都存储在一个名为people的列表中。遍历这个列表，将其中每个人的所有信息都打印出来。
# 练习6.8：宠物　创建多个表示宠物的字典，每个字典都包含宠物的类型及其主人的名字。将这些字典存储在一个名为pets的列表中，再遍历该列表，并将有关每个宠物的所有信息打印出来。
# # 多个宠物字典
# pet_1 = {'type': 'dog',   'owner': 'Alice'}
# pet_2 = {'type': 'cat',   'owner': 'Bob'}
# pet_3 = {'type': 'parrot','owner': 'Carol'}
# pet_4 = {'type': 'hamster','owner': 'David'}

# # 统一放入列表
# pets = [pet_1, pet_2, pet_3, pet_4]
# for pet in pets:
#     print(f"{pet['owner']} has a {pet['type']}")

# 练习6.9：喜欢的地方　创建一个名为favorite_places的字典。在这个字典中，将三个人的名字用作键，并存储每个人喜欢的1～3个地方。为让这个练习更有趣些，让一些朋友说出他们喜欢的几个地方。遍历这个字典，并将其中每个人的名字及其喜欢的地方打印出来。
# favorite_places = {
#     'Alice': ['Kyoto', 'Santorini'],
#     'Bob':   ['New York'],
#     'Carol': ['Paris', 'Rome', 'Bali']
# }
# for name, cities in favorite_places.items():
#     print(f"{name.title()}, your favorite places are:")
#     for city in cities:
#         print(f"\t{city}")

# 练习6.10：喜欢的数2　修改为练习6.2编写的程序，让每个人都可以有多个喜欢的数字，然后将每个人的名字及其喜欢的数打印出来。
# favorite_nums = {
#     'Jack': [9, 8],
#     'Tom': [5],
#     "Alice": [8, 3],
#     'Lucy': [1],
#     'Bob': [6]
# }

# for name, numbers in favorite_nums.items():
#     print(f"{name}'s favorite numbers are:")
#     for num in numbers:
#         print(f"\t{num}")

# 练习6.11：城市　创建一个名为cities的字典，将三个城市名用作键。对于每座城市，都创建一个字典，并在其中包含该城市所属的国家、人口约数以及一个有关该城市的事实。表示每座城市的字典都应包含country、population和fact等键。将每座城市的名字以及相关信息都打印出来。
cities = {
    'Tokyo': {
        'country': 'Japan',
        'population': 37_400_000,        # Greater Tokyo Area, 2023 est.
        'fact': 'The Greater Tokyo Area is the most populous metropolitan region in the world.'
    },
    'New York': {
        'country': 'United States',
        'population': 8_300_000,         # NYC proper, 2023 est.
        'fact': 'New York City is home to the United Nations Headquarters.'
    },
    'Paris': {
        'country': 'France',
        'population': 2_100_000,         # Paris proper, 2023 est.
        'fact': 'Paris is known as the "City of Light" and was one of the first European cities to adopt street lighting.'
    }
}
for city, info in cities.items():
    print(f"{city} is the city of {info['country']}, and the population of {city} is {info['population']}, {info['fact']}")

第 7 章用户输入和 while 循环

第八章函数

8.1 定义函数

8.1.1 响函数传递信息

8.1.2 实参和形参

8.2 传递参数

8.2.1 位置实参

# 位置参数
def describe_pet(animal_type, pet_name):
    """打印宠物种类及名称"""
    print(f"\nI have a {animal_type}.")
    print(f"My {animal_type}'s name is {pet_name.title()}.")
describe_pet('dog', 'cola')
describe_pet('hamster', 'harry')

多次调用函数
位置实参的顺序很重要

8.2.2 关键字实参

def describe_pet(animal_type, pet_name):
    """打印宠物的种类和名称"""
    print(f"\nI have a {animal_type}.")
    print(f"My {animal_type}'s name is {pet_name.title()}.")
# 关键字参数
describe_pet(pet_name='cola', animal_type='dog')

8.2.3 默认值

# 默认值，具有默认值的参数只能放在参数列表的后面
def describe_pet(pet_name, animal_type = 'dog'):
    """描述宠物"""
    print(f"\nI have a {animal_type}.")
    print(f"My {animal_type}'s name is {pet_name.title()}.")
describe_pet('willie')
describe_pet(pet_name='harry', animal_type='hamster') # 仓鼠

当使用默认值时，必须在形参列表中先列出没有默认值的形参，再列出有默认值的形参。这让 Python 依然能够正确地解读位置实参。

8.2.4 等效的函数调用

鉴于可混合使用位置实参、关键字实参和默认值，通常有多种等效的函数调用方式。

#一条名为Willie的小狗
describe_pet('willie')
describe_pet(pet_name='willie')

#一只名为Harry的仓鼠
describe_pet('harry', 'hamster')
describe_pet(pet_name='harry', animal_type='hamster')
describe_pet(animal_type='hamster', pet_name='harry')

8.2.5 避免实参错误

8.3 返回值

在函数中，可以使用 return 语句将值返回到调用函数的哪行代码。

8.3.1 返回简单的值

def get_formatted_name(first_name, last_name):
    """返回标准格式的姓名"""
    full_name = f"{first_name} {last_name}"
    return full_name.title()
musician = get_formatted_name("jimi", 'hendrix')
print(musician)

8.3.2 让实参变成可选的

有时候，需要让实参变成可选的，以便使用函数的人只在必要时才提供额外的信息。可以使用默认值来让实参变成可选的。

def get_formatted_name(first_name, medium_name, last_name):
    full_name = f"{first_name} {medium_name} {last_name}"
    return full_name.title()

musician = get_formatted_name('john', 'lee', 'hooker')
print(musician)

将上述函数中的 medium_name 变为可选参数

def get_formatted_name(first_name, last_name, medium_name = ''):
    # Python会将非空字符转换成True
    if medium_name:
        full_name = f"{first_name} {medium_name} {last_name}"
    else:
        full_name = f"{first_name} {last_name}"
    return full_name.title()
musician = get_formatted_name('jimi', 'hendrix')
print(musician)

musician = get_formatted_name('john', 'lee', 'hooker')
print(musician)

8.3.3 返回字典

函数可以返回任意类型的值，包括列表和字典等较为复杂的数据结构。

# 定义函数，返回一个字典
def build_person(first_name, last_name):
    """返回一个字典，其中包含一个人的信息"""
    person_info = {
        'first_name': first_name,
        'last_name': last_name
    }
    return person_info
musician = build_person('jimi', 'hendrix')
print(musician)

增加可选参数，返回更为丰富的字典。

# 定义age参数有默认值的函数，返回字段
def build_person(first_name, last_name, age = None):
    person_info = {
        'first_name': first_name.title(),
        'last_name': last_name.title()
    }
    if age:
        person_info['age'] = age
    return person_info
musician = build_person('jimi', 'hendrix', 27)
print(musician)

可将 None 视为占位符，在条件测试中，None 相等于 False。

8.3.3 结合使用函数和 while 循环

def get_formatted_name(first_name, last_name):
    """返回规范格式的姓名"""
    full_name = f"{first_name} {last_name}"
    return full_name.title()
# 这是一个无限循环！
while True:
    print("Please tell me your name:")
    first_name = input("Input your first name:")
    last_name = input("Input your last name:")
    print(f"{get_formatted_name(first_name, last_name)}")

解决无限循环，增加提示语，判断用户输入是否为 q ，从而决定循环是否继续

def get_formatted_name(first_name, last_name):
    """返回规范格式的姓名"""
    full_name = f"{first_name} {last_name}"
    return full_name.title()
while True:
    print("Please tell me your name:")
    print("Enter 'q' at any time to quit.")
    first_name = input("Input your first name:")
    if first_name == 'q':
        break
    last_name = input("Input your last name:")
    if last_name == 'q':
        break
    print(f"{get_formatted_name(first_name, last_name)}")

8.4 传递列表

def greet_users(users):
    """向列表中的每个用户发送简单的问候"""
    for user in users:
        message = f"Hello, {user.title()}!"
        print(f"{message}")

users = ['alice', 'lucy', 'sam']

greet_users(users)

8.4.1 在函数中修改列表

# 首先创建一个列表，其中包含一些要打印的设计
unprinted_designs = ['phone case', 'robot pendant', 'dodecahedron']
completed_models = []

# 模拟打印每个设计，直到没有未打印的设计为止
# 打印每个设计后，都将其移到列表 completed_designs 中
while unprinted_designs:
    current_design = unprinted_designs.pop()
    print(f"Printing model: {current_design}")
    completed_models.append(current_design)

print("\nThe following models have been printed:")
for completed_model in completed_models:
    print(completed_model)

将上述逻辑拆分成两个函数调用：

def print_models(unprinted_designs, completed_models):
    """模拟打印每个设计，直到没有未打印的设计为止。打印每个设计后，将其移到列表 completed_models 中"""
    while unprinted_designs:
        current_design = unprinted_designs.pop()
        print(f"Printing model: {current_design}")
        completed_models.append(current_design)
    return completed_models

def show_completed_models(completed_models):
    """显示打印好的所有模型"""
    print("\nThe following models have been printed:")
    for model in completed_models:
        print(f"{model}")

unprinted_designs = ['phone case', 'robot pendant', 'dodecahedron']
completed_models = []
print_models(unprinted_designs, completed_models)
show_completed_models(completed_models)

8.4.2 禁止函数修改列表

为了防止函数修改原始列表数据，可以在调用函数时，利用列表切片，传递列表的副本进去，避免修改原列表

function_name(list_name[:])
print_models(unprinted_designs[:], completed_models)

8.5 传递任意数量的实参

有时候预先不知道函数需要多少个参数，好在 Python 允许函数从调用语句中收集任意数量的实参。

def make_pizza(*toppings):
    """打印顾客点的所有配料"""
    print(toppings)

make_pizza('pepperoni')
make_pizza('mushrooms', 'green peppers', 'extra cheese')

形参名*toppings 中的星号让 Python 创建一个名为 toppings 的元组，该元组包含函数收到的所有实参。

def make_pizza(*toppings):
    """概述只做pizza的配料"""
    print("\nMaking a pizza with the following toppings:")
    for topping in toppings:
        print(f"- {topping}")

make_pizza('pepperoni')
make_pizza('mushrooms', 'green peppers', 'extra cheese')

8.5.1 结合使用位置实参和任意数量的实参

如果要让函数接受不同类型的实参，必须在函数定义中将接纳任意数量实参的形参放在最后。Python 先匹配位置实参和关键字实参，再将余下的实参都收集在最后一个形参中。

# 结合使用位置参数和任意数量的实参
def make_pizza(size, *toppings):
    print(f"\nMaking a {size} inch pizza with the following toppings:")
    for topping in toppings:
        print(f"- {topping}")

make_pizza(16, 'pepperoni')
make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

8.5.2 使用任意数量的关键字实参

有时候，需要接受任意数量的实参，但是预先不知道传递给函数的会是什么样的信息。在这种情况下，可将函数编写成能够接受任意数量的键值对-调用语句提供多少就接受多少。

def build_profile(first, last, **user_info):
    """创建一个字典，其中包含我们直到的有关用户的一切"""
    user_info['first_name'] = first
    user_info['last_name'] = last
    return user_info

user_profile = build_profile('albert', 'einstein', location = 'princeton', field = 'physics')
print(user_profile)

参数 **user_info 中的两个星号让 Python 创建一个名为 user_info 的字典，该字典包含函数收到的其他所有名值对。在这个函数中，可以像访问其他字典那样访问 user_info 中的名值对。

8.6 将函数存储在模块中

将函数存储在称为模块的独立文件中，再将模块导入到主程序。import 语句可以让你在当前运行的程序中使用模块中的代码。

8.6.1 导入整个模模块

要让函数是可导入的，得先创建模块。模块是扩展名为.py 的文件，包含要导入函数的代码。

创建一个 pizza.py 文件，代码如下：

def make_pizza(size, *toppings):
    """概述要制作的披萨"""
    print(f"\nMaking a {size} inch pizza with the following toppings:")
    for topping in toppings:
        print(f"- {topping}")

在同级目录下创建一个 making_pizzas.py 的程序，代码如下：

import pizza

pizza.make_pizza(16, 'pepperoni')
pizza.make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

这是一种导入方法：只需要编写一条 import 语句并在其中指定模块名，就可在程序中使用该模块中的所有函数。如果使用这种 import 语句导入名为 module_name.py 的整个模块，就可使用下面的语法来使用其中的任意一个函数：

import module_name
module_name.function_name()

8.6.2 导入特定的函数

还可以导入模块中的特定函数：

from module_name import function_name

用逗号分隔函数名，可根据需要从模块中导入任意数量的函数：

from module_name import function_0, function_1, function_2

上面示例改写如下：

from pizza import make_pizza

make_pizza(16, 'pepperoni')
make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

8.6.3 使用 as 给函数指定别名

如果要导入的函数名称太长或者与程序中的既有函数名冲突，可指定简短而独一无二的别名：函数的另一个名称，类似外号。关键字 as 可在导入函数时给函数指定一个别名：

from pizza import make_pizza as map

map(16, 'pepperoni')
map(12, 'mushrooms', 'green peppers', 'extra cheese')

指定别名的语法如下：

from module_name import function_name as function_alias

8.6.4 使用 as 给模块指定别名

还可以使用 as 给模块指定别名。

import pizza as p

p.make_pizza(16, 'pepperoni')
p.make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

给模块指定别名的语法如下：

import module_name as module_alias

8.6.5 导入模块中的所有函数

使用星号运算符 * 可让 Python 导入模块中的所有函数。

from pizza import *

make_pizza(16, 'pepperoni')
make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

导入模块中所有函数的语法如下：

from module_name import *

最佳的做法是，要么只导入使用到的函数，要么导入整个模块并使用点号。

8.7 函数编写指南

函数名只能使用小写字母加下划线，指定描述性名称。
每个函数应该包含简要阐述其功能的注释。
在给函数参数指定默认值时，等号两侧不要留空格；函数调用关键字实参也需要尊选该规则。
```
 def function_name(parameter_0, parameter_1='default value')
 function_name(parameter_1=value_1, parameter_0=value_0)
```
如果模块中存在多个函数，函数声明之间使用两行空白行分隔。。
所有 import 语句应该都放在文件开头。唯一的例外是需要在文件开头使用注释来描述整个模块。

8.7.1 动手练一练

# 练习8.15：打印模型　将示例printing_models.py中的函数放在一个名为printing_functions.py的文件中。
# 在printing_models.py的开头编写一条import语句，并修改这个文件以使用导入的函数。


# 练习8.16：导入　选择一个你编写的且只包含一个函数的程序，将这个函数放在另一个文件中。
# 在主程序文件中，使用下述各种方法导入这个函数，再调用它：
# import module_name
# from module_name import function_name
# from module_name import function_name as fn
# import module_name as mn
# from module_name import *

# 练习8.17：函数编写指南　选择你在本章编写的三个程序，确保它们遵循了本节介绍的函数编写指南。

简介​

第一部分 基础知识​

第 1 章 起步​

第 2 章 变量和简单的数据类型​

第 3 章 列表简介​

第 4 章 操作列表​

4.1 遍历整个列表​

4.1.1 深入研究循环​

4.1.2 在 for 循环中执行更多操作​

4.1.3 在 for 循环结束之后执行一些操作​

4.2 避免缩进错误​

4.2.1 忘记缩进​

4.2.2 忘记缩进额外的代码行​

4.2.3 不必要的缩进​

4.2.4 循环后不必要的缩进​

4.2.5 遗漏冒号​

4.2.6 动手试一试​

4.3 创建数值列表​

4.3.1 使用 range()函数​

4.3.2 使用 range() 创建数值列表​

4.3.3 对数值列表执行简单的统计计算​

4.3.4 列表推导式​

4.3.5 动手练一练​

4.4 使用列表的一部分​

4.4.1 切片​

4.4.2 遍历切片​

4.4.3 复制列表​

4.4.4 动手试一试​

4.5 元组​

4.5.1 定义元组​

4.5.2 便利元组中的所有值​

4.5.3 修改元组变量​

4.5.4 动手试一试​

第 5 章 if 语句​

5.1 一个简单的示例​

5.2 条件测试​

5.2.1 检查是否相等​

5.2.2 如何在检查是否相等是忽略大小写​

5.2.3 检查是否不等​

5.2.4 数值比较​

5.2.5 检查多个条件​

5.2.6 检查特定的值是否在列表中​

5.2.7 检查特定的值是否不在列表中​

5.2.8 布尔表达式​

5.2.9 动手试一试​

5.3 if 语句​

5.3.1 简单的 if 语句​

5.3.2 if-else 语句​

5.3.3 if- elif-else 语句​

5.3.4 使用多个 elif 代码块​

5.3.5 省略 else 代码块​

5.3.6 测试多个条件​

5.3.7 动手试一试​

5.4 使用 if 语句处理列表​

5.4.1 检查特殊元素​

5.4.2 确定列表非空​

5.4.3 使用多个列表​

5.4.4 动手练一练​

5.5 设置 if 语句的格式​

5.5.1 动手练一练​

第 6 章 字典​

6.1 一个简单的字典​

6.2 使用字典​

6.2.1 访问字典中的值​

6.2.2 添加键值对​

6.2.3 从创建一个空字典开始​

6.2.4 修改字典中的值​

6.2.5 删除键值对​

6.2.6 由类似的对象组成的字典​

6.2.7 使用 get() 来访问值​

6.2.8 动手试一试​

6.3 遍历字典​

6.3.1 遍历所有的键值对​

6.3.2 遍历字典中的所有键​

6.3.3 按特定的顺序遍历字典中的值​

6.3.4 遍历字典中的所有值​

6.3.5 动手练一练​

6.4 嵌套​

6.4.1 字典列表​

6.4.2 在字典中存储列表​

简介

第一部分基础知识

第 1 章起步

第 2 章变量和简单的数据类型

第 3 章列表简介

第 4 章操作列表

4.1 遍历整个列表

4.1.1 深入研究循环

4.1.2 在 for 循环中执行更多操作

4.1.3 在 for 循环结束之后执行一些操作

4.2 避免缩进错误

4.2.1 忘记缩进

4.2.2 忘记缩进额外的代码行

4.2.3 不必要的缩进

4.2.4 循环后不必要的缩进

4.2.5 遗漏冒号

4.2.6 动手试一试

4.3 创建数值列表

4.3.1 使用 range()函数

4.3.2 使用 range() 创建数值列表

4.3.3 对数值列表执行简单的统计计算

4.3.4 列表推导式

4.3.5 动手练一练

4.4 使用列表的一部分

4.4.1 切片

4.4.2 遍历切片

4.4.3 复制列表

4.4.4 动手试一试

4.5 元组

4.5.1 定义元组

4.5.2 便利元组中的所有值

4.5.3 修改元组变量

4.5.4 动手试一试

第 5 章 if 语句

5.1 一个简单的示例

5.2 条件测试

5.2.1 检查是否相等

5.2.2 如何在检查是否相等是忽略大小写

5.2.3 检查是否不等

5.2.4 数值比较

5.2.5 检查多个条件

5.2.6 检查特定的值是否在列表中

5.2.7 检查特定的值是否不在列表中

5.2.8 布尔表达式

5.2.9 动手试一试

5.3 if 语句

5.3.1 简单的 if 语句

5.3.2 if-else 语句

5.3.3 if- elif-else 语句

5.3.4 使用多个 elif 代码块

5.3.5 省略 else 代码块

5.3.6 测试多个条件

5.3.7 动手试一试

5.4 使用 if 语句处理列表

5.4.1 检查特殊元素

5.4.2 确定列表非空

5.4.3 使用多个列表

5.4.4 动手练一练

5.5 设置 if 语句的格式

5.5.1 动手练一练

第 6 章字典

6.1 一个简单的字典

6.2 使用字典

6.2.1 访问字典中的值

6.2.2 添加键值对

6.2.3 从创建一个空字典开始

6.2.4 修改字典中的值

6.2.5 删除键值对

6.2.6 由类似的对象组成的字典

6.2.7 使用 get() 来访问值

6.2.8 动手试一试

6.3 遍历字典

6.3.1 遍历所有的键值对

6.3.2 遍历字典中的所有键

6.3.3 按特定的顺序遍历字典中的值

6.3.4 遍历字典中的所有值

6.3.5 动手练一练

6.4 嵌套

6.4.1 字典列表

6.4.2 在字典中存储列表