上一篇咱们吃透了字典这个"高效数据字典"，在实战案例里，你应该已经接触到了for循环的简单用法------比如遍历字典统计学生成绩、计数文本中的单词。当时咱们只是"用了"循环，但没深入说清楚"为什么能用""还有哪些用法"。其实，循环和条件判断是Python的"逻辑控制核心"，有了它们，你的代码才能摆脱"顺序执行"的死板，具备根据不同情况做不同决策、重复执行复杂操作的能力。
就像生活里的场景："如果明天不下雨，就去公园跑步；如果下雨，就居家锻炼"------这是条件判断；"每天早上读30分钟书，重复30天"------这是循环。今天咱们就围绕思维导图"条件判断与循环"核心模块，从if-else条件判断的语法、嵌套用法，到for循环、while循环的实战技巧，再到循环控制语句（break/continue）的使用，把Python的逻辑控制能力彻底掌握。学会这些，你就能写出带"智能决策"的程序，比如成绩等级判断系统、密码验证程序、批量数据处理脚本等。
一、先搞懂：为什么需要逻辑控制？
在学具体语法前，先明确逻辑控制的核心价值------解决"顺序执行"无法覆盖的场景。
咱们之前写的代码，都是"从上到下依次执行"的顺序结构，比如定义一个字典、访问一个值、打印一个结果。但实际编程中，很多场景需要"判断条件再执行"或"重复执行某段代码"：
-
场景1：根据学生成绩判断等级（90分以上为A，80-89分为B......）------需要"条件判断"；
-
场景2：验证用户输入的密码，直到输入正确才放行------需要"循环"；
-
场景3：遍历字典中所有学生的成绩，计算平均分并筛选出优秀学生------需要"循环+条件判断"。
这些场景，顺序结构根本无法实现。而条件判断（if-else）和循环（for/while），就是Python为我们提供的"逻辑控制工具"。接下来，咱们逐个拆解这些工具的用法。
二、条件判断：if-else让程序"会做决策"
条件判断的核心逻辑是："如果满足某个条件，就执行一段代码；如果不满足，就执行另一段代码"。Python中最基础的条件判断是if语句，进阶用法是if-else、if-elif-else嵌套。
1. 基础语法：if语句（单条件判断）
格式：
python
if 条件表达式:
满足条件时执行的代码块（缩进4个空格）关键说明：
-
条件表达式：结果必须是"布尔值（True/False）"，可以是比较运算（>、<、==、!=等）、逻辑运算（and、or、not），或直接是布尔值；
-
冒号（:）：条件表达式后面必须加冒号，表示"接下来是满足条件时要执行的代码块"；
-
缩进：满足条件的代码块必须缩进（推荐4个空格），缩进是Python区分代码块的标志（不缩进会报错）；
-
执行逻辑：如果条件表达式结果为True，就执行缩进的代码块；如果为False，就跳过该代码块，执行后面的非缩进代码。
示例1：判断成绩是否及格（单条件）
python
score = 85
if score >= 60:
print(f"成绩{score}，及格！") # 缩进4个空格，满足条件时执行
print("判断结束") # 不缩进，无论条件是否满足都会执行
# 输出：
# 成绩85，及格！
# 判断结束示例2：判断字典中是否存在某个键（结合字典知识）
python
person = {"name": "小明", "age": 20}
if "gender" not in person: # 条件：person字典中不存在"gender"键
person["gender"] = "未知" # 满足条件，添加键值对
print(person) # 输出：{'name': '小明', 'age': 20, 'gender': '未知'}2. 进阶语法：if-else语句（双条件判断）
格式：
python
if 条件表达式:
满足条件时执行的代码块
else:
不满足条件时执行的代码块（同样需要缩进）执行逻辑：二选一执行------条件为True时执行if后的代码块，为False时执行else后的代码块，两者必选其一。
示例：判断成绩是否及格（双条件）
python
score = 55
if score >= 60:
print(f"成绩{score}，及格！")
else:
print(f"成绩{score}，不及格，需要补考！")
# 输出：成绩55，不及格，需要补考！示例：验证用户输入的用户名（结合input()函数）
python
username = input("请输入用户名：") # input()函数获取用户输入（返回字符串）
if username == "admin":
print("欢迎管理员登录！")
else:
print(f"欢迎普通用户{username}登录！")
# 测试1：输入admin → 输出：欢迎管理员登录！
# 测试2：输入user1 → 输出：欢迎普通用户user1登录！3. 高级语法：if-elif-else语句（多条件判断）
格式：
python
if 条件1:
满足条件1时执行的代码块
elif 条件2:
不满足条件1，但满足条件2时执行的代码块
elif 条件3:
不满足条件1和2，但满足条件3时执行的代码块
...（可以有多个elif）
else:
所有条件都不满足时执行的代码块（可选）执行逻辑：逐个判断条件，一旦某个条件为True，就执行对应的代码块，然后跳过后续所有条件判断（不会再检查后面的条件）；如果所有条件都为False，执行else后的代码块（如果有）。
示例：根据成绩判断等级（多条件）
python
score = 92
if score >= 90:
grade = "A"
elif score >= 80: # 隐含条件：score < 90
grade = "B"
elif score >= 70: # 隐含条件：score < 80
grade = "C"
elif score >= 60: # 隐含条件：score < 70
grade = "D"
else: # 隐含条件：score < 60
grade = "不及格"
print(f"成绩{score}，等级：{grade}") # 输出：成绩92，等级：A避坑提醒：多条件判断的顺序很重要！如果把"score >= 60"放在最前面，那么所有≥60的成绩都会被判断为D，后面的条件永远不会执行。比如：
python
# 错误示范：条件顺序颠倒
score = 92
if score >= 60: # 92≥60，条件为True，执行后跳过后续条件
grade = "D"
elif score >= 70:
grade = "C"
...
print(grade) # 输出：D（错误结果）4. 嵌套条件判断：在条件块中再写条件
如果需要更复杂的判断逻辑，可以在if、elif、else的代码块中，再嵌套另一个条件判断（缩进要更深入一层，推荐4个空格）。
示例：判断成绩等级的同时，判断是否为优秀学员（≥90分为优秀，且语文、数学均≥90）
python
scores = {"语文": 95, "数学": 88}
total_score = sum(scores.values())
average = total_score / len(scores)
if average >= 90:
grade = "A"
# 嵌套判断：是否两门课都≥90
if scores["语文"] >= 90 and scores["数学"] >= 90:
print(f"等级{grade}，优秀学员！")
else:
print(f"等级{grade}，继续加油！")
elif average >= 80:
grade = "B"
print(f"等级{grade}，表现良好！")
else:
grade = "C及以下"
print(f"等级{grade}，需要努力！")
# 输出：等级A，继续加油！（数学88<90，不满足优秀学员条件）5. 条件表达式中的常用操作符
条件判断的核心是"条件表达式"，常用的操作符有两类：比较操作符和逻辑操作符，结合使用能实现复杂条件判断。
（1）比较操作符（用于判断两个值的大小/相等关系）
| 操作符 | 含义 | 示例 | 结果 |
|---|---|---|---|
| == | 等于（判断两个值是否相等） | 5 == 5 | True |
| != | 不等于 | 5 != 3 | True |
| > | 大于 | 5 > 3 | True |
| < | 小于 | 5 < 3 | False |
| >= | 大于等于 | 5 >= 5 | True |
| <= | 小于等于 | 5 <= 3 | False |
| in | 判断元素是否在容器中（字符串、列表、字典等） | "a" in "abc" | True |
| not in | 判断元素是否不在容器中 | "d" not in "abc" | True |
（2）逻辑操作符（用于组合多个条件）
| 操作符 | 含义 | 示例 | 结果 |
|---|---|---|---|
| and | 逻辑与：所有条件都为True，结果才为True | 5 > 3 and 2 < 4 | True |
| or | 逻辑或：至少一个条件为True，结果就为True | 5 > 3 or 2 > 4 | True |
| not | 逻辑非：取反条件结果 | not (5 > 3) | False |
示例：组合条件判断（判断是否为成年人且年龄在18-30岁之间）
python
age = 25
if age >= 18 and age <= 30:
print("青年成年人")
else:
print("非青年成年人")
# 输出：青年成年人三、循环结构：让程序"重复做事情"
循环结构的核心逻辑是："重复执行一段代码，直到满足停止条件"。Python中常用的循环有两种：for循环和while循环，适用场景不同------for循环适合"已知循环次数"的场景（比如遍历列表、字典），while循环适合"未知循环次数"的场景（比如等待用户输入正确密码）。
1. for循环：遍历可迭代对象（已知循环次数）
格式：
python
for 变量名 in 可迭代对象:
循环体（每次迭代执行的代码块，缩进4个空格）关键说明：
-
可迭代对象：能被"逐个取出元素"的对象，比如字符串、列表、元组、字典、range()函数返回的序列等；
-
变量名：每次迭代时，从可迭代对象中取出的元素会赋值给这个变量；
-
执行逻辑：从可迭代对象中逐个取出元素，赋值给变量，然后执行循环体；直到所有元素都取完，循环结束。
（1）遍历列表/元组（最常用场景）
python
# 遍历列表
students = ["小明", "小红", "小李"]
for student in students:
print(f"欢迎{student}！")
# 输出：
# 欢迎小明！
# 欢迎小红！
# 欢迎小李！
# 遍历元组（和列表用法一致）
scores = (95, 88, 92)
total = 0
for score in scores:
total += score # 累加成绩
average = total / len(scores)
print(f"平均分：{average}") # 输出：平均分：91.66666666666667（2）遍历字典（三种常用方式）
结合第7章字典的keys()、values()、items()方法，能实现字典的不同遍历需求：
python
person = {"name": "小明", "age": 20, "height": 1.75}
# 方式1：遍历所有键
for key in person.keys():
print(f"键：{key}")
# 方式2：遍历所有值
for value in person.values():
print(f"值：{value}")
# 方式3：遍历所有键值对（拆包，最常用）
for key, value in person.items():
print(f"{key}: {value}")
# 输出：
# 键：name
# 键：age
# 键：height
# 值：小明
# 值：20
# 值：1.75
# name: 小明
# age: 20
# height: 1.75（3）遍历字符串（逐个字符）
python
text = "Python"
for char in text:
print(f"字符：{char}")
# 输出：
# 字符：P
# 字符：y
# 字符：t
# 字符：h
# 字符：o
# 字符：n（4）用range()函数生成序列（指定循环次数）
range()函数能生成一个"整数序列"，专门用于for循环指定循环次数，格式：range(起始值, 结束值, 步长)（起始值默认0，步长默认1，结束值不包含在内）。
python
# 示例1：range(5) → 生成0-4的序列（默认起始0，步长1）
for i in range(5):
print(i) # 输出：0、1、2、3、4
# 示例2：range(1, 6) → 生成1-5的序列（起始1，结束6，不包含6）
for i in range(1, 6):
print(i) # 输出：1、2、3、4、5
# 示例3：range(1, 10, 2) → 生成1-9的奇数序列（步长2，每次加2）
for i in range(1, 10, 2):
print(i) # 输出：1、3、5、7、9
# 示例4：用range()遍历列表（通过索引）
students = ["小明", "小红", "小李"]
for i in range(len(students)): # len(students)=3 → range(3) → 0、1、2
print(f"索引{i}：{students[i]}")
# 输出：
# 索引0：小明
# 索引1：小红
# 索引2：小李2. while循环：满足条件就循环（未知循环次数）
格式：
python
while 条件表达式:
循环体（条件为True时执行的代码块，缩进4个空格）
（可选）更新条件的代码（避免无限循环）执行逻辑：
-
判断条件表达式是否为True；
-
如果为True，执行循环体，然后回到步骤1重新判断；
-
如果为False，循环结束，执行后面的代码。
核心注意事项：while循环必须在循环体中包含"更新条件的代码"，否则条件永远为True，会导致"无限循环"（程序卡死，只能强制结束）。
（1）基础示例：循环打印1-5的数字
python
i = 1 # 初始化变量（条件的一部分）
while i <= 5: # 条件：i≤5
print(i)
i += 1 # 更新条件：i自增1（避免无限循环）
# 输出：1、2、3、4、5（2）实战示例：密码验证（未知循环次数）
需求：让用户输入密码，直到输入正确的密码（"123456"）才停止循环。
python
correct_password = "123456"
while True: # 条件为True，无限循环（需要在循环体内用break终止）
password = input("请输入密码：")
if password == correct_password:
print("密码正确，登录成功！")
break # 终止循环（后面会讲）
else:
print("密码错误，请重新输入！")
# 测试：
# 输入：123 → 输出：密码错误，请重新输入！
# 输入：456 → 输出：密码错误，请重新输入！
# 输入：123456 → 输出：密码正确，登录成功！（循环结束）说明：这里用了while True创建"无限循环"，然后在循环体内用break语句终止循环，这是while循环的常用技巧（适合"直到某个条件满足才停止"的场景）。
（3）避坑：无限循环的后果
python
# 错误示范：没有更新条件，无限循环
i = 1
while i <= 5:
print(i) # i永远是1，条件永远为True，会一直打印1，程序卡死
# 解决方法：添加i += 1更新条件3. 循环嵌套：在循环体内再写循环
如果需要实现更复杂的重复逻辑，可以在循环体内嵌套另一个循环（缩进要更深入一层）。比如"打印99乘法表""遍历二维列表"等场景。
示例1：打印99乘法表（外层循环控制行数，内层循环控制列数）
python
# 外层循环：控制行数（1-9）
for i in range(1, 10):
# 内层循环：控制列数（1-i，比如第3行打印1×3、2×3、3×3）
for j in range(1, i+1):
print(f"{j}×{i}={j*i}", end="\t") # end="\t"：用制表符分隔，保持对齐
print() # 换行（每打印完一行，换一行）
# 输出：
# 1×1=1
# 1×2=2 2×2=4
# 1×3=3 2×3=6 3×3=9
# ...（直到9×9=81）示例2：遍历二维列表（列表中嵌套列表）
python
# 二维列表：存储3个学生的2门课成绩
scores = [
[95, 88], # 小明：语文、数学
[82, 78], # 小红：语文、数学
[75, 68] # 小李：语文、数学
]
# 外层循环：遍历每个学生的成绩列表
for student_scores in scores:
total = 0
# 内层循环：遍历每个学生的两门课成绩
for score in student_scores:
total += score
average = total / len(student_scores)
print(f"平均分：{average}")
# 输出：
# 平均分：91.5
# 平均分：80.0
# 平均分：71.5四、循环控制语句：break与continue（灵活控制循环）
默认情况下，for循环会遍历完所有元素才结束，while循环会直到条件为False才结束。但有时我们需要"提前终止循环"或"跳过当前迭代，直接进入下一次循环"，这就需要用到break和continue语句。
1. break语句：终止整个循环
作用：当执行到break语句时，立即终止当前所在的循环（无论循环是否还有未执行的迭代），然后跳转到循环后面的代码执行。
示例1：for循环中用break（找到目标元素后终止循环）
python
students = ["小明", "小红", "小李", "小张"]
target = "小李"
for student in students:
if student == target:
print(f"找到目标：{student}")
break # 找到后立即终止循环
print(f"当前遍历：{student}")
# 输出：
# 当前遍历：小明
# 当前遍历：小红
# 找到目标：小李（循环终止，不再遍历小张）示例2：while循环中用break（之前的密码验证案例已用到）
python
correct_password = "123456"
while True:
password = input("请输入密码：")
if password == correct_password:
print("登录成功！")
break # 终止无限循环
else:
print("密码错误，重试！")2. continue语句：跳过当前迭代，进入下一次循环
作用：当执行到continue语句时，立即跳过当前迭代的剩余代码，直接进入下一次迭代（循环不会终止，只是跳过当前次）。
示例：打印1-10中的奇数（跳过偶数）
python
for i in range(1, 11):
if i % 2 == 0: # 如果是偶数
continue # 跳过当前迭代，不执行后面的print语句
print(i) # 只打印奇数
# 输出：1、3、5、7、9break与continue的区别：break是"终止整个循环"，循环直接结束；continue是"跳过当前次迭代"，循环继续执行下一次。
3. 循环中的else语句（可选）
Python中，for循环和while循环都可以搭配else语句使用，else块会在"循环正常结束"时执行（如果循环被break终止，则else块不会执行）。
格式：
python
# for循环+else
for 变量 in 可迭代对象:
循环体
else:
循环正常结束时执行的代码块
# while循环+else
while 条件:
循环体
else:
循环正常结束时执行的代码块示例1：for循环正常结束，执行else块
python
for i in range(3):
print(i)
else:
print("循环正常结束，执行else块")
# 输出：
# 0
# 1
# 2
# 循环正常结束，执行else块示例2：for循环被break终止，不执行else块
python
for i in range(3):
if i == 1:
break
print(i)
else:
print("循环正常结束，执行else块")
# 输出：0（循环被break终止，else块不执行）实用场景：判断目标元素是否存在于列表中（找不到时执行else块）
python
students = ["小明", "小红", "小李"]
target = "小张"
for student in students:
if student == target:
print(f"找到{target}")
break
else:
print(f"未找到{target}")
# 输出：未找到小张五、实战案例：综合运用条件判断与循环
学完所有知识点，用两个综合案例把内容串起来，巩固条件判断和循环的结合使用。
案例1：学生成绩管理系统（基础版）
需求：
-
用字典存储3个学生的姓名和各科成绩；
-
遍历每个学生，计算平均分；
-
根据平均分判断等级（A/B/C/D）；
-
筛选出平均分≥80分的学生，生成新字典并打印。
python
# 1. 存储学生成绩（字典嵌套列表）
student_scores = {
"小明": [95, 88, 92],
"小红": [82, 78, 85],
"小李": [75, 68, 72]
}
# 2. 遍历学生，计算平均分、判断等级，筛选优秀学生
excellent_students = {} # 存储平均分≥80的学生
for name, scores in student_scores.items():
total = sum(scores)
average = round(total / len(scores), 1) # 保留1位小数
# 3. 条件判断等级
if average >= 90:
grade = "A"
elif average >= 80:
grade = "B"
excellent_students[name] = {"average": average, "grade": grade} # 筛选优秀学生
elif average >= 70:
grade = "C"
else:
grade = "D"
print(f"姓名：{name}，平均分：{average}，等级：{grade}")
# 4. 打印优秀学生
print("\n平均分≥80的优秀学生：")
for name, info in excellent_students.items():
print(f"{name}：平均分{info['average']}，等级{info['grade']}")
# 输出：
# 姓名：小明，平均分：91.7，等级：A
# 姓名：小红，平均分：81.7，等级：B
# 姓名：小李，平均分：71.7，等级：C
#
# 平均分≥80的优秀学生：
# 小红：平均分81.7，等级B案例2：猜数字游戏（进阶版）
需求：
-
程序随机生成一个1-100之间的整数（用random模块）；
-
用户多次输入数字猜答案，程序提示"太大""太小"；
-
猜对后，提示"猜对了"并显示猜测次数；
-
如果猜测次数≤5次，提示"你太厉害了！"；否则提示"继续加油！"。
python
import random # 导入随机数模块
# 1. 随机生成1-100的整数
secret_number = random.randint(1, 100)
guess_count = 0 # 记录猜测次数
print("欢迎来到猜数字游戏！请猜1-100之间的整数：")
# 2. 循环猜数字（未知次数，用while True）
while True:
# 获取用户输入（注意：input()返回字符串，需要转成整数）
guess_input = input("请输入你猜的数字：")
# 判断输入是否为整数（避免用户输入非数字导致报错）
if not guess_input.isdigit():
print("请输入有效的整数！")
continue # 跳过当前迭代，重新输入
guess_number = int(guess_input)
guess_count += 1 # 猜测次数+1
# 3. 条件判断：提示太大/太小/猜对
if guess_number > secret_number:
print("太大了！再试试小一点的数字。")
elif guess_number < secret_number:
print("太小了！再试试大一点的数字。")
else:
# 猜对了，终止循环
print(f"\n恭喜你，猜对了！答案是{secret_number}")
print(f"你一共猜了{guess_count}次")
# 4. 判断猜测次数等级
if guess_count <= 5:
print("你太厉害了！")
else:
print("继续加油！")
break
# 测试示例：
# 欢迎来到猜数字游戏！请猜1-100之间的整数：
# 请输入你猜的数字：50
# 太小了！再试试大一点的数字。
# 请输入你猜的数字：75
# 太大了！再试试小一点的数字。
# 请输入你猜的数字：63
# 恭喜你，猜对了！答案是63
# 你一共猜了3次
# 你太厉害了！六、注意事项与避坑指南
新手用条件判断和循环时，容易踩一些坑，这里总结了5个核心注意事项，帮你避开。
1. 缩进要规范（Python的"灵魂"）
Python用缩进区分代码块，条件判断和循环的代码块必须缩进（推荐4个空格），缩进不一致会报错。比如：
python
# 错误示范：缩进不一致
if 5 > 3:
print("条件成立")
print("缩进少了1个空格") # 报错：IndentationError: unexpected indent
# 正确做法：所有代码块缩进4个空格，保持一致2. 避免无限循环
while循环必须包含"更新条件的代码"，for循环如果遍历无限迭代对象（比如itertools.count()）也会无限循环。如果不小心写出无限循环，按Ctrl+C强制终止程序。
3. 比较操作符"=="和赋值操作符"="的区别
新手容易把"=="（判断相等）写成"="（赋值），导致条件判断失效。比如：
python
# 错误示范：用=代替==
if score = 60: # 报错：can't assign to conditional expression（不能在条件中赋值）
print("及格")
# 正确做法：用==判断相等
if score == 60:
print("及格")4. 循环嵌套的缩进层次要清晰
嵌套循环的缩进层次要分明（外层循环4个空格，内层循环8个空格），否则容易混淆代码块归属，导致逻辑错误。
5. 处理用户输入时，注意数据类型转换
input()函数返回的是字符串类型，如果需要用用户输入的内容进行数值比较（比如猜数字游戏），必须先转成整数或浮点数，否则会报错。比如：
python
# 错误示范：直接用字符串比较数值
guess = input("请输入数字：")
if guess > 50: # 报错：'str' and 'int' instances can't be compared
print("太大")
# 正确做法：转成整数后比较
guess = int(input("请输入数字："))
if guess > 50:
print("太大")结尾：逻辑控制搞定了，该学"函数"了
今天咱们彻底掌握了Python的逻辑控制核心------条件判断（if-else）和循环（for/while），还有灵活控制循环的break/continue语句。现在你已经能写出带"智能决策"和"重复执行"功能的程序了，比如成绩管理系统、猜数字游戏、密码验证程序等，这些都是实际开发中常用的基础功能。
但你有没有发现一个问题：如果需要多次使用"计算平均分""判断成绩等级"这些功能，每次都要重新写一遍代码，非常繁琐。比如在多个地方都需要判断成绩等级，就需要重复写if-elif-else那段代码，代码冗余且难以维护。
这时候，"函数（function）"就该登场了。函数能把"一段实现特定功能的代码块"封装起来，起一个名字，后续需要使用时，直接调用这个名字即可，不用重复写代码。下一篇咱们就进入思维导图的"函数"模块，学习函数的定义、调用、参数传递、返回值等核心知识点，解锁Python的"代码复用"能力------学会函数，你就能写出更简洁、更易维护的代码，为后续学习复杂项目打下基础。如果今天的循环嵌套、break/continue用法有没搞懂的地方，随时告诉我，咱们再拆解一遍！