Idioms, Comprehensions & Iterators

Coming from another language, you can write Python that works while still writing it with a foreign accent. Fluent Python leans on a small set of idioms and on the data model — the set of special methods that let your own objects behave like built-in ones. This lesson is about writing code that reads like Python.

Comprehensions over manual loops

The single most recognizable Python idiom. A comprehension builds a list, dict, or set in one expressive line:

squares = [n * n for n in range(10)]
evens = [n for n in nums if n % 2 == 0]
by_id = {user.id: user for user in users}
unique_words = {w.lower() for w in text.split()}

They’re not just shorter — they signal intent (“I am transforming/filtering a collection”) more clearly than an accumulator loop. Reach for a plain loop only when there are side effects or the logic gets complex enough to hurt readability.

Iterators and generators: laziness as a superpower

An iterator produces values one at a time; a generator is the easiest way to make one, using yield. The payoff is that you can process data that never fully exists in memory at once — a million-line file, an infinite sequence, a paginated API.

def read_large_file(path):
    with open(path) as f:
        for line in f:          # the file object is itself a lazy iterator
            yield line.strip()

# processes one line at a time, constant memory
for line in read_large_file("huge.log"):
    handle(line)

Generators are the backbone of memory-efficient Python and pair naturally with data pipelines — exactly the kind you’ll build when preprocessing text for an embedding model.

The data model: dunder methods

Python’s “magic” is not magic — it’s a set of dunder (double-underscore) methods the language calls on your behalf. Implement them and your objects plug into the language’s syntax:

class Vector:
    def __init__(self, x, y):
        self.x, self.y = x, y

    def __repr__(self):                 # what you see in a debugger
        return f"Vector({self.x}, {self.y})"

    def __add__(self, other):           # enables  a + b
        return Vector(self.x + other.x, self.y + other.y)

    def __eq__(self, other):            # enables  a == b
        return (self.x, self.y) == (other.x, other.y)

    def __len__(self):                  # enables  len(a)
        return 2

len(obj), obj[i], a + b, for x in obj, with obj, print(obj) — each is just Python calling a dunder. Understanding this demystifies the whole language: built-in types and your own classes play by identical rules.

A handful of idioms that mark fluency

# Unpacking and swapping — no temp variable
a, b = b, a
first, *rest = [1, 2, 3, 4]        # first=1, rest=[2,3,4]

# enumerate instead of range(len(...))
for i, item in enumerate(items): ...

# zip to walk collections in parallel
for name, score in zip(names, scores): ...

# Truthiness — empty collections are falsy
if not results:                    # not  len(results) == 0
    return

# Context managers guarantee cleanup
with open(path) as f:              # file closes even on exception
    data = f.read()

Why it’s worth the effort

Idiomatic code is faster to read, easier to review, and less bug-prone because it uses well-trodden paths. In an interview, fluent Python is a quiet signal that you’ve written a lot of it. In a codebase, it’s the difference between code your teammates skim and code they have to decode.

When to reach for this

Variations

Try it

These exercises are about making intent visible. Shorter is not the goal; removing bookkeeping noise is.

active_emails = []
for i in range(len(users)):
    user = users[i]
    if user["active"] == True:
        active_emails.append(user["email"].lower())

active_emails = [
    user["email"].lower()
    for user in users
    if user["active"]
]

def label_score(score: int) -> str:
    if score >= 70:
        return "pass"
    if score >= 50:
        return "review"
    return "fail"


labels = [label_score(score) for score in scores]

names = ["Ada", "Grace", "Katherine"]
scores = [98, 95]
for i, (name, score) in enumerate(zip(names, scores), start=1):
    print(i, name, score)

names = ["Ada", "Grace", "Katherine"]
scores = [98, 95]

for rank, (name, score) in enumerate(zip(names, scores, strict=True), start=1):
    print(rank, name, score)