Python 中的 for 循环：从基础到高级应用的全面解析

文章大纲

引言

Python 中的 for 循环以其简洁和灵活性著称，是编程中最常用的控制结构之一。与 C 或 Java 等语言中基于计数器的传统循环不同，Python 的 for 循环专注于迭代可迭代对象，如列表、元组、字符串等，极大地简化了数据遍历的代码逻辑。无论是处理简单序列还是复杂数据结构，for 循环都能展现出强大的能力，成为 Python 开发者日常工作中不可或缺的工具。本文旨在为读者提供一个全面的指南，从 for 循环的基础语法入手，逐步深入到高级应用场景，如推导式、生成器以及并行迭代等。通过丰富的示例和实践案例，本文将帮助读者掌握 for 循环的各种用法，并在实际编程中灵活运用，解决从简单到复杂的数据处理问题。

for 循环的基本语法与工作原理

在 Python 中，for 循环是一种专门用于遍历可迭代对象（如列表、元组、字符串、字典等）的控制结构。其基本语法简洁明了，能够以直观的方式逐一访问序列中的元素。for 循环的核心结构如下：

for item in sequence:
    # 循环体：对每个 item 执行的操作
    print(item)

这里，sequence 是一个可迭代对象，item 是循环过程中每次迭代获取的元素，循环体会对每个元素依次执行指定的操作。例如，遍历一个列表并打印每个元素：

fruits = ["苹果", "香蕉", "橙子"]
for fruit in fruits:
    print(f"当前水果是：{
              fruit}")

输出结果为：

当前水果是：苹果
当前水果是：香蕉
当前水果是：橙子

for 循环的工作原理是基于 Python 的迭代协议：它会通过调用可迭代对象的 __iter__() 方法获取一个迭代器，然后反复调用迭代器的 __next__() 方法获取下一个元素，直到引发 StopIteration 异常时循环结束。这一机制使得 for 循环可以处理多种类型的可迭代对象，而不仅仅局限于列表或元组。

此外，for 循环还支持一个可选的 else 子句，这一特性在 Python 中较为独特。else 子句会在循环正常结束（即未被 break 语句中断）时执行。例如：

numbers = [1, 2, 3]
for num in numbers:
    if num == 0:
        print("找到 0，循环终止")
        break
else:
    print("循环正常结束，未找到 0")

在这个例子中，由于列表中没有 0，循环正常结束，else 子句会被执行，输出“循环正常结束，未找到 0”。如果列表中包含 0，break 语句会中断循环，else 子句则不会执行。这种结构在搜索或条件判断场景中非常有用。

通过以上内容可以看出，for 循环在 Python 中的设计不仅简单易用，还提供了灵活的控制选项，为开发者处理数据提供了强大的支持。

控制流程：break 与 continue 语句

在 Python 的 for 循环中，break 和 continue 语句是两种重要的控制流程工具，用于改变循环的执行行为。它们可以帮助开发者更灵活地处理迭代过程中的特定情况。

break 语句用于立即终止整个循环，无论是否还有未遍历的元素。当 break 被执行时，循环会直接结束，且不会执行 for 循环中可选的 else 子句。这在需要在特定条件下提前退出循环时非常有用。例如，假设我们在一个数字列表中查找第一个大于 5 的数字：

numbers = [1, 3, 6, 8, 10]
for num in numbers:
    if num > 5:
        print(f"找到第一个大于 5 的数字：{
              num}")
        break
else:
    print("未找到大于 5 的数字")

输出结果为：

找到第一个大于 5 的数字：6

在这个例子中，一旦找到大于 5 的数字，break 语句会立即终止循环，后续元素不会被检查，else 子句也不会执行。

与之相对，continue 语句用于跳过当前迭代，直接进入下一次迭代。它不会终止整个循环，而是忽略当前循环体中 continue 之后的代码。例如，跳过列表中的偶数，只打印奇数：

numbers = [1, 2, 3, 4, 5]
for num in numbers:
    if num % 2 == 0:
        continue
    print(f"奇数：{
              num}")

输出结果为：

奇数：1
奇数：3
奇数：5

在这个例子中，当遇到偶数时，continue 语句会跳过 print 语句，直接进入下一个数字的迭代。continue 在需要过滤某些元素或避免执行特定操作时非常实用。

通过 break 和 continue，开发者可以精细地控制 for 循环的执行流程，适应不同的逻辑需求。合理使用这两种语句，能够显著提高代码的效率和可读性，尤其是在处理复杂数据或需要条件判断的场景中。

range 函数：生成索引与序列

在 Python 中，range 函数是一个强大的内置工具，专门用于生成一系列整数，常与 for 循环结合使用，以便进行基于索引的迭代或生成特定步长的序列。它的设计不仅简单易用，而且具有内存高效的特性，非常适合处理大规模数据或需要精确控制循环次数的场景。

range 函数的基本语法有三种形式，分别对应不同的参数组合：

单参数形式：range(stop)，从 0 开始，生成一个从 0 到 stop-1 的整数序列。例如，range(5) 会生成 [0, 1, 2, 3, 4]。
双参数形式：range(start, stop)，从 start 开始，生成一个从 start 到 stop-1 的整数序列。例如，range(2, 6) 会生成 [2, 3, 4, 5]。
三参数形式：range(start, stop, step)，从 start 开始，以 step 为步长，生成一个从 start 到 stop-1 的整数序列。step 可以是正数（递增）或负数（递减）。例如，range(1, 10, 2) 会生成 [1, 3, 5, 7, 9]，而 range(10, 0, -2) 会生成 [10, 8, 6, 4, 2]。

一个重要的特性是，range 函数返回的并不是一个完整的列表，而是一个 range 对象。这是一种惰性求值（lazy evaluation）的机制，只有在需要时才会生成具体的数字，因此内存占用非常小。例如：

for i in range(1000000):
    if i == 5:
        print("找到 5")
        break

在这个例子中，即使 range(1000000) 表示一个包含一百万个数字的范围，Python 不会一次性将所有数字加载到内存中，而是按需生成，大大提高了效率。

range 函数在 for 循环中的一个常见用途是遍历列表的索引。通过结合 len 函数，可以轻松访问列表的每个元素及其对应的位置。例如：

fruits = ["苹果", "香蕉", "橙子"]
for i in range(len(fruits)):
    print(f"索引 {
              i} 对应的水果是：{
              fruits[i]}")

输出结果为：

索引 0 对应的水果是：苹果
索引 1 对应的水果是：香蕉
索引 2 对应的水果是：橙子

此外，range 的步长参数 step 也非常实用。例如，如果需要每隔两个元素处理一次数据，可以设置步长为 2：

numbers = [1, 2, 3, 4, 5, 6]
for i in range(0, len(numbers), 2):
    print(f"当前元素：{
              numbers[i]}")

输出结果为：

当前元素：1
当前元素：3
当前元素：5

通过这种方式，可以灵活地控制循环的步长，适应不同的数据处理需求。range 函数的灵活性和高效性使其成为 for 循环中的重要工具，尤其在需要基于索引操作或生成特定序列的场景中。通过合理利用其参数，开发者可以编写更简洁、更高效的代码，轻松应对各种编程任务。

元组解包在 for 循环中的应用

在 Python 的 for 循环中，元组解包（tuple unpacking）是一种非常优雅且实用的技术，可以简化代码并提升可读性。特别是当处理嵌套结构或多元素序列时，元组解包能够让代码更加直观，避免繁琐的索引访问。

元组解包的基本思想是将一个可迭代对象中的元素直接赋给多个变量。在 for 循环中，这通常用于处理列表中的元组或嵌套序列。例如，假设我们有一个包含姓名和年龄的列表，每个元素是一个二元元组：

people = [("张三", 25), ("李四", 30), ("王五", 28)]
for name, age in people:
    print(f"姓名：{
              name}，年龄：{
              age}")

输出结果为：

姓名：张三，年龄：25
姓名：李四，年龄：30
姓名：王五，年龄：28

在这个例子中，for name, age in people 直接将每个元组的两个元素分别赋值给 name 和 age，无需通过索引（如 person[0] 和 person[1]）访问。这种方式不仅代码更简洁，而且逻辑更清晰，避免了手动解构元组的麻烦。

相比之下，如果不使用元组解包，代码会显得冗长且容易出错：

people = [("张三", 25), ("李四", 30), ("王五", 28)]
for person in people:
    print(f"姓名：{
              person[0]}，年龄：{
              person[1]}")

虽然结果相同，但使用索引访问的方式在处理更复杂的嵌套结构时会变得难以维护。而元组解包则可以轻松应对更多元素的元组。例如，处理包含姓名、年龄和职业的三元元组：

people = [("张三", 25, "工程师"), ("李四", 30, "教师"), ("王五", 28, "设计师")]
for name, age, job in people:
    print(f"姓名：{
              name}，年龄：{
              age}，职业：{
              job}")

输出结果为：

姓名：张三，年龄：25，职业：工程师
姓名：李四，年龄：30，职业：教师
姓名：王五，年龄：28，职业：设计师

元组解包的另一个优势是它可以与嵌套循环或其他复杂数据结构结合使用，进一步简化代码逻辑。例如，当处理嵌套列表中的多元素数据时，元组解包依然能保持代码的清晰性。

需要注意的是，元组解包要求可迭代对象中的元素数量与解包变量的数量一致，否则会引发 ValueError。因此，在使用时应确保数据结构的格式统一。通过元组解包，开发者可以在 for 循环中以更自然的方式处理多元素数据，减少代码冗余，同时提高程序的可读性和可维护性。这种技术在处理键值对、坐标点或其他多维数据时尤为实用，是 Python 编程中的一大亮点。

enumerate 函数：同时获取索引与元素

在 Python 中，enumerate 函数是一个非常实用且高效的内置工具，专门用于在 for 循环中同时获取可迭代对象的索引和元素。它特别适合那些需要在迭代过程中跟踪元素位置的场景，避免了手动维护计数器或使用 range(len()) 的繁琐方式。

enumerate 函数的基本用法是将其应用到一个可迭代对象上，它会返回一个枚举对象（enumerate object），每次迭代时生成一个包含索引和对应元素的元组。其基本语法如下：

for index, value in enumerate(iterable, start=0):
    # 循环体：处理 index 和 value
    print(f"索引：{
              index}，值：{
              value}")

其中，iterable 是任何可迭代对象（如列表、元组、字符串等），start 是一个可选参数，用于指定索引的起始值，默认为 0。例如，遍历一个列表并打印每个元素的索引和值：

fruits = ["苹果", "香蕉", "橙子"]
for index, fruit in enumerate(fruits):
    print(f"索引：{
              index}，水果：{
              fruit}")

输出结果为：

索引：0，水果：苹果
索引：1，水果：香蕉
索引：2，水果：橙子

如果需要从自定义的索引值开始，可以通过设置 start 参数。例如，从 1 开始计数：

fruits = ["苹果", "香蕉", "橙子"]
for index, fruit in enumerate(fruits, start=1):
    print(f"编号：{
              index}，水果：{
              fruit}")

输出结果为：

编号：1，水果：苹果
编号：2，水果：香蕉
编号：3，水果：橙子

与使用 range(len()) 的传统方法相比，enumerate 函数的优势在于代码的简洁性和可读性。传统的索引遍历方式如下：

fruits = ["苹果", "香蕉", "橙子"]
for i in range(len(fruits)):
    print(f"索引：{
              i}，水果：{
              fruits[i]}")

虽然结果相同，但这种方法需要通过索引访问元素，显得不够直观。而 enumerate 直接返回索引和元素对，既减少了代码量，又避免了手动索引可能引入的错误。此外，enumerate 函数的性能也非常高效，因为它是一个惰性求值的迭代器，不会一次性生成所有数据，节省了内存资源。

enumerate 函数在实际编程中有着广泛的应用，例如在需要记录元素位置或对列表进行编号的场景中。通过结合元组解包，开发者可以轻松处理索引和元素，同时保持代码的清晰性。无论是处理简单列表还是复杂数据结构，enumerate 都能提供一种优雅的解决方案，是 for 循环中不可或缺的辅助工具。

zip 函数：并行迭代多个可迭代对象

在 Python 中，zip 函数是一个非常有用的内置工具，用于在 for 循环中并行迭代多个可迭代对象。它可以将多个序列（如列表、元组等）的对应元素组合成元组，从而方便地同时处理多个数据源。这种并行迭代的能力在处理相关数据集或需要同步遍历多个序列的场景中尤为实用。

zip 函数的基本用法是将多个可迭代对象作为参数传递给它，返回一个迭代器，每次迭代时生成一个包含各可迭代对象对应元素的元组。其基本语法如下：

for item1, item2, ... in zip(iterable1, iterable2, ...):
    # 循环体：处理 item1, item2, ...
    print(item1, item2, ...)

例如，假设我们有两个列表，分别存储姓名和对应的年龄，可以使用 zip 函数同时遍历这两个列表：

names = ["张三", "李四", "王五"]
ages = [25, 30, 28]
for name, age in zip(names, ages):
    print(f"姓名：{
              name}，年龄：{
              age}")

输出结果为：

姓名：张三，年龄：25
姓名：李四，年龄：30
姓名：王五，年龄：28

在这个例子中，zip(names, ages) 将两个列表的对应元素配对成元组，for 循环通过元组解包直接获取每个姓名和年龄，代码简洁且逻辑清晰。

需要注意的是，zip 函数会以最短的可迭代对象长度为准进行迭代。如果传入的可迭代对象长度不一致，zip 会在最短序列结束时停止，忽略较长序列中剩余的元素。例如：

names = ["张三", "李四", "王五", "赵六"]
ages = [25, 30, 28]
for name, age in zip(names, ages):
    print(f"姓名：{
              name}，年龄：{
              age}")

输出结果为：

姓名：张三，年龄：25
姓名：李四，年龄：30
姓名：王五，年龄：28

在这个例子中，names 列表有 4 个元素，而 ages 列表只有 3 个元素，zip 函数会在 ages 列表结束时停止，因此 赵六 不会被处理。如果需要处理所有元素，可以考虑使用 itertools.zip_longest 函数（需导入 itertools 模块），它会以最长序列为准，并为较短序列缺失的位置填充默认值（如 None）。

zip 函数不仅限于两个可迭代对象，也可以处理三个或更多。例如，同时遍历姓名、年龄和职业：

names = ["张三", "李四", "王五"]
ages = [25, 30, 28]
jobs = ["工程师", "教师", "设计师"]
for name, age, job in zip(names, ages, jobs):
    print(f"姓名：{
              name}，年龄：{
              age}，职业：{
              job}")

输出结果为：

姓名：张三，年龄：25，职业：工程师
姓名：李四，年龄：30，职业：教师
姓名：王五，年龄：28，职业：设计师

zip 函数在实际编程中的应用场景非常广泛，例如处理表格数据、并行处理多个相关列表，或者在机器学习中同时迭代特征和标签数据等。通过 zip，开发者可以避免手动同步多个序列的复杂操作，显著提高代码的可读性和效率。总之，zip 是 for 循环中并行迭代的理想工具，适用于任何需要同时处理多个序列的场景。

列表、集合与字典推导式：简化循环操作

在 Python 中，推导式（comprehensions）是一种简洁而强大的语法结构，用于替代常见的 for 循环模式，快速创建列表、集合或字典等数据结构。列表推导式、集合推导式和字典推导式不仅能减少代码量，还能提高代码的可读性和表达力，使逻辑更加清晰。它们是 Python 编程中处理数据的高效工具，尤其在数据过滤、转换和构建键值对等场景中表现出色。

列表推导式（List Comprehension）是最常见的一种形式，用于基于现有可迭代对象创建新列表。其基本语法为：

new_list = [expression for item in iterable if condition]

其中，expression 是对每个元素执行的操作，item 是循环变量，iterable 是可迭代对象，if condition 是可选的条件过滤。例如，创建一个包含 1 到 10 的偶数列表：

evens = [x for x in range(1, 11) if x % 2 == 0]
print(evens)

输出结果为：

[2, 4, 6, 8, 10]

相比传统的 for 循环写法，列表推导式更加简洁。传统方式需要显式地定义一个空列表并追加元素：

evens = []
for x in range(1, 11):
    if x % 2 == 0:
        evens.append(x)
print(evens)

列表推导式还可以包含更复杂的表达式。例如，将一个列表中的所有数字平方后生成新列表：

numbers = [1, 2, 3, 4]
squares = [x**2 for x in numbers]
print(squares)

输出结果为：

[1, 4, 9, 16]

集合推导式（Set Comprehension）与列表推导式类似，但用于创建集合，集合的特点是元素无序且不重复。其语法结构几乎相同，只是将方括号 [] 替换为大括号 {}：

new_set = {
            expression for item in iterable if condition}

例如，从一个列表中提取唯一的大于 5 的数字：

numbers = [1, 6, 2, 6, 8, 3, 8, 9]
unique_above_5 = {
            x for x in numbers if x > 5}
print(unique_above_5)

输出结果可能是：

{6, 8, 9}

由于集合的特性，重复元素（如 6 和 8）会被自动去除，适合需要去重操作的场景。

字典推导式（Dictionary Comprehension）则用于创建字典，语法结构为：

new_dict = {
            key_expression: value_expression for item in iterable if condition}

例如，将一个列表转换为字典，其中键是元素，值是元素的平方：

numbers = [1, 2, 3, 4]
squared_dict = {
            x: x**2 for x in numbers}
print(squared_dict)

输出结果为：

{1: 1, 2: 4, 3: 9, 4: 16}

字典推导式也可以结合条件筛选。例如，只对偶数进行处理：

numbers = [1, 2, 3, 4, 5, 6]
even_squared_dict = {
            x: x**2 for x in numbers if x % 2 == 0}
print(even_squared_dict)

输出结果为：

{2: 4, 4: 16, 6: 36}

推导式还可以嵌套使用，处理更复杂的数据结构。例如，使用嵌套列表推导式展平一个二维列表：

nested_list = [[1, 2, 3], [4, 5, 6]]
flattened = [num for sublist in nested_list for num in sublist]
print(flattened)

输出结果为：

[1, 2, 3, 4, 5, 6]

需要注意的是，虽然推导式非常强大，但过度复杂的推导式可能降低代码的可读性。在涉及多重嵌套或复杂逻辑时，传统的 for 循环可能更容易理解和维护。此外，推导式会一次性生成整个数据结构，如果处理的数据量非常大，可能会占用大量内存。在这种情况下，可以考虑使用生成器表达式（将在下一节讨论）来替代。

总之，列表、集合和字典推导式是 Python 中简化循环操作的重要工具，适用于快速构建数据结构、过滤数据和转换数据等多种场景。通过合理使用推导式，开发者可以编写更加简洁和表达力强的代码，同时保持逻辑的清晰性。这些特性使得推导式成为现代 Python 编程中不可或缺的一部分，尤其在数据处理和分析领域有着广泛的应用。

生成器表达式：内存高效的迭代工具

在 Python 中，生成器表达式（Generator Expression）是一种内存高效的迭代工具，与列表推导式类似，但它不会一次性创建整个数据结构，而是按需生成值。这种惰性求值（lazy evaluation）的特性使得生成器表达式非常适合处理大数据集或需要在迭代过程中节省内存的场景。它在 for 循环中尤其有用，可以替代列表推导式，减少内存占用。

生成器表达式的语法与列表推导式非常接近，唯一的区别在于使用小括号 () 而非方括号 []。其基本结构如下：

generator = (expression for item in iterable if condition)

例如，假设我们需要遍历一个包含 1 到 10 的偶数序列，但不希望一次性将所有值存储在内存中，可以使用生成器表达式：

evens = (x for x in range(1, 11) if x % 2 == 0)
for num in evens:
    print(num)

输出结果为：

2
4
6
8
10

在这个例子中，evens 是一个生成器对象，而不是一个完整的列表。生成器对象不会一次性生成所有值，而是每次迭代时才计算并返回下一个值。这意味着即使范围很大（例如 range(1000000)），生成器表达式也不会占用大量内存，因为它只在需要时生成数据。

生成器表达式与列表推导式的另一个区别在于，生成器对象是一次性的。一旦迭代完成，生成器对象会被耗尽，无法再次使用。例如：

evens = (x for x in range(1, 11) if x % 2 == 0)
print(list(evens))  # 转换为列表并打印
print(list(evens))  # 再次尝试转换，发现生成器已耗尽

输出结果为：

[2, 4, 6, 8, 10]
[]

如果需要多次使用相同的数据，可以将生成器表达式转换为列表（使用 list()），或者重新定义生成器表达式。需要注意的是，将生成器转换为列表会失去其内存高效的优势，因为所有值都会被加载到内存中。

生成器表达式在 for 循环中的一个常见用途是处理大规模数据。例如，读取大文件时，可以逐行处理而无需一次性加载整个文件到内存中：

# 假设有一个大文件
with open('large_file.txt', 'r') as file:
    lines = (line.strip() for line in file if line.startswith('Error'))
    for error_line in lines:
        print(error_line)

在这个例子中，生成器表达式 (line.strip() for line in file if line.startswith('Error')) 只会按需读取和处理文件中的行，极大地减少了内存使用，特别适合处理无法一次性加载到内存的大文件。

此外，生成器表达式还可以与其他迭代工具结合使用，例如与 sum() 或 max() 等函数一起处理数据：

numbers = range(1, 1000001)
total = sum(x for x in numbers if x % 2 == 0)
print(f"1到1000000的偶数之和：{
              total}")

在这个例子中，生成器表达式 (x for x in numbers if x % 2 == 0) 避免了创建一个包含五十万个偶数的列表，而是直接在计算总和的过程中生成值，显著降低了内存占用。

需要注意的是，虽然生成器表达式在内存使用上非常高效，但它们不支持索引或切片操作，因为数据并未存储在内存中。如果需要这些功能，必须先将其转换为列表或元组。总的来说，生成器表达式是 for 循环中处理大数据或追求内存效率的理想选择。通过合理使用生成器表达式，开发者可以在性能和资源使用之间找到平衡，尤其是在数据分析、流式处理或处理大型数据集时，生成器表达式展现了其独特的优势。

实践案例与问题解答

在学习了 Python 中 for 循环的基础语法和高级工具后，通过实际案例将理论知识应用于问题解决是巩固理解的关键。本节通过三个具体的实践问题，展示 for 循环及相关工具（如 enumerate、zip、推导式等）的综合应用，并提供详细的代码和解析，帮助读者掌握从简单到复杂的实际编程技巧。

案例 1：移除列表中的负数
假设我们有一个包含正数和负数的列表，需要创建一个新列表，只保留其中的非负数（即大于或等于 0 的数字）。这是一项常见的数据过滤任务，可以使用列表推导式或传统 for 循环实现。以下是两种解决方案：

# 方案 1：使用列表推导式
numbers = [-3, 5, -1, 0, 8, -7, 2]
non_negative = [num for num in numbers if num >= 0]
print(f"非负数列表：{
              non_negative}")

# 方案 2：使用传统 for 循环
non_negative_loop = []
for num in numbers:
    if num >= 0:
        non_negative_loop.append(num)
print(f"非负数列表（循环方式）：{
              non_negative_loop}")

输出结果为：

非负数列表：[5, 0, 8, 2]
非负数列表（循环方式）：[5, 0, 8, 2]

解析：列表推导式方案更加简洁，直接通过条件 if num >= 0 过滤数据，生成新列表。而传统 for 循环方案虽然代码量稍多，但逻辑更显式，适合初学者理解。两种方法都能有效解决问题，选择哪种取决于代码风格和可读性需求。如果数据量非常大，可以考虑使用生成器表达式替代列表推导式，以节省内存。

案例 2：统计嵌套列表中的负数个数
假设有一个嵌套列表（二维列表），我们需要统计其中所有负数的个数。这涉及到嵌套 for 循环的使用。以下是实现代码：

nested_numbers = [[1, -2, 3], [-4, 5, -6], [7, -8, 9]]
negative_count = 0
for sublist in nested_numbers:
    for num in sublist:
        if num < 0:
            negative_count += 1
print(f"嵌套列表中的负数个数：{
              negative_count}")

输出结果为：

嵌套列表中的负数个数：4

解析：通过外层循环遍历每个子列表，内层循环遍历子列表中的每个元素，结合条件判断 if num < 0 统计负数个数。嵌套循环是处理多维数据结构的常见方式，逻辑清晰且易于扩展。如果需要更简洁的写法，可以使用列表推导式展平嵌套列表后统计：negative_count = sum(1 for sublist in nested_numbers for num in sublist if num < 0)，但这种方式可能会在数据量大时影响可读性。

案例 3：根据值范围输出分类结果
假设有一个数字列表，需要根据值范围将其分类为“低”（小于 0）、“中”（0 到 10）和“高”（大于 10），并打印每个数字的分类结果。这需要结合 for 循环和条件判断。以下是实现代码，并结合 enumerate 函数添加编号：

numbers = [-5, 3, 15, 0, 8, 20, -10]
for index, num in enumerate(numbers, start=1):
    if num < 0:
        category = "低"
    elif 0 <= num <= 10:
        category = "中"
    else:
        category = "高"
    print(f"数字 {
              index}: {
              num}，分类：{
              category}")

输出结果为：

数字 1: -5，分类：低
数字 2: 3，分类：中
数字 3: 15，分类：高
数字 4: 0，分类：中
数字 5: 8，分类：中
数字 6: 20，分类：高
数字 7: -10，分类：低

解析：使用 enumerate 函数为每个数字添加编号（从 1 开始），通过条件判断对数字进行分类。代码逻辑直观，适合处理需要分类或分组的任务。如果需要将分类结果存储为字典或列表，可以在循环中构建新的数据结构。例如，使用字典推导式：categories = {num: "低" if num < 0 else "中" if num <= 10 else "高" for num in numbers}，进一步简化代码。

通过以上三个案例，读者可以看到 for 循环在数据过滤、统计和分类等任务中的灵活应用。结合列表推导式、enumerate 等工具，可以根据具体需求选择最适合的解决方案。在实际编程中，建议从问题需求出发，选择既高效又易于维护的方法，同时注意代码的可读性和性能优化。例如，处理大数据时优先考虑生成器表达式，避免内存过度占用。这些实践经验将帮助开发者在面对更复杂问题时游刃有余，真正掌握 for 循环的精髓。