Iterators in Python

# The difference between an iterable and an iterator

nums = [10, 20, 30]   # ITERABLE — can produce an iterator

# iter() asks the iterable for its iterator
it = iter(nums)       # now 'it' is the ITERATOR

# next() asks the iterator for the next value
print(next(it))   # 10
print(next(it))   # 20
print(next(it))   # 30

# One more call raises StopIteration — nothing left
try:
    print(next(it))
except StopIteration:
    print("Exhausted — StopIteration raised")

# The original list is still intact — iterators are separate objects
print("List still intact:", nums)
print("List iterator type:", type(iter(nums)))

items = ["a", "b", "c"]

# What you write:
for item in items:
    print(item)

print("---")

# What Python ACTUALLY does internally:
_it = iter(items)            # Step 1: get the iterator
while True:
    try:
        item = next(_it)     # Step 2: get next value
        print(item)          # Step 3: run loop body
    except StopIteration:
        break                # Step 4: stop when exhausted

# This is why you can't loop over a plain integer:
try:
    iter(42)
except TypeError as e:
    print("Error:", e)

# Custom iterator — counts down from start to 1

class Countdown:
    """Counts down from a given start number to 1."""

    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    # signal completion
        val = self.current
        self.current -= 1          # advance internal state
        return val

# Works in a for loop
for n in Countdown(5):
    print(n, end=" ")
print()

# Works with list(), sum(), max()
print("As list:", list(Countdown(4)))
print("Sum    :", sum(Countdown(4)))
print("Max    :", max(Countdown(4)))

# next() with a default — avoids StopIteration exception
cd = Countdown(2)
print(next(cd, "done"))   # 2
print(next(cd, "done"))   # 1
print(next(cd, "done"))   # "done" — default returned instead of raising

# Separate iterable and iterator classes

class NumberRange:
    """The iterable — holds the data, creates fresh iterators on demand."""
    def __init__(self, start, end):
        self.start = start
        self.end   = end

    def __iter__(self):
        return NumberRangeIterator(self)   # fresh iterator each time

class NumberRangeIterator:
    """The iterator — holds traversal state."""
    def __init__(self, source):
        self.current = source.start
        self.end     = source.end

    def __iter__(self):
        return self

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

r = NumberRange(1, 4)

# Two independent iterators over the same range
it1 = iter(r)
it2 = iter(r)

print(next(it1))   # 1  — it1 at position 1
print(next(it1))   # 2  — it1 advances
print(next(it2))   # 1  — it2 is independent, still at start

# The range itself can be looped multiple times
for n in r:
    print(n, end=" ")
print()
for n in r:          # second full loop — fresh iterator
    print(n, end=" ")
print()

from collections.abc import Iterable, Iterator

# Check if something is iterable
for obj in [[1,2,3], "hello", 42, {"a":1}, range(5)]:
    print(f"{str(obj):<20} iterable: {isinstance(obj, Iterable)}")

print()

# Check if something is an iterator (has __next__)
my_list  = [1, 2, 3]
my_iter  = iter(my_list)

print("list is Iterator :", isinstance(my_list, Iterator))   # False
print("iter is Iterator :", isinstance(my_iter, Iterator))   # True
print("list is Iterable :", isinstance(my_list, Iterable))   # True
print("iter is Iterable :", isinstance(my_iter, Iterable))   # True

class Squares:
    """Yields perfect squares from 1 up to limit."""
    def __init__(self, limit):
        self.n     = 1
        self.limit = limit
    def __iter__(self): return self
    def __next__(self):
        if self.n > self.limit:
            raise StopIteration
        val   = self.n ** 2
        self.n += 1
        return val

# All built-in functions work with custom iterators
print("list  :", list(Squares(5)))
print("tuple :", tuple(Squares(4)))
print("sum   :", sum(Squares(5)))
print("max   :", max(Squares(5)))
print("min   :", min(Squares(5)))
print("sorted:", sorted(Squares(5), reverse=True))

# zip with a custom iterator
names   = ["Alice", "Bob", "Carol"]
squares = Squares(3)
for name, sq in zip(names, squares):
    print(f"  {name}: {sq}")

# enumerate with a custom iterator
print("Enumerated:")
for i, sq in enumerate(Squares(4), start=1):
    print(f"  {i}. {sq}")

import sys

# A list of 1 million numbers — all in memory at once
big_list  = list(range(1_000_000))
big_range = range(1_000_000)    # range is lazy — stores only start/stop/step

print("list  size:", sys.getsizeof(big_list),  "bytes")
print("range size:", sys.getsizeof(big_range), "bytes")   # tiny — ~48 bytes

# An infinite counter — impossible with a list, trivial with an iterator
class Counter:
    """An infinite counter starting from a given value."""
    def __init__(self, start=0):
        self.n = start
    def __iter__(self): return self
    def __next__(self):
        val    = self.n
        self.n += 1
        return val

# Take only the first 5 values using next()
c = Counter(10)
first_five = [next(c) for _ in range(5)]
print("First 5 from infinite counter:", first_five)

# Use itertools.islice to take a slice from any iterator
import itertools
c2     = Counter(100)
sample = list(itertools.islice(c2, 8))
print("8 from counter starting at 100:", sample)

import random

random.seed(42)   # fixed seed for reproducible output

# Roll a die repeatedly until we get a 6
roller = iter(lambda: random.randint(1, 6), 6)
rolls  = list(roller)    # collect all rolls before the first 6
print("Rolls before 6:", rolls)

# Read a file in fixed-size chunks until empty bytes signal EOF
# (This is the most common real-world use)
# with open("large_file.bin", "rb") as f:
#     for chunk in iter(lambda: f.read(4096), b""):
#         process(chunk)

# Read lines from stdin until user types "quit"
# for line in iter(input, "quit"):
#     print("You entered:", line)

# Count how many rolls to reach a 6 (re-roll)
random.seed(42)
count = 0
for _ in iter(lambda: random.randint(1, 6), 6):
    count += 1
print(f"Took {count} rolls to get a 6")