Python Tutorial: Iterators and Iterables - What Are They and How Do They Work?

Iterables and iterators in Python boil down to two distinct contracts: an iterable can produce an iterator via its `__iter__` method, while an iterator is a stateful object that yields values one at a time through `__next__` until it raises `StopIteration`. That distinction matters because it determines how loops consume data, how custom classes integrate with Python’s iteration protocols, and how memory-efficient code can be built without materializing entire collections.

A list is the canonical example of an iterable that is not itself an iterator. A `for` loop works by calling `__iter__` on the object to obtain an iterator, then repeatedly calling `__next__` on that iterator. The transcript demonstrates this by showing that calling `next()` directly on a list raises a `TypeError` (“list object is not an iterator”), because lists don’t implement `__next__`. Running `__iter__` on the list returns a “list iterator” object that does implement both `__iter__` and `__next__`. That iterator also behaves as expected when `next()` is called repeatedly: it returns the next element each time, remembers its position internally (its “state”), and eventually raises `StopIteration` once the data is exhausted.

The mechanics of `for` loops become clearer through a manual re-creation of the loop. Instead of relying on Python’s built-in handling, the transcript sketches the equivalent control flow: keep calling `next(iterator)` inside a `try` block, print each item, and break when `StopIteration` occurs. Another key property highlighted is that iterators move only forward. There’s no built-in “rewind” or copying of iteration state; restarting requires creating a new iterator instance.

From there, the tutorial shifts to practical implementation. A custom class, `my_range`, is built to mimic the behavior of Python’s `range`. The class stores `start` and `end` in instance attributes, implements `__iter__` to return an iterator object, and implements `__next__` to advance an internal counter. When the counter reaches the end condition, `__next__` raises `StopIteration`. The result is a class that can be used in a `for` loop and also supports manual stepping with `next()`.

Generators provide the same iteration behavior with less boilerplate. A generator function like `my_range(start, end)` uses `yield` to produce values lazily, automatically creating the iterator protocol methods behind the scenes. The transcript also shows a generator that can run forever by replacing the end condition with `while True`. Used with a `for` loop, this creates an infinite loop—illustrating both the power and the risk of unbounded iterators.

Finally, the memory-efficiency angle is emphasized: iterators fetch one value at a time, so they can handle enormous search spaces that would be impossible to store in a list. The example given is brute-force password cracking, where generating all candidate passwords at once would exhaust memory, but iterating through candidates incrementally can keep memory usage under control even if the computation takes time.