Learn Python Programming

Python Iterators

An iterator is an object that produces values one at a time when you call next() on it. Iterators power for loops, comprehensions, and many built-in functions in Python.

How Iterators Work

# Any iterable (list, string, etc.) can produce an iterator
numbers = [10, 20, 30]
it = iter(numbers)  # create an iterator

print(next(it))  # 10
print(next(it))  # 20
print(next(it))  # 30
# next(it)       # StopIteration — no more items

# for loops use iterators internally
# This:
for n in numbers:
    print(n)

# Is equivalent to:
it = iter(numbers)
while True:
    try:
        n = next(it)
        print(n)
    except StopIteration:
        break

Iterables vs Iterators

# Iterable: has __iter__() method — can produce an iterator
# Iterator: has __next__() method — produces values one at a time

# Lists are iterable but NOT iterators
my_list = [1, 2, 3]
# next(my_list)  # TypeError! Lists do not have __next__

# Call iter() to get an iterator from an iterable
my_iter = iter(my_list)
next(my_iter)  # 1 — works!

# An iterator IS also iterable (iter(iterator) returns itself)
print(iter(my_iter) is my_iter)  # True

# Key difference: iterables can be looped multiple times
# Iterators are exhausted after one pass
it = iter([1, 2, 3])
print(list(it))  # [1, 2, 3]
print(list(it))  # [] — already exhausted!

Creating Custom Iterators

# Implement __iter__ and __next__ to make a class iterable
class Countdown:
    def __init__(self, start):
        self.current = start

    def __iter__(self):
        return self  # the object is its own iterator

    def __next__(self):
        if self.current <= 0:
            raise StopIteration
        value = self.current
        self.current -= 1
        return value

# Usage
for num in Countdown(5):
    print(num, end=" ")
# 5 4 3 2 1

# Infinite iterator
class InfiniteCounter:
    def __init__(self, start=0, step=1):
        self.current = start
        self.step = step

    def __iter__(self):
        return self

    def __next__(self):
        value = self.current
        self.current += self.step
        return value

# Use with islice to limit
from itertools import islice
counter = InfiniteCounter(start=10, step=5)
print(list(islice(counter, 5)))  # [10, 15, 20, 25, 30]

Built-in Iterator Tools

# enumerate — index + value
fruits = ["apple", "banana", "cherry"]
for i, fruit in enumerate(fruits, start=1):
    print(f"{i}. {fruit}")

# zip — combine iterables in parallel
names = ["Alice", "Bob", "Charlie"]
scores = [85, 92, 78]
for name, score in zip(names, scores):
    print(f"{name}: {score}")

# reversed — iterate backwards
for n in reversed([1, 2, 3, 4, 5]):
    print(n, end=" ")  # 5 4 3 2 1

# itertools — powerful iterator utilities
from itertools import chain, cycle, repeat, islice

# chain — concatenate iterables
combined = list(chain([1, 2], [3, 4], [5, 6]))
# [1, 2, 3, 4, 5, 6]

# cycle — repeat infinitely
colors = cycle(["red", "green", "blue"])
print([next(colors) for _ in range(7)])
# ["red", "green", "blue", "red", "green", "blue", "red"]

# islice — slice an iterator
from itertools import count
first_10_evens = list(islice(count(0, 2), 10))
# [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

Practical Example: File Line Iterator

# Memory-efficient file processing
class FilteredLines:
    """Iterate over non-empty, non-comment lines in a file."""
    def __init__(self, filename):
        self.filename = filename
        self._file = None

    def __iter__(self):
        self._file = open(self.filename)
        return self

    def __next__(self):
        while True:
            line = next(self._file).strip()  # raises StopIteration at EOF
            if line and not line.startswith("#"):
                return line

    def __del__(self):
        if self._file:
            self._file.close()

# Usage — processes file line by line (memory efficient)
for line in FilteredLines("config.txt"):
    print(line)

• Iterators produce values lazily — one at a time, on demand, saving memory.
• Implement __iter__ and __next__ to make any class iterable.
• Iterators are exhausted after one pass — create a new iterator to loop again.
• Use itertools for powerful iterator utilities: chain, cycle, islice, etc.
• For most cases, generators (using yield) are easier than writing a full iterator class.