---

1. 循环的核心概念与作用

1.1 什么是循环

循环是Python中让计算机重复执行某一段固定代码块的程序结构，是编程中最核心的基础语法之一。

1.2 循环的核心价值

• 减少代码冗余：无需重复编写相同代码，比如打印100次"Hello Python"，不用写100行print，1行循环即可实现
• 提升开发效率：批量处理重复任务，比如遍历列表、计算累加和、批量处理数据等
• 实现复杂逻辑：配合条件判断，可实现用户交互、数据筛选、算法实现等复杂业务场景

---

2. Python两大核心循环类型

Python中只有两种原生循环结构，两者适用场景完全不同，新手先记住核心区别：

循环类型	核心逻辑	核心适用场景
while循环	先判断条件，条件为True就重复执行	未知循环次数，需要根据动态条件判断是否继续
for循环	遍历可迭代对象，逐个取出元素执行	已知循环次数、遍历序列/集合等数据结构

---

3. while循环详解

while循环是基于条件判断的循环，只要条件满足，就会一直执行循环体。

3.1 基本语法

while 条件表达式:
    # 循环体：条件为True时重复执行的代码
    # 注意：Python靠缩进区分代码块，循环体必须统一缩进（推荐4个空格）

3.2 执行逻辑

1. 第一步：判断条件表达式的布尔值，结果为True则执行循环体
2. 第二步：循环体执行完毕后，再次回到第一步判断条件
3. 第三步：直到条件表达式结果为False，直接退出循环

3.3 基础代码示例

示例1：打印1到5的数字（最基础用法）

# 1. 初始化计数器（必须有！否则无法控制循环结束）
num = 1
# 2. 循环条件：num小于等于5时，持续执行循环体
while num <= 5:
    print(num)
    # 3. 更新计数器（核心！忘记写会导致无限循环）
    num += 1  # 等价于 num = num + 1

示例2：无限循环+break控制退出（高频实用场景）

while True会创建无限循环，必须配合break控制退出，适合持续监听用户输入的场景

# 无限循环：条件永远为True
while True:
    user_input = input("请输入'quit'退出程序：")
    # 判断用户输入，符合条件则跳出循环
    if user_input == 'quit':
        print("程序正常退出")
        break  # 强制终止整个循环
    # 不符合退出条件，执行正常逻辑
    print(f"你输入的内容是：{user_input}")

3.4 while-else结构（Python特有）

Python独有的语法，else代码块只有循环正常结束（未被break强制中断）时才会执行

语法格式

while 条件表达式:
    循环体
else:
    # 循环正常结束（无break中断）时，执行此处代码

代码示例

# 示例1：循环正常结束，执行else
num = 1
while num <= 3:
    print(num)
    num += 1
else:
    print("循环正常结束，else代码块执行")

# 示例2：循环被break中断，else不执行
num = 1
while num <= 3:
    if num == 2:
        break
    print(num)
    num += 1
else:
    print("循环被中断，此处不会执行")

3.5 while循环适用场景

• 循环次数不固定，需要根据用户输入、程序运行状态动态判断是否继续
• 持续监听场景（比如用户交互、接口轮询）
• 需要实现无限循环，配合break手动控制退出时机的场景

---

4. for循环详解（重点高频）

for循环是Python中使用频率最高的循环，核心是遍历可迭代对象，逐个取出元素执行循环体，适合已知循环次数或遍历数据的场景。

4.1 基础语法

for 临时变量 in 可迭代对象:
    # 循环体：每次取出可迭代对象的一个元素，赋值给临时变量，执行代码
    # 循环体必须统一缩进

新手必懂：什么是可迭代对象

简单理解：可以按顺序一个一个取出元素的对象，新手常用的有：

• 序列类型：列表list、元组tuple、字符串str
• 整数序列生成器：range()函数（for循环黄金搭档）
• 其他：字典dict、集合set、文件对象等

4.2 核心工具：range()函数（必学）

range()用于生成一个整数序列，是for循环最常用的搭档，专门处理指定次数的循环，新手必须吃透它的左闭右开特性。

三种核心用法

用法	说明	示例	生成的序列
range(stop)	生成0到stop-1的整数，左闭右开	range(5)	0,1,2,3,4
range(start, stop)	生成start到stop-1的整数	range(2,6)	2,3,4,5
range(start, stop, step)	生成start到stop-1的整数，步长为step	range(1,10,2)	1,3,5,7,9

代码示例

# 用法1：range(stop) 打印0-4
print("=== range(stop) ===")
for i in range(5):
    print(i)

# 用法2：range(start, stop) 打印1-5
print("=== range(start, stop) ===")
for i in range(1, 6):  # 左闭右开，想要包含5，stop必须写6
    print(i)

# 用法3：range(start, stop, step) 打印10以内的偶数
print("=== range带步长 ===")
for i in range(0, 11, 2):
    print(i)

# 进阶：逆序打印5-1
print("=== 逆序遍历 ===")
for i in range(5, 0, -1):
    print(i)

4.3 基础代码示例

示例1：遍历列表（最常用场景）

# 定义一个水果列表
fruits = ["苹果", "香蕉", "橙子", "葡萄"]
# 遍历列表，逐个取出元素赋值给临时变量fruit
for fruit in fruits:
    print(f"我喜欢吃：{fruit}")

示例2：遍历字符串

# 遍历字符串的每一个字符
word = "Python"
for char in word:
    print(f"字符：{char}")

示例3：计算1-100的累加和（经典入门题）

# 初始化累加结果
sum_result = 0
# 遍历1-100的所有数字
for i in range(1, 101):
    sum_result += i  # 等价于 sum_result = sum_result + i
# 循环结束后打印结果
print(f"1-100的累加和是：{sum_result}")  # 输出：5050

4.4 for-else结构

和while-else完全一致，else代码块仅在循环正常结束（未被break中断）时执行

# 判断列表中是否有负数
numbers = [1, 3, 5, 7, 9]
for num in numbers:
    if num < 0:
        print("发现负数，循环中断")
        break
    print(f"当前数字：{num}")
else:
    print("列表中没有负数，循环正常结束")

4.5 for循环适用场景

• 已知循环次数的重复执行任务
• 遍历列表、元组、字符串、字典等所有可迭代对象
• 批量处理数据、生成序列、数据筛选等绝大多数开发场景

---

5. 循环控制关键字（break/continue/pass）

这三个关键字用于控制循环的执行流程，是循环语法的核心补充，新手必须分清三者的区别。

5.1 break：终止整个循环

作用：立即跳出当前所在的一层循环，循环彻底终止，无论循环条件是否满足
适用场景：找到目标数据、触发终止条件后，无需继续执行循环

# 找到列表中第一个等于5的元素，找到后立即退出循环
nums = [1, 2, 3, 4, 5, 6, 7, 8]
for num in nums:
    if num == 5:
        print(f"找到目标数字5，退出循环")
        break  # 触发后，循环直接终止
    print(f"当前遍历数字：{num}")

5.2 continue：跳过本次循环

作用：跳过本次循环剩余的代码，直接进入下一次循环，循环不会终止
适用场景：遇到不需要处理的元素，跳过本次执行，继续处理下一个元素

# 打印1-10的奇数，跳过所有偶数
for i in range(1, 11):
    if i % 2 == 0:
        # 是偶数，跳过本次循环，后面的print不会执行
        continue
    print(f"奇数：{i}")

5.3 核心区别：break vs continue

关键字	作用范围	执行结果
break	整个循环	循环彻底终止，不再执行任何后续循环
continue	本次循环	仅跳过本次循环剩余代码，下一次循环正常执行

5.4 pass：空占位语句

作用：不执行任何实际操作，仅作为代码占位符，避免语法报错
适用场景：循环体还未编写完成，先占位保证代码能正常运行

for i in range(5):
    # 还没想好循环体逻辑，用pass占位，不会报语法错误
    pass

---

6. 嵌套循环

6.1 什么是嵌套循环

一个循环的循环体中，包含另一个完整的循环，称为嵌套循环。

• 外层循环执行1次，内层循环会完整执行一轮
• while循环和for循环可以互相嵌套，无限制
• 新手建议嵌套层级不超过3层，否则代码可读性会极差

6.2 基础语法

# 外层循环
for 外层变量 in 外层可迭代对象:
    # 内层循环
    for 内层变量 in 内层可迭代对象:
        内层循环体
    外层循环体

6.3 经典入门示例

示例1：打印5行5列的星号正方形

# 外层循环：控制行数，执行5次
for i in range(5):
    # 内层循环：控制每行的星号数量，执行5次
    for j in range(5):
        print("*", end="")  # end="" 表示不换行
    # 内层循环结束后，换行
    print()

示例2：九九乘法表（新手必练）

# 外层循环：控制行数，1-9行
for i in range(1, 10):
    # 内层循环：控制列数，每行的列数=行数
    for j in range(1, i + 1):
        # 格式化输出，\t 制表符保证对齐
        print(f"{j}×{i}={i*j}\t", end="")
    # 每行结束后换行
    print()

6.4 嵌套循环注意事项

• break只能跳出当前所在的一层循环：内层循环的break不会跳出外层循环
• 缩进必须严格：内层循环必须比外层循环多一层缩进，否则会报语法错误
• 控制嵌套层级：超过3层的嵌套会导致代码难以维护和调试，新手尽量避免

---

7. Python循环进阶实用技巧

学完基础循环后，掌握这些技巧能让你的代码更简洁、更Pythonic，也是实际开发中的高频用法。

7.1 enumerate()：遍历元素同时获取索引

新手常写for i in range(len(list))来获取索引，enumerate()是更优雅的替代方案，可同时获取索引+元素。

fruits = ["苹果", "香蕉", "橙子", "葡萄"]
# 同时获取索引和元素，index默认从0开始
for index, fruit in enumerate(fruits):
    print(f"索引{index}：{fruit}")

# 自定义索引起始值为1（适合序号场景）
for index, fruit in enumerate(fruits, start=1):
    print(f"序号{index}：{fruit}")

7.2 zip()：并行遍历多个可迭代对象

同时遍历两个或多个列表，按位置一一对应取出元素，适合多组数据关联处理。

names = ["张三", "李四", "王五"]
ages = [20, 21, 22]
genders = ["男", "女", "男"]

# 同时遍历3个列表，一一对应取值
for name, age, gender in zip(names, ages, genders):
    print(f"姓名：{name}，年龄：{age}，性别：{gender}")

注意：zip以最短的可迭代对象为准，多个列表长度不一致时，遍历到最短的列表结束就会停止。

7.3 reversed()：逆序遍历

无需修改原对象，直接倒序遍历可迭代对象，比range(..., -1)更通用。

# 逆序遍历1-5
for i in reversed(range(1, 6)):
    print(i)

# 逆序遍历列表
fruits = ["苹果", "香蕉", "橙子", "葡萄"]
for fruit in reversed(fruits):
    print(fruit)

7.4 sorted()：排序后遍历

先对可迭代对象排序，再遍历，不会修改原对象，支持升序/降序。

numbers = [5, 2, 8, 1, 9, 3]
# 升序遍历
print("=== 升序 ===")
for num in sorted(numbers):
    print(num)

# 降序遍历
print("=== 降序 ===")
for num in sorted(numbers, reverse=True):
    print(num)

7.5 列表推导式：循环的极简写法

Python最具特色的语法之一，用一行代码实现for循环+条件判断的列表生成，替代冗长的循环代码。

基础语法：[表达式 for 变量 in 可迭代对象 if 条件]

代码示例

# 需求：生成1-10的平方列表
# 普通for循环写法
square_list = []
for i in range(1, 11):
    square_list.append(i ** 2)
print(square_list)

# 列表推导式写法（一行搞定）
square_list = [i ** 2 for i in range(1, 11)]
print(square_list)

# 进阶：带条件筛选，生成1-10的偶数的平方
even_square = [i ** 2 for i in range(1, 11) if i % 2 == 0]
print(even_square)

---

8. 新手高频错误与避坑指南

8.1 无限循环（while循环高频）

错误原因：忘记更新循环条件的变量，导致条件永远为True，循环无法终止

# 错误示例
num = 1
while num <= 5:
    print(num)
    # 忘记写 num += 1，num永远是1，条件永远为True

# 正确示例
num = 1
while num <= 5:
    print(num)
    num += 1  # 必须更新计数器，保证条件最终会变成False

避坑：while循环必须确保循环条件最终会变为False，无限循环必须配合break使用。

8.2 缩进错误（Python特有高频）

错误原因：Python靠缩进区分代码块，循环体未缩进、缩进不一致、混用空格和Tab，都会导致语法错误

# 错误示例1：循环体未缩进
for i in range(5):
print(i)  # 报错：expected an indented block

# 错误示例2：缩进不一致
num = 0
while num < 5:
    print(num)
  num += 1  # 缩进和上一行不一致，报错

# 正确示例：统一4个空格缩进
for i in range(5):
    print(i)

避坑：使用编辑器的自动缩进功能，全程统一用4个空格，不要混用空格和Tab。

8.3 忽略range()的左闭右开特性

错误原因：误以为range(start, stop)会包含stop，导致循环次数少1

# 错误示例：想打印1-5，结果只打印1-4
for i in range(1, 5):
    print(i)

# 正确示例：想要包含5，stop必须写6
for i in range(1, 6):
    print(i)

避坑：记住range的结束值是开区间，想要包含数字n，stop参数必须写n+1。

8.4 循环中修改正在遍历的可迭代对象

错误原因：遍历原列表时，删除/添加元素，导致元素遗漏、索引混乱

# 错误示例：删除列表中的偶数，结果漏删
nums = [1,2,3,4,5,6]
for num in nums:
    if num % 2 == 0:
        nums.remove(num)
print(nums)  # 错误结果：[1,3,5,6]，4被漏删

# 正确示例1：遍历列表的副本
nums = [1,2,3,4,5,6]
for num in nums[:]:  # nums[:] 是列表的切片副本
    if num % 2 == 0:
        nums.remove(num)
print(nums)  # 正确结果：[1,3,5]

# 正确示例2：列表推导式（推荐）
nums = [1,2,3,4,5,6]
nums = [num for num in nums if num % 2 != 0]
print(nums)

避坑：永远不要在for循环遍历原列表时，修改原列表的长度（添加/删除元素）。

8.5 break和continue混用

错误原因：分不清两者的作用，导致循环逻辑不符合预期

# 错误示例：想跳过偶数打印奇数，结果用break，只打印1就退出
for i in range(1, 11):
    if i % 2 == 0:
        break
    print(i)

# 正确示例：用continue跳过本次循环
for i in range(1, 11):
    if i % 2 == 0:
        continue
    print(i)

8.6 循环else子句执行时机错误

错误原因：误以为循环结束就会执行else，忽略了break中断的情况

避坑：else子句只有循环正常执行完毕、未被break中断时，才会执行。

---

9. 新手实战练习题（从易到难）

学完知识点后，一定要动手敲代码练习，以下题目从基础到进阶，覆盖所有核心知识点。

基础题

1. 计算1-100的所有偶数的和
2. 打印1-20的数字，规则：遇到3的倍数打印"福"，遇到5的倍数打印"利"，同时是3和5的倍数打印"福利"，其余情况打印数字本身
3. 接收用户输入的正整数n，计算n的阶乘（5! = 5×4×3×2×1）

进阶题

1. 打印5行的直角三角形，效果如下：

*
**
***
****
*****

1. 找出100以内的所有素数（素数：大于1，且只能被1和它本身整除的整数）
2. 生成斐波那契数列的前20项（斐波那契数列：前两项为1，从第三项开始，每一项等于前两项之和：1,1,2,3,5,8...）

参考答案

# 基础题1：1-100偶数和
sum_even = 0
for i in range(0, 101, 2):
    sum_even += i
print(f"1-100偶数和：{sum_even}")

# 基础题2：福利打印
for i in range(1, 21):
    if i % 3 == 0 and i % 5 == 0:
        print("福利")
    elif i % 3 == 0:
        print("福")
    elif i % 5 == 0:
        print("利")
    else:
        print(i)

# 基础题3：阶乘计算
n = int(input("请输入一个正整数："))
factorial = 1
for i in range(1, n+1):
    factorial *= i
print(f"{n}的阶乘是：{factorial}")

# 进阶题1：直角三角形
for i in range(1, 6):
    print("*" * i)

# 进阶题2：100以内素数
prime_list = []
for num in range(2, 101):
    is_prime = True
    # 判断是否能被2到平方根之间的数整除
    for i in range(2, int(num ** 0.5) + 1):
        if num % i == 0:
            is_prime = False
            break
    if is_prime:
        prime_list.append(num)
print("100以内素数：", prime_list)

# 进阶题3：斐波那契数列前20项
fib_list = [1, 1]
for i in range(2, 20):
    next_num = fib_list[i-1] + fib_list[i-2]
    fib_list.append(next_num)
print("斐波那契前20项：", fib_list)

---

10. 循环学习核心建议

1. 先理解逻辑，再敲代码：写循环前，先想清楚循环的终止条件、循环体要执行的操作，不要盲目敲代码
2. 多动手，少看不动：循环是编程基础，只有多写多练，才能真正吃透，不要只看示例不实操
3. 遇到报错不要慌：新手报错大多是缩进、循环条件、range左闭右开的问题，看报错信息定位行号，逐一排查
4. 循序渐进学习：先掌握基础的while和for循环，再学嵌套循环，最后学进阶技巧和列表推导式，不要跳步
5. 多做练习题：通过练习题巩固知识点，从基础题开始，逐步挑战进阶题，培养循环逻辑思维