Python零基础入门实战教程：从Hello World到文件处理-5

最新推荐文章于 2026-01-07 13:36:22 发布

原创最新推荐文章于 2026-01-07 13:36:22 发布 · 719 阅读

20 ·

CC 4.0 BY-SA版权

文章标签：

#python #开发语言

python 专栏收录该内容

13 篇文章

订阅专栏

第5章：控制程序的逻辑——流程控制

章节介绍

想象一下，一个程序如果只能僵硬地、按顺序执行每一行代码，就像火车只能在一条固定的轨道上运行，那该多无趣，也多有局限。现实中，我们需要程序能“思考”、能“决策”、能“重复”做某些事情。这正是流程控制要赋予程序的能力。

程序就像一份灵活的食谱。有时候，你需要根据手头是否有鸡蛋，来决定是做炒蛋还是煎饼（这需要条件判断）。有时候，你需要重复搅拌面糊，直到它变得顺滑（这需要循环）。流程控制，就是编写这份智能食谱的语法规则。

在Python里，我们使用 if、elif 和 else 来为程序做决策。比如，一个根据分数判断等级的功能：

def calculateGrade(score: float) -> str:
    """
    根据分数计算等级
    
    参数:
        score (float): 学生的分数，范围0-100
    
    返回:
        str: 等级（A、B、C、D、F）
    
    示例:
        >>> calculateGrade(95)
        'A'
        >>> calculateGrade(75)
        'C'
    """
    if score >= 90:
        return "A"
    elif score >= 80:
        return "B"
    elif score >= 70:
        return "C"
    elif score >= 60:
        return "D"
    else:
        return "F"

这个函数检查 score 的值，并像老师批改试卷一样，返回对应的等级。它清晰地展示了如何让程序在不同的条件下选择不同的路径。类似的，判断一个数字是正、负还是零，逻辑也一样清晰：

def checkNumberType(num: int) -> str:
    """
    检查数字的类型
    
    参数:
        num (int): 要检查的整数
    
    返回:
        str: 数字类型的描述
    
    示例:
        >>> checkNumberType(10)
        '正数'
        >>> checkNumberType(-5)
        '负数'
        >>> checkNumberType(0)
        '零'
    """
    if num > 0:
        return "正数"
    elif num < 0:
        return "负数"
    else:
        return "零"

但程序的力量不止于做一次选择。当我们需要重复一个动作时，循环就派上用场了。while 循环会在条件满足时一直运行，就像“只要水没开，就继续烧”的指令。用它来计算从1累加到n的和非常直观：

def sumNumbers(n: int) -> int:
    """
    计算1到n的和
    
    参数:
        n (int): 求和的上限
    
    返回:
        int: 1到n的和
    
    示例:
        >>> sumNumbers(5)
        15
        >>> sumNumbers(10)
        55
    """
    total = 0
    i = 1
    while i <= n:
        total += i
        i += 1
    return total

更常见的 for 循环，则擅长在一个已知的集合里进行遍历，比如处理列表中的每一个元素。我们可以轻松地从一个数字列表里挑出所有的偶数：

def findEvenNumbers(numbers: list) -> list:
    """
    从列表中找出所有偶数
    
    参数:
        numbers (list): 包含整数的列表
    
    返回:
        list: 包含所有偶数的列表
    
    示例:
        >>> findEvenNumbers([1, 2, 3, 4, 5, 6])
        [2, 4, 6]
        >>> findEvenNumbers([1, 3, 5])
        []
    """
    even_numbers = []
    for number in numbers:
        if number % 2 == 0:
            even_numbers.append(number)
    return even_numbers

循环还可以层层嵌套，解决更复杂的问题，比如生成一个乘法表：

def printMultiplicationTable(n: int) -> None:
    """
    打印n的乘法表
    
    参数:
        n (int): 要打印乘法表的数字
    
    示例:
        >>> printMultiplicationTable(5)
        5 x 1 = 5
        5 x 2 = 10
        5 x 3 = 15
        5 x 4 = 20
        5 x 5 = 25
        5 x 6 = 30
        5 x 7 = 35
        5 x 8 = 40
        5 x 9 = 45
        5 x 10 = 50
    """
    for i in range(1, 11):
        result = n * i
        print(f"{n} x {i} = {result}")

在循环里，你还能进行更精细的控制。使用 break 可以像紧急刹车一样立刻终止整个循环，比如一个倒计时程序：

def countdown(start: int) -> None:
    """
    从指定数字开始倒计时
    
    参数:
        start (int): 开始倒计时的数字
    
    示例:
        >>> countdown(5)
        5
        4
        3
        2
        1
        发射！
    """
    count = start
    while True:
        if count == 0:
            print("发射！")
            break
        print(count)
        count -= 1

而 continue 则像是跳过当前这一步，直接进入下一轮循环。比如在处理一个列表时，我们想忽略掉所有奇数，只收集偶数：

def skipOddNumbers(numbers: list) -> list:
    """
    跳过列表中的奇数
    
    参数:
        numbers (list): 包含整数的列表
    
    返回:
        list: 只包含偶数的列表
    
    示例:
        >>> skipOddNumbers([1, 2, 3, 4, 5, 6])
        [2, 4, 6]
    """
    even_numbers = []
    for number in numbers:
        if number % 2 != 0:
            continue
        even_numbers.append(number)
    return even_numbers

流程控制的这些基本结构，能组合出强大的逻辑。例如，验证一个密码是否足够强壮，需要同时检查长度、数字、字母等多种条件：

def validatePassword(password: str) -> tuple:
    """
    验证密码强度
    
    参数:
        password (str): 要验证的密码
    
    返回:
        tuple: (是否有效, 错误信息)
    
    示例:
        >>> validatePassword("Abc123!")
        (True, '密码强度足够')
        >>> validatePassword("abc")
        (False, '密码必须至少8个字符，包含大小写字母和数字')
    """
    if len(password) < 8:
        return False, "密码必须至少8个字符"
    
    has_upper = any(char.isupper() for char in password)
    has_lower = any(char.islower() for char in password)
    has_digit = any(char.isdigit() for char in password)
    
    if not has_upper:
        return False, "密码必须包含至少一个大写字母"
    if not has_lower:
        return False, "密码必须包含至少一个小写字母"
    if not has_digit:
        return False, "密码必须包含至少一个数字"
    
    return True, "密码强度足够"

或者模拟一个购物车的结算逻辑，筛选商品并计算总价：

def processShoppingCart(items: list, max_price: float = 100.0) -> dict:
    """
    处理购物车商品
    
    参数:
        items (list): 商品列表，每个商品是包含名称和价格的字典
        max_price (float): 允许的最大单价，默认为100.0
    
    返回:
        dict: 处理结果，包含总价、有效商品列表和无效商品列表
    
    示例:
        >>> items = [{"name": "苹果", "price": 5.0},
        ...          {"name": "香蕉", "price": 3.0},
        ...          {"name": "电脑", "price": 200.0}]
        >>> processShoppingCart(items)
        {'total_price': 8.0,
         'valid_items': [{'name': '苹果', 'price': 5.0},
                        {'name': '香蕉', 'price': 3.0}],
         'invalid_items': [{'name': '电脑', 'price': 200.0}]}
    """
    valid_items = []
    invalid_items = []
    total_price = 0.0
    
    for item in items:
        price = item.get("price", 0)
        
        if price <= 0:
            invalid_items.append(item)
        elif price > max_price:
            invalid_items.append(item)
        else:
            valid_items.append(item)
            total_price += price
    
    return {
        "total_price": round(total_price, 2),
        "valid_items": valid_items,
        "invalid_items": invalid_items
    }

一个经典的编程练习是寻找质数，它完美融合了循环嵌套和条件判断：

def findPrimeNumbers(limit: int) -> list:
    """
    找出小于等于limit的所有质数
    
    参数:
        limit (int): 上限
    
    返回:
        list: 所有质数的列表
    
    示例:
        >>> findPrimeNumbers(10)
        [2, 3, 5, 7]
        >>> findPrimeNumbers(20)
        [2, 3, 5, 7, 11, 13, 17, 19]
    """
    primes = []
    
    for num in range(2, limit + 1):
        is_prime = True
        
        # 检查是否为质数
        for i in range(2, int(num ** 0.5) + 1):
            if num % i == 0:
                is_prime = False
                break
        
        if is_prime:
            primes.append(num)
    
    return primes

有时，你还会遇到一种基于一个变量的多个不同值，来执行不同分支的逻辑。虽然Python没有 switch-case 语句，但我们可以用 if-elif-else 链或者字典映射来优雅地实现，比如进行温度单位转换：

def convertTemperature(value: float, unit: str) -> float:
    """
    温度转换
    
    参数:
        value (float): 温度值
        unit (str): 转换类型，可选值：'c_to_f', 'f_to_c'
    
    返回:
        float: 转换后的温度值
    
    示例:
        >>> convertTemperature(100, 'c_to_f')
        212.0
        >>> convertTemperature(32, 'f_to_c')
        0.0
    """
    if unit == "c_to_f":
        # 摄氏度转华氏度
        return (value * 9/5) + 32
    elif unit == "f_to_c":
        # 华氏度转摄氏度
        return (value - 32) * 5/9
    else:
        raise ValueError("无效的转换类型。请使用 'c_to_f' 或 'f_to_c'")

更有趣的是，函数甚至可以调用自身，这被称为递归。它用另一种简洁的方式表达了重复和决策，例如计算一个数的阶乘：

def calculateFactorial(n: int) -> int:
    """
    计算阶乘
    
    参数:
        n (int): 非负整数
    
    返回:
        int: n的阶乘
    
    示例:
        >>> calculateFactorial(5)
        120
        >>> calculateFactorial(0)
        1
    """
    if n == 0 or n == 1:
        return 1
    else:
        return n * calculateFactorial(n - 1)

理解条件、循环以及它们的控制语句（break, continue），你就掌握了指挥程序流程的“语法”。这不再是让代码一条直线走到底，而是让它能够灵活地判断、重复、跳转，从而解决真正多变的问题。尝试运行和修改上面这些例子，比如改变 calculateGrade 函数的分数，或者看看 findPrimeNumbers 函数找到的质数列表，你会对流程控制有更直接的感受。

核心概念

程序执行通常是从上到下、一行一行进行的。但现实问题很少这么简单。我们需要根据不同的情况执行不同的代码，或者让某些代码重复执行多次。指挥代码何时运行、运行多少次的能力，就是流程控制。

想想看，如果没有流程控制会怎样？一个计算成绩等级的程序，将只能输出一种结果；一个处理用户购物车的程序，也无法根据商品价格或数量做出任何调整。流程控制赋予了程序最基本的“智能”，让它能做出判断和重复劳动。

流程控制的核心是两件事：条件判断和循环。

条件判断让程序能够做决定。在Python中，这主要通过 if、elif 和 else 语句来实现。比如，一个根据分数划分等级的函数：

def calculateGrade(score: float) -> str:
    """
    根据分数计算等级
    
    参数:
        score (float): 学生的分数，范围0-100
    
    返回:
        str: 等级（A、B、C、D、F）
    
    示例:
        >>> calculateGrade(95)
        'A'
        >>> calculateGrade(75)
        'C'
    """
    if score >= 90:
        return "A"
    elif score >= 80:
        return "B"
    elif score >= 70:
        return "C"
    elif score >= 60:
        return "D"
    else:
        return "F"

这个函数清晰地展示了“如果…否则如果…否则”的逻辑链条。条件判断还可以嵌套，形成更复杂的决策树，比如检查一个数字是正数、负数还是零：

def checkNumberType(num: int) -> str:
    """
    检查数字的类型
    
    参数:
        num (int): 要检查的整数
    
    返回:
        str: 数字类型的描述
    
    示例:
        >>> checkNumberType(10)
        '正数'
        >>> checkNumberType(-5)
        '负数'
        >>> checkNumberType(0)
        '零'
    """
    if num > 0:
        return "正数"
    elif num < 0:
        return "负数"
    else:
        return "零"

循环则让程序能够高效地处理重复性任务。Python提供了两种主要的循环结构：while 循环和 for 循环。

while 循环在条件为真时持续执行，适合当你不知道需要循环多少次时。例如，计算从1加到n的和：

def sumNumbers(n: int) -> int:
    """
    计算1到n的和
    
    参数:
        n (int): 求和的上限
    
    返回:
        int: 1到n的和
    
    示例:
        >>> sumNumbers(5)
        15
        >>> sumNumbers(10)
        55
    """
    total = 0
    i = 1
    while i <= n:
        total += i
        i += 1
    return total

for 循环更常用于遍历一个已知的序列（如列表、字符串）中的每个元素。它能让你简洁地对集合中的每一项进行操作。比如，从一个数字列表中筛选出所有偶数：

def findEvenNumbers(numbers: list) -> list:
    """
    从列表中找出所有偶数
    
    参数:
        numbers (list): 包含整数的列表
    
    返回:
        list: 包含所有偶数的列表
    
    示例:
        >>> findEvenNumbers([1, 2, 3, 4, 5, 6])
        [2, 4, 6]
        >>> findEvenNumbers([1, 3, 5])
        []
    """
    even_numbers = []
    for number in numbers:
        if number % 2 == 0:
            even_numbers.append(number)
    return even_numbers

有时，我们需要在循环内部进行更精细的控制，比如提前跳出循环，或者跳过当前轮次。break 语句用于立即终止整个循环，continue 语句则是跳过当前循环的剩余语句，直接开始下一轮。

def countdown(start: int) -> None:
    """
    从指定数字开始倒计时
    
    参数:
        start (int): 开始倒计时的数字
    
    示例:
        >>> countdown(5)
        5
        4
        3
        2
        1
        发射！
    """
    count = start
    while True:
        if count == 0:
            print("发射！")
            break
        print(count)
        count -= 1

def skipOddNumbers(numbers: list) -> list:
    """
    跳过列表中的奇数
    
    参数:
        numbers (list): 包含整数的列表
    
    返回:
        list: 只包含偶数的列表
    
    示例:
        >>> skipOddNumbers([1, 2, 3, 4, 5, 6])
        [2, 4, 6]
    """
    even_numbers = []
    for number in numbers:
        if number % 2 != 0:
            continue
        even_numbers.append(number)
    return even_numbers

循环的另一个强大概念是“递归”，即函数调用自身。它是一种优雅的解决问题的方式，尤其适合处理可以分解为同类子问题的情况，比如计算阶乘：

def calculateFactorial(n: int) -> int:
    """
    计算阶乘
    
    参数:
        n (int): 非负整数
    
    返回:
        int: n的阶乘
    
    示例:
        >>> calculateFactorial(5)
        120
        >>> calculateFactorial(0)
        1
    """
    if n == 0 or n == 1:
        return 1
    else:
        return n * calculateFactorial(n - 1)

在实际编程中，条件判断和循环总是紧密结合的。一个处理购物车的函数可能需要在循环遍历商品的同时，根据价格条件进行筛选和计算：

def processShoppingCart(items: list, max_price: float = 100.0) -> dict:
    """
    处理购物车商品
    
    参数:
        items (list): 商品列表，每个商品是包含名称和价格的字典
        max_price (float): 允许的最大单价，默认为100.0
    
    返回:
        dict: 处理结果，包含总价、有效商品列表和无效商品列表
    
    示例:
        >>> items = [{"name": "苹果", "price": 5.0},
        ...          {"name": "香蕉", "price": 3.0},
        ...          {"name": "电脑", "price": 200.0}]
        >>> processShoppingCart(items)
        {'total_price': 8.0,
         'valid_items': [{'name': '苹果', 'price': 5.0},
                        {'name': '香蕉', 'price': 3.0}],
         'invalid_items': [{'name': '电脑', 'price': 200.0}]}
    """
    valid_items = []
    invalid_items = []
    total_price = 0.0
    
    for item in items:
        price = item.get("price", 0)
        
        if price <= 0:
            invalid_items.append(item)
        elif price > max_price:
            invalid_items.append(item)
        else:
            valid_items.append(item)
            total_price += price
    
    return {
        "total_price": round(total_price, 2),
        "valid_items": valid_items,
        "invalid_items": invalid_items
    }

流程控制是构建程序逻辑的骨架。掌握了条件与循环，你就获得了让代码“活”起来的基本工具，能够应对从简单数据分类到复杂算法实现的各类任务。试着用这些工具去分解你遇到的每一个问题：需要做决定吗？需要重复操作吗？答案通常会指向 if 或某个循环结构。

实践应用

理解了，我们现在来看看这些流程控制的结构如何组合起来，解决一些更贴近实际的问题。编程的魅力在于将零散的命令组织成有效的逻辑，而不仅仅是记住语法。

想象一下，你需要判断一个学生的成绩等级。这需要根据不同的分数区间给出不同的结果，这正是 if-elif-else 链条的典型场景。

def calculateGrade(score: float) -> str:
    """
    根据分数计算等级
    
    参数:
        score (float): 学生的分数，范围0-100
    
    返回:
        str: 等级（A、B、C、D、F）
    
    示例:
        >>> calculateGrade(95)
        'A'
        >>> calculateGrade(75)
        'C'
    """
    if score >= 90:
        return "A"
    elif score >= 80:
        return "B"
    elif score >= 70:
        return "C"
    elif score >= 60:
        return "D"
    else:
        return "F"

这个函数清晰地展示了多分支条件判断。它从上到下依次检查分数满足哪个条件，一旦匹配就执行对应的代码块并返回结果，后面的条件就不再判断了。类似的，检查一个数字是正数、负数还是零，也会用到这种结构。

def checkNumberType(num: int) -> str:
    """
    检查数字的类型
    
    参数:
        num (int): 要检查的整数
    
    返回:
        str: 数字类型的描述
    
    示例:
        >>> checkNumberType(10)
        '正数'
        >>> checkNumberType(-5)
        '负数'
        >>> checkNumberType(0)
        '零'
    """
    if num > 0:
        return "正数"
    elif num < 0:
        return "负数"
    else:
        return "零"

循环则让我们能处理重复性的工作。比如，计算从1加到n的总和，你不需要手动写n行加法，一个 while 循环就能搞定。

def sumNumbers(n: int) -> int:
    """
    计算1到n的和
    
    参数:
        n (int): 求和的上限
    
    返回:
        int: 1到n的和
    
    示例:
        >>> sumNumbers(5)
        15
        >>> sumNumbers(10)
        55
    """
    total = 0
    i = 1
    while i <= n:
        total += i
        i += 1
    return total

这里的逻辑是：只要当前的数字 i 没有超过目标 n，就把它加到总和里，然后让 i 增加1，进入下一轮循环。直到条件不满足，循环结束。对于遍历一个已知的集合，比如列表，for 循环更加方便。

def findEvenNumbers(numbers: list) -> list:
    """
    从列表中找出所有偶数
    
    参数:
        numbers (list): 包含整数的列表
    
    返回:
        list: 包含所有偶数的列表
    
    示例:
        >>> findEvenNumbers([1, 2, 3, 4, 5, 6])
        [2, 4, 6]
        >>> findEvenNumbers([1, 3, 5])
        []
    """
    even_numbers = []
    for number in numbers:
        if number % 2 == 0:
            even_numbers.append(number)
    return even_numbers

这个函数遍历列表中的每个数字，用 if 条件检查它是否为偶数（num % 2 == 0），如果是就添加到结果列表中。这是一种非常常见的“过滤”模式。

真正的程序很少只使用单一的结构，而是将它们组合在一起。考虑一个处理购物车的函数，它需要遍历所有商品，检查库存和价格，并计算总金额。

def processShoppingCart(items: list, max_price: float = 100.0) -> dict:
    """
    处理购物车商品
    
    参数:
        items (list): 商品列表，每个商品是包含名称和价格的字典
        max_price (float): 允许的最大单价，默认为100.0
    
    返回:
        dict: 处理结果，包含总价、有效商品列表和无效商品列表
    
    示例:
        >>> items = [{"name": "苹果", "price": 5.0},
        ...          {"name": "香蕉", "price": 3.0},
        ...          {"name": "电脑", "price": 200.0}]
        >>> processShoppingCart(items)
        {'total_price': 8.0,
         'valid_items': [{'name': '苹果', 'price': 5.0},
                        {'name': '香蕉', 'price': 3.0}],
         'invalid_items': [{'name': '电脑', 'price': 200.0}]}
    """
    valid_items = []
    invalid_items = []
    total_price = 0.0
    
    for item in items:
        price = item.get("price", 0)
        
        if price <= 0:
            invalid_items.append(item)
        elif price > max_price:
            invalid_items.append(item)
        else:
            valid_items.append(item)
            total_price += price
    
    return {
        "total_price": round(total_price, 2),
        "valid_items": valid_items,
        "invalid_items": invalid_items
    }

你看到了吗？这里有一个 for 循环来遍历商品列表。在循环内部，使用了 if 语句来检查价格是否超过上限，并使用 elif 检查库存。根据不同的条件，商品被归类到不同的列表中。循环结束后，再用收集到的信息汇总返回。这就是条件判断和循环的典型协作。

有时，任务的逻辑需要更精细的控制。比如找出一定范围内的所有质数，这需要一些算法思维。

def findPrimeNumbers(limit: int) -> list:
    """
    找出小于等于limit的所有质数
    
    参数:
        limit (int): 上限
    
    返回:
        list: 所有质数的列表
    
    示例:
        >>> findPrimeNumbers(10)
        [2, 3, 5, 7]
        >>> findPrimeNumbers(20)
        [2, 3, 5, 7, 11, 13, 17, 19]
    """
    primes = []
    
    for num in range(2, limit + 1):
        is_prime = True
        
        # 检查是否为质数
        for i in range(2, int(num ** 0.5) + 1):
            if num % i == 0:
                is_prime = False
                break
        
        if is_prime:
            primes.append(num)
    
    return primes

这个函数使用了嵌套循环：外层循环遍历所有待检查的数字，内层循环检查当前数字是否能被某个更小的数整除。如果在内层循环中发现它是合数，就使用 break 提前结束内层循环。如果内层循环完整执行完毕（即没有找到能整除的数），则说明它是质数，被添加到结果列表。break 用于彻底跳出当前循环。

def countdown(start: int) -> None:
    """
    从指定数字开始倒计时
    
    参数:
        start (int): 开始倒计时的数字
    
    示例:
        >>> countdown(5)
        5
        4
        3
        2
        1
        发射！
    """
    count = start
    while True:
        if count == 0:
            print("发射！")
            break
        print(count)
        count -= 1

在倒计时函数中，当 t 减到0时，break 语句会立即终止 while 循环。与 break 不同，continue 不是结束循环，而是跳过当前循环迭代的剩余部分，直接开始下一次迭代。

def skipOddNumbers(numbers: list) -> list:
    """
    跳过列表中的奇数
    
    参数:
        numbers (list): 包含整数的列表
    
    返回:
        list: 只包含偶数的列表
    
    示例:
        >>> skipOddNumbers([1, 2, 3, 4, 5, 6])
        [2, 4, 6]
    """
    even_numbers = []
    for number in numbers:
        if number % 2 != 0:
            continue
        even_numbers.append(number)
    return even_numbers

这里，当遇到奇数时，continue 语句会跳过 result.append(num) 这行代码，直接进入 for 循环的下一个数字，这样就实现了“只保留偶数”的效果。

除了循环，函数调用自身——也就是递归——也是控制程序流程的一种强大方式，它能以简洁的代码解决某些特定问题。

def calculateFactorial(n: int) -> int:
    """
    计算阶乘
    
    参数:
        n (int): 非负整数
    
    返回:
        int: n的阶乘
    
    示例:
        >>> calculateFactorial(5)
        120
        >>> calculateFactorial(0)
        1
    """
    if n == 0 or n == 1:
        return 1
    else:
        return n * calculateFactorial(n - 1)

计算阶乘 n! 定义为 n * (n-1)!，这天然就是一个递归定义。函数在内部调用自己来计算更小规模的相同问题，直到达到基线条件（n <= 1）时返回。递归和循环可以相互转换，但递归的思维模式有时能让代码更清晰。

再看一个需要复杂条件判断的例子：验证密码强度。这通常不是单一条件，而是多个条件需要同时或分别满足。

def validatePassword(password: str) -> tuple:
    """
    验证密码强度
    
    参数:
        password (str): 要验证的密码
    
    返回:
        tuple: (是否有效, 错误信息)
    
    示例:
        >>> validatePassword("Abc123!")
        (True, '密码强度足够')
        >>> validatePassword("abc")
        (False, '密码必须至少8个字符，包含大小写字母和数字')
    """
    if len(password) < 8:
        return False, "密码必须至少8个字符"
    
    has_upper = any(char.isupper() for char in password)
    has_lower = any(char.islower() for char in password)
    has_digit = any(char.isdigit() for char in password)
    
    if not has_upper:
        return False, "密码必须包含至少一个大写字母"
    if not has_lower:
        return False, "密码必须包含至少一个小写字母"
    if not has_digit:
        return False, "密码必须包含至少一个数字"
    
    return True, "密码强度足够"

这个函数通过一系列布尔标志（has_upper, has_lower 等）来记录密码是否满足各种强度规则。最后，根据这些标志的组合情况，使用 if-elif-else 来判断整体强度等级。它演示了如何将复杂的、多方面的条件判断分解为多个简单的步骤，然后综合评估。

最后，我们经常需要根据不同的输入执行不同的操作。在其他编程语言中可能有 switch-case 语句，在Python中，我们通常用字典映射或 if-elif-else 来实现。

def convertTemperature(value: float, unit: str) -> float:
    """
    温度转换
    
    参数:
        value (float): 温度值
        unit (str): 转换类型，可选值：'c_to_f', 'f_to_c'
    
    返回:
        float: 转换后的温度值
    
    示例:
        >>> convertTemperature(100, 'c_to_f')
        212.0
        >>> convertTemperature(32, 'f_to_c')
        0.0
    """
    if unit == "c_to_f":
        # 摄氏度转华氏度
        return (value * 9/5) + 32
    elif unit == "f_to_c":
        # 华氏度转摄氏度
        return (value - 32) * 5/9
    else:
        raise ValueError("无效的转换类型。请使用 'c_to_f' 或 'f_to_c'")

这个函数接收一个温度值和单位，然后根据单位选择不同的计算公式。它使用了 if-elif-else 结构来模拟“多路选择”。对于更复杂的情况，事先定义一个将“选项”映射到“处理函数”的字典，会是更优雅和易于扩展的方式。

把这些流程控制的工具放在一起，你就拥有了构建程序逻辑的基础模块。关键不在于记住每一个语法细节，而在于理解如何将一个复杂任务分解成“在什么条件下做什么事”以及“重复做什么事直到满足条件”这样的基本步骤。试着去读别人写的函数，分析里面的循环和条件判断；然后从解决小问题开始，自己动手组合它们。

章节总结

要让一段代码真正“活”起来，拥有处理各种情况的能力，关键在于流程控制。它决定了代码执行的路径，是程序逻辑的骨架。

想想看，如果没有条件判断，程序只能机械地从头走到尾；如果没有循环，重复的任务会让我们写到手软。流程控制赋予代码做决定和重复行动的能力。

做决定，依靠的是条件语句。最基本的 if-elif-else 结构就像路标，根据不同的情况选择不同的方向。比如，判断一个分数属于哪个等级，直接使用 `

def calculateGrade(score: float) -> str:
    """
    根据分数计算等级
    
    参数:
        score (float): 学生的分数，范围0-100
    
    返回:
        str: 等级（A、B、C、D、F）
    
    示例:
        >>> calculateGrade(95)
        'A'
        >>> calculateGrade(75)
        'C'
    """
    if score >= 90:
        return "A"
    elif score >= 80:
        return "B"
    elif score >= 70:
        return "C"
    elif score >= 60:
        return "D"
    else:
        return "F"

函数就能清晰明了地完成这个分支选择。当条件变得更复杂时，比如需要同时满足长度、包含数字字母等多种要求时，

def validatePassword(password: str) -> tuple:
    """
    验证密码强度
    
    参数:
        password (str): 要验证的密码
    
    返回:
        tuple: (是否有效, 错误信息)
    
    示例:
        >>> validatePassword("Abc123!")
        (True, '密码强度足够')
        >>> validatePassword("abc")
        (False, '密码必须至少8个字符，包含大小写字母和数字')
    """
    if len(password) < 8:
        return False, "密码必须至少8个字符"
    
    has_upper = any(char.isupper() for char in password)
    has_lower = any(char.islower() for char in password)
    has_digit = any(char.isdigit() for char in password)
    
    if not has_upper:
        return False, "密码必须包含至少一个大写字母"
    if not has_lower:
        return False, "密码必须包含至少一个小写字母"
    if not has_digit:
        return False, "密码必须包含至少一个数字"
    
    return True, "密码强度足够"

` 函数展示了如何将这些判断逻辑组合在一起。

重复行动，则是循环的舞台。for 循环擅长处理已知集合或确定次数，比如从一个数字列表中筛选出偶数，`

def findEvenNumbers(numbers: list) -> list:
    """
    从列表中找出所有偶数
    
    参数:
        numbers (list): 包含整数的列表
    
    返回:
        list: 包含所有偶数的列表
    
    示例:
        >>> findEvenNumbers([1, 2, 3, 4, 5, 6])
        [2, 4, 6]
        >>> findEvenNumbers([1, 3, 5])
        []
    """
    even_numbers = []
    for number in numbers:
        if number % 2 == 0:
            even_numbers.append(number)
    return even_numbers

就演示了如何遍历列表并与条件判断配合。而while 循环则在“只要条件为真，就继续执行”的场景下大放异彩，像计算累加和，

def sumNumbers(n: int) -> int:
    """
    计算1到n的和
    
    参数:
        n (int): 求和的上限
    
    返回:
        int: 1到n的和
    
    示例:
        >>> sumNumbers(5)
        15
        >>> sumNumbers(10)
        55
    """
    total = 0
    i = 1
    while i <= n:
        total += i
        i += 1
    return total

` 函数就是一个典型例子。

在实际问题中，循环和条件判断常常紧密合作。想象一下处理一个购物车，你需要遍历所有商品，同时检查价格、计算总价，并根据规则进行打折或提醒，`

def processShoppingCart(items: list, max_price: float = 100.0) -> dict:
    """
    处理购物车商品
    
    参数:
        items (list): 商品列表，每个商品是包含名称和价格的字典
        max_price (float): 允许的最大单价，默认为100.0
    
    返回:
        dict: 处理结果，包含总价、有效商品列表和无效商品列表
    
    示例:
        >>> items = [{"name": "苹果", "price": 5.0},
        ...          {"name": "香蕉", "price": 3.0},
        ...          {"name": "电脑", "price": 200.0}]
        >>> processShoppingCart(items)
        {'total_price': 8.0,
         'valid_items': [{'name': '苹果', 'price': 5.0},
                        {'name': '香蕉', 'price': 3.0}],
         'invalid_items': [{'name': '电脑', 'price': 200.0}]}
    """
    valid_items = []
    invalid_items = []
    total_price = 0.0
    
    for item in items:
        price = item.get("price", 0)
        
        if price <= 0:
            invalid_items.append(item)
        elif price > max_price:
            invalid_items.append(item)
        else:
            valid_items.append(item)
            total_price += price
    
    return {
        "total_price": round(total_price, 2),
        "valid_items": valid_items,
        "invalid_items": invalid_items
    }

` 函数就体现了这种组合的威力。

循环中还有两个重要的控制语句：break 和 continue。break 用于完全终止循环，比如倒计时归零后停止，`

def countdown(start: int) -> None:
    """
    从指定数字开始倒计时
    
    参数:
        start (int): 开始倒计时的数字
    
    示例:
        >>> countdown(5)
        5
        4
        3
        2
        1
        发射！
    """
    count = start
    while True:
        if count == 0:
            print("发射！")
            break
        print(count)
        count -= 1

函数展示了这种“中断”逻辑。而continue则是跳过当前循环的剩余部分，直接开始下一轮，这在需要过滤掉某些元素时非常有用，例如

def skipOddNumbers(numbers: list) -> list:
    """
    跳过列表中的奇数
    
    参数:
        numbers (list): 包含整数的列表
    
    返回:
        list: 只包含偶数的列表
    
    示例:
        >>> skipOddNumbers([1, 2, 3, 4, 5, 6])
        [2, 4, 6]
    """
    even_numbers = []
    for number in numbers:
        if number % 2 != 0:
            continue
        even_numbers.append(number)
    return even_numbers

` 函数就跳过了所有奇数。

将这些基本结构——顺序执行、条件分支、循环——进行组合和嵌套，就能构建出解决复杂问题的逻辑。例如，找出一定范围内的所有质数，这需要嵌套循环来测试每个数，并在内层循环中使用条件判断来检查整除性，`

def findPrimeNumbers(limit: int) -> list:
    """
    找出小于等于limit的所有质数
    
    参数:
        limit (int): 上限
    
    返回:
        list: 所有质数的列表
    
    示例:
        >>> findPrimeNumbers(10)
        [2, 3, 5, 7]
        >>> findPrimeNumbers(20)
        [2, 3, 5, 7, 11, 13, 17, 19]
    """
    primes = []
    
    for num in range(2, limit + 1):
        is_prime = True
        
        # 检查是否为质数
        for i in range(2, int(num ** 0.5) + 1):
            if num % i == 0:
                is_prime = False
                break
        
        if is_prime:
            primes.append(num)
    
    return primes