5、《Python 循环结构全攻略（while/for）》

Python 循环结构全攻略（while/for）从入门到精通

引言

循环结构是Python编程的核心控制流之一，本文将从基础语法到高级应用，全方位解析while和for循环的奥秘。通过20+代码示例详解循环控制语句、迭代器协议、性能优化等关键技术，并配套10道实战练习题。无论您是编程新手还是想深化理解的开发者，都将在此找到所需知识。

---

一、while循环深度解析

1.1 基础语法与执行流程

count = 0
while count < 5:
    print(f"当前计数: {count}")
    count += 1
# 输出0-4的数字

执行流程：

1. 检查条件表达式
2. 条件为真则执行代码块
3. 重复步骤1-2直到条件为假

注意事项：

• 必须设置合理的终止条件
• 推荐使用增量控制而非无限循环
• 避免在循环体内修改外部条件变量以外的控制变量

1.2 高级应用场景

场景1：用户输入验证

valid = False
while not valid:
    user_input = input("请输入1-100之间的整数: ")
    if user_input.isdigit() and 1 <= int(user_input) <= 100:
        valid = True
    else:
        print("输入无效，请重新输入！")

场景2：实时数据监控

import time
temperature = 25.0
while True:
    print(f"当前温度: {temperature}℃")
    temperature += 0.5
    time.sleep(1)
    if temperature >= 30.0:
        print("温度过高！系统终止")
        break

---

二、for循环全面掌握

2.1 遍历可迭代对象

# 遍历字符串
for char in "Python":
    print(char, end=' ')  # 输出：P y t h o n 

# 遍历字典
user = {'name': 'Alice', 'age': 25, 'city': 'New York'}
for key, value in user.items():
    print(f"{key}: {value}")

2.2 range()函数详解

参数特性：

range(stop)          # 0 ~ stop-1
range(start, stop)   # start ~ stop-1 
range(start, stop, step)  # 步长控制

# Python3特性：延迟计算
nums = range(1, 1000000)  # 不立即生成所有数字

内存优化对比：

# Python2的range生成列表
# Python3的range生成可迭代对象
import sys
print(sys.getsizeof(range(1000)))    # 48 bytes
print(sys.getsizeof(list(range(1000))))  # 9024 bytes

---

三、循环控制语句实战

3.1 break与continue

# 查找第一个3的倍数
numbers = [1, 5, 7, 9, 12, 15]
for num in numbers:
    if num % 3 == 0:
        print(f"找到第一个3的倍数: {num}")
        break

# 跳过奇数
for i in range(10):
    if i % 2 != 0:
        continue
    print(i, end=' ')  # 输出0 2 4 6 8

3.2 else子句妙用

# 质数检测优化版
n = 17
for i in range(2, int(n**0.5)+1):
    if n % i == 0:
        print(f"{n}不是质数")
        break
else:
    print(f"{n}是质数")

---

四、嵌套循环进阶

4.1 经典案例：九九乘法表

for i in range(1, 10):
    for j in range(1, i+1):
        print(f"{j}×{i}={i*j}", end='\t')
    print()  # 换行

# 输出对齐优化版：
for i in range(1,10):
    print(' '*(7*(9-i)), end='')  # 右对齐处理
    for j in range(1,i+1):
        print(f"{j}×{i}={i*j:2}",end=' ')
    print()

4.2 矩阵运算

matrix1 = [[1,2], [3,4]]
matrix2 = [[5,6], [7,8]]
result = [[0]*len(matrix2[0]) for _ in range(len(matrix1))]

for i in range(len(matrix1)):
    for j in range(len(matrix2[0])):
        for k in range(len(matrix2)):
            result[i][j] += matrix1[i][k] * matrix2[k][j]
print(result)  # [[19, 22], [43, 50]]

---

五、迭代器协议原理

5.1 可迭代对象 vs 迭代器

# 自定义迭代器示例
class Fibonacci:
    def __init__(self, max_num):
        self.max = max_num
        self.a, self.b = 0, 1

    def __iter__(self):
        return self

    def __next__(self):
        if self.a > self.max:
            raise StopIteration
        current = self.a
        self.a, self.b = self.b, self.a + self.b
        return current

# 使用示例
fib = Fibonacci(1000)
for n in fib:
    print(n, end=' ')

---

六、性能优化技巧

6.1 循环优化策略

1. 减少内层循环计算

   # 优化前
   for i in range(len(data)):
       process(data[i] * len(data))
   
   # 优化后
   length = len(data)
   for i in range(length):
       process(data[i] * length)
   

2. 使用生成器表达式

   sum(x**2 for x in range(1000000))  # 内存友好
   

---

七、实战练习题完整答案

1. 优化版质数筛（埃拉托斯特尼筛法）

def sieve_of_eratosthenes(n):
    sieve = [True] * (n+1)
    sieve[0:2] = [False, False]
    
    for current in range(2, int(n**0.5)+1):
        if sieve[current]:
            sieve[current*current : n+1 : current] = [False]*len(range(current*current, n+1, current))
    
    return [num for num, is_prime in enumerate(sieve) if is_prime]

print(sieve_of_eratosthenes(100))  # 输出100以内所有质数

2. 异常处理循环（浮点数验证）

def get_valid_float():
    while True:
        try:
            value = float(input("请输入浮点数: "))
            return value
        except ValueError:
            print("输入无效，请重新输入！")

print("获取的有效浮点数:", get_valid_float())

3. 星号金字塔（已提供示例）

n = 5
for i in range(1, n+1):
    spaces = ' ' * (n - i)
    stars = '*' * (2*i - 1)
    print(spaces + stars)

4. 文件词频统计

def word_counter(file_path):
    word_count = {}
    with open(file_path, 'r') as f:
        for line in f:
            words = line.strip().lower().split()
            for word in words:
                word = word.strip('.,!?')
                word_count[word] = word_count.get(word, 0) + 1
    return word_count

print(word_counter('sample.txt'))  # 需替换实际文件路径

5. 控制台进度条模拟

import time

def progress_bar(total):
    for i in range(total+1):
        percent = i / total * 100
        bar = '[' + '#' * int(percent//2) + ' ' * (50 - int(percent//2)) + ']'
        print(f"\r{bar} {percent:.1f}%", end='')
        time.sleep(0.1)
    print()

progress_bar(100)  # 模拟100%进度

6. 矩阵转置（不使用zip）

def matrix_transpose(matrix):
    return [[row[i] for row in matrix] for i in range(len(matrix[0]))]

original = [[1,2,3], [4,5,6]]
print("转置结果:", matrix_transpose(original))  # [[1,4], [2,5], [3,6]]

7. 最大公约数（欧几里得算法）

def gcd(a, b):
    while b != 0:
        a, b = b, a % b
    return a

print("最大公约数:", gcd(48, 18))  # 输出6

8. 密码爆破模拟

def password_cracker():
    correct_pwd = "secret"
    attempts = 5
    
    while attempts > 0:
        guess = input(f"剩余尝试次数{attempts}次，请输入密码: ")
        if guess == correct_pwd:
            print("登录成功！")
            return
        attempts -= 1
        print("密码错误！")
    print("账户已锁定！")

password_cracker()

9. 日历生成器

import calendar

def month_calendar(year, month):
    cal = calendar.TextCalendar()
    return cal.formatmonth(year, month)

print(month_calendar(2023, 12))  # 打印2023年12月日历

10. 迷宫路径查找（基础BFS实现）

def maze_solver(maze, start, end):
    directions = [(-1,0), (1,0), (0,-1), (0,1)]
    queue = [start]
    visited = set()
    
    while queue:
        x, y = queue.pop(0)
        
        if (x, y) == end:
            return True
        
        for dx, dy in directions:
            nx, ny = x + dx, y + dy
            if 0 <= nx < len(maze) and 0 <= ny < len(maze[0]):
                if maze[nx][ny] == 0 and (nx, ny) not in visited:
                    visited.add((nx, ny))
                    queue.append((nx, ny))
    
    return False

maze = [
    [0,1,0,0],
    [0,0,0,1],
    [1,1,0,0],
    [0,0,0,0]
]
print("路径存在:", maze_solver(maze, (0,0), (3,3)))  # 输出True

---

答案说明与注意事项

1. 质数筛：时间复杂度优化至O(n log log n)，注意列表切片的高效操作
2. 浮点验证：使用try-except结构处理所有非数字输入
3. 词频统计：包含基本的文本清洗处理（大小写转换、标点去除）
4. 进度条：使用\r实现单行刷新，避免控制台刷屏
5. 矩阵转置：使用列表推导式实现，不依赖zip函数
6. 迷宫求解：采用广度优先搜索（BFS）基础实现，返回布尔值表示路径存在性
7. 日历生成：直接调用标准库但展示接口使用方法
8. 密码爆破：使用计数器控制尝试次数，注意实际应用应加入加密验证

建议读者在实际编码时：

1. 添加更多异常处理逻辑
2. 对迷宫等算法进行可视化扩展
3. 尝试将进度条改为百分比+进度字符的混合显示
4. 对词频统计结果进行排序输出

结语

掌握循环结构需要理解其底层逻辑并积累实战经验。建议读者：

1. 根据应用场景选择循环类型
2. 关注循环终止条件和性能影响
3. 善用迭代器协议提升代码效率
4. 通过复杂模式训练空间思维能力

拓展学习：

• 生成器表达式与列表推导式的差异
• itertools模块的高级迭代器
• 异步循环在协程中的应用