在 Python 中，并没有一个名为 foreach 的关键字，Python 的 for 循环在功能上完全等同于 foreach，它的设计哲学就是用来遍历任何可迭代对象（iterable）中的每一个元素。

下面我们从基础到高级,全面地解析 Python 的 for 循环。

基础：for 循环就是 foreach

Python 的 for 循环语法非常简洁直观。

语法结构

for item in iterable:
    # 循环体：对 item 执行操作
    print(item)

• for 和 in 是关键字。
• item 是一个变量名，在每次循环迭代时，它会自动被赋值为 iterable 中的下一个元素。
• iterable 是任何可迭代对象，例如列表、元组、字符串、字典、集合等。
• 冒号 和缩进（通常是 4 个空格）是 Python 语法的一部分，用于定义循环体的范围。

示例：遍历不同类型的对象

a) 遍历列表

这是最常见的用法,类似于其他语言的 foreach。

fruits = ['apple', 'banana', 'cherry']
print("使用 for 循环遍历列表:")
for fruit in fruits:
    print(f"I like {fruit}")
# 输出:
# 使用 for 循环遍历列表:
# I like apple
# I like banana
# I like cherry

b) 遍历字符串

字符串在 Python 中也是可迭代的，它会遍历其中的每一个字符。

message = "Hello"
print("\n使用 for 循环遍历字符串:")
for char in message:
    print(char)
# 输出:
# 使用 for 循环遍历字符串:
# H
# e
# l
# l
# o

c) 遍历元组

元组和列表类似,也是有序的集合。

coordinates = (10.0, 20.0)
print("\n使用 for 循环遍历元组:")
for x, y in coordinates: # 元组解包
    print(f"坐标: ({x}, {y})")
# 输出:
# 使用 for 循环遍历元组:
# 坐标: (10.0, 20.0)

d) 遍历字典

遍历字典时,默认是遍历其键。

student = {'name': 'Alice', 'age': 25, 'grade': 'A'}
print("\n使用 for 循环遍历字典的键:")
for key in student:
    print(key)
# 输出:
# 使用 for 循环遍历字典的键:
# name
# age
# grade

如果你想要同时获取键和值,可以使用 items() 方法。

print("\n使用 for 循环遍历字典的键值对:")
for key, value in student.items():
    print(f"{key}: {value}")
# 输出:
# 使用 for 循环遍历字典的键值对:
# name: Alice
# age: 25
# grade: A

e) 遍历集合

集合是无序的,遍历时元素的顺序可能与添加顺序不同。

unique_numbers = {1, 5, 2, 8, 3}
print("\n使用 for 循环遍历集合:")
for number in unique_numbers:
    print(number)
# 输出 (顺序可能不同):
# 1
# 2
# 3
# 5
# 8

进阶：for 循环与 range() 函数

当你需要基于一个数字序列进行循环时,可以使用 range() 函数，这在其他语言中通常用 for (int i = 0; i < N; i++) 的形式实现。

range(stop)

生成一个从 0 开始到 stop-1 的数字序列。

print("使用 range(5) 遍历:")
for i in range(5):
    print(i)
# 输出:
# 使用 range(5) 遍历:
# 0
# 1
# 2
# 3
# 4

range(start, stop)

生成一个从 start 开始到 stop-1 的数字序列。

print("\n使用 range(2, 5) 遍历:")
for i in range(2, 5):
    print(i)
# 输出:
# 使用 range(2, 5) 遍历:
# 2
# 3
# 4

range(start, stop, step)

生成一个从 start 开始，到 stop-1 结束，步长为 step 的数字序列。

print("\n使用 range(0, 10, 2) 遍历:")
for i in range(0, 10, 2):
    print(i)
# 输出:
# 使用 range(0, 10, 2) 遍历:
# 0
# 2
# 4
# 6
# 8

高级：遍历的同时获取索引

在 C# 或 Java 中，我们经常使用 foreach 加一个 for 循环来获取元素的索引，for (int i = 0; i < list.Count; i++)。

在 Python 中，有更 Pythonic 的方式来实现这一点，那就是使用 enumerate() 函数。

enumerate() 会返回一个包含索引和值的元组。

fruits = ['apple', 'banana', 'cherry']
print("使用 enumerate() 获取索引和值:")
for index, fruit in enumerate(fruits):
    print(f"索引 {index}: {fruit}")
# 输出:
# 使用 enumerate() 获取索引和值:
# 索引 0: apple
# 索引 1: banana
# 索引 2: cherry

你还可以自定义索引的起始值：

print("\n使用 enumerate(start=1) 自定义起始索引:")
for index, fruit in enumerate(fruits, start=1):
    print(f"序号 {index}: {fruit}")
# 输出:
# 使用 enumerate(start=1) 自定义起始索引:
# 序号 1: apple
# 序号 2: banana
# 序号 3: cherry

控制循环流程

在 for 循环中，你可以使用 break 和 continue 来控制流程。

• break：立即终止整个循环。
• continue：跳过当前迭代，直接进入下一次迭代。

break 示例

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print("\n使用 break 查找第一个大于 5 的数:")
for num in numbers:
    if num > 5:
        print(f"找到了: {num}")
        break  # 找到后立即退出循环
# 输出:
# 使用 break 查找第一个大于 5 的数:
# 找到了: 6

continue 示例

print("\n使用 continue 打印除了 3 以外的所有偶数:")
for num in range(1, 6):
    if num == 3:
        continue  # 跳过 3
    if num % 2 == 0:
        print(num)
# 输出:
# 使用 continue 打印除了 3 以外的所有偶数:
# 2
# 4

遍历自定义对象（实现 __iter__）

如果你的自定义类对象也想被 for 循环遍历，你需要让你的类成为一个可迭代对象，这通过实现 __iter__() 方法来完成。

__iter__() 方法应该返回一个迭代器对象，迭代器对象需要实现 __next__() 方法，该方法会在每次被调用时返回下一个元素，并在没有更多元素时引发 StopIteration 异常。

虽然你可以手动实现这两个方法,但更简单、更常见的方式是使用 Python 的生成器（generator）。

示例：使用生成器创建一个可迭代对象

class Countdown:
    def __init__(self, start):
        self.start = start
    # __iter__ 方法使这个类成为可迭代对象
    def __iter__(self):
        # 当一个函数包含 yield 语句时，它就变成了一个生成器
        n = self.start
        while n > 0:
            yield n  # yield 返回一个值，并“暂停”函数
            n -= 1
        # 当函数执行完毕时，会自动引发 StopIteration
# 现在我们可以用 for 循环遍历 Countdown 对象了
print("\n遍历自定义的 Countdown 对象:")
for number in Countdown(5):
    print(number)
# 输出:
# 遍历自定义的 Countdown 对象:
# 5
# 4
# 3
# 2
# 1

当你想实现 foreach 时，直接使用 for item in my_object: 即可，这是 Python 中最基本、最强大的循环方式。