Python循环语句练习题：从基础到进阶的边界控制与实战技巧

循环是Python里最容易被低估的一块内容。刚学完for和while的语法，写个1到100求和、打印个九九乘法表，感觉已经会了。可真到用的时候——处理一批数据、写个带重试的逻辑、遍历嵌套结构——才发现卡壳的地方全在循环的边界、跳出条件和变量作用域上。这篇内容就是围绕"Python循环语句练习题"这个主题，把我自己带人、自己踩坑过程中反复用到的练习思路和解题细节整理出来。不管你是刚接触Python的新手，还是想回头把基础打扎实的开发者，下面这些题目的拆解方式、常见错误和优化思路，应该都能直接用上。

1. 为什么循环练习题不能只刷"求和"和"乘法表"

1.1 循环的真正难点不在语法，在边界控制

大部分人练循环，第一反应就是写for i in range(1, 101)求和。这类题当然要练，但它只训练了"循环体怎么写"，完全没有训练"循环什么时候停、什么时候跳、什么时候提前结束"。而实际写代码时，出问题最多的恰恰是后面这些。

举个很典型的例子：从列表里找第一个满足条件的元素。新手很容易写成遍历完整个列表再判断，而正确做法是找到就break。这两种写法在结果上可能一样，但效率差很多，而且一旦逻辑复杂起来，不break的写法会引入一堆额外的状态变量，代码迅速变得难以维护。

所以我在设计循环练习题时，会有意识地覆盖这几类能力：

• 计数与累加：最基础，训练循环体和累加变量的配合。
• 条件筛选：在循环里做判断，训练if和循环的嵌套。
• 提前终止：用break跳出，训练"找到就停"的思维。
• 跳过当前：用continue跳过，训练"过滤"的思维。
• 嵌套循环：训练多层遍历和内外层变量的关系。
• 循环与else：Python特有的for...else、while...else，训练"循环正常结束"的判断。
• 边界与死循环：训练while的终止条件设计，避免死循环。

这七类能力，基本覆盖了循环在实际项目里90%的使用场景。下面我按这个思路，把每一类拆开讲，每类给几道有代表性的题，重点讲"为什么这么写"和"容易错在哪"。

1.2 一道题练三遍，比三道题各练一遍更有效

我观察到一个现象：很多人做题是"做完就过"，对了就下一道。但循环这种东西，同一道题用不同写法实现一遍，收获远大于做三道不同的题。

比如"求1到100的和"这道题，至少可以写出四种版本：

# 版本一：最朴素的for循环 total = 0 for i in range(1, 101): total += i print(total) # 版本二：while循环 total = 0 i = 1 while i <= 100: total += i i += 1 print(total) # 版本三：用sum和range一行搞定 print(sum(range(1, 101))) # 版本四：递归（虽然不推荐，但能训练思维） def sum_to(n): if n == 1: return 1 return n + sum_to(n - 1) print(sum_to(100))

四种写法背后是四种不同的思维方式。版本一和版本二的区别在于"循环变量由谁管理"——for由range管理，while要自己手动维护i，手动维护就容易忘记i += 1导致死循环。版本三告诉你Python内置函数能省事，但前提是你得知道sum和range的配合。版本四训练的是把循环转成递归的能力，虽然Python对递归深度有限制，但理解这个转换对后面学算法很有帮助。

我的建议是：每道基础题，至少用for和while各写一遍，再想想有没有内置函数或库能一行解决。这个习惯坚持下来，你对循环的理解会完全不一样。

2. 计数、累加与条件筛选：把基础题写出层次

2.1 累加题的三个进阶方向

求和是最基础的累加题，但可以往三个方向进阶。

方向一：改变累加条件。比如"求1到100中所有偶数的和"。这时候循环体里要加判断：

total = 0 for i in range(1, 101): if i % 2 == 0: total += i print(total)

更优雅的写法是直接让range只产生偶数：

total = sum(range(2, 101, 2)) print(total)

range(2, 101, 2)的第三个参数是步长，从2开始每次加2，直接跳过所有奇数。这个写法比循环里加if更高效，因为它减少了循环次数。很多人不知道range有第三个参数，或者知道但想不起来用，这就是练习的价值——把"知道"变成"条件反射"。

方向二：改变累加对象。比如"求一个列表中所有数字的平方和"。这时候循环遍历的是列表元素，而不是range产生的数字：

nums = [1, 2, 3, 4, 5] total = 0 for n in nums: total += n ** 2 print(total)

这里有个细节：for n in nums直接遍历元素，比for i in range(len(nums))再nums[i]要清晰得多。新手常犯的错是用索引遍历，代码里一堆nums[i]，可读性差还容易越界。记住一个原则：只需要元素时直接遍历元素，需要索引时才用enumerate。

方向三：累加结果不是数字。比如"把列表中所有字符串拼成一个长字符串"。这时候累加变量初始值不是0，而是空字符串：

words = ["Py", "thon", " ", "循", "环"] result = "" for w in words: result += w print(result)

这里有个性能坑：字符串在Python里是不可变的，每次+=都会创建新字符串。如果列表很长，这种写法效率很低。更好的做法是用"".join(words)。但作为练习，先用循环写一遍，理解"累加"这个概念可以作用于任何支持+的类型，然后再学优化写法。

2.2 条件筛选：在循环里做判断的三种模式

条件筛选类题目，核心是在循环体里加if。但if放的位置不同，效果完全不同。

模式一：过滤后处理。先判断，满足条件才执行累加或其他操作：

# 统计列表中正数的个数 nums = [3, -1, 4, -1, 5, -9, 2] count = 0 for n in nums: if n > 0: count += 1 print(count)

模式二：分类处理。用if...elif...else在循环里分流：

# 统计正数、负数、零的个数 nums = [3, -1, 4, 0, 5, -9, 0] pos = neg = zero = 0 for n in nums: if n > 0: pos += 1 elif n < 0: neg += 1 else: zero += 1 print(pos, neg, zero)

这里有个小技巧：pos = neg = zero = 0这种链式赋值在初始化多个同类型变量时很简洁，但要注意它只适合不可变类型（数字、字符串、元组）。如果写成a = b = []，a和b会指向同一个列表，改一个另一个也变，这是个经典坑。

模式三：条件决定是否继续。这个模式用continue实现，后面讲跳过时会详细说。

条件筛选题最容易错的地方是判断条件的边界。比如"统计大于等于60的分数个数"，有人写成> 60，有人写成>= 60，一字之差结果完全不同。我的习惯是：写完条件后，拿边界值手动代入验证一遍。比如列表里有60，就看它该不该被算进去，然后检查代码是否符合预期。

2.3 用表格梳理常见累加/筛选题的解法

这张表里的"常见错误"一栏，每一条我都见人犯过。尤其是range的右边界问题，Python的range(a, b)是左闭右开，包含a不包含b，这个设计一开始很反直觉，但用多了会发现它和索引、切片保持一致，是合理的。记不住的时候就想：range(1, 101)产生1到100，正好100个数，因为101 - 1 = 100。

3. break、continue与循环else：控制流的精细操作

3.1 break：找到就停，别做无用功

break的作用是立即结束整个循环。最典型的场景是"查找"：在列表里找某个元素，找到就停。

# 查找目标值，返回索引，找不到返回-1 nums = [4, 7, 2, 9, 5, 1] target = 9 index = -1 for i, n in enumerate(nums): if n == target: index = i break print(index) # 3

如果不写break，循环会继续跑完，虽然结果一样，但做了无用功。数据量小的时候无所谓，数据量大的时候差距明显。更重要的是，不break的写法在逻辑复杂时容易出错——比如你找到后还想做点别的操作，不break的话后面的元素还会触发同样的操作。

break还有一个常见用法是配合while True做"无限循环+条件退出"：

# 模拟一个输入验证，直到输入合法才退出 while True: user_input = input("请输入一个正整数: ") if user_input.isdigit() and int(user_input) > 0: print(f"你输入的是 {user_input}") break print("输入不合法，请重试")

这种模式在实际项目里非常常见，比如重试逻辑、菜单循环、游戏主循环。while True本身是死循环，靠内部的break退出。写这种代码时，一定要确保每条路径最终都能到达break或return，否则就是真死循环。

注意：break只跳出当前这一层循环。如果有多层嵌套，break只结束最内层，外层继续。这是新手最容易搞混的点之一。

3.2 continue：跳过当前，继续下一个

continue的作用是跳过本次循环剩下的代码，直接进入下一次循环。它和break的区别是：break是"不干了"，continue是"这个不要，下一个"。

# 打印1到10中所有的奇数 for i in range(1, 11): if i % 2 == 0: continue print(i)

这段代码里，遇到偶数就continue，跳过print，所以只打印奇数。等价的写法是把print放进if i % 2 != 0里，两种写法结果一样，但思路不同。continue的写法是"排除法"——先排除不要的，剩下的就是要的；if包裹的写法是"筛选法"——直接挑出要的。

什么时候用continue更合适？当循环体很长，而需要跳过的条件在开头时。比如：

for item in data: if not item: continue # 空数据跳过 if item.type != "target": continue # 类型不对跳过 # 下面是长长的处理逻辑 process(item)

这种"守卫式"写法把各种排除条件集中在开头，主逻辑放在后面，可读性比层层嵌套的if好很多。这是我个人很推荐的一种风格。

continue的一个坑是：在while循环里用continue时，如果continue跳过了循环变量的更新语句，会导致死循环。比如：

i = 0 while i < 10: if i == 5: continue # 错误！i永远等于5，死循环 print(i) i += 1

这段代码在i == 5时会无限循环，因为continue跳过了i += 1。正确做法是把i += 1放在continue之前，或者改用for循环。这个坑我在实际项目里见过不止一次，排查起来还挺费劲，因为程序不报错，就是卡住不动。

3.3 循环else：一个被严重低估的特性

Python的for和while都可以带else子句，这个else在循环正常结束（没有被break中断）时执行。很多人学Python好几年都不知道这个特性，或者知道但不敢用，怕别人看不懂。

它的典型应用场景是"查找+未找到处理"：

# 查找目标值，找到打印索引，找不到打印提示 nums = [4, 7, 2, 9, 5, 1] target = 8 for i, n in enumerate(nums): if n == target: print(f"找到了，索引是 {i}") break else: print("没找到")

如果用传统写法，需要额外一个标志变量：

found = False for i, n in enumerate(nums): if n == target: print(f"找到了，索引是 {i}") found = True break if not found: print("没找到")

对比一下，for...else省掉了标志变量，逻辑更紧凑。但它的可读性确实有争议——else这个词在这里的含义是"没有break"，而不是"否则"，容易让人误解。我的建议是：自己写代码时可以用，但团队协作时要看团队规范；读别人代码时要知道这个特性，别看到else就以为是条件分支。

while...else的用法类似，但更少见。一个典型场景是"重试N次，都失败则报错"：

attempts = 3 while attempts > 0: result = try_operation() if result == "success": print("操作成功") break attempts -= 1 else: print("重试3次都失败了")

这里else在while条件变为False（即attempts减到0）时执行，表示"循环跑完了都没成功"。

3.4 break/continue/else的对比与选择

选择的原则很简单：要停止整个循环用break，要跳过当前用continue，要处理"循环跑完但没触发break"用else。三者可以组合使用，但组合太多会降低可读性，这时候宁可多写几行代码换清晰。

4. 嵌套循环：从打印图形到处理二维数据

4.1 嵌套循环的执行顺序：外层走一步，内层走一圈

嵌套循环是循环练习里最容易绕晕的部分。核心要记住一句话：外层循环每执行一次，内层循环完整执行一遍。

for i in range(1, 4): for j in range(1, 4): print(f"i={i}, j={j}")

输出是：

i=1, j=1 i=1, j=2 i=1, j=3 i=2, j=1 i=2, j=2 i=2, j=3 i=3, j=1 i=3, j=2 i=3, j=3

可以看到，i=1时，j从1跑到3；然后i=2，j又从1跑到3。总共执行3×3=9次。理解了这个顺序，打印各种图形就顺理成章了。

4.2 打印图形的通用思路：把图形翻译成行列关系

打印图形题的本质是：找出每一行打印什么，以及行数和列数的关系。

直角三角形：

# 打印5行，第i行打印i个星号 for i in range(1, 6): print("*" * i)

输出：

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

这里其实只用了一层循环，因为"*" * i直接生成了i个星号。如果非要用嵌套循环：

for i in range(1, 6): for j in range(i): print("*", end="") print() # 换行

内层range(i)产生0到i-1，共i次，每次打印一个星号不换行，内层结束后print()换行。这个写法虽然啰嗦，但训练的是"内层控制列"的思维。

等腰三角形：

# 打印5行等腰三角形 n = 5 for i in range(1, n + 1): spaces = " " * (n - i) stars = "*" * (2 * i - 1) print(spaces + stars)

输出：

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

这道题的关键是找出空格数和星号数与行号i的关系：第i行有n - i个空格，有2 * i - 1个星号。这个关系不是猜出来的，是数出来的——拿n=5，第1行4个空格1个星号，第2行3个空格3个星号，第3行2个空格5个星号，规律一目了然。

九九乘法表：

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

输出：

1*1=1 1*2=2 2*2=4 1*3=3 2*3=6 3*3=9 ...

这里内层range(1, i + 1)保证第i行打印i个式子，end="\t"用制表符分隔，内层结束后换行。九九乘法表是嵌套循环的经典题，因为它同时训练了"内层次数依赖外层变量"和"格式化输出"两个能力。

4.3 嵌套循环处理二维数据

除了打印图形，嵌套循环更实用的场景是处理二维数据，比如矩阵。

# 矩阵转置 matrix = [ [1, 2, 3], [4, 5, 6], [7, 8, 9] ] transposed = [] for j in range(len(matrix[0])): row = [] for i in range(len(matrix)): row.append(matrix[i][j]) transposed.append(row) print(transposed) # [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

这段代码的逻辑是：外层遍历列索引j，内层遍历行索引i，把matrix[i][j]收集成新的一行。注意外层是len(matrix[0])（列数），内层是len(matrix)（行数），这个顺序和直觉相反，容易写错。写的时候先想清楚"新矩阵的每一行对应原矩阵的每一列"，就不容易搞混。

Python里矩阵转置其实有更简单的写法：list(zip(*matrix))。但作为练习，先用嵌套循环写一遍，理解转置的本质，再学这种"一行流"写法，收获更大。

嵌套循环的性能问题也值得提一句。如果外层和内层都是遍历大数据集，总次数是两者相乘，很容易爆炸。比如两个各1000元素的列表做笛卡尔积，就是100万次操作。实际项目里遇到嵌套循环，要想想能不能用字典、集合或itertools优化。比如"找两个列表中相同的元素"，用嵌套循环是O(n²)，用集合交集是O(n)：

a = [1, 2, 3, 4, 5] b = [4, 5, 6, 7, 8] # 嵌套循环写法 common = [] for x in a: for y in b: if x == y: common.append(x) # 集合写法 common = list(set(a) & set(b))

两种写法结果一样，但集合写法快得多。练习时两种都写，理解差异，实际用的时候选高效的。

5. while循环的终止条件与死循环排查

5.1 while和for的选择：知道次数用for，不知道次数用while

for循环适合"遍历一个已知序列"或"重复固定次数"，while循环适合"重复直到某个条件满足"。判断标准很简单：如果你能提前说出循环要跑多少次，用for；如果只能说出"跑到什么时候停"，用while。

# 已知次数：用for for i in range(10): print(i) # 未知次数：用while total = 0 n = 1 while total < 100: total += n n += 1 print(n) # 找到累加到超过100需要多少个数

第二段代码里，你不知道要加多少个数才能超过100，所以用while。这种"条件驱动"的循环是while的主场。

5.2 死循环的三种典型成因

死循环是while最常见的坑。程序不报错，就是卡住不动，CPU跑满。三种典型成因：

成因一：忘记更新循环变量。

i = 0 while i < 10: print(i) # 忘记写 i += 1

i永远是0，条件永远为真。这是最经典的死循环。

成因二：更新语句写错方向。

i = 10 while i > 0: print(i) i += 1 # 应该是 i -= 1

i越来越大，永远大于0。

成因三：条件永远为真。

while True: print("hello") # 没有break

while True本身没问题，但必须有break或return退出。写while True时，我习惯先把退出条件写好，再写循环体，避免忘记。

排查死循环的方法：在循环体里加一句print打印循环变量，跑一下看变量有没有按预期变化。如果变量不变或变化方向不对，就是死循环。更专业的做法是用调试器打断点，单步执行看变量。但初学阶段，print大法足够用。

5.3 while循环的实战模式

模式一：累加到阈值。

# 累加自然数，直到和超过1000 total = 0 n = 0 while total <= 1000: n += 1 total += n print(f"加到{n}时和超过1000，和为{total}")

模式二：数字处理。

# 反转一个整数 num = 12345 reversed_num = 0 while num > 0: reversed_num = reversed_num * 10 + num % 10 num //= 10 print(reversed_num) # 54321

这道题很经典，训练的是"用取余和整除逐位处理数字"。num % 10取最后一位，num // 10去掉最后一位，循环直到num为0。每一步的逻辑要能说清楚，不然容易写错。

模式三：输入验证。

while True: age = input("请输入年龄: ") if age.isdigit() and 0 < int(age) < 150: print(f"年龄是 {age}") break print("输入不合法，请重新输入")

这种模式在实际项目里到处都是，核心是"循环+校验+break"。

模式四：模拟过程。

# 模拟一个球从100米落下，每次弹起高度为上次的一半，求第10次弹起高度 height = 100 for i in range(10): height /= 2 print(height)

这道题其实用for更合适，因为次数已知。但如果问"弹起到高度小于1米需要多少次"，就得用while：

height = 100 count = 0 while height >= 1: height /= 2 count += 1 print(count)

选择for还是while，就看"次数是否已知"。

5.4 while循环的常见错误对照表

这张表里的每一条，都是我在实际写代码和帮人排查时反复遇到的。尤其是"结果多算/少算一次"，几乎每个人都犯过。解决办法就是拿最小案例手动跑一遍，比如循环3次的情况，一步步看变量怎么变。

6. 循环练习的进阶方向与实战建议

6.1 从循环到推导式：什么时候该换写法

Python的列表推导式、字典推导式、生成器表达式，本质上都是循环的语法糖。练完基础循环后，应该逐步学会在合适场景下用推导式替代循环。

# 循环写法 squares = [] for i in range(1, 11): squares.append(i ** 2) # 推导式写法 squares = [i ** 2 for i in range(1, 11)]

推导式更简洁，但不是什么情况都适合。我的判断标准是：如果循环体只有"遍历+简单变换+收集"三步，用推导式；如果循环体里有复杂逻辑、多个分支、或者副作用操作（如打印、写文件），用普通循环。

带条件的推导式：

# 1到20中所有偶数的平方 evens_squared = [i ** 2 for i in range(1, 21) if i % 2 == 0]

嵌套推导式（对应嵌套循环）：

# 生成乘法表的所有式子 table = [f"{j}*{i}={i*j}" for i in range(1, 10) for j in range(1, i + 1)]

注意嵌套推导式的顺序：for i在前，for j在后，和嵌套循环的书写顺序一致。这个顺序容易搞反，记不住就想想等价的循环写法。

6.2 用循环解决实际小问题

练习题做多了，可以尝试用循环解决一些实际小问题，这样能真正体会到循环的用处。

问题一：统计一段文本中每个字符出现的次数。

text = "hello world" count = {} for ch in text: if ch in count: count[ch] += 1 else: count[ch] = 1 print(count)

更简洁的写法用dict.get：

count = {} for ch in text: count[ch] = count.get(ch, 0) + 1

count.get(ch, 0)的意思是"取ch的值，没有就返回0"，这样就不用写if...else了。这个技巧在实际项目里非常常用。

问题二：找出列表中出现次数最多的元素。

nums = [1, 3, 2, 3, 5, 3, 2, 1, 3] count = {} for n in nums: count[n] = count.get(n, 0) + 1 max_count = 0 max_num = None for n, c in count.items(): if c > max_count: max_count = c max_num = n print(max_num, max_count)

这段代码用了两个循环：第一个统计次数，第二个找最大值。第二个循环也可以用内置函数max(count, key=count.get)一行搞定，但作为练习，先手写一遍理解逻辑。

问题三：判断一个数是不是质数。

def is_prime(n): if n < 2: return False for i in range(2, int(n ** 0.5) + 1): if n % i == 0: return False return True

这道题的关键是循环范围到sqrt(n)就够了，因为如果n有大于sqrt(n)的因子，必然有小于sqrt(n)的对应因子。这个优化能把复杂度从O(n)降到O(√n)。int(n ** 0.5) + 1里的+1是为了包含sqrt(n)本身，因为range右边界不包含。

6.3 循环练习的节奏建议

最后说说练习节奏。我的建议是分三阶段：

第一阶段：单知识点练习。每学一个循环特性（for、while、break、continue、else、嵌套），就集中做5到10道针对这个特性的题。这个阶段追求"会用"，不追求快。

第二阶段：混合练习。把多个特性混在一起做题，比如"用循环+条件+break实现一个查找功能"。这个阶段追求"用对"，即知道什么场景用什么特性。

第三阶段：项目练习。用循环解决实际小问题，比如统计文本、处理数据、实现小游戏逻辑。这个阶段追求"用好"，即写出可读、高效、健壮的代码。

每个阶段不用严格分开，可以交叉进行。但有一点很重要：每道题做完后，回头看看有没有更简洁或更高效的写法。这个"回头看"的习惯，是区分"会写"和"写好"的关键。

提示：练习时不要怕写错。循环的边界问题、死循环问题，只有自己踩过才能真正记住。看别人代码觉得懂了，和自己动手写对，中间差着十万八千里。

我在带人的过程中发现，循环这块内容，光看是看不会的，必须动手写、动手调、动手改。上面这些题目和思路，建议你挑几道自己敲一遍，尤其是那些"常见错误"的部分，故意写错一次，看看报什么错、卡在哪里，比直接写对印象深得多。循环是后面学函数、类、算法的基础，这块打扎实了，后面的路会顺很多。