跳至主要內容

12. for

Ran原创2025/6/13...大约 35 分钟

1. for 的语法

for 变量 in 可迭代对象：
	循环体代码

代码：

代码中 x 是临时变量。

for x in [1, 2, 3]:
    print(x)

print('循环结束后，x 的值为：', x)

#-------output-------
1
2
3
循环结束后，x 的值为： 3

例子：

student_list = ['李雷', '韩梅梅', '马冬梅']
for student in student_list:
    print(student)
    
#-------output-------
李雷
韩梅梅
马冬梅

2. while 循环实现 for 循环

上述代码用 while 循环如何实现？

student_list = ['李雷', '韩梅梅', '马冬梅']
i = 0

while i < len(student_list):
    print(student_list[i])
    i += 1

3. 小试牛刀

3.1 遍历列表并将每个元素平方后放回原列表

Answer:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

index = 0
for num in numbers:
    new_num = num ** 2
    numbers[index] = new_num
    index += 1

print(numbers)

#-------output-------
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

思路：问题拆解

step1: 明确提取方法：取下标

step2: 下标如何生成

step3: 提取

3.2 输出带序号的数据

Answer:

方法一：内置函数 .index()

student_list = ['李雷', '韩梅梅', '马冬梅']

for student in student_list:
    print(student_list.index(student), student)
    
#-------output-------
0 李雷
1 韩梅梅
2 马冬梅

方法二：创建储存下标的变量

student_list = ['李雷', '韩梅梅', '马冬梅']

index = 0
for st in student_list:
    print(index, st)
    index += 1

优化：

若需要输出

stid_0 李雷
stid_1 韩梅梅
stid_2 马冬梅

则代码可以改为：

student_list = ['李雷', '韩梅梅', '马冬梅']

index = 0
for st in student_list:
    print(f'stid_{index} {st}')
    index += 1

4. range()

当需要生成一系列连续数字时，例如遍历列表、控制循环次数等。Python 提供了一个简单又高效的工具—— range() 函数，专门用于生成 不可变（immutable）的数字序列，尤其配合 for 循环进行迭代操作。

4.1 基本用法

range() 函数最多可以接收三个参数：start 起始值，stop 终止值， step 步长，下面详细解释这些参数：

  • start ：数字序列的起始值，默认是 0 ；
  • stop ：数字序列停止的地方，但注意不包含这个值；
  • step ：每个数字之间的差值（步长），默认值是 1.

代码如下：

for i in range(5):
    print(i)
    
#-------output-------
0
1
2
3
4

指定开始结束：

for i in range(2, 6):
    print(i)
    
#-------output-------
2
3
4
5

指定间隔：

for i in range(1, 10, 2):
    print(i)

#-------output-------
1
3
5
7
9

4.2 例子：生成一个列表包含 0 到 100

方法一：

lst = []

for i in range(0, 101):
    lst.append(i)                # 注意不能用 lst = lst.append(i) ，因为 .append() 是直接修改原列表
print(lst)

方法二：

print(list(range(0, 101)))

因此上文输出元素可以用 range() 完成，此处用 len(student_list) ，若有两个相关联的列表，则可以用另一个列表的长度来提取该列表的元素。

student_list = ['李雷', '韩梅梅', '马冬梅']

for student in range(len(student_list)):
    print(student_list[student])
    
#-------output-------
李雷
韩梅梅
马冬梅

5. 小试牛刀2：打印星号三角形

Answer:

n = input('请输入高度：')

for i in range(1, int(n)+1):
    print(i*'*')
    
#-------output-------
请输入高度：3
*
**
***

思路：

先输出一次，再考虑循环

n = int(input('请输入三角形的高度'))

第一行 print(*)

第二行 print(**)

第三行 print(***)

转化为：

print(1 * '*')

print(2 * '*')

print(3 * '*')

转化为前面获得 1-3 的数字的问题。

6. enumerate()

任务：按照索引得到水果。

6.1 基本用法

引入新函数enumerate()

fruits = ["apple", "banana", "cherry"]

for index, fruit in enumerate(fruits):
    print(index, fruit)

#-------output-------
0 apple
1 banana
2 cherry

那么 enumerate(fruits) 的结果是什么？如何理解 enumerate 语句？

6.2 指定起始索引

默认情况下， enumerate 是从 0 开始计数，可以通过添加一个可选的 start 参数来指定起始索引。

fruits = ["apple", "banana", "cherry"]

for index, fruit in enumerate(fruits, start=1):
    print(index, fruit)
    
#-------output-------
1 apple
2 banana
3 cherry

6.3 使用场景

  1. 需要同时对索引和元素处理；
  2. 需要修改原列表或数组的某些特定位置（修改或替换某些元素时拿到索引比较必要，在循环内可以完成索引和元素的映射）；
  3. 减少硬编码，提升可读性。

7. 找到列表的最大值

Answer:

nums = [12, 43, 5, 2, 66, 74, 28, 91, 66]

max_num = nums[0]             # 先假设第一个元素是最大的
for n in nums:
    if n > max_num:
        max_num = n

print(f'Max Value is {max_num}')

#-------output-------
Max Value is 91

思路：从篮子里拿桃子比较，先拿出一个假设是最大的，然后再从篮子里拿桃子比较，大的留下。

因此，该代码思路一样，先假设第一个元素最大，穷举列表中的元素比大小，把比较出来的大的值覆盖掉上一个最大值。

8. 找到列表最大值的下标

nums = [12, 43, 5, 2, 66, 74, 28, 91, 66]

max_num = nums[0]
for index, n in enumerate(nums):
    if n > max_num:
        max_num = n
        max_index = index


print(f'The index of max value is {max_index}')

#-------output-------
The index of max value is 7

9. 找到列表的多个最大值以及对应的多个下标

9.1 两次循环结合 enumerate() 方法

9.2 两次循环结合下标赋值方法

思考：用下标方法如何实现？

优化：将 n += 1 这一句提出来到 if 外即可。

# 第二次循环，找到所有最大值的下标
n = 0
for num in nums:
    if num == max_value:
        max_indices.append(n)
    n += 1

9.3 两次循环结合 range() 方法

思考：如何用 range 实现？

9.4 一个循环结合 enumerate() 实现

思考：如何一个循环实现？

优化：

line 5 代码 max_indices = [0] 不需要在列表中填一个 0 了，修改为：

max_indices = []

9.5 一个循环结合 range() 实现

9.6 一个循环结合下标实现（纠错）

某同学代码：

修改：少了小于的情况

不加 else 如何修改？

将 n += 1 从 if 中提取出来。

10. 嵌套 for 循环

10.1 基本结构

一个嵌套的 for 循环通常的书写形式如下：

for 变量1 in 可迭代对象1：
	for 变量2 in 可迭代对象2：
    	#执行代码块

例子：

for i in range(2):
    print(f'外层循环执行了第 {i+1} 次')
    for j in range(3):
        print(f'\t内层循环执行了第 {j+1}次')
        
#-------output-------
外层循环执行了第 1 次
	内层循环执行了第 1次
	内层循环执行了第 2次
	内层循环执行了第 3次
外层循环执行了第 2 次
	内层循环执行了第 1次
	内层循环执行了第 2次
	内层循环执行了第 3次

外层代码每执行一次，内层代码都要全部执行一遍。

10.2 遍历求和

将下列矩阵中所有的元素相加。

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

原始思路：（不好）

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

sum_rows = []
for rows in matrix:
    sum_rows.append(sum(rows))
sum_all = sum(sum_rows)

print(sum_all)

思考：如何从0加到100？

首先需要设置一个 total 的变量为 0 ，然后提出一个数字，在 total 上加一个数字。

total = 0
for i in range(101):
    total = total + i
print(total)

同样的逻辑：

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

total = 0
for rows in matrix:            # 提出每个列表
    for row in rows:           # 提出每个列表里的元素
        total += row           # 往 total 里加
print(total)

#-------output-------
45

10.3 求每一单独列的和

# 手动方法
col1 = 0
col2 = 0
col3 = 0

for row in matrix:
    col1 += row[0]
    col2 += row[1]
    col3 += row[2]
print([col1, col2, col3])

#-------output-------
[12, 15, 18]

用循环方法：

思路：

  • 仿照手动解决，第1 列的和是自增下标为 0 的 row ，第2 列的和是自增下标为 1 的 row ，以此类推，可以初始化一个列表，专门放第1、2、3 列的和，而这个列表的长度，就是 matrix 含有的列表元素的个数，因此，初始化一个列表，长度为 matrix 的列数（即每个列表元素的长度），每个元素的初始值为 0 。

  • 原本的 col1 就是 column_sums[0] ， col2 就是 column_sums[1] ， col3 就是 column_sums[2] ，那么上述代码中的 line 7-9

    col1 += row[0]
col2 += row[1]
col3 += row[2]

    就变为

    column_sums[0] += rows[0]
column_sums[1] += rows[1]
column_sums[2] += rows[2]

    发现两者的下标一致，即可遍历 matrix 包含的列表元素的个数（matrix 的长度）。

最终代码如下：

方法二：全部用下标索引

10.4 输出九九乘法表

思路：

方法一：拆解

step 1：首先需要得到 1到9 的数字

step 2：进行乘法运算

发现每一列等式，乘号左边的数字都是不变的，因此将乘号左侧的数字设为变量 i ，为外层循环；乘号右侧的为变量 j ，为内层循环（原理：每运行一次外层循环，内层循环都全部循环一次）。

注意：乘号左侧和右侧虽然都是 1到9，但是最好设为两个变量。

那么可以得到如下代码：

观察发现，第三行代码每运行一次都会换行，不符合我们的格式，那么将末尾换行修改为空格\t ，而外层循环每次结束后再进行换行，可得到如下代码：

此时观察代码发现，乘号左右的数字与图片上不同，乘号左侧的数字应不变，乘号右侧的数字变化，因此输出时，可以将 i 和j 调换位置。

需要的最终结果是左下角的三角形，则第一次外层循环时，不输出2 x 1 = 2 3 x 1 = 3 4 x 1 = 4 5 x 1 = 5 6 x 1 = 6 7 x 1 = 7 8 x 1 = 8 9 x 1 = 9 ，第二次外层循环时，不输出3 x 2 = 6 4 x 2 = 8 5 x 2 = 10 6 x 2 = 12 7 x 2 = 14 8 x 2 = 16 9 x 2 = 18 以此类推，控制j 的范围即可实现，即外层第一次循环时，j 只取到1，外层第二次循环时，j 只取到2，代码如下：

方法二：

观察发现我们需要的左下角数据，乘号左面的数都是 ≤ 乘号右面的数字，即 j<=i ，那么可以增加一个条件来决定内层循环何时停止。

代码如下：

for i in range(1, 10):
    for j in range(1, 10):
        if j <= i:
            print(f'{j} x {i} = {i*j}', end='\t')
    print()

若需要实现保留右上角的式子，如何完成：

小技巧：

在探究过程中，我们从最开始的整列实现，到后面转化为一行一行实现，辅助探究和理解的好工具是 time 库。

代码如下：

11. continue——跳过这一步，直接奔向下一轮

continue 用于跳过当前循环的剩余部分，并直接进入下一次循环的判断。也就是说，当循环体内遇到continue 语句时，会跳过该次循环中 continue 之后的代码，并直接进入下一次循环。

11.1 现实生活中的例子

检查一篮苹果，挑出好的苹果防在袋子里。如果发现苹果坏了，不会放到袋子里，而是直接跳过它，检查下一个苹果。这种情况就可以使用 continue 表示。

for 例子：

for i in range(1, 6):
    if i == 3:
        continue
    print(i)
    
#-------output-------  
1
2
4
5

while 例子：

num = 0
while num < 5:
    num += 1          # 为什么写在if之前，因为如果等于3， continue了之后会跳过
    if num == 3:
        continue
    print(num)
    
#-------output-------  
1
2
4
5

11.2 continue只会影响当前循环

  1. continue 只会影响当前循环，不会影响外部或其他循环。
  2. 在嵌套循环中，如果你想控制外层循环的运行，需要在外层循环的层级写相应的判断或语句，而不是简单的在内层调用 continue 。

12. break ——提前结束循环的“紧急刹车”

在编程中，可能遇到这样的场景：一但满足了某个条件，就不需要浪费时间在接下来的循环操作上。Python 提供的 break 语句，正是用来在循环中“紧急刹车”的指令。一但执行到 break ，循环会被立刻打断，无论循环原本还需要跑多久。break 只能终止当前所在的那一层循环，循环结束以后，程序会继续往下执行。

for i in range(10):
    print(i)
    if i > 5:
        break
        
#-------output------- 
0
1
2
3
4
5
6
for i in range(10):
    if i == 3:
        break
    print(i)
print('for 循环结束之后的代码，当你看见这句话时，表明这个print正常执行~')

#-------output------- 
0
1
2
for 循环结束之后的代码，当你看见这句话时，表明这个print正常执行~

12.1 break 只会影响当前循环，不影响外层循环。

12.2 如何实现内层循环结束，外层循环也随之结束

修改如下代码，使内层循环结束，外层循环也随之结束。

for i in range(5):
    for j in range(5):
        print(f"i={i}, j={j}")
        if (i + j) == 3:
            print("触发条件，准备终止所有循环！")
            break  # 先结束内层循环
print("外层循环结束，这里才是程序真正的结束点。")

Answer:

优化：

13. while 与 for 如何选择

13.1 while 循环的特点

while 是基于条件判断（是否满足某个条件）的循环结构。只要满足给定的条件，循环就会一直执行，适合循环次数不确定的情况。

例子：抄写《红豆》

安排任务，我出门一下，你在家里抄写《红豆》这首诗。当我出门以后，你就开始不停地抄写，直到我回家。在这个过程中，不知道具体要写多少遍，只能根据“我是否回家“来判断是否停止抄写，只知道循环结束的条件，不知道循环的次数（抄几遍），所以此时用 while 循环比较合适。

13.2 for 循环的特点

for 循环能在循环开始前就确定循环几次，是基于序列或计数的循环结构。for 循环的语法为for 变量 in 可迭代对象： 这里的可迭代对象是有一定范围的。并且前文中学到的range()、 enumerate 等都是给定了范围，确认了循环的次数。因此，当你明确知道需要执行多少次循环，或者需要遍历一个固定集合时，for 循环会让代码显得更加直观和简洁

例子：跑步

去操场跑步减肥，计划跑 10 圈。此时非常清楚循环的次数是 10 。当 10 圈跑完以后，自然停止，循环也相应的结束了，此时用 for 循环就非常合适。

若是计划跑步 30 分钟，那么 30 分钟内需要跑多少圈不得而知，此时则用 while 循环更合适。

13.3 如何选择 while 和 for？

主要依据以下两个方面：

  1. 循环次数的确定性
    1. 已知次数：事先清除循环需要执行的次数，或利用一个已知序列来遍历数据，可以考虑使用 for 循环。
    2. 未知次数：如果循环的终止条件是动态的，依赖于程序运行时的状态而非一个固定的次数，那么就可以考虑 while 循环。例如：不断获取用户输入直到合法；不断读取文件数据直到文件末尾。
  2. 代码的简洁性和灵活性
    1. for 循环：将初始化、条件判断和更新迭代变量整合到一行代码中，代码结构清晰、紧凑。
    2. while 循环：提供了更大的灵活性，但需要额外关注循环条件和退出机制，防止出现无限循环的问题。

小提示：

尽管所有的 while 循环都可以通过 for 循环实现，反之亦然。但在实际编程中，选择最直观、最能反应问题本质的循环结构，会让代码更容易理解和维护。

14. 程序循环的逐步实现

14.1 for 循环实现0到100的总和

total = 0

for i in range(101):
    total += i
print(total)

14.2 增加用户输入功能，用户指定开始整数和结束整数

获取一次用户输入：

user_input = input('请输入两个数字，用空格分隔：').split()
total = 0


for i in range(int(user_input[0]), int(user_input[1]) + 1):
    total += i
print(total)

#-------output-------
请输入两个数字，用空格分隔：0 100
5050

14.3 防止用户先输入结束整数

14.4 防止用户输入的非纯数字

注意：也可将 line3 改为 if not ，将核心内容放在else 里。

14.5 实现输入不合法重新输入

输入错误后，用户往往需要再试一次，而不是直接停止运行，这就用到 while 循环来反复检查。

思路：

在上述代码外侧加一个while 循环判断输入是否合法

发现问题：如果用户没输入完不小心按了回车，输入中不包含空格，那么程序会报错，可以再加一句 if 判断。

不用嵌套如何实现？

方法一：

上述循环结束是根据 is_valid 的状态判断的。

方法二：

注意：continue 的使用之存在于 while 或 for 循环中，虽然看起来 continue 是处于 if 判断中，但实际是处于 while 循环中，因此 if 只是用来确定 continue 执行的条件，continue 执行后，所在循环中，该语句后的代码均不执行。

该方法用 break 来结束循环，因此前面是 while True 也并不会一直循环下去。

15. 练习

注意：

判断输入是否合法的时候，可以建立两个循环，性别的时候一个循环，年龄的时候一个循环。

优化：

  1. 多次判断是否继续，可以全部提出来 （line 78-80）。
  1. int(age) 多次出现，在判断完它是否合法以后可以存成一个变量，在 line 62 加入代码 age = int(age) 。

其他方法：

更新日志

2025/7/1 08:02
查看所有更新日志
  • 24a8f-Refactor code structure for improved readability and maintainability于
  • 72d73-Enhance user input validation: Add while loop to ensure valid numeric input and handle edge cases in input format于
  • 155ec-update notes in the chapter 'for'于
  • 05bf3-Refactor code structure for improved readability and maintainability于
  • b78a1-Refactor section headings for clarity: Update headings for summation examples in matrix operations于
  • 5bfd5-Enhance column sum calculation: Refactor code to use a list for dynamic column sums in matrix operations于
  • 48c16-Refactor content structure: Update explanations and examples for clarity in 'for' loop section于
  • d15a6-Refactor code structure for improved readability and maintainability于
  • e18ce-Refactor section headings: Update formatting for clarity in maximum value index examples于
  • 02d63-Implement code changes to enhance functionality and improve performance于
  • bf9ca-Add comprehensive documentation for 'for' loop in Python于
默认页脚
Copyright © 2025 Ran