（3）深入探索Python：条件语句、循环结构与函数定义的全面解析

1. 前言

在Python编程中，条件语句、循环结构和函数定义是构建程序逻辑的核心要素。它们不仅决定了程序的执行流程，还影响了程序的性能和可读性。
通过深入理解和熟练掌握这些结构，我们可以编写出更加高效、可维护的Python代码。

本文章将对条件语句、循环结构和函数定义进行详细解析，帮助读者提升Python编程技能。

2. 条件语句

条件语句用于根据特定的条件来执行不同的代码块。
Python 条件语句是通过一条或多条判断语句的执行结果（True 或者 False）， 来决定执行的代码块。

2.1 if 语句

if 条件语句的执行过程如下：

if 语句的表达形式如下：

if 执行条件:
     逻辑代码

如果【执行条件】为True，则执行【逻辑代码】，否则，结束。

注意：执行条件后面必须加冒号 ：

下面是一个简单示例：
如果用户名叫架构筑梦，输出 欢迎来到架构筑梦的空间。

name = "架构筑梦"
if(name == '架构筑梦'):
  print("欢迎来到架构筑梦的空间")

输出：

欢迎来到架构筑梦的空间

2.2 if else 语句

if else 条件语句的执行过程如下：

if else 语句的表达形式如下：

if 执行条件:
     逻辑代码1
else:
     逻辑代码2

如果【执行条件】为True，则执行【逻辑代码1】，否则，执行【逻辑代码2】。

注意：执行条件 及 else 后面必须加冒号 ：

下面是一个简单示例：
如果 当前股票价格 < 买入价格，输出：满足买入条件，建议买入
否则，输出：不满足买入条件，建议观望

# 假设股票当前价格为current_price，买入价格为buy_price
current_price = 100.0
buy_price = 95.0
	
# 使用条件语句判断股票是否满足买入条件
if current_price <= buy_price:
    print("满足买入条件，建议买入")
else:
    print("不满足买入条件，建议观望")

输出：

不满足买入条件，建议观望

2.3 if elif else 语句

if elif else 条件语句的执行过程如下：

if elif else 语句的表达形式如下：

if 执行条件1:
     逻辑代码1
elif 执行条件2:
     逻辑代码2
…
elif 执行条件n:
     逻辑代码n
else:
     逻辑代码

如果【执行条件1】为True，则执行【逻辑代码1】，否则，进入【执行条件2】。
如果【执行条件2】为True，则执行【逻辑代码2】，否则，执行【执行条件3】。
依此类推。
如果【执行条件n】为True，则执行【逻辑代码n】，否则，执行【逻辑代码】。

注意：所有执行条件 及 else 后面必须加冒号 ：

下面是一个简单示例：
根据不同的投资回报率，打印出相应的税收金额和消息。

# 回报率
return_rate = 0.12

if return_rate < 0:
    # 如果投资亏损，则不收税，但可能需要收取其他费用（这里为了简化省略）
    tax = 0
    message = "没有盈利，无需交税。"
elif 0 <= return_rate < 0.1:
    # 如果盈利在10%以下，税率为10%
    tax = return_rate * 0.10
    message = "盈利在10%以下，税率为10%。"
elif 0.1 <= return_rate < 0.25:
    # 如果盈利在10%到25%之间，税率为15%
    tax = return_rate * 0.15
    message = "盈利在10%到25%之间，税率为15%。"
elif 0.25 <= return_rate <= 0.5:
    # 如果盈利在25%到50%之间，税率为20%
    tax = return_rate * 0.20
    message = "盈利在25%到50%之间，税率为20%。"
else:
    # 假设回报率不可能超过50%，否则为无效输入
    tax = 0
    message = "回报率无效或超过上限，无法计算税收。"

print(f"您的投资回报率为：{return_rate * 100}%，应缴税款为：{tax * 100}%。")
print(message)

输出：

您的投资回报率为：12.0%，应缴税款为：1.7999999999999998%。
盈利在10%到25%之间，税率为15%。

2.4 if 嵌套

在金融领域，嵌套 if 语句经常用于处理复杂的逻辑条件，特别是在涉及多个参数和条件的情况下。
以下是一个金融相关的嵌套 if 语句示例，它可能用于决定一种金融产品的费用结构：

下面是一个简单的 if 嵌套示例：
我们首先根据 is_vip_client 的值确定是否有折扣。然后，我们根据 investment_amount 的值计算vip客户的最终折扣。

investment_amount = 50000; # 投资金额
investment_duration = 5;  # 投资期限（以年为单位）
is_vip_client = True;   # 是否为VIP客户
fee = 0

# 检查是否为VIP客户，VIP客户可能享有费用折扣
if is_vip_client:
    discount_rate = 0.1  # VIP客户享有10%的折扣
    print("您是VIP客户，将享受费用折扣。")

    # 根据投资金额计算进一步的折扣
    if investment_amount < 100000:
        discount_rate = discount_rate * 0.9  # 小额投资的基础费用
    elif 100000 <= investment_amount < 500000:
        discount_rate = discount_rate * 0.7  # 中等投资的基础费用
    else:
        discount_rate = discount_rate * 0.5  # 大额投资的基础费用

else:
    discount_rate = 0  # 非VIP客户没有折扣

print(round(discount_rate, 2))

输出：

您是VIP客户，将享受费用折扣。
0.09

2.5 match…case 语句

Python 在 3.10 版本中引入了 match...case 语法，这是基于模式匹配（pattern matching）的 match 语句的一部分。这个新特性允许你根据值的形状或内容来执行不同的代码块。

以下是 Python 中 match...case 语法的基本格式：

value = ...  # 需要匹配的值

match value:
    case pattern1:
        # 如果 value 与 pattern1 匹配，则执行这里的代码
        ...
    case pattern2:
        # 如果 value 与 pattern2 匹配，则执行这里的代码
        ...
    case pattern3 as variable:
        # 如果 value 与 pattern3 匹配，则执行这里的代码，并将匹配的部分赋值给 variable
        ...
    case _:
        # 如果没有其他情况匹配，则执行这里的代码（类似于其他语言中的 default）
        ...

• value 是你要匹配的值。
• pattern1, pattern2, pattern3 等是你要与 value 匹配的模式。这些可以是常量、变量、字面量、类型、序列（列表、元组等）、映射（字典）、类或类的实例等。
• as variable 允许你将匹配的部分绑定到一个变量上，以便在 case 块中使用。
• _ 是一个特殊的模式，表示“其他所有情况”。如果 value 不与任何先前的模式匹配，则会执行与 _ 关联的代码块。

以下是一个简单的示例：
transaction_type 为交易类型，使用 match…case 语句来检查交易的类型，并基于其类型进行不同的处理。如果交易类型不受支持，则输出一个错误消息。

transaction_type = "buy"

match transaction_type:
    case "buy":
        print("Processing a buy transaction")
        # 可能是扣款操作或添加库存等操作

    case "sell":
        print("Processing a sell transaction")
        # 可能是收款操作或减少库存等操作

    case "dividend":
        print("Processing a dividend payment")
        # 可能是分红派息操作

    case "transfer":
        print("Processing a transfer transaction")
        # 可能是资金转账操作

    case _:
        print("Unsupported transaction type: {transaction_type}")

输出：

Processing a buy transaction

3. 循环结构

循环结构允许程序在特定的条件下重复执行某个代码块。Python提供了两种主要的循环结构：for循环和while循环。

3.1 for循环

在Python中，for 循环用于遍历一个序列（比如列表、元组、字符串、字典等）或其他可迭代对象。

以下是 for 循环的几种类型的简单示例：

3.1.1 对于列表、元组、字符串等序列类型

sequence = [1, 2, 3, 4, 5]  # 示例序列，可以替换为元组、字符串等

for item in sequence:
    # 对item进行操作
    print(item)

输出：

1
2
3
4
5

3.1.2 对于字典（遍历键、值或键值对）

dictionary = {'a': 1, 'b': 2, 'c': 3}

# 遍历键
for key in dictionary:
    print(key)

# 遍历值
for value in dictionary.values():
    print(value)

# 遍历键值对
for key, value in dictionary.items():
    print(key, value)

输出：

a 1
b 2
c 3

3.1.3 对于文件等迭代器或自定义的迭代对象

# 假设我们有一个文件对象
with open('filename.txt', 'r') as file:
    for line in file:
        # 对文件中的每一行进行处理
        print(line.strip())  # strip() 去除行尾的换行符

输出文件中每一行

3.1.4 对于 range() 函数生成的数字序列

遍历0到4（不包括5）的数字

for i in range(5): # 从0开始，到5，不包含5
    print(i)

输出：

0
1
2
3
4

指定开始值和步长，遍历1-10

for i in range(1, 10, 2):  # 从1开始，到10（不包括10），步长为2
    print(i)

输出：

1
3
5
7
9

3.1.5 对于 enumerate() 函数，它用于同时获取索引和值

sequence = ['apple', 'banana', 'cherry']

for index, item in enumerate(sequence):
    print(index, item)

输出：

0 apple
1 banana
2 cherry

3.2 for else 语句

在Python中，for循环可以搭配一个可选的else子句。这个else子句在for循环正常结束（即不是通过break语句终止的）时执行。
这对于在循环结束后执行一些清理工作或者处理没有找到任何匹配项的情况特别有用。

以下是for循环与else子句的基本格式和示例：

# 另一个示例，用于说明遍历完整个列表的情况
sequence = [1, 2, 3, 4, 5]

for item in sequence:
    # 对每一个item做一些处理
    print(item)

# 执行else子句
else:
    print("循环已正常结束")

输出：

1
2
3
4
5
循环已正常结束

for循环会遍历整个列表，循环结束后else子句会执行，告诉我们循环已经正常结束。

3.3 for else break 语句

sequence = [1, 2, 3, 4, 5]

# 假设我们在寻找一个特定的元素
target = 4

found = False
for item in sequence:
    if item == target:
        print(f"找到了目标值 {target} 在列表中")
        found = True
        break  # 如果找到了就跳出循环

# for 循环之后的 else 子句
else:
    if not found:
        print(f"在列表中未找到目标值 {target}")
    else:
      print(f"在列表中找到目标值 {target} ")
 

输出：

找到了目标值 4 在列表中

在这个例子中，当我们在列表中寻找一个特定的值target时，如果找到了，我们就设置found为True并使用break语句退出循环。如果循环正常结束（即没有通过break退出），那么else子句就会执行，告诉我们目标值在列表中未找到。

3.4 for continue 语句

在Python的for循环中，continue语句用于跳过当前迭代并立即开始下一次迭代。当在循环的某个点，你希望跳过当前元素或条件并继续处理列表中的下一个元素时，可以使用continue。

以下是一个for循环中使用continue语句的示例：

sequence = [0, 1, 2, 3, 4, 0, 5]

for item in sequence:
    if item == 0:
        continue  # 如果当前元素是0，则跳过并继续下一个元素
    print(item)

# 输出将是：1 2 3 4 5，因为所有的0都被跳过了

输出：

1
2
3
4
5

在这个示例中，当遍历到列表中的0时，continue语句会执行，这将导致跳过当前迭代，并立即开始处理列表中的下一个元素。因此，程序不会打印出任何0，只会打印出非0的元素。

你还可以将continue与更复杂的条件逻辑结合使用，以跳过不满足特定条件的所有元素。

例如，如果你想跳过列表中所有小于3的元素：

sequence = [0, 1, 2, 3, 4, 5]

for item in sequence:
    if item < 3:
        continue  # 如果当前元素小于3，则跳过并继续下一个元素
    print(item)

# 输出将是：3 4 5，因为所有小于3的元素都被跳过了

3.5 while循环

在Python中，while循环是一个控制流语句，它允许你重复执行一段代码，直到某个条件不再满足为止。以下是while循环的基本语法：

while 条件:
    # 这里是要重复执行的代码块
    # 当条件为True时，代码块将被执行
    # 当条件为False时，循环将停止

以下是一个简单的示例，演示了如何使用while循环打印从1到5的数字：

# 假设我们需要模拟连续几天的交易过程，使用while循环
days = 5
current_day = 0
 
while current_day < days:
    current_day += 1
    print(f"今天是第{current_day}天交易，执行交易策略...")
    # 这里可以添加具体的交易策略代码

输出：

今天是第1天交易，执行交易策略...
今天是第2天交易，执行交易策略...
今天是第3天交易，执行交易策略...
今天是第4天交易，执行交易策略...
今天是第5天交易，执行交易策略...

在这个示例中，我们首先定义了变量days 并设置其值为5，定义了变量current_day ，并设置其值为0。然后，我们使用while循环检查current_day 是否小于days。如果是，current_day 加1天，并打印今天是第几天的交易，执行交易策略…

这通常是不希望的，因为它会导致程序无法继续执行或响应其他操作。因此，在使用while循环时，务必确保有一个明确的退出条件。

3.6 while … else 语句

在Python中，while循环可以有一个与之相关联的else子句。while...else的结构使得在while循环条件不满足、自然结束时（而非由于break语句提前结束），else块中的代码会被执行。

这里有一个简单的例子来演示while...else的用法：

count = 0
while count < 5:
    print(f"Count is {count}")
    count += 1
else:
    print("Count is 5 or above, exiting the while loop.")

输出：

Count is 0
Count is 1
Count is 2
Count is 3
Count is 4
Count is 5 or above, exiting the while loop.

在这个例子中，while循环会一直执行，直到count变量的值大于或等于5。一旦条件count < 5不再满足，循环就会结束，并且执行else块中的代码。

需要注意的是，如果while循环内部使用了break语句，那么else块中的代码将不会被执行。例如：

count = 0
while count < 5:
    print(f"Count is {count}")
    count += 1
    if count == 3:
        break
else:
    print("Count is 5 or above, exiting the while loop.")

输出：

Count is 0
Count is 1
Count is 2

在这个修改后的例子中，当count变量的值达到3时，break语句会终止while循环，因此else块中的代码不会被执行。

4. 函数

4.1 函数定义

函数是Python中用于封装可重用代码块的工具。通过定义函数，我们可以将具有特定功能的代码块封装起来，并在需要时通过调用函数来执行这些代码。

在Python中，函数定义的基本语法如下：

def function_name(parameters):
    """Docstring describing the function."""
    # Function body
    # ...
    return result

其中：

• def 是定义函数的关键字。
• function_name 是你给函数取的名字，需要符合Python的命名规范。
• parameters 是传递给函数的参数，多个参数之间用逗号,分隔。
• Docstring 是对函数的描述，可以包含多行，通常用三引号括起来。虽然不是必需的，但写文档字符串是一个好习惯，因为它可以帮助其他人（或未来的你）理解函数的作用和用法。
• Function body 是函数的主体，包含了实现函数功能的代码。
• return 语句用于返回函数的结果。如果函数没有返回值，可以省略return语句或只写return而不带任何值，这将导致函数返回None。

下面是一个简单的例子，定义了一个计算两个数之和的函数：

def add_numbers(a, b):
    """This function adds two numbers together."""
    result = a + b
    return result

# 使用函数
sum_of_numbers = add_numbers(3, 5)
print(sum_of_numbers)  # 输出：8

在这个例子中，add_numbers 是函数名，a 和 b 是传递给函数的参数，result 是函数体中的变量，用于存储计算结果，并通过 return 语句返回这个结果。

下面是一个更复杂的案例，用于计算贷款的每月还款金额（等额本息还款法）：

def calculate_monthly_payment(principal, interest_rate, years):
   """
   计算贷款的每月还款金额（等额本息还款法）。

   :param principal: 贷款本金
   :param interest_rate: 年利率（小数形式）
   :param years: 贷款年数
   :return: 每月还款金额
   """
   # 将年利率和贷款年数转换为月利率和贷款月份数
   monthly_interest_rate = interest_rate / 12 / 100
   total_months = years * 12

   # 使用等额本息还款法公式计算每月还款额
   monthly_payment = (principal * monthly_interest_rate * (1 + monthly_interest_rate) ** total_months) / (
           (1 + monthly_interest_rate) ** total_months - 1)

   return round(monthly_payment, 2)  # 保留两位小数

4.2 函数调用

在Python中，函数定义之后，你可以通过调用函数来使用它。调用函数意味着你正在执行函数中的代码块。要调用一个函数，你需要使用函数名加上括号（()），并在括号内传递任何必要的参数（如果有的话）。

以下是一个简单的示例，展示了如何定义和调用一个函数：

# 定义一个函数，它接受两个数字作为参数并返回它们的和
def add_numbers(a, b):
    return a + b

# 调用函数，并将结果存储在变量中
result = add_numbers(3, 5)

# 打印结果
print(result)  # 输出: 8

在这个例子中，我们定义了一个名为add_numbers的函数，它接受两个参数a和b，并返回它们的和。然后，我们调用了这个函数，并将3和5作为参数传递给它。函数执行后返回的结果（即8）被存储在变量result中，最后我们通过print函数打印了这个结果。

对于前面提到的金融相关的函数calculate_monthly_payment，你可以这样调用它：

# 调用calculate_monthly_payment函数并传入参数
monthly_payment = calculate_monthly_payment(1000000, 5.0 / 100, 30)

# 打印每月还款金额
print(f"每月还款金额为：{monthly_payment} 元")

在这个调用中，我们传入了三个参数：贷款本金1000000元、年利率5%（注意这里我们将其除以100转换为了小数形式）和贷款期限30年。函数返回的结果（即每月还款金额）被存储在变量monthly_payment中，并通过print函数打印出来。

4.3 参数及参数传递

在Python中，函数参数和参数传递是函数定义和调用时的一个重要部分。函数参数允许你为函数提供输入数据，而参数传递则决定了如何将这些数据从调用者传递到函数中。

4.3.1 函数参数类型

位置参数（Positional Arguments）：位置参数是函数定义时指定的参数，调用函数时需要按照指定的顺序提供这些参数的值。

def greet(name, age):
    print(f"Hello, {name}! You are {age} years old.")

greet("Alice", 30)  # 正确的调用方式

关键字参数（Keyword Arguments）：关键字参数在调用函数时使用参数名来指定参数值，不需要按照位置参数的顺序提供。

greet(age=35, name="David")  # 使用关键字参数

默认参数（Default Arguments）：在函数定义时，可以为某些参数指定默认值。如果在调用函数时没有为这些参数提供值，则使用默认值。

def greet(name, age=None):
    if age is not None:
        print(f"Hello, {name}! You are {age} years old.")
    else:
        print(f"Hello, {name}!")

greet("Bob")  # 使用默认参数

可变位置参数（*args）：*args允许你在函数调用时传入任意数量的位置参数，这些参数在函数内部会被收集到一个元组中。

def print_args(*args):
    for arg in args:
        print(arg)

print_args(1, 2, 3, 4)  # 输出: 1 2 3 4

**可变关键字参数（**kwargs）****：kwargs允许你在函数调用时传入任意数量的关键字参数，这些参数在函数内部会被收集到一个字典中。

def print_kwargs(**kwargs):
    for key, value in kwargs.items():
        print(f"{key} = {value}")

print_kwargs(name="John", age=30)  # 输出: name = John 和 age = 30

4.4 参数传递

在Python中，参数传递通常是通过值传递（Pass by Value）进行的。这意味着函数接收的是参数值的副本，而不是原始变量本身。但是，对于可变类型（如列表、字典等），函数内部对可变对象的修改会影响外部原始对象，因为传递的是引用的副本，而不是对象本身的副本。

对于位置参数和关键字参数，传递的值是实参（调用函数时提供的参数值）到形参（函数定义中指定的参数名）的直接映射。

对于可变位置参数和可变关键字参数，Python将它们收集到元组和字典中，并在函数内部作为这些数据结构进行操作。

示例

下面是一个结合了所有类型参数的函数示例：

def complex_function(a, b, c=10, *args, **kwargs):
    print(f"a = {a}, b = {b}, c = {c}")
    for arg in args:
        print(f"args: {arg}")
    for key, value in kwargs.items():
        print(f"kwargs: {key} = {value}")

complex_function(1, 2, 3, 4, 5, name="John", age=30)

输出结果将是：

a = 1, b = 2, c = 3
args: 4
args: 5
kwargs: name = John
kwargs: age = 30

5. 总结

条件语句、循环结构和函数定义是Python编程中不可或缺的部分。它们不仅帮助我们构建出复杂的程序逻辑，还提高了代码的可读性和可维护性。通过深入学习和熟练掌握这些结构，我们可以编写出更加高效、清晰的Python代码，并在实际项目中发挥更大的作用。希望本文的解析能够帮助读者更好地理解和应用这些结构，提升Python编程技能。