# 7 Built-In Python Techniques to Sharpen Your Coding
Every developer encounters moments where a solution feels clunky—a loop that refuses to terminate cleanly, a stack of nested context managers that becomes unreadable, or a configuration merge that silently hides its layers. Python’s standard library quietly offers contracts for these exact pain points, and they require no external packages. This guide walks through seven of those contracts, each paired with the scenarios where it shines and the boundaries you should respect before reaching for it.
—
## Quick Reference
| Manual Approach You Might Use | Built-In Solution | What You Gain | Minimum Python |
|——————————-|——————-|—————|—————-|
| `while True` loop with a `break` | `iter(callable, sentinel)` | The loop terminates itself when the sentinel appears | Any 3.x |
| Nested `with` blocks for a dynamic list of resources | `contextlib.ExitStack` | Reverse-order, exception-safe cleanup for any number of resources | Any 3.x |
| Slicing large `bytes` or `bytearray` objects | `memoryview` | A view into the same buffer—no copy, writes pass through | Any 3.x |
| Handling several independent failures at once | `ExceptionGroup` + `except*` | All failures are preserved and routed by type | 3.11 |
| Layering configuration dictionaries | `collections.ChainMap` | Live lookup across layers; writes affect only the first layer | Any 3.x |
| Exposing an internal dictionary without write access | `types.MappingProxyType` | A read-only window that stays current as the underlying dict changes | Any 3.x |
| Binding a middle positional argument with `partial()` | `functools.Placeholder` | `partial()` can now fix any slot, not just the leftmost ones | 3.14 |
—
## 1. Replace Polling Loops with `iter(callable, sentinel)`
The two-argument form of `iter()` is one of Python’s lesser-known contracts. You pass a zero-argument callable and a sentinel value. Python repeatedly invokes the callable until its return value equals the sentinel, at which point the loop ends—no `break` required.
“`python
for chunk in iter(lambda: stream.read(64), b””):
process(chunk)
“`
Here, `stream.read(64)` is called over and over. Once it returns an empty bytes object, iteration stops. This pattern works for any pull-based source: database cursor batches, queue consumers, or generator-like streams. The limitation is that the callable cannot accept arguments directly, so if you need to pass parameters, wrap the call in a `lambda` or `functools.partial` first.
—
## 2. Clean Up a Dynamic Set of Resources with `ExitStack`
When you know exactly which resources you are managing, nested `with` blocks read beautifully. But when the number of resources is determined at runtime—say, a list of files chosen by a user—those blocks become impossible to write. `ExitStack` solves this.
“`python
from contextlib import ExitStack
with ExitStack() as stack:
files = [stack.enter_context(open(path)) for path in paths]
combine_results(files)
“`
All files close automatically when the block exits, even if an exception occurs. Cleanup happens in reverse order of entry, which matters when resources have dependencies. Because `enter_context()` accepts any object with a context-manager interface, you can mix files, locks, network connections, and custom objects in the same stack. For a small, fixed number of resources, plain `with` statements remain the clearer choice.
—
## 3. Manipulate Binary Data Without Copying Using `memoryview`
Slicing a `bytes` or `bytearray` object creates a full copy of that slice. For small payloads this is invisible, but in a tight loop over large buffers, the copies multiply memory usage and slow execution. A `memoryview` exposes the original buffer without copying.
“`python
packet = bytearray(16)
header = memoryview(packet)[:4]
header[0] = 0xFF # packet[0] is now 0xFF
“`
The view shares the underlying memory, so writes through the view affect the original object. Keep in mind that a `memoryview` pins the buffer it refers to—trying to resize the `bytearray` while a view is alive raises `BufferError` until you call `release()`. This behavior surfaces lifetime bugs early rather than letting corrupted data slip through.
—
## 4. Preserve Every Failure with `ExceptionGroup` and `except*`
In concurrent or batch-processing code, multiple independent tasks might each raise a different exception. Before Python 3.11, you often had to choose between reporting the first failure and losing the rest, or writing elaborate error-collection logic. Exception groups change that.
“`python
raise ExceptionGroup(“batch failed”, [
ValueError(“row 3”),
OSError(“disk”),
ValueError(“row 9”)
])
“`
The matching `except*` syntax routes each subgroup separately. A `ValueError` handler receives both row errors, while an `OSError` handler receives the disk problem. Unhandled exceptions continue to propagate normally, which is exactly what should happen. Reserve this tool for situations where multiple distinct failures genuinely coexist—such as concurrent coroutines or validating a batch of inputs. A single, well-understood failure still deserves a simple `raise`.
—
## 5. Layer Configuration Dictionaries with `ChainMap`
Merging configuration dictionaries into one flat copy is a common pattern, but it creates a snapshot that diverges from its sources when the originals change. `ChainMap` keeps the layers separate and searches them in order.
“`python
from collections import ChainMap
cfg = ChainMap(cli_args, env_vars, defaults)
timeout = cfg[“timeout”] # env_vars wins, falls back to defaults
“`
Updates to `defaults` are immediately visible through the `ChainMap`, which a merged copy can’t provide. Writes and deletes affect only the first mapping, so assigning `cfg[“retries”] = 5` puts the key into `cli_args` without touching the other layers—precisely the override semantics most configuration systems need. Use `new_child()` to push a temporary scope for a subtask, and reach for the `|` merge operator when you truly need a frozen snapshot.
—
## 6. Hand Out Read-Only Access with `MappingProxyType`
Returning an internal dictionary from a class gives every caller a remote control for your state. `MappingProxyType` wraps the dictionary in a read-only view that stays live.
“`python
from types import MappingProxyType
self._registry = {“csv”: load_csv}
self.registry = MappingProxyType(self._registry)
“`
Any attempt to write to `registry` raises a `TypeError`, while your internal code can still modify `_registry` and those changes show through the proxy instantly. Unlike a copy, the view never goes stale. Remember that the protection is shallow—mutable values stored inside the dictionary remain mutable—and that this is an API-clarity tool rather than a security boundary. A determined caller can always reach the underlying dictionary.
—
## 7. Fix Any Positional Argument with `functools.Placeholder`
`functools.partial()` has always frozen arguments starting from the left. If you need to bind the second or third positional parameter, the old workaround was a small wrapper function or a `lambda`. Python 3.14 introduces `Placeholder` to reserve an open slot anywhere in the argument list.
“`python
from functools import partial
from functools import Placeholder
send_json = partial(send, Placeholder, “application/json”, retries=3)
send_json(payload) # payload fills the first slot
“`
Open slots fill left to right at call time, preserving a predictable call signature. On Python 3.13 or earlier, a well-named helper function remains the most readable fallback, and it gives reviewers and tracebacks a clear label to latch onto.
—
## Frequently Asked Questions
**Q: Are these tricks worth learning if I already have working code?**
A: They become worthwhile when they replace code you are actively maintaining. The real benefit is not brevity—it is removing a source of bugs (forgotten cleanups, hidden copies, stale configuration) and making the intent unmistakable.
**Q: Can I use `memoryview` on any object?**
A: Only on objects that support the buffer protocol—`bytes`, `bytearray`, `array.array`, and some third-party array types. Regular lists of integers do not qualify.
**Q: What happens if an exception in an `ExceptionGroup` is not handled by any `except*` clause?**
A: It propagates as part of the original group. If no handler catches the unmatched subgroup, the entire group is raised at the end.
**Q: Is `ChainMap` a good replacement for `dict.update()` when merging configs?**
A: It depends on what you need. Use `ChainMap` when you want live layering and override semantics. Use the `|` operator or `dict.update()` when you need an independent, flattened snapshot that won’t change when the source layers change.
**Q: Does `MappingProxyType` protect against mutation of nested mutable values?**
A: No. The proxy prevents adding, removing, or replacing keys, but if a value is a list or another dictionary, that value can still be mutated in place.
**Q: Can `Placeholder` be used with keyword arguments?**
A: `Placeholder` only reserves positional slots. For keyword arguments, use `partial()` with explicit keyword binding or a wrapper function.
—
## Conclusion
The most powerful Python tools are often the ones already baked into the language. These seven contracts—iterating with a sentinel, cleaning up dynamic resources, slicing without copying, grouping exceptions, layering configurations, exposing read-only mappings, and pre-filling arbitrary positional arguments—do not introduce new syntax. They deepen your understanding of what Python already promised you.
Before adopting any of them, ask three questions: what hand-written mechanism does this replace? What are the mutation and lifetime guarantees? Does my minimum Python version support it? When a technique deletes code you were maintaining and makes the remaining behavior easier to explain, you have found the right tool. Everything else is just novelty.
Thank you for reading
