Python循环编程：从基础到高级技巧全解析

1. Python循环基础：从入门到避坑指南

作为Python中最基础也最常用的语法结构，循环几乎出现在每一个Python程序中。但看似简单的循环语句，却让无数新手在条件控制、流程跳转和嵌套逻辑上栽跟头。今天我们就来彻底拆解Python循环的方方面面，让你不仅能写出正确的循环代码，更能理解背后的设计逻辑。

1.1 为什么需要循环？

想象你是一个餐厅服务员，需要为10桌客人上菜。如果没有循环，你的代码会是这样：

python复制serve_table(1)
serve_table(2)
serve_table(3)
...
serve_table(10)

而使用循环后：

python复制for table in range(1, 11):
    serve_table(table)

循环的本质是代码复用和自动化控制。它解决了两个核心问题：

1. 减少重复代码，提高开发效率
2. 动态控制执行次数，适应不同场景需求

1.2 Python中的两种循环结构

Python提供了两种主要的循环方式：

1. for循环：已知迭代次数或需要遍历集合时使用
2. while循环：根据条件动态决定循环次数时使用

这两种循环不是相互替代的关系，而是针对不同场景的工具选择。理解它们的适用场景是写出高效Python代码的第一步。

2. for循环深度解析

2.1 for循环的基本结构

for循环的标准语法如下：

python复制for 变量 in 可迭代对象:
    循环体代码块

这里的"可迭代对象"可以是：

• 序列类型：列表、元组、字符串
• 字典
• 集合
• 生成器（如range）
• 文件对象
• 任何实现了迭代器协议的对象

2.1.1 列表遍历示例

python复制fruits = ['apple', 'banana', 'orange']
for fruit in fruits:
    print(fruit.upper())

这段代码会依次输出：

code复制APPLE
BANANA
ORANGE

注意：for循环中的变量名（上例中的fruit）可以是任意合法的变量名，但应该尽量使用有意义的名称，提高代码可读性。

2.2 range函数的妙用

range()是for循环的最佳搭档，它可以生成一个整数序列。range有三种使用方式：

1. range(stop)：0到stop-1
2. range(start, stop)：start到stop-1
3. range(start, stop, step)：从start开始，每次增加step，直到stop-1

2.2.1 range使用示例

python复制# 打印0-4
for i in range(5):
    print(i)

# 打印2-5
for i in range(2, 6):
    print(i)

# 打印0-10的偶数
for i in range(0, 11, 2):
    print(i)

避坑提示：range生成的序列是"左闭右开"的，即包含起始值，不包含结束值。这是Python中常见的区间表示方式，与列表切片一致。

2.3 字典遍历技巧

字典的遍历比序列稍复杂，因为涉及键和值。Python提供了几种方式：

2.3.1 遍历键

python复制person = {'name': 'Alice', 'age': 25, 'job': 'Engineer'}
for key in person:
    print(key)

2.3.2 遍历键值对

python复制for key, value in person.items():
    print(f"{key}: {value}")

2.3.3 仅遍历值

python复制for value in person.values():
    print(value)

经验分享：在Python 3中，.keys()、.values()和.items()返回的是视图对象，而非列表。它们会动态反映字典的变化，且更节省内存。

2.4 for循环的陷阱与解决方案

2.4.1 遍历时修改列表的危险

这是一个经典错误：

python复制numbers = [1, 2, 3, 4, 5]
for num in numbers:
    if num % 2 == 0:
        numbers.remove(num)
print(numbers)  # 输出可能是[1, 3, 5]，但不可靠

问题原因：在遍历列表的同时修改它，会导致Python的内部迭代器混乱。

解决方案：

1. 遍历列表的副本

python复制for num in numbers[:]:
    if num % 2 == 0:
        numbers.remove(num)

2. 使用列表推导式创建新列表

python复制numbers = [num for num in numbers if num % 2 != 0]

2.4.2 无限循环的风险

虽然for循环通常不会无限循环，但在某些情况下也可能出现问题：

python复制# 无限循环示例（理论上）
iterator = iter([1, 2, 3])
for num in iterator:
    print(num)
    if num == 2:
        iterator.send(1)  # 手动干预迭代器可能导致意外行为

最佳实践：除非你完全理解迭代器协议，否则不要在for循环中手动操作迭代器。

3. while循环完全指南

3.1 while循环的基本结构

while循环的语法如下：

python复制while 条件表达式:
    循环体代码块

while循环会重复执行代码块，直到条件表达式变为False。

3.1.1 基础示例

python复制count = 0
while count < 5:
    print(f"这是第{count+1}次循环")
    count += 1

3.2 while循环的典型应用场景

while循环特别适合以下情况：

1. 不确定循环次数时：

python复制# 读取用户输入直到输入'quit'
user_input = ''
while user_input.lower() != 'quit':
    user_input = input("请输入内容(输入quit退出): ")
    print(f"你输入了: {user_input}")

2. 处理实时数据流：

python复制# 模拟从网络接收数据
data_available = True
while data_available:
    data = get_network_data()  # 假设的函数
    if not data:
        data_available = False
    else:
        process_data(data)

3. 实现简单游戏循环：

python复制game_active = True
while game_active:
    player_action = get_player_input()
    game_state = update_game(player_action)
    render_game(game_state)
    if game_state['game_over']:
        game_active = False

3.3 while循环的常见陷阱

3.3.1 无限循环

这是while循环最常见的错误：

python复制# 危险的无限循环
count = 0
while count < 5:
    print("Oops, forgot to increment count!")

预防措施：

1. 总是确保循环条件最终会变为False
2. 设置安全计数器

python复制max_attempts = 1000
attempts = 0
while condition and attempts < max_attempts:
    # 循环体
    attempts += 1

3.3.2 复杂的退出条件

当退出条件过于复杂时，代码可读性会下降：

python复制# 难以理解的退出条件
while (not process_complete and not timeout) or (allow_retry and retries_left > 0):
    # 循环体

改进方案：

python复制should_continue = True
while should_continue:
    # 循环体
    
    # 更新继续条件
    if process_complete or timeout:
        should_continue = False
    elif not allow_retry or retries_left <= 0:
        should_continue = False

3.4 while与for的选择策略

如何决定使用哪种循环？考虑以下因素：

经验法则：

• 能使用for循环的场景优先使用for
• 只有在循环次数无法预先确定时才使用while

4. 循环控制：break与continue

4.1 break语句详解

break用于立即退出当前循环（无论是for还是while），不再执行循环中剩余的代码，也不会进行下一次迭代。

4.1.1 典型应用场景

1. 搜索满足条件的元素：

python复制numbers = [1, 3, 5, 8, 10, 13]
found = False
for num in numbers:
    if num % 2 == 0:
        print(f"找到第一个偶数: {num}")
        found = True
        break
if not found:
    print("没有找到偶数")

2. 处理错误或异常情况：

python复制max_retries = 3
retries = 0
while retries < max_retries:
    try:
        result = do_something_risky()
        break  # 成功则退出循环
    except Exception as e:
        print(f"尝试 {retries+1} 失败: {e}")
        retries += 1

4.2 continue语句详解

continue跳过当前迭代的剩余部分，直接进入下一次循环迭代。

4.2.1 典型应用场景

1. 过滤不符合条件的元素：

python复制# 打印1-10的奇数
for i in range(1, 11):
    if i % 2 == 0:
        continue
    print(i)

2. 处理部分数据：

python复制data = [1, 2, None, 4, '5', 6]
total = 0
for item in data:
    if not isinstance(item, int):
        continue
    total += item
print(f"有效数字总和: {total}")

4.3 break与continue的注意事项

1. 嵌套循环中的行为：

   • break和continue只影响当前所在的循环
   • 要退出多层循环，可以使用标志变量或异常

2. 避免过度使用：

   • 过多使用会降低代码可读性
   • 有时可以用if-else结构替代

3. 与else子句的交互：

   • break会跳过循环的else块
   • continue不影响else块执行

5. 循环嵌套与高级技巧

5.1 循环嵌套的原理

循环嵌套是指在一个循环体内包含另一个完整的循环结构。理解嵌套循环的关键是：

1. 外层循环每执行一次，内层循环会完整执行一遍
2. 内层循环可以访问外层循环的变量
3. 嵌套层数越多，复杂度呈指数增长

5.1.1 经典示例：乘法表

python复制for i in range(1, 10):  # 外层控制行
    for j in range(1, i+1):  # 内层控制列
        print(f"{j}×{i}={i*j}", end="\t")
    print()  # 换行

5.2 嵌套循环的性能考量

嵌套循环容易成为性能瓶颈，特别是当循环次数多时：

python复制# O(n^2)时间复杂度
for i in range(1000):
    for j in range(1000):
        # 一些操作

优化策略：

1. 尽量减少内层循环的工作量
2. 考虑是否可以用算法优化（如使用字典查找）
3. 使用内置函数替代显式循环（如itertools.product）

5.3 循环与else子句

Python循环有一个独特的else子句，它在以下情况下执行：

• for循环：当循环正常结束（未被break中断）时
• while循环：当条件变为False时

5.3.1 实际应用

python复制# 检查质数
num = 13
for i in range(2, num):
    if num % i == 0:
        print(f"{num}不是质数")
        break
else:
    print(f"{num}是质数")

注意：这个else属于循环，不是if语句的一部分。它提供了一种在没有break发生时执行代码的机制。

6. 循环最佳实践与性能优化

6.1 代码可读性技巧

1. 有意义的变量名：

   • 避免使用i、j、k等单字母变量（除非是简单循环）
   • 使用描述性名称，如for student in students

2. 限制嵌套层数：

   • 嵌套不应超过3层
   • 深层嵌套考虑拆分为函数

3. 适当添加注释：

   • 解释复杂循环逻辑
   • 注明循环不变量和终止条件

6.2 性能优化建议

1. 预计算可迭代对象：

   • 避免在循环条件中重复计算

   python复制# 不好
   while len(my_list) > 0:
       # 每次循环都计算len(my_list)
   
   # 更好
   length = len(my_list)
   while length > 0:
       length -= 1
   

2. 使用内置函数：

   • map()、filter()等通常比显式循环快
   • 但可能牺牲一些可读性

3. 避免不必要的循环：

   • 检查是否真的需要循环
   • 有时用切片或列表推导式更高效

6.3 调试循环的技巧

1. 打印关键变量：

   python复制for i, item in enumerate(items):
       print(f"迭代{i}: item={item}")
       # 其他代码
   

2. 使用断言检查循环不变量：

   python复制total = 0
   for num in numbers:
       assert isinstance(num, (int, float)), "非数字元素"
       total += num
   

3. 设置断点：

   • 在IDE中调试时，在循环开始处设置断点
   • 检查每次迭代的变量状态

7. 实战案例：循环的综合应用

7.1 案例1：统计文本词频

python复制def word_frequency(text):
    """统计文本中单词频率"""
    frequency = {}
    words = text.lower().split()
    
    for word in words:
        # 去除标点
        word = word.strip('.,!?;:"')
        if word:
            frequency[word] = frequency.get(word, 0) + 1
    
    return frequency

text = "Hello world. Hello Python. Python is great!"
print(word_frequency(text))

7.2 案例2：猜数字游戏

python复制import random

def guess_number():
    """猜数字游戏"""
    secret = random.randint(1, 100)
    attempts = 0
    max_attempts = 7
    
    print("猜一个1-100之间的数字，你有7次机会")
    
    while attempts < max_attempts:
        guess = input(f"第{attempts+1}次尝试，请输入你的猜测: ")
        
        try:
            guess = int(guess)
        except ValueError:
            print("请输入有效数字!")
            continue
        
        if guess == secret:
            print(f"恭喜! 你在{attempts+1}次尝试后猜对了!")
            break
        elif guess < secret:
            print("太小了!")
        else:
            print("太大了!")
        
        attempts += 1
    else:
        print(f"很遗憾，数字是{secret}")

guess_number()

7.3 案例3：文件处理

python复制def process_log_file(filename):
    """处理日志文件，提取错误信息"""
    errors = []
    line_number = 0
    
    try:
        with open(filename, 'r') as file:
            for line in file:
                line_number += 1
                line = line.strip()
                
                if not line:  # 跳过空行
                    continue
                
                if 'ERROR' in line:
                    errors.append((line_number, line))
                    
    except FileNotFoundError:
        print(f"文件 {filename} 不存在")
        return []
    
    return errors

# 使用示例
error_lines = process_log_file('app.log')
for line_num, error in error_lines:
    print(f"行{line_num}: {error}")

8. 常见问题与解决方案

8.1 循环不执行的可能原因

1. for循环：

   • 可迭代对象为空
   • range参数错误（如range(0)）

2. while循环：

   • 初始条件为False
   • 条件表达式逻辑错误

检查步骤：

1. 打印或检查可迭代对象/初始条件
2. 确认循环条件逻辑
3. 检查是否有语法错误

8.2 循环执行次数不对的调试方法

1. 添加打印语句：

   python复制print(f"开始循环，可迭代对象: {list(my_iterable)}")
   for item in my_iterable:
       print(f"当前处理: {item}")
       # 其他代码
   

2. 使用enumerate跟踪索引：

   python复制for i, item in enumerate(my_list):
       print(f"索引{i}: 值{item}")
   

3. 检查循环体内的修改操作：

   • 是否意外修改了循环变量？
   • 是否修改了正在迭代的对象？

8.3 处理大型数据集的循环优化

当处理大量数据时，循环可能成为性能瓶颈：

优化策略：

1. 分批处理：

   python复制chunk_size = 1000
   for i in range(0, len(big_list), chunk_size):
       chunk = big_list[i:i+chunk_size]
       process_chunk(chunk)
   

2. 使用生成器：

   python复制def data_stream():
       with open('big_file.txt') as f:
           for line in f:
               yield process_line(line)
   
   for data in data_stream():
       # 处理数据
   

3. 考虑并行处理：

   python复制from multiprocessing import Pool
   
   def process_item(item):
       # 处理单个项目
       return result
   
   with Pool(4) as p:  # 4个进程
       results = p.map(process_item, big_list)
   

9. 循环的进阶应用

9.1 列表推导式与生成器表达式

列表推导式提供了一种更简洁的创建列表的方式：

python复制# 传统方式
squares = []
for x in range(10):
    squares.append(x**2)

# 列表推导式
squares = [x**2 for x in range(10)]

生成器表达式则更节省内存：

python复制# 生成器表达式
squares_gen = (x**2 for x in range(10))

9.2 使用zip并行迭代

当需要同时遍历多个序列时：

python复制names = ['Alice', 'Bob', 'Charlie']
scores = [95, 87, 91]

for name, score in zip(names, scores):
    print(f"{name}: {score}")

9.3 enumerate获取索引

需要索引和值时：

python复制for index, value in enumerate(['a', 'b', 'c']):
    print(f"索引{index}的值是{value}")

9.4 使用itertools高级循环

Python的itertools模块提供了许多强大的循环工具：

python复制import itertools

# 无限计数器
for i in itertools.count(start=0, step=2):
    if i > 10:
        break
    print(i)

# 排列组合
for combo in itertools.permutations('ABC', 2):
    print(combo)

10. 循环在不同Python版本中的差异

10.1 Python 2 vs Python 3的主要区别

1. range函数：

   • Python 2: range返回列表，xrange返回生成器
   • Python 3: range返回range对象（类似生成器）

2. 字典方法：

   • Python 2: keys()、values()、items()返回列表
   • Python 3: 返回视图对象

3. 性能优化：

   • Python 3的循环通常比Python 2快

10.2 编写兼容代码的建议

1. 使用six等兼容库
2. 避免在循环中依赖版本特定的行为
3. 充分测试不同版本下的表现

11. 循环在Python生态系统中的应用

11.1 与流行库的结合

1. NumPy/Pandas中的向量化操作：

   • 通常避免显式循环
   • 使用内置的向量化函数

2. 异步编程中的循环：

   python复制import asyncio
   
   async def my_coroutine():
       print("Hello")
       await asyncio.sleep(1)
       print("World")
   
   async def main():
       for i in range(3):
           await my_coroutine()
   
   asyncio.run(main())
   

11.2 在Web框架中的应用

1. Django模板中的循环：

   html复制{% for item in item_list %}
       <p>{{ item.name }}</p>
   {% endfor %}
   

2. Flask中的路由循环：

   python复制from flask import Flask
   
   app = Flask(__name__)
   
   @app.route('/')
   def home():
       return "Welcome"
   
   # 动态路由
   for page in ['about', 'contact']:
       @app.route(f'/{page}')
       def show_page(page=page):
           return f"This is the {page} page"
   

12. 循环的替代方案

虽然循环是基础控制结构，但有时其他方法更合适：

12.1 递归

某些问题用递归更自然：

python复制def factorial(n):
    if n == 1:
        return 1
    return n * factorial(n-1)

但要注意Python的递归深度限制（通常1000）。

12.2 高阶函数

map、filter、reduce等函数式编程工具：

python复制from functools import reduce

numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))
evens = list(filter(lambda x: x % 2 == 0, numbers))
product = reduce(lambda x, y: x * y, numbers)

12.3 向量化操作

在科学计算中：

python复制import numpy as np

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
c = a + b  # 向量化加法，比循环快

13. 循环的性能基准测试

了解不同循环方式的性能差异：

13.1 测试方法

python复制import timeit

def test_for_loop():
    total = 0
    for i in range(10000):
        total += i
    return total

def test_while_loop():
    total = 0
    i = 0
    while i < 10000:
        total += i
        i += 1
    return total

def test_list_comprehension():
    return sum([i for i in range(10000)])

def test_generator_expression():
    return sum(i for i in range(10000))

# 测试执行时间
print("for循环:", timeit.timeit(test_for_loop, number=1000))
print("while循环:", timeit.timeit(test_while_loop, number=1000))
print("列表推导式:", timeit.timeit(test_list_comprehension, number=1000))
print("生成器表达式:", timeit.timeit(test_generator_expression, number=1000))

13.2 典型结果分析

通常性能排序（从快到慢）：

1. 内置函数/向量化操作
2. 生成器表达式
3. 列表推导式
4. for循环
5. while循环

但实际差异取决于具体场景和数据规模。

14. 循环的调试与错误处理

14.1 常见循环错误类型

1. 语法错误：

   • 忘记冒号
   • 缩进错误

2. 逻辑错误：

   • 循环条件错误
   • 变量作用域问题

3. 运行时错误：

   • 迭代过程中修改集合
   • 无限循环

14.2 调试技巧

1. 使用pdb调试器：

   python复制import pdb
   
   for item in collection:
       pdb.set_trace()  # 设置断点
       # 检查变量
   

2. 日志记录：

   python复制import logging
   
   logging.basicConfig(level=logging.DEBUG)
   
   for i in range(10):
       logging.debug(f"循环变量i={i}")
       # 其他代码
   

3. 可视化调试工具：

   • PyCharm的调试器
   • VS Code的Python调试工具

14.3 异常处理

在循环中合理处理异常：

python复制for url in url_list:
    try:
        data = fetch_url(url)
        process(data)
    except ConnectionError as e:
        print(f"连接{url}失败: {e}")
        continue
    except ValueError as e:
        print(f"处理{url}数据错误: {e}")
        break  # 严重错误，终止循环
    else:
        record_success(url)
    finally:
        cleanup_resources()

15. 循环在算法中的应用

15.1 基本算法实现

1. 线性搜索：

python复制def linear_search(items, target):
    for i, item in enumerate(items):
        if item == target:
            return i
    return -1

2. 冒泡排序：

python复制def bubble_sort(items):
    n = len(items)
    for i in range(n):
        for j in range(0, n-i-1):
            if items[j] > items[j+1]:
                items[j], items[j+1] = items[j+1], items[j]
    return items

15.2 更复杂的算法模式

1. 滑动窗口：

python复制def max_subarray_sum(nums, k):
    max_sum = 0
    window_sum = 0
    start = 0
    
    for end in range(len(nums)):
        window_sum += nums[end]
        
        if end >= k-1:
            max_sum = max(max_sum, window_sum)
            window_sum -= nums[start]
            start += 1
            
    return max_sum

2. 双指针：

python复制def two_sum_sorted(numbers, target):
    left, right = 0, len(numbers)-1
    
    while left < right:
        current_sum = numbers[left] + numbers[right]
        if current_sum == target:
            return [left+1, right+1]
        elif current_sum < target:
            left += 1
        else:
            right -= 1
    
    return []

16. 循环与函数式编程的结合

16.1 使用map/filter/reduce

python复制from functools import reduce

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

# map示例
squares = list(map(lambda x: x**2, numbers))

# filter示例
evens = list(filter(lambda x: x % 2 == 0, numbers))

# reduce示例
product = reduce(lambda x, y: x * y, numbers)

16.2 生成器函数

使用yield创建自定义迭代器：

python复制def fibonacci_sequence(limit):
    a, b = 0, 1
    while a < limit:
        yield a
        a, b = b, a + b

# 使用
for num in fibonacci_sequence(100):
    print(num)

16.3 惰性求值与循环

生成器实现惰性求值，节省内存：

python复制def read_large_file(file_path):
    with open(file_path, 'r') as f:
        for line in f:
            yield line.strip()

# 逐行处理大文件，不一次性加载到内存
for line in read_large_file('huge_file.txt'):
    process_line(line)

17. 循环在数据处理中的应用

17.1 数据清洗

python复制def clean_data(raw_data):
    cleaned = []
    for record in raw_data:
        # 跳过空记录
        if not record:
            continue
            
        try:
            # 转换数据类型
            processed = {
                'id': int(record['id']),
                'name': record['name'].strip(),
                'value': float(record['value'])
            }
            cleaned.append(processed)
        except (ValueError, KeyError) as e:
            print(f"无效记录: {record}, 错误: {e}")
    
    return cleaned

17.2 数据聚合

python复制def aggregate_sales(sales_data):
    totals = {}
    for sale in sales_data:
        product = sale['product']
        amount = sale['amount']
        
        if product in totals:
            totals[product] += amount
        else:
            totals[product] = amount
    
    return totals

17.3 数据分块处理

python复制def process_in_chunks(data, chunk_size, process_func):
    for i in range(0, len(data), chunk_size):
        chunk = data[i:i + chunk_size]
        process_func(chunk)
        print(f"已处理{i + len(chunk)}/{len(data)}条记录")

18. 循环在自动化任务中的应用

18.1 文件批量处理

python复制import os

def batch_rename_files(directory, prefix):
    for i, filename in enumerate(os.listdir(directory)):
        if filename.endswith('.txt'):
            new_name = f"{prefix}_{i}.txt"
            os.rename(
                os.path.join(directory, filename),
                os.path.join(directory, new_name)
            )
            print(f"重命名 {filename} 为 {new_name}")

18.2 网页抓取

python复制import requests
from bs4 import BeautifulSoup

def scrape_multiple_pages(base_url, pages):
    all_data = []
    
    for page in range(1, pages + 1):
        url = f"{base_url}?page={page}"
        response = requests.get(url)
        soup = BeautifulSoup(response.text, 'html.parser')
        
        # 提取数据
        items = soup.select('.item')
        for item in items:
            data = extract_item_data(item)  # 假设的函数
            all_data.append(data)
        
        print(f"已处理第{page}页，共获取{len(items)}条数据")
    
    return all_data

18.3 定时任务

python复制import time

def run_periodically(interval, func, max_runs=None):
    runs = 0
    while True:
        if max_runs and runs >= max_runs:
            break
            
        start_time = time.time()
        func()
        runs += 1
        
        elapsed = time.time() - start_time
        sleep_time = max(0, interval - elapsed)
        time.sleep(sleep_time)

19. 循环在测试中的应用

19.1 参数化测试

python复制import unittest

class TestMathOperations(unittest.TestCase):
    test_cases = [
        (1, 1, 2),
        (2, 3, 5),
        (0, 0, 0),
        (-1, 1, 0)
    ]
    
    def test_addition(self):
        for a, b, expected in self.test_cases:
            with self.subTest(a=a, b=b):
                self.assertEqual(a + b, expected)

19.2 性能测试

python复制def benchmark_operations(operations, sizes):
    results = {}
    
    for op in operations:
        op_results = []
        for size in sizes:
            data = generate_test_data(size)  # 假设的函数
            start = time.perf_counter()
            op(data)
            duration = time.perf_counter() - start
            op_results.append((size, duration))
        results[op.__name__] = op_results
    
    return results

19.3 模糊测试

python复制import random

def fuzz_test(function, valid_inputs, num_tests=1000):
    for _ in range(num_tests):
        # 生成随机输入
        test_input = mutate_input(random.choice(valid_inputs))
        
        try:
            function(test_input)
        except Exception as e:
            print(f"输入 {test_input} 导致错误: {e}")
            continue

20. 循环的替代控制结构

20.1 递归与尾递归优化

虽然Python不直接支持尾递归优化，但可以模拟：

python复制def factorial(n, accumulator=1):
    if n == 0:
        return accumulator
    return factorial(n - 1, accumulator * n)

20.2 协程与异步循环

python复制import asyncio

async def fetch_data(url):
    print(f"开始获取 {url}")
    await asyncio.sleep(1)  # 模拟IO操作
    print(f"完成获取 {url}")
    return f"{url} 的数据"

async def main():
    urls = ['url1', 'url2', 'url3']
    tasks = [fetch_data(url) for url in urls]
    results = await asyncio.gather(*tasks)
    print(results)

asyncio.run(main())

20.3 基于事件的循环

python复制import pygame

def game_loop():
    pygame.init()
    screen = pygame.display.set_mode((800, 600))
    running = True
    
    while running:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
        
        # 游戏逻辑和渲染
        screen.fill((0, 0, 0))
        pygame.display.flip()
    
    pygame.quit()

21. 循环与设计模式

21.1 迭代器模式

实现自定义迭代器：

python复制class CountDown:
    def __init__(self, start):
        self.current = start
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.current <= 0:
            raise StopIteration
        else:
            self.current -= 1
            return self.current + 1

# 使用
for num in CountDown(5):
    print(num)  # 输出5,4,3,2,1

21.2 观察者模式中的循环

python复制class Subject:
    def __init__(self):
        self._observers = []
    
    def attach(self, observer):
        self._observers.append(observer)
    
    def notify(self):
        for observer in self._observers:
            observer.update(self)

21.3 状态模式中的循环

python复制class StateMachine:
    def __init__(self):
        self.state = IdleState()
    
    def run(self):
        while True:
            self.state = self.state.handle()
            if isinstance(self.state, ExitState):
                break

22. 循环在图形处理中的应用

22.1 图像像素处理

python复制from PIL import Image

def apply_filter(image_path, output_path, filter_func):
    img = Image.open(image_path)
    pixels = img.load()
    
    for i in range(img.width):
        for j in range(img.height):
            pixels[i, j] = filter_func(pixels[i, j])
    
    img.save(output_path)

22.2 生成图形模式

python复制import turtle

def draw_pattern():