Python Concepts Explained: 17 Answer-First Guides to Python's Most-Asked Questions

This is a curated reference for the 17 Python concept questions asked most often on Stack Overflow, Reddit, and Python forums. Each entry below answers a real question that millions of Python developers have searched: what does yield actually do, why are tuples faster than lists, how do decorators work, what's the difference between append and extend, when is += dangerous. Every linked explainer is answer-first, covers the modern Python (3.12, 3.13, 3.14 previews where relevant), and includes the unique angles other tutorials skip: the bytecode proof for ternary expressions, the call-by-sharing model behind argument passing, the format spec mini-language, the four shallow-copy idioms, the strict mode for batched. The pillar page itself sits inside the broader complete Python beginner guide, which threads these concepts into a learning path from first print to first paid role.

How to Use This Reference

Three usage patterns cover almost every reader.

• Searching for one answer. Scroll the index below or use the in-page table of contents. Each entry's TL;DR answers the question in one or two sentences; the linked explainer covers the depth.
• Working through a topic. Pick the sub-cluster that interests you (iteration, containers, mutation, etc.) and read the four or so explainers in order. Within a cluster, the concepts build on each other.
• Browsing for what you don't know. Skim every TL;DR. The ones that surprise you are the ones to read first.

The explainers are roughly ordered by Stack Overflow vote count, which loosely correlates with how often the question gets asked. The numbers below each TL;DR show the SO vote total at the time of writing.

Iteration and Generators

The three explainers in this group share one mental model: lazy iteration. A generator produces values on demand without materializing the whole sequence; enumerate and zip are lightweight iterators that wrap one or more inputs; dict view objects are iterators that stay in sync with the underlying dict.

What Does yield Do in Python? Generators Explained With Real Use Cases

yield turns a regular function into a generator: a producer that emits items lazily, one at a time, on demand. Each yield pauses execution and hands back a single item; the next iteration resumes from where it left off, with all local state intact. A generator over range(10**9) weighs ~48 bytes; the equivalent materialized list would need ~8 GB. (Stack Overflow: 13,134+ votes; #1 Python question of all time.)

Iterate With Index in Python: enumerate, zip, and the Modern Toolkit

Four patterns: for k in d (default), enumerate(items) (with index), zip(a, b) (parallel), and enumerate(zip(a, b)) (both at once). Python 3.10+ added zip(strict=True) to catch length mismatches loudly instead of silently truncating. The range(len()) pattern is officially an anti-pattern. (Stack Overflow: 5,676+ votes.)

How to Iterate a Dictionary in Python: keys, values, items, and the Set-Op Superpower

Four iteration patterns plus the under-used superpower: dict.keys() and dict.items() behave as sets, so d1.keys() & d2.keys() returns the shared keys in one line. Insertion order has been guaranteed since 3.7; reversed(d) works from 3.8 onward. (Stack Overflow: 4,428+ votes.)

Containers and Data Structure Choice

The "which container do I use?" question shows up in code reviews, interviews, and refactors. These three explainers decode the choice.

Tuple vs List in Python: Mutability, Hashability, and the Modern Record Alternatives

Lists are mutable; tuples are immutable. From that one fact follow hashability (tuples can be dict keys; lists can't), performance (tuples use ~27% less memory and are slightly faster to create), and CPython's compile-time constant caching. For records with named fields, the modern alternatives are collections.namedtuple, typing.NamedTuple, and dataclasses.dataclass(frozen=True). (Reddit signal: 317 votes on r/learnpython.)

Python Sets: Five Real-World Use Cases, Venn Diagrams, frozenset, and Dict Views

Sets store unique, hashable, unordered elements with O(1) membership testing. Five common uses: deduplication, fast lookup, permission systems, change detection between snapshots, tag intersection. frozenset adds hashability so you can have sets of sets; dict views support the full set-operator vocabulary natively. (Reddit signal: 57 votes; community-mined gap.)

How to Merge Two Dictionaries in Python (Every Pythonic Way)

Python 3.9 (PEP 584) added | and |= for dict union. Older code uses {**d1, **d2} or d1.update(d2). The trap nobody flags: collections.ChainMap gives LEFTMOST precedence, the opposite of every other merge. And none of these methods walks into nested dicts; deeply structured configs need a small recursive helper. (Stack Overflow: 7,126+ votes.)

Mutation, References, and Memory

The cluster that explains the largest single category of Python bugs: "why did my variable change?"

Shallow vs Deep Copy in Python: The Memory Diagram and Every Idiom

A shallow copy makes a new outer object that shares references to the same inner objects. A deep copy recursively copies every inner object. Python ships copy.copy() and copy.deepcopy(); plus four equivalent shallow-copy idioms (a[:], a.copy(), list(a), copy.copy(a)), Python 3.13's new copy.replace(), and the tuple-of-mutables trap that catches everyone exactly once. (Stack Overflow: 3,371+ votes.)

Pass by Reference or Value in Python? (It's Neither — It's Call by Sharing)

Python doesn't pass by reference, and it doesn't pass by value. It uses call by sharing (Barbara Liskov's term from CLU, 1974). The function receives a new local name for the same object the caller had; whether the caller sees changes depends on what you do inside the function, not on the type of the argument. The mutable default argument trap is in this cluster too. (Stack Overflow: 3,364+ votes.)

append vs extend vs += on Python Lists: When to Use Which

append(x) adds one item, even if x is itself a list. extend(iterable) spreads the iterable's items. += compiles to the same bytecode as extend, but a = a + b builds a new list and rebinds: if anything else aliased the original list, the two behaviors diverge. (Stack Overflow: 3,109+ votes.)

Slicing and Manipulation

Three classics that pair indexing patterns with the modern Python toolkit for batched data.

Python Slicing Demystified: a[start:stop:step] Explained

Indices point BETWEEN elements, not AT them. That one shift fixes 90% of off-by-one bugs. The article also covers slice assignment for mutation, the a[:] shallow-copy gotcha with nested lists, the slice() object, and NumPy's view-vs-copy distinction that bites everyone exactly once. (Stack Overflow: 4,709+ votes.)

Flatten a List of Lists in Python: Every Method Compared

Three methods that actually win: list(itertools.chain.from_iterable(nested)) (fastest), [x for sub in nested for x in sub] (most readable), and a for loop with .extend() (clearest in production). Skip sum(nested, []); it's quadratic. Watch the string trap: strings are iterable, so naive flatten splits "abc" into characters. (Stack Overflow: 5,515+ votes.)

Split a Python List Into Chunks: itertools.batched and Modern Tools

Python 3.12 added itertools.batched(data, n) as the canonical chunker; 3.13 added strict=True for explicit failure on uneven inputs. The fixed-size vs fixed-count distinction (batched vs numpy.array_split) is the source of most "split into chunks" bugs. Streaming chunkers and the sliding-window cousin (itertools.pairwise) round out the toolkit. (Stack Overflow: 3,177+ votes.)

Sorting

Sort a Python Dictionary by Value: Beyond the Lambda

The canonical sorted(d.items(), key=lambda kv: kv[1]) answer plus three upgrades nobody publishes: operator.itemgetter(1) is faster and cleaner; heapq.nlargest(n, ...) beats sorted for top-N (O(n log k) vs O(n log n)); and dict(sorted(...)) is a one-shot snapshot that breaks on the next mutation. For persistent sorted state, use sortedcontainers.SortedDict or a sorted list of tuples. (Stack Overflow: 3,413+ votes.)

Syntax and Patterns

Four explainers covering the language-design choices that make Python feel like Python.

The Python Ternary Operator: Syntax, Bytecode Proof, and When Not to Use It

Python's one-line if/else is value_if_true if condition else value_if_false (value first, condition middle, fallback last). Despite the persistent myth, ternary is NOT faster than the equivalent if/else block; dis.dis() proves they compile to nearly identical bytecode. The article also covers the Pythonic "None-coalescing" idiom (Python has no ?? operator) and the modern alternatives: walrus (3.8+) and match/case (3.10+). (Stack Overflow: 8,126+ votes.)

What Does if __name__ == "__main__": Do in Python?

The idiom that lets a file behave as both a runnable script and an importable module. When you run python myfile.py, Python sets __name__ to "__main__" and the guarded code runs; when something else does import myfile, __name__ takes the module's name and the same block stays silent. The article also covers the multiprocessing recursion bug this guard prevents on Windows and macOS. (Stack Overflow: 8,438+ votes.)

Python Decorators From Scratch: Modern Typing, Async, and Performance

A decorator is a callable that takes a function and returns a replacement function that wraps the original. The @decorator syntax is sugar for func = decorator(func). Coverage includes functools.wraps internals, the optional-argument pattern (@retry vs @retry(3)), class-based stateful decorators, decorating async functions, PEP 612 ParamSpec typing (3.10+), and the performance cost. (Stack Overflow: 3,202+ votes.)

Python f-strings Deep Dive: Format Mini-Language, PEP 701, Custom __format__

The complete tour: f"{value:format_spec}" with the format mini-language slot by slot, the = debug specifier (Python 3.8+), conversions (!r, !s, !a), date formatting, PEP 701's parser changes in 3.12 (outer quotes, backslashes, multi-line), custom __format__ for your own classes, and the three places f-strings are wrong (logging, SQL, i18n). (Stack Overflow: 2,720+ votes.)

How the Concepts Connect

Read the explainers in isolation and each one stands on its own. Read them together and the connections appear.

• Call by sharing explains shallow copy. Both rest on the same "one object, two names" model. The pass-by-reference explainer and the shallow vs deep copy explainer reach the same conclusion from different angles.
• Slicing explains a[:]. The shallow-copy idiom is just a full-range slice. Once you internalize the slicing model, the copy semantics fall out for free.
• Dict views are sets. The iterate-dict explainer points at the set-operator vocabulary; the set-use-cases explainer covers the same vocabulary in more detail.
• Generators and decorators are close cousins. Both return callable objects that wrap state. Once you can write a generator from scratch, you can write a decorator from scratch.
• The += vs + trap is a function of pass-by-sharing. The append-vs-extend explainer cross-references the call-by-sharing model.

If you read only one explainer to understand "why does Python work this way?", make it the pass-by-reference piece. It's the conceptual foundation for half the others.

Quick Index (Alphabetical)

For when you know the name of the thing but not which cluster it lives in.

The Bottom Line: One Reference for Python's Most-Asked Questions

Seventeen explainers, six clusters, one through-line: each piece answers the question Python developers actually search for, in the modern way Python developers actually solve it. The list comes from real community signal; the explanations cover the version differences, the unique angles, and the production traps that other tutorials skip. Treat this page as a reference: bookmark it, link to it from your team's wiki, and come back when the next "wait, how does that work again?" question shows up. For the structured learning path that threads these concepts into a course, the complete Python beginner guide is the natural next stop.