编程学习网 > 编程语言 > Python > python-迭代器和可迭代对象: for 循环到底做了什么!
2026
11-19

python-迭代器和可迭代对象: for 循环到底做了什么!


今天我们来学习和探讨 Python 里一个很基础但又容易被忽略的话题——迭代器和可迭代对象。

在日常的编程中,for循环是最常见的一种循环。但你有没有想过,for item in data: Python到底在背后做了什么?为什么列表、元组、字典、文件甚至自定义对象都能被for循环遍历?这背后其实有一套完整的机制在支撑。

最熟悉的for循环

假设我们有一个列表:

fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

这段代码太简单了,简单到我们几乎不会去思考它是怎么工作的。但如果尝试用while循环来手动实现同样的功能,就会发现事情没那么简单:

fruits = ["apple", "banana", "cherry"]
index = 0
while index < len(fruits):
    print(fruits[index])
    index += 1

用 while 循环需要维护一个索引变量,还要判断边界条件。而for循环一行就搞定了。那for循环是怎么知道什么时候该停的?它是怎么一个一个取出元素的?

可迭代对象(Iterable)

在Python中,可迭代对象是指那些可以被for循环遍历的对象。常见的可迭代对象包括:

列表(list)

元组(tuple)

字典(dict)

集合(set)

字符串(str)

文件对象

以及任何实现了__iter__方法的对象

怎么判断一个对象是不是可迭代对象?可以用collections.abc模块里的Iterable来判断:

from collections.abc import Iterable
print(isinstance([1, 2, 3], Iterable))   # True
print(isinstance("hello", Iterable))      # True
print(isinstance(123, Iterable))          # False

那一个对象要成为可迭代对象,需要满足什么条件呢?答案是:它必须实现__iter__方法,这个方法返回一个迭代器对象。

迭代器(Iterator)

迭代器是真正负责"逐个取出元素"的那个对象。迭代器需要满足两个条件:

实现__iter__方法,返回自身

实现__next__方法,返回下一个元素,如果没有更多元素了就抛出StopIteration异常

我们来手动实现一个简单的迭代器,感受一下这个过程:

class MyIterator:
    def __init__(self, items):
        self.items = items
        self.index = 0
    def __iter__(self):
        return self
    def __next__(self):
        if self.index >= len(self.items):
            raise StopIteration
        item = self.items[self.index]
        self.index += 1
        return item
# 使用
items = ["red", "green", "blue"]
iterator = MyIterator(items)
print(next(iterator))  # red
print(next(iterator))  # green
print(next(iterator))  # blue
print(next(iterator))  # 抛出 StopIteration 异常

每次调用next(),迭代器就返回下一个元素,直到没有元素可返回时抛出StopIteration。

for循环到底做了什么?

现在可以揭开for循环的面纱了。

for item in items:
    print(item)

Python实际上在背后做了这些事:

# 1. 调用 iter() 获取迭代器
iterator = iter(items)  # 等价于 fruits.__iter__()
while True:
    try:
        # 2. 不断调用 next() 获取下一个元素
        item = next(iterator)  # 等价于 iterator.__next__()
        print(item)
    except StopIteration:
        # 3. 捕获异常,结束循环
        break

所以for循环的本质就是:

先调用对象的__iter__方法获取一个迭代器

然后不断调用迭代器的__next__方法获取元素

直到抛出StopIteration异常,循环结束

实际应用场景

理解了迭代器和可迭代对象之后,我们来看看在实际开发中有什么用。

场景一:处理大文件

假设你要处理一个几个G的日志文件,如果一次性读入内存,可能会把内存撑爆。这时候可以用迭代器的方式逐行读取:

def read_large_file(file_path):
    """生成器函数,逐行读取大文件"""
    with open(file_path, 'r', encoding='utf-8') as f:
        for line in f:
            yield line.strip()
# 使用
for line in read_large_file("huge_log.txt"):
    if "ERROR" in line:
        print(line)

这里用了yield关键字,它会自动把函数变成一个生成器,而生成器本身就是一种迭代器。这样无论文件多大,内存中始终只保存一行数据。

场景二:自定义范围生成器

Python内置的range()就是一个迭代器,我们也可以自己实现一个:

class MyRange:
    def __init__(self, start, end):
        self.current = start
        self.end = end
    def __iter__(self):
        return self
    def __next__(self):
        if self.current >= self.end:
            raise StopIteration
        value = self.current
        self.current += 1
        return value
# 使用
for num in MyRange(0, 5):
    print(num)  # 0, 1, 2, 3, 4

场景三:链式数据处理

迭代器可以链式组合,形成数据处理管道:

def filter_even(numbers):
    """只保留偶数"""
    for num in numbers:
        if num % 2 == 0:
            yield num
def square(numbers):
    """计算平方"""
    for num in numbers:
        yield num ** 2
# 链式调用
data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
result = square(filter_even(data))
for value in result:
    print(value)  # 4, 16, 36, 64, 100

这种写法的好处是惰性求值——只有在你真正需要数据的时候才会计算,不会提前生成中间结果,节省内存。

生成器:更简洁的迭代器

前面我们手动实现迭代器需要写__iter__和__next__两个方法,其实挺麻烦的。Python提供了生成器这种更简洁的方式来创建迭代器。 生成器有两种写法:

生成器函数:使用yield关键字

def countdown(n):
    while n > 0:
        yield n
        n -= 1
for i in countdown(5):
    print(i)  # 5, 4, 3, 2, 1

生成器表达式:类似列表推导式,但用圆括号

squares = (x ** 2 for x in range(10))
for s in squares:
    print(s)

生成器表达式的内存占用远小于列表推导式,因为它不会一次性生成所有元素:

import sys
# 列表推导式:一次性生成所有元素
list_comp = [x ** 2 for x in range(10000)]
print(sys.getsizeof(list_comp))  # 大约 87616 字节
# 生成器表达式:惰性生成
gen_exp = (x ** 2 for x in range(10000))
print(sys.getsizeof(gen_exp))    # 大约 200 字节

总结

可迭代对象:实现了__iter__方法,可以被for循环遍历

迭代器:实现了__iter__和__next__方法,负责逐个返回元素

for循环:先调用iter()获取迭代器,再不断调用next()直到StopIteration

生成器:用yield或生成器表达式创建迭代器的简便方式

惰性求值:迭代器不会提前生成所有数据,适合处理大数据或无限序列

理解了这些,你就明白了for循环背后的魔法。下次写代码的时候,不妨想想能不能用迭代器或生成器来优化内存使用,让代码更优雅、更高效。

以上就是“python-迭代器和可迭代对象: for 循环到底做了什么!”的详细内容,想要了解更多Python教程欢迎持续关注编程学习网。 

扫码二维码 获取免费视频学习资料

Python编程学习

查 看2022高级编程视频教程免费获取