06-for 循环内容补充
1. for 循环嵌套
点击展开阅读
在 Python 中，嵌套的 for 循环是指在一个 for 循环内部再包含一个或多个 for 循环。这种结构在处理多维数据（例如二维、三维的列表或数组）以及需要多层次迭代的场景中非常常见，可以大幅提高编程的灵活性与效率。
1. 嵌套 for 循环的基本结构
1.1 基本定义
嵌套的 for 循环的基本结构如下：
一个嵌套的 for 循环通常的书写形式如下：
for 变量1 in 可迭代对象1:
for 变量2 in 可迭代对象2:
# 执行代码块每个 for 循环工作原理如下：
- 外层循环从
可迭代对象1中取出一个元素赋值给变量1。 - 然后，内层循环开始执行，从
可迭代对象2中逐一取出元素赋值给变量2。 - 特别注意：对于外层循环的每一个（次）单独的迭代，内层循环都会完整地循环一遍（举个例子：假如外层循环2次，内层循环3次。当程序开始运行时：外层循环执行第一次，内层循环会完整的执行完 3次。然后外层循环才会再执行下一次循环，内层循环接着重复执行完整的3次。如此反复～）
1.2 代码示例
查看下面的代码示例，助于理解：
for i in range(2):
print(f"外层循环执行了第 {i + 1} 次")
for j in range(3):
print(f"\t内层循环执行了第 {j + 1} 次")运行结果如下：
外层循环执行了第 1 次
内层循环执行了第 1 次
内层循环执行了第 2 次
内层循环执行了第 3 次
外层循环执行了第 2 次
内层循环执行了第 1 次
内层循环执行了第 2 次
内层循环执行了第 3 次看了上面的输出，你会对 for 循环嵌套有更好的理解。我接下来还有写一个生活中的例子来辅助理解嵌套循环，学代码不要脱离现实！一切都来源于生活～
1.3 生活中的例子
让我们用一个贴近生活的场景来解释嵌套 for 循环的思想。想象你是餐厅的经理，负责统计一晚上的销售收入。
场景描述：
在一家繁忙的餐厅中，每张桌子都有几位顾客，每位顾客可能会点多道菜。为了统计当晚的总收入，你会采取以下步骤：
- 逐桌检查：你首先走遍整个餐厅，对每一张桌子进行查看。这一步相当于第一层“循环”——每张桌子都要统计。
- 逐人点单：对于每张桌子，你会询问每位顾客点了哪些菜，并记录每道菜的价格。这就相当于在每张桌子内部，你又需要逐一处理桌子上的所有订单，也就是第二层“循环”。
- 汇总统计：当你收集完每桌的所有订单后，将每张桌子的总金额加起来，就可以得出餐厅的总收入。
这个过程可以形象地理解为：
- 外层循环（第一层）： 遍历餐厅的每张桌子。
- 内层循环（第二层）： 对每张桌子上的每位顾客及其订单进行统计。
这种分步走的做法正是嵌套循环的思想：先处理大范围的分组（桌子），再在每个分组内部逐个处理细节（顾客订单）。这种方法不仅让你更有条理地完成任务，还能防止遗漏细节。
通过这种方式，你就能准确地统计出餐厅一整晚的销售额，同时也能发现某一桌的消费是否特别高、哪种菜品更受欢迎等信息。这正是嵌套 for 循环在现实生活中的一个直观应用。
2. 示例：处理二维列表
2.1 基本遍历输出
假设我们有一个二维列表（即列表的列表），我们可以使用嵌套的 for 循环来遍历每一个元素。
假设我们有一个二维列表（列表中存放列表），现在需要依次遍历并访问里面的每个元素。示例代码如下：
假设我们有一个二维列表（即列表的列表），比如一个 3x3 的矩阵。我们希望依次访问矩阵中的每个元素。下面的示例代码展示了如何使用嵌套循环来完成这个任务：
matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
for row in matrix: # 外层循环：遍历每一行
for item in row: # 内层循环：遍历当前行中的每个元素
print(item)这段代码首先遍历 matrix 中的每一行（外层循环），然后遍历该行中的每个元素（内层循环），并打印出来。
运行结果将依次打印 1 2 3 4 5 6 7 8 9。这里的 row 是外层循环的元素（即矩阵中的一行），item 则代表当前行中的某个具体元素。
逐步解析：
- 外层循环：
for row in matrix:这一行代码会依次取出matrix中的每一行（每一行本身也是一个列表），并将它赋值给变量row。 - 内层循环：
for item in row:每当外层循环取得一行数据后，内层循环会遍历该行中的所有元素，依次将元素赋值给item，并执行print(item)。
小实验：尝试在代码中添加注释或打印调试信息，观察内外层循环的执行顺序，加深理解。
2.2 小试牛刀 5：遍历二维列表
小试牛刀： 用 for 循环嵌套求 matrix 数据总和。
用 for 循环嵌套对二维列表求和，二维列表数据如下：
matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]第一步：先思考如何实现，我们要计算出列表 matrix 中的总和，前提是什么？前提是先得到每个数字！
第二步：得到列表中的每个数字，前面已经讲解过：
matrix = [ [1, 2, 3], [4, 5, 6], [7, 8, 9] ] for row in matrix: # 外层循环：遍历每一行 for item in row: # 内层循环：遍历当前行中的每个元素 print(item)第三步：得到每一个数字后，我们需要实现累加。现实生活中，我们加一个数时会怎么计算？
- 例如计算一组：
[1, 2, 3]； - 首先计算 1 + 2 得到 3，我们记下来；
- 接着用前面记着的 3，加上下一个待相加的 3 得到：
3 + 3 = 6。 - 我记下来是怎么记的？——无非是记在草稿子上或者是记在脑子的某个位置；
- 那在代码中如何实现？——找一个类似草稿子或者脑子的某个位置来记，在 Python 中我们就可以创建一个变量来存储待求的总和，我们就把变量叫
total吧。 - 下一个问题来了，直接就在代码里面写
total吗？——肯定不行，语法也不允许。肯定是需要给 total 赋一个值，因为我们是要求和，赋什么值不会影响最终的计算结果呢？——零（0），零加上任何数都等于本身！
最终代码如下：
# 我们先初始化一个变量 total 用于累加每个元素的值。 total = 0- 例如计算一组：
第四步：直接进行累加即可
matrix = [ [1, 2, 3], [4, 5, 6], [7, 8, 9] ] total = 0 for row in matrix: for item in row: total += item # 外层循环遍历每一行，内层循环遍历每一行中的每个数字，并不断将数字加到 total 上。 print(total)这段代码会将所有数字相加并打印出结果
45，如果可以：试着在内层循环中添加print(item)，观察程序是如何逐步累加的。
上面成功实现求和，但 for 循环嵌套并不是必须的，我们如何实现只用一个 for 循环实现呢？
并非所有情形都必须使用嵌套循环，我们学会跳出思维惯性，开阔自己的思维。有时解决问题的方法不止一种，如同上面的求和任务。若仅仅是想把所有数字相加，还可以用下面的写法，一个 for 循环就足够了。
这里我们可以利用 Python 内置的 sum() 函数对每一行列表求和，然后再累加。例如：
matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
total = 0
for row in matrix:
total += sum(row)
print(total)这种方式代码更简洁，但理解嵌套循环的工作原理对于你日后面对更复杂问题时非常重要。如果说推荐，我肯定推荐现在的第二种方法。这里用到 for 嵌套，纯粹是为了教你用而用。
2.3 难度升级：二维数组竖列求和
2.3.1 任务描述
在更复杂的情形下，我们可能需要按“列”来计算和。
现在让我们挑战一下：是我们的“老熟人”二维数组 matrix，要求计算每一列的元素之和，并将结果存储在一个一维数组中。该任务不仅锻炼你对嵌套循环的理解，同时也会让你更熟悉如何操作数组索引。
对于下面的矩阵：
matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]对于上述 matrix，你的程序应该输出：
每列的和: [12, 15, 18]说明：
第一列（第 0 列）的和：
1 + 4 + 7 = 12第二列（第 1 列）的和：
2 + 5 + 8 = 15第三列（第 2 列）的和：
3 + 6 + 9 = 18
要求：你必须使用 for 循环来遍历二维数组并计算每列的和。
提示：你可以通过初始化一个长度为 n 的数组来存储每列的和，并在遍历每行时将每列的值加到相应的数组位置上。
好好思考一下，看看上面如何实现。接下来，我会一步步带你实现。
2.3.2 第一步：从现实生活角度理解如何按列求和
想象一下，你有一个由多行数字组成的表格，每一列都排列着一组数字。假如你要计算每一列的总和，首先你会在心中设定一个记录器，每一列都有一个“计数器”。
当你逐行查看这张表格时，每读到一行，就会把这一行中每一列的数字分别加到对应的计数器上。
比如，第一行的三个数字分别加到第一、第二、第三个计数器上；接着第二行同样处理……直到所有行都看完。
最终，每个计数器中的数值就是对应列的总和。
接下来，我举个具体的例子，来让你更好的理解。文字表达终归有局限性，但是我会尽可能表达完全且清楚。
假设你面前有一个表格，表格中的数字排列如下：
+---+---+---+
| 1 | 2 | 3 |
+---+---+---+
| 4 | 5 | 6 |
+---+---+---+
| 7 | 8 | 9 |
+---+---+---+这个表格其实就是一个二维数组，每一行代表一组数据，每一列代表一类数据。现在，你的任务是计算每一列数字的总和。
具体步骤演示：
准备工作
为了计算每列的和，我们需要给每一列设立一个“计数器”。
假设初始时，每个计数器的值都为 0。
例如，第一列、第二列、第三列的初始值分别为 0、0、0。
第一列求和
第一行：第一列的数字是 1。把 1 加到第一列的计数器上，原来的 0 变为 1。
第二行：第一列的数字是 4。将当前的计数器值 1 加上 4，得到 1 + 4 = 5。
第三行：第一列的数字是 7。再将 5 加上 7，得到 5 + 7 = 12。
结果：第一列的和就是 12。
第二列求和
第一行：第二列的数字是 2。初始值 0 加上 2，变为 2。
第二行：第二列的数字是 5。当前值 2 加上 5，得到 2 + 5 = 7。
第三行：第二列的数字是 8。再加上 8，7 + 8 = 15。
结果：第二列的和为 15。
第三列求和
第一行：第三列的数字是 3。初始值 0 加上 3，得到 3。
第二行：第三列的数字是 6。当前值 3 加上 6，得到 3 + 6 = 9。
第三行：第三列的数字是 9。再加上 9，9 + 9 = 18。
结果：第三列的和为 18。
总结一下，这个二维数组每一列的和分别为：
- 第一列：12
- 第二列：15
- 第三列：18
这种按列求和的方式就好比你在给每一列都开了一个小账户，依次将每行对应列的数字存入账户，最后得到每个账户的总金额。
2.3.3 第二步：将现实操作转化为代码
初始化：
- 首先确定矩阵中有几列（例如：用
len(matrix[0])获取第一行的元素个数）。 - 然后创建一个与列数等长的列表，用来存储每列的累计和，初始值全部为 0。
- 例如：
column_sums = [0] * len(matrix[0])表示我们为每一列都设立了一个“计数器”，初始值均为 0。
- 首先确定矩阵中有几列（例如：用
嵌套循环累加：
- 遍历每一行，再遍历这一行的每一列，把每个数字加到对应列的计数器中。
- 对应现实生活中的“第一行的第一列累加到第一列计数器”、“第二行的第一列继续累加到第一列计数器”等步骤。
- 代码示例如下：
for row in matrix: # 遍历每一行 for i in range(len(row)): # 遍历每一行的每个元素（按列） column_sums[i] += row[i] # 将当前数字加到对应的列累计和中输出结果：
遍历完成后，
column_sums中存储的就是每一列的累计和，然后输出结果：print("每列的和:", column_sums)完整代码如下：
# 定义二维数组（矩阵） matrix = [ [1, 2, 3], [4, 5, 6], [7, 8, 9] ] # 初始化一个列表，长度为列数，每个元素初始为 0 column_sums = [0] * len(matrix[0]) # 嵌套循环：外层遍历每一行，内层遍历每一行的每个元素 for row in matrix: for i in range(len(row)): column_sums[i] += row[i] # 输出每列的和 print("每列的和:", column_sums)运行结果：
每列的和: [12, 15, 18]解释：
初始化部分：我们创建了一个列表
column_sums，其长度与矩阵的列数一致。就好比给每一列开了一个“账户”，初始余额为 0。嵌套循环部分：外层循环每次取出一行
row，内层循环遍历这行中每个数字，通过i代表列的索引，将当前行中第i个数字累加到column_sums[i]中。这正对应了现实生活中逐行将每一列数字累加到各自账户的过程。输出部分：最后，我们输出
column_sums，显示每列累计的结果。
2.3.4 多种实现代码
接下来，我提供多种实现代码，便于你学习和参考其中思路。前面要理解了之后，再看下面的代码。下面的代码和前面的很类似，我就不重复赘述了。
方法一：按列遍历累加（基于索引）
# 定义矩阵
matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
# 初始化一个列表来存储每列的和，列表长度由第一行的元素个数决定
column_sums = [0] * len(matrix[0])
# 遍历每一列（外层循环）
for i in range(len(matrix[0])):
# 遍历每一行（内层循环），逐行取出对应列的数字
for j in range(len(matrix)):
column_sums[i] += matrix[j][i]
# 输出每列的和
print("每列的和:", column_sums)方法一：讲解
初始化：先用
len(matrix[0])获取第一行的列数，并创建一个与之等长的列表column_sums，初始每个元素为 0，代表每列的累加器。双重循环：
外层循环以列为单位，索引
i表示当前正在处理的列。内层循环遍历所有行，通过
matrix[j][i]取出当前行第i列的数字，并累加到column_sums[i]中。
输出：最后打印结果
[12, 15, 18]，分别代表每列的和。
方法二：逐行累加（适用于固定列数的情况）
如果你更喜欢直接处理每一行，可以这样操作：假设你知道矩阵每行的长度固定为 3，可以用单独的变量来累计每一列的和。
matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
# 初始化三个变量分别记录三列的和
col1 = 0
col2 = 0
col3 = 0
# 遍历每一行，将每列的值累加到对应变量上
for row in matrix:
print(row[0], row[1], row[2])
col1 += row[0]
col2 += row[1]
col3 += row[2]
column_sums = [col1, col2, col3]
print(column_sums) # 输出：12 15 183. 小试牛刀 6: 九九乘法表
九九乘法表是学习嵌套循环的经典练习题。通过编写乘法表程序，你不仅能巩固嵌套循环的概念，还能体验如何利用循环控制输出格式。
下面是我们的程序实现的目标结果：
3.1 示例：生成乘法表
嵌套循环也常用于生成乘法表等需要行和列计算的场景。
嵌套循环是生成乘法表等涉及行和列的计算中常用的技巧。我们可以通过观察生活中如何“排列表格”的直观过程，来理解代码中的循环结构。
3.2 思路分析
- 从现实场景理解
- 想象一下你在书写乘法表：你先确定有几行（例如 9 行），每一行对应一个乘数；每一行中又分成多个“格子”，每个格子显示不同乘数的乘积。
- 你会先写下第一行，然后换行，再写第二行……直到所有行都完成。
- 这种结构正好对应于嵌套循环：外层循环控制行数（乘数），内层循环控制列数（另一个乘数或因子）。
- 如何用代码实现
- 外层循环：使用
for i in range(1, 10)表示从 1 到 9 的行。 - 内层循环：使用
for j in range(1, 10)表示每一行内也从 1 到 9 依次计算乘积。 - 打印与换行：在内层循环中使用
end='\t'保持在同一行打印多个结果；每完成一行内层循环后，用print()输出换行符。
- 外层循环：使用
3.3 基本实现代码
for i in range(1, 10): # 行，从1到9
for j in range(1, 10): # 列，同样从1到9
print(f"{i} * {j} = {i * j}", end='\t')
print() # 每完成一行乘法后换行在这个例子中，外层循环和内层循环都使用 range(1, 10)，分别代表乘法表的行和列。每次外层循环进入新的一行，内层循环依次计算并打印该行所有乘积。并且在每内层循环结束后，使用 print() 函数来创建一个新行。
3.4 现有问题
运行前面的代码，我们一起来看看有没有什么问题：
我们可以看见很明显的两个问题：
- 问题一：出现的乘法结构不对，现在是：
3 * 1 = 3，正确结构为：1 * 3 = 3； - 问题二：不是三角形形式输出（就是和题目的不一样），还出现重复的计算。
认真观察一下，看看怎么解决。
3.5 问题一
一图胜千言，看下图。“上”、“下”两个部分，哪个部分是我们需要的部分？——“下”是我们需要的部分。
那么“下”部分有什么问题？——位置反了。一起看看特点：
1 * 1 = 1
2 * 1 = 2
3 * 1 = 3
4 * 1 = 4
5 * 1 = 5
6 * 1 = 6
7 * 1 = 7
8 * 1 = 8
9 * 1 = 9我们从上面贴出的部分输出，可知：第一列的数字是 1、2、3、4、5、6、7、8、9，第二列的数字都是 1。这显然和实际的九九乘法表不一样，实际的 1 在前面，而 1、2、3、4、5、6、7、8、9 在后面。
那么按照嵌套循环的逻辑可知：都是 1 的是外层循环产生的，而 1、2、3、4、5、6、7、8、9 是由内层循环产生的。
接着，我们结合我们现有的代码：
print(f"{i} * {j} = {i * j}", end='\t')可知，直接交换 i 和 j 的位置即可。
print(f"{j} * {i} = {i * j}", end='\t')现在修改后的完整代码如下：
for i in range(1, 10): # 行，从1到9
for j in range(1, 10): # 列，同样从1到9
print(f"{j} * {i} = {i * j}", end='\t')
print() # 每完成一行乘法后换行到此，我们一起解决了乘法表中数字位置的切换！
3.6 问题二
第二个问题比较简单，去掉多余的输出即可。我们看看下面的图：
观察上图输出可知，我们需要的下半部分的三角形输出。并且观察上下部分特点可知：下班部分的输出结构需要满足 j <= i。
为什么是：j <= i，因为原本代码是：f"{j} * {i} = {i * j}"，前面的数字代表 j，后面的数字代表 i。而且从规律可知：j <= i。规律用文字不好描述，还是看下图：
所以，我们只要添加一个 if 判断即可筛选我们想要的下半部分三角形：
if j <= i:
print(f"{j} * {i} = {i * j}", end='\t')修改后的完整代码如下：
for i in range(1, 10): # 行，从1到9
for j in range(1, 10): # 列，同样从1到9
if j <= i:
print(f"{j} * {i} = {i * j}", end='\t')
print() # 每完成一行乘法后换行3.7 有趣的实现
我的一位来自香港理工大学的学员，在上课时提出的奇思妙想：想要保留上半部分的代码且格式。
当时可是费了不少劲，才写出来的。代码贴在下面，有兴趣的查看即可。
for i in range(1, 10):
# 在每行的开头添加足够的制表符，以形成缩进
print("\t\t\t" * (i - 1), end='')
for j in range(i, 10):
print(f"{i} * {j} = {i * j}\t", end='')
print() # 每完成一行乘法后换行运行后输出如下：
3.8 另一种实现：用内层循环控制范围
for i in range(1, 10): # 行数：1 到 9
for j in range(1, i + 1): # 列数：1 到 i
print(f"{j} * {i} = {i*j}", end="\t")
print() # 每完成一行后换行接下来，着重分析 i + 1 的由来。
在传统的九九乘法表里，第 1 行只有
1 x 1一个乘积，第 2 行通常是1 x 2、2 x 2，第 3 行是1 x 3、2 x 3、3 x 3，依此类推。也就是说，第 i 行只需要展示从
1一直到i这几个数和i相乘的结果。这样能让表格看起来更简洁，并且避免重复组合（例如2 x 3和3 x 2）。如果我们想在代码中表达“第 i 行的列数只到
i”，就可以在内层循环里写range(1, i + 1)。
提示：
你可以尝试把
range(1, i + 1)改成range(1, i)，运行看看会出现什么情况，直观感受为什么需要加+1。在学习编程时，多加这一步“实验对比”是非常好的习惯，它能帮助你快速抓住关键知识点，并把它记得更牢。
4. 注意事项
- 嵌套循环可以使代码复杂度增加，尤其是当循环层数增多时。需要注意代码的可读性和性能。
- 在可能的情况下，尽量避免使用太多层的嵌套循环，以免造成代码的运行效率降低。
嵌套循环是编程中常见的一个概念，通过适当使用可以解决很多复杂的问题，但也需要注意其对性能的影响。
2. 肖同学代码示例
点击展开阅读
num_check = False
while not num_check:
# 获取用户输入，并去除首尾空白字符
lst_str = input('Enter two numbers separated by space: ').strip()
# 判断输入中空格数量是否正好为1（避免输入过多或过少的数字）
if lst_str.count(' ') != 1:
print('输入空格数目不为1，请重新输入。')
else:
# 将输入中的空格去除后，检查剩余字符是否均为数字
lst_check = lst_str.replace(' ', '')
if not lst_check.isnumeric():
print('输入不符合要求，请查看是否用空格间隔。')
else:
# 进一步判断是否为纯数字
if not lst_check.isdigit():
print('输入不是纯数字，报错。')
else:
# 将输入字符串按空格分割，并转换为整数列表
lst = list(map(int, lst_str.split(' ')))
sta = lst[0]
en = lst[1]
sum = 0
# 检查输入数字的个数是否确实为2
if len(lst) != 2:
print('输入数字个数不符合要求，重新输入。')
else:
# 判断起始数字是否大于结束数字
if sta > en:
print('起始数字大于结束数字，重新输入。')
else:
# 利用 for 循环计算从 sta 到 en 的累加和
for i in range(sta, en + 1):
sum += i
print(sum)
num_check = True对于她的代码，我当时有如下观点：
- 观点一：肖同学想到使用
.count()来判断，这个有点让我惊奇到的思路。我一开始就没想到使用.count()这个实现策略我觉得有值得参考的地方，拓宽了解题思路。 - 观点二：上面观点一说了惊奇，那我们来说说哪里惊奇了：我们不用
len(lst_str.split(' ')) > 1 and len(...) < 3来判断用户是否输入恰好由一个空格分隔的两个数字，而是巧妙地用lst_str.count(' ') != 1来判断，这样更直接，也避免了中间拆分字符串的步骤。并且如果你细心的话，应该发现了前面我们实现的代码并没有考虑用户输入是否规范的问题。虽然不论用户在两个数字之间输入了多少空格，.split()以默认空格分割时，是会自动去掉多个空格的。不过，能考虑到限制用户输入标准的“一个空格”这时值得表扬的。（还可以这么写：1< len(lst_str.split(' ')) < 3） - 观点三：肖同学还提出，我之前还想过这么写：
if not (len(lst_str.split()) != 2):，但是发现没有.count()好。你知道为什么么？——使用这个方法，有一定的局限性并且有强烈的指向性，如果个数小于 2 或大于 2，那么len(lst_str.split()) != 2得到的都为 True，只有在列表长度为 2 的时候，才为 False。 - 观点四（探究
!=的应用场景）：对于上一个观点做一个补充，这也是在给肖同学上课时突然提到的，关于不等于（!=）这个运算符：在某些情况下，!=可以快速排除掉某个特定值，只要不是特定值就可以通过（得到 True）。但它的缺点是判断过于单一，“除了不等于特定值之外”什么都通过（得到 True），逻辑太宽泛、不够灵活。（总结一句：常用于特定条件，使用不够灵活）
上面代码的局限性有哪些：
嵌套层级过多，导致判断逻辑变得复杂，可读性下降。
同时使用了
while和for循环，在逻辑结构上较为冗长。（虽然，我们前面实现的代码也是这样实现的哈哈哈哈，不过目前入门学习为主，不考虑优化问题。）
优点：
- 处理了多种因用户输入不规范，导致的报错，使程序更健壮。
- 利用整组
if...elif...elif...else...只会执行其中一个的特性实现程序； - 允许用户在输入错误后，能继续尝试输入。给用户试错的机会，直到输入合法才进行计算，开发了一个较为完备的程序。
3. 不用嵌套实现
点击展开阅读
嵌套会使逻辑变得复杂，如果不使用嵌套，应该如何实现？「尽可能避免嵌套，不是不能使用嵌套」
下面我直接提供不嵌套实现的版本，便于你阅读学习：
while True:
user_input = input('请输入两个数字（用空格分隔）：')
# 1. 检查是否只含空格和数字
if not user_input.replace(' ', '').isdigit():
print('输入不合法，需要输入纯数字！\n请重新输入:')
continue
# 2. 分割输入为两部分
parts = user_input.strip().split()
if len(parts) != 2:
print('输入不合法，需要输入两个数字！\n请重新输入:')
continue
# 3. 将分割后的字符串转换成整数（此时不会出现转换异常）
start_num = int(parts[0])
end_num = int(parts[1])
# 4. 验证起始数字和结束数字的关系
if start_num >= end_num:
print('输入不合法，开始数字需要小于结束数字！\n请重新输入:')
continue
# 5. 合法输入则计算并输出结果，然后跳出循环
# 使用等差数列公式 (首项 + 末项) × 项数 / 2
count = end_num - start_num + 1
total = (start_num + end_num) * count // 2
print(f"{start_num} 到 {end_num} 之间的总和 = {total}")
brea更新日志
475af-于0583b-于61ab5-于aa5ec-于b655b-于41e05-于28174-于57129-于bd51e-于3f9a7-于c4ea1-于9ab1e-于b5b9d-于b9ee7-于