第二章：掌握 Python 的控制流与函数-优快云博客

本文链接：https://blog.youkuaiyun.com/m0_51778705/article/details/144782644

第二章：掌握 Python 的控制流与函数

在编程的世界里，控制流决定了程序的执行顺序，而函数则是我们实现代码复用的强大工具。无论你是初学者还是有一定经验的开发者，理解并熟练运用这些概念都是至关重要的。本章将通过详细的讲解和示例，帮助你掌握 Python 中的控制流和函数，为构建高效的程序打下坚实的基础。

控制流：让代码有逻辑地执行

条件判断：程序的决策力

条件判断是控制流的核心。通过条件语句，程序可以根据输入或当前状态选择不同的分支，从而变得更加灵活。

基本结构

Python 的条件语句使用 if-elif-else 结构：

if 条件1:
    # 条件1成立时执行的代码
elif 条件2:
    # 条件1不成立但条件2成立时执行的代码
else:
    # 所有条件均不成立时执行的代码

这种结构从上到下依次检查每个条件，直到找到满足的条件为止。如果没有任何条件成立，就会执行 else 块。

示例：简单的数字分类器

number = int(input("请输入一个整数："))

if number > 0:
    print("这是一个正数")
elif number < 0:
    print("这是一个负数")
else:
    print("这是零")

在这个例子中，用户输入的数字会被分类为正数、负数或零。程序逻辑清晰，易于扩展。

循环：重复中寻找规律

在编程中，循环用于让某段代码重复执行，直到满足某个条件。Python 提供了两种主要的循环结构：for 和 while。

`for` 循环：遍历序列的利器

for 循环用于依次迭代可迭代对象（如列表、字符串等）。

fruits = ["苹果", "香蕉", "橙子"]
for fruit in fruits:
    print(f"我喜欢吃 {fruit}")

在这个例子中，程序会依次访问列表中的每个元素，并执行相同的操作。

使用 `range()` 函数

当需要生成一个整数序列时，可以使用 range() 函数：

for i in range(1, 6):
    print(f"第 {i} 次尝试")

`while` 循环：更灵活的控制方式

while 循环在条件为真时不断执行代码块，适合处理未知次数的重复任务：

count = 5
while count > 0:
    print(f"倒计时：{count}")
    count -= 1
print("发射！")

通过调整 count 的值，程序控制了循环的执行次数。

循环控制语句：灵活中增加选择

break：立即退出循环
continue：跳过当前循环，继续下一次迭代
pass：占位符，不执行任何操作

嵌套的条件语句和循环

嵌套是控制流的重要特性，尤其在复杂的逻辑中非常常见。

for i in range(3):
    for j in range(3):
        print(f"({i}, {j})")

在循环中嵌套条件语句也很常见：

for i in range(5):
    if i % 2 == 0:
        print(f"{i} 是偶数")
    else:
        print(f"{i} 是奇数")

`else` 子句在循环中的用法

Python 支持在循环后附加 else，但这一特性容易被忽视：

for i in range(5):
    if i == 3:
        break
else:
    print("未执行 break，循环完整运行")

当 break 未被触发时，else 中的代码会执行。

`try-except` 的异常处理与控制流

异常处理也是一种特殊的控制流，用于捕获并处理运行时错误：

try:
    x = int(input("请输入一个整数："))
    print(f"您输入的是 {x}")
except ValueError:
    print("输入无效，请输入整数！")

函数：构建模块化程序的基础

函数的定义与调用

函数是组织代码的基本单元，可以将重复的逻辑封装起来，提高程序的可读性和可维护性。

定义一个函数

函数由 def 关键字定义：

def greet(name):
    """
    这是一个简单的问候函数
    """
    return f"你好, {name}!"

定义的函数可以通过名称直接调用：

print(greet("小明"))  # 输出：你好, 小明!

函数参数与返回值

函数的参数是它的输入，返回值是它的输出。在 Python 中，函数可以有默认参数：

def introduce(name, age=18):
    return f"我是 {name}, 今年 {age} 岁"

print(introduce("小红"))  # 输出：我是 小红, 今年 18 岁
print(introduce("小明", 20))  # 输出：我是 小明, 今年 20 岁

通过这种方式，用户可以选择性地提供部分参数，从而简化函数的调用。

函数的高级用法

可变参数：处理不定数量的输入

*args 用于捕获任意数量的位置参数，**kwargs 捕获任意数量的关键字参数：

def add(*numbers):
    return sum(numbers)

print(add(1, 2, 3))  # 输出：6
print(add(10, 20, 30, 40))  # 输出：100
def display_info(**info):
    for key, value in info.items():
        print(f"{key}: {value}")

display_info(name="小明", age=20, city="北京")

匿名函数：精简的小工具

匿名函数（lambda）可以快速定义无需命名的小型函数：

square = lambda x: x ** 2
print(square(5))  # 输出：25

更常见的用法是将匿名函数与内置函数如 map 或 filter 结合使用：

numbers = [1, 2, 3, 4]
squared = map(lambda x: x ** 2, numbers)
print(list(squared))  # 输出：[1, 4, 9, 16]

上述内容覆盖了 控制流 和函数的大部分核心内容，但并未完全涵盖这两个主题的所有可能细节和高级用法。如果希望更加全面，可以补充以下内容：

作用域与闭包

函数中的变量作用域分为局部作用域（local）、全局作用域（global）和嵌套作用域（nonlocal）。

def outer_function():
    x = "outer variable"
    def inner_function():
        nonlocal x
        x = "inner variable"
        print(x)
    inner_function()
    print(x)

outer_function()

使用 nonlocal 可以在嵌套函数中修改外层函数的变量。

高阶函数与函数式编程

高阶函数是指可以接受函数作为参数或返回函数的函数：

def apply_function(func, value):
    return func(value)

print(apply_function(lambda x: x**2, 3))  # 输出：9

Python 的 map、filter 和 reduce 都是典型的高阶函数：

from functools import reduce

numbers = [1, 2, 3, 4]
print(list(map(lambda x: x**2, numbers)))  # [1, 4, 9, 16]
print(list(filter(lambda x: x % 2 == 0, numbers)))  # [2, 4]
print(reduce(lambda x, y: x + y, numbers))  # 10

递归的高级应用

在之前介绍了简单的递归，这里可以补充更复杂的递归用法，例如解决分治问题：

def merge_sort(arr):
    if len(arr) <= 1:
        return arr
    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
    return merge(left, right)

def merge(left, right):
    result = []
    i = j = 0
    while i < len(left) and j < len(right):
        if left[i] < right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
    result.extend(left[i:])
    result.extend(right[j:])
    return result

print(merge_sort([4, 2, 5, 1, 3]))

装饰器（Decorators）

装饰器用于动态地增强函数的功能。

def logger(func):
    def wrapper(*args, **kwargs):
        print(f"调用函数 {func.__name__}，参数为 {args} {kwargs}")
        return func(*args, **kwargs)
    return wrapper

@logger
def add(a, b):
    return a + b

print(add(3, 5))

生成器与迭代器

函数中使用 yield 关键字定义生成器，可以逐步返回值：

def fibonacci(n):
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b

for num in fibonacci(5):
    print(num)  # 输出：0 1 1 2 3

综合示例：编写实用函数

示例 1：质数判断函数

def is_prime(n):
    if n <= 1:
        return False
    for i in range(2, int(n ** 0.5) + 1):
        if n % i == 0:
            return False
    return True

print(is_prime(17))  # 输出：True

示例 2：递归计算阶乘

def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n - 1)

print(factorial(5))  # 输出：120

示例 3：自定义简单计算器

def calculator(a, b, operator):
    if operator == "+":
        return a + b
    elif operator == "-":
        return a - b
    elif operator == "*":
        return a * b
    elif operator == "/":
        return a / b
    else:
        return "无效操作符"

print(calculator(10, 5, "+"))  # 输出：15