In Python, an iterator is an object that allows traversing elements in a collection one by one; it works by implementing the __iter__() and __next__() methods. 1. To be an iterable object, the __iter__() method must return the iterator, or a sequence that supports indexes such as lists and strings; 2. The iterator itself needs to implement __iter__() to return itself, __next__() returns the next value and throw StopIteration at the end; 3. Customize iterator classes, such as the Squared class generates a square number until the upper limit; 4. Differentiate between iterators and iterable objects: the latter, such as the list, can be looped but not the iterator itself, while both the file and the generator are; 5. Once the iterator is exhausted, it will not be reset automatically, and a new instance needs to be created.

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 (ie, 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 comprehensives.

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.

The above is the detailed content of What are iterators in Python, and how do they work?. For more information, please follow other related articles on the PHP Chinese website!