Iterators & Generators Deep Dive

# List is an iterable, not an iterator
nums = [1, 2, 3]
print(hasattr(nums, '__iter__'))  # True
print(hasattr(nums, '__next__'))  # False

# iter() returns an iterator
it = iter(nums)
print(next(it))  # 1
print(next(it))  # 2
print(next(it))  # 3
# next(it) would raise StopIteration

# For loop does this automatically:
for num in nums:   # calls iter(nums), then next() repeatedly
    print(num)

class Countdown:
    def __init__(self, start):
        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 num in Countdown(3):
    print(num)  # 3, 2, 1, 0

# Separate iterator objects (better pattern):
class CountdownIterable:
    def __init__(self, start):
        self.start = start
    def __iter__(self):
        return CountdownIterator(self.start)

class CountdownIterator:
    def __init__(self, start):
        self.current = start
    def __next__(self):
        if self.current < 0:
            raise StopIteration
        val = self.current
        self.current -= 1
        return val

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

# Using the generator
for num in fibonacci(50):
    print(num, end=' ')  # 0 1 1 2 3 5 8 13 21 34

# Or manually:
gen = fibonacci(10)
print(next(gen))  # 0
print(next(gen))  # 1
print(list(gen))  # [1, 2, 3, 5, 8]  (rest of values)

# Infinite generator – no StopIteration (careful!)
def infinite_counter(start=0):
    while True:
        yield start
        start += 1

# List comprehension – creates entire list in memory
squares_list = [x**2 for x in range(10)]  # 10 items in memory

# Generator expression – creates generator object
squares_gen = (x**2 for x in range(10))   # lazy, no memory used yet
print(next(squares_gen))  # 0
print(next(squares_gen))  # 1
print(list(squares_gen))  # [4, 9, 16, 25, 36, 49, 64, 81]

# Passing generator expression directly to a function
sum_of_squares = sum(x**2 for x in range(1000))  # no intermediate list

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

def accumulator():
    total = 0
    while True:
        value = yield total   # yields current total, receives next value
        if value is None:
            break
        total += value

acc = accumulator()
print(next(acc))      # 0 (start the generator, yields initial total)
print(acc.send(10))   # 10 (adds 10, yields new total)
print(acc.send(5))    # 15
print(acc.send(3))    # 18
acc.close()           # raises GeneratorExit inside generator

# throw() to inject exceptions
def controlled():
    try:
        while True:
            yield "running"
    except ValueError:
        yield "caught ValueError"

gen = controlled()
print(next(gen))       # "running"
print(gen.throw(ValueError))  # "caught ValueError"
# gen is now exhausted

from itertools import chain, islice, product

# Chain multiple lists lazily
for item in chain([1,2], ['a','b'], (True, False)):
    print(item)  # 1 2 a b True False

# Slice an infinite generator
from itertools import count
first_ten = islice(count(100, 5), 10)  # 100, 105, ..., 145
print(list(first_ten))

# Generate all 2‑letter combinations of 'abc'
for combo in product('abc', repeat=2):
    print(combo)  # ('a','a'), ('a','b'), ... ('c','c')

# 1. Processing pipeline with generators (efficient & composable)
def read_logs(filename):
    with open(filename) as f:
        for line in f:
            yield line.strip()

def filter_errors(lines):
    for line in lines:
        if "ERROR" in line:
            yield line

def extract_timestamps(errors):
    for err in errors:
        yield err[:19]  # first 19 chars are timestamp

# Compose the pipeline
pipeline = extract_timestamps(filter_errors(read_logs("app.log")))
for ts in pipeline:
    print(ts)

# 2. Async generator (Python 3.6+) – for async streaming
async def async_counter():
    for i in range(5):
        await asyncio.sleep(0.1)
        yield i

# 3. Generator with resource cleanup (context manager inside)
def read_csv_rows(filename):
    with open(filename, newline='') as f:
        reader = csv.reader(f)
        for row in reader:
            yield row
    # file automatically closed when generator is exhausted or garbage collected