python : iterable & iterator

正文

在 Python 中，可迭代对象（Iterable）和迭代器（Iterator）是两个相关但不同的概念，它们都与遍历元素的能力相关。理解它们的区别非常重要，尤其是在编写 Python 程序时需要处理迭代时。

1. Iterable（可迭代对象）

一个对象如果是可迭代的，意味着它可以返回一个迭代器。具体来说，Iterable 是指任何实现了 __iter__() 方法的对象。这个方法会返回一个迭代器对象。

• 特点：

  • 你可以在一个 for 循环中使用它，或者使用像 list()、tuple()、next() 等函数。
  • 一个 Iterable 对象本身不能直接返回一个元素，而是返回一个迭代器。
  • 实现了 __iter__() 方法的对象是可迭代的。

• 常见的可迭代对象：list、tuple、str、set、dict（当你遍历字典时，遍历的是它的键）等。

示例：Iterable（可迭代对象）

class MyIterable:
    def __init__(self, start, end):
        self.start = start
        self.end = end

    def __iter__(self):
        # 返回一个迭代器对象
        return MyIterator(self.start, self.end)

# 可迭代对象
my_iterable = MyIterable(0, 5)
for num in my_iterable:
    print(num)

• 这里 MyIterable 是可迭代的，因为它实现了 __iter__() 方法。__iter__() 返回一个迭代器对象 MyIterator，这是一个负责遍历数据的对象。

2. Iterator（迭代器）

一个 Iterator 是一个实现了两个核心方法的对象：

• __iter__()：返回该对象本身，表示它是可迭代的（这是一个迭代器对象的方法）。
• __next__()：返回下一个元素。如果没有元素可以返回（即迭代结束），它会抛出 StopIteration 异常。

Iterator 是一个状态保持的对象，它通过 __next__() 方法维持和返回当前的迭代状态。

• 特点：
  • 迭代器是一个已经处于迭代状态的对象，能够一次返回一个元素。
  • 迭代器是“消耗性的”，即一旦遍历完，它就不能再重新开始，除非重新创建一个新的迭代器。
  • 只有实现了 __iter__() 和 __next__() 方法的对象才是迭代器。

示例：Iterator（迭代器）

class MyIterator:
    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  # 迭代结束，抛出 StopIteration 异常
        self.current += 1
        return self.current - 1

# 迭代器
my_iterator = MyIterator(0, 5)
for num in my_iterator:
    print(num)

• MyIterator 是一个迭代器，因为它实现了 __next__() 和 __iter__() 方法。
• 每次调用 next(my_iterator) 时，都会返回一个新的元素，直到抛出 StopIteration 表示迭代结束。

3. 主要区别：

4. 总结：

• Iterable 是一个可迭代的对象，通常实现了 __iter__() 方法，并返回一个迭代器。

• Iterator 是一个已经实现了 __iter__() 和 __next__() 方法的对象，负责实际的迭代过程。

• 任何 Iterator 都是 Iterable，但是并非所有 Iterable 都是 Iterator。

  例子：

  • 列表（list）是一个 Iterable，因为它实现了 __iter__() 方法，但是它本身不是一个迭代器。
  • 如果你调用 iter(list)，会得到一个迭代器（Iterator），它可以使用 next() 获取元素。

通过这两者的区分，我们能够更好地理解 Python 中的迭代机制，并且能灵活地控制如何在不同的场景中使用它们。