Python Iterators & Generators
Lazy, Memory‑Efficient Iteration

# Python's for loop is syntactic sugar for this:
numbers = [1, 2, 3]
iterator = iter(numbers)   # calls numbers.__iter__()

while True:
    try:
        value = next(iterator)   # calls iterator.__next__()
        print(value)
    except StopIteration:
        break

# Output: 1 2 3

import io

# List iterator
fruits = ["apple", "banana", "cherry"]
it = iter(fruits)
print(next(it))   # apple
print(next(it))   # banana
print(next(it))   # cherry

# Dictionary iterator – yields keys
user = {"name": "Ana", "age": 28}
for key in user:
    print(key)   # name, age

# Use items() to get key-value pairs
for k, v in user.items():
    print(k, v)

# String iterator
for ch in "Python":
    print(ch)

# Simulated file iterator – reads line by line, memory‑efficient
data = "Line 1\nLine 2\nLine 3\n"
with io.StringIO(data) as f:
    for line in f:
        print(line.strip())

class CountDown:
    def __init__(self, start: int):
        self.current = start

    def __iter__(self):
        return self

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

# Usage
for n in CountDown(5):
    print(n)   # 5, 4, 3, 2, 1, 0

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

    def __iter__(self):
        return _RangeIterator(self.start, self.end)

class _RangeIterator:
    def __init__(self, start: int, end: int):
        self.current = start
        self.end     = end

    def __iter__(self):
        return self

    def __next__(self):
        if self.current >= self.end:
            raise StopIteration
        value = self.current
        self.current += 1
        return value

r = Range(0, 3)
print(list(r))   # [0, 1, 2]
print(list(r))   # [0, 1, 2] – fresh iterator each time

def fibonacci(limit: int):
    """Generate Fibonacci numbers up to limit."""
    a, b = 0, 1
    while a < limit:
        yield a
        a, b = b, a + b

for num in fibonacci(100):
    print(num)   # 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89

fibs = list(fibonacci(100))
print(fibs)

def infinite_counter(start: int = 0):
    """Count forever from start."""
    n = start
    while True:
        yield n
        n += 1

counter = infinite_counter(10)
print(next(counter))   # 10
print(next(counter))   # 11
print(next(counter))   # 12

import itertools
first_five = list(itertools.islice(infinite_counter(), 5))
print(first_five)   # [0, 1, 2, 3, 4]

def squares(n: int):
    for i in range(n):
        yield i ** 2

gen = squares(3)
print(list(gen))   # [0, 1, 4]
print(list(gen))   # [] – generator is exhausted

gen2 = squares(3)
print(list(gen2))  # [0, 1, 4]

# List comprehension – eager, uses memory for all items
squares = [x**2 for x in range(1_000_000)]   # ~28 MB

# Generator expression – lazy, uses almost no memory
squares_gen = (x**2 for x in range(1_000_000))   # ~48 bytes

# Sum of squares without materialising the list
total = sum(x**2 for x in range(1_000_000))   # generator expression
print(total)

# Filtering with generator expression
even_squares = (x**2 for x in range(100) if x % 2 == 0)
for val in even_squares:
    print(val)

import itertools

# chain – flatten multiple iterables
result = list(itertools.chain([1, 2], [3, 4], [5, 6]))
print(result)   # [1, 2, 3, 4, 5, 6]

# cycle – repeat an iterable forever
counter = 0
for color in itertools.cycle(["red", "green", "blue"]):
    print(color)
    counter += 1
    if counter > 5: break   # red, green, blue, red, green, blue

# islice – slice an iterator lazily
data = itertools.count(0, 2)
first_10 = list(itertools.islice(data, 10))
print(first_10)   # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

# groupby – group consecutive items by a key
data = ["apple", "apricot", "banana", "blueberry"]
for key, group in itertools.groupby(data, key=lambda x: x[0]):
    print(key, list(group))   # a ['apple', 'apricot']  b ['banana', 'blueberry']

# combinations, permutations, product
cards = ["A", "B", "C"]
pairs = list(itertools.combinations(cards, 2))   # AB, AC, BC
perms = list(itertools.permutations(cards, 2))   # AB, AC, BA, BC, CA, CB
product = list(itertools.product([1, 2], [3, 4])) # (1,3), (1,4), (2,3), (2,4)

import io

log_data = """2026-06-21 INFO Application started
2026-06-21 ERROR Database connection timeout
2026-06-21 WARNING Memory usage high
2026-06-21 ERROR User login failed for 'admin'
2026-06-21 FATAL System crash - restarting
2026-06-21 INFO Shutdown complete"""

def process_log_from_string(data: str):
    """Yield parsed ERROR entries from a log string."""
    for line in io.StringIO(data):
        line = line.strip()
        if "ERROR" in line or "FATAL" in line:
            parts = line.split()
            yield {"timestamp": parts[0], "message": " ".join(parts[1:])}

for entry in process_log_from_string(log_data):
    print(entry)
    if entry["message"].startswith("FATAL"):
        print("⚠️  Fatal error found – stopping early")
        break