在Python中，迭代器是允許逐個遍歷集合中元素的對象；它通過實現(xiàn)__iter__()和__next__()方法工作。1. 要成為可迭代對象，必須有__iter__()方法返回迭代器，或支持索引的序列如列表、字符串；2. 迭代器本身需實現(xiàn)__iter__()返回自身，__next__()返回下一個值并在結(jié)束時拋出StopIteration；3. 可自定義迭代器類，例如Squared類生成平方數(shù)直到上限；4. 區(qū)分迭代器與可迭代對象：后者如列表可循環(huán)但不是迭代器自身，而文件和生成器兩者皆是；5. 一旦迭代器耗盡，不會自動重置，需新建實例。

In Python, an iterator is an object that allows you to loop through a collection of items — like lists, dictionaries, or strings — one at a time. It works by keeping track of your position in the sequence and giving you the next item when you ask for it.

What makes something iterable?

An object is considered iterable if it has the __iter__() method, which returns an iterator. When you use a for loop in Python, like for item in my_list, what’s really happening is that Python calls iter(my_list) behind the scenes to get an iterator, then repeatedly calls next() on that iterator until it runs out of items.

So, not all objects can be iterated over directly — only those that are either:

• An iterable (has __iter__()), or
• A sequence that supports indexing (like a list or string)

This is why trying to loop through something like an integer will raise a TypeError.

How do iterators actually work?

At the core, an iterator is any object that implements two methods:

• __iter__() – returns the iterator itself
• __next__() – returns the next value from the iterator

When there are no more items left, __next__() raises a StopIteration exception, which signals the end of the iteration.

Here’s a simple example of how you might manually iterate through a list:

my_list = [1, 2, 3]
it = iter(my_list)  # Get the iterator

print(next(it))  # 1
print(next(it))  # 2
print(next(it))  # 3
print(next(it))  # Raises StopIteration

This is essentially what happens during a for loop, except the loop handles the StopIteration automatically so you don’t have to catch it yourself.

Creating your own iterator

You can define custom iterators by creating a class that implements both __iter__() and __next__().

For example, here’s a basic iterator that gives you squared numbers up to a limit:

class Squared:
    def __init__(self, max_value):
        self.max_value = max_value
        self.current = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.current >= self.max_value:
            raise StopIteration
        result = self.current ** 2
        self.current  = 1
        return result

# Usage
squares = Squared(5)
for num in squares:
    print(num)

This prints: 0, 1, 4, 9, 16. The key points here are:

• We keep track of internal state (current)
• Each call to __next__() computes the next value
• Once we reach the max, we raise StopIteration

Keep in mind that once an iterator is exhausted (i.e., you've gone through all its items), it doesn't reset automatically. If you want to reuse it, you'll need to create a new instance.

Iterators vs. iterables — what's the difference?

It’s easy to confuse these two terms:

• An iterable is anything you can loop over — like a list, string, or dictionary. It must return a fresh iterator each time iter() is called.
• An iterator is the object that actually does the looping. It remembers where it is in the sequence and gives you the next item with next().

So:

• Lists are iterable but not iterators themselves
• Generators and files are examples of objects that are both iterable and iterators

A quick test:

my_list = [1, 2, 3]
it = iter(my_list)

print(iter(my_list) is my_list)      # False → list is iterable, not iterator
print(iter(it) is it)                # True  → iterator returns itself

Final thoughts

Iterators are a fundamental part of how Python handles looping. They’re flexible, efficient, and underlie many of the built-in types and tools you use every day — including generators and comprehensions.

Once you understand how they work, you’ll see them everywhere — and writing your own becomes a powerful tool for handling sequences cleanly and efficiently.

That’s basically it.

以上是Python的迭代器是什么，它們?nèi)绾喂ぷ鳎康脑敿殐?nèi)容。更多信息請關(guān)注PHP中文網(wǎng)其他相關(guān)文章！