How can you process large amounts of data in Python without running out of memory?

Iterators and generators are Python's way of handling sequences of data efficiently, particularly when dealing with large or infinite sequences.

An iterator is any object that implements __iter__() and __next__() methods. __iter__ returns the iterator object, __next__ returns the next value or raises StopIteration. Lists, tuples, and dicts are iterable (they can produce iterators), but they're not iterators themselves.

A generator is a special type of iterator created using a function with yield statements. When called, a generator function returns a generator object without executing the function body. Each call to next() executes until the next yield, returns that value, and pauses.

Generators are memory-efficient: they generate values on-demand (lazy evaluation) rather than storing the entire sequence in memory. This is crucial for processing large files, streaming data, or infinite sequences.

Generator expressions provide a concise syntax: (x*x for x in range(10)) creates a generator without defining a full function. They look like list comprehensions but use parentheses.

Use cases include: reading large files line by line, processing streaming data, implementing data pipelines (chain generators together), creating infinite sequences, and anywhere you need to iterate but don't need all values simultaneously.

Generator methods like .send(), .throw(), and .close() enable coroutine-like behavior, though for modern async code, async generators and async/await are preferred. Understanding generators is fundamental for writing efficient Python code.