7 Advanced Python Tricks to Level Up Your Coding Skills

At some point every Python developer writes a while True loop with a break, or a teetering stack of nested with blocks, and feels vaguely certain there’s a better way. There usually is. The standard library already solved these problems; it just solved them in corners most tutorials never visit. KDnuggets has covered advanced tricks for data scientists before, with pandas and NumPy doing the heavy lifting.

This list is different. Every item here is a built-in or standard-library contract, no dependencies, and each comes with the caveat that keeps it from being misused. Leveling up rarely means new syntax. It means learning what the language already promised you.

1. Turn a Callable into an Iterator with a Sentinel

iter() has a second form almost nobody uses. Hand it a zero-argument callable plus a sentinel value. Python then calls the function over and over, stopping the moment a return value equals the sentinel:

for chunk in iter(lambda: stream.read(64), b""):
    process(chunk)

That replaces the classic while True / break read loop entirely. Feed it a 200-byte stream and out come chunks of 64, 64, 64 and 8. Then it simply stops, because read() returned the empty-bytes sentinel. The same form handles anything pull-shaped, from database cursor batches to queue messages. The catch is the zero-argument part. iter() won’t pass arguments for you, so anything that needs them gets wrapped in a lambda or a partial first.

2. Manage a Runtime-Sized Set of Resources with ExitStack

Nested with blocks work beautifully until the number of resources is decided at runtime. Opening a list of files chosen by the user doesn’t fit a fixed syntax, and that’s the gap ExitStack fills:

with ExitStack() as stack:
    files = [stack.enter_context(open(p)) for p in paths]
    merge(files)

Every file closes when the block exits, exceptions included. Cleanup runs in reverse order of entry too; register three trackers and watch them close as 2, 1, 0. The stack also composes: enter_context() accepts anything with a context-manager interface, so files, locks and network clients can share one cleanup guarantee. When the resource count is fixed and small, keep the ordinary with. It reads better, and readers outnumber writers.

3. Slice Binary Data Without Copying It

Slicing bytes copies. On a small payload nobody notices, but slice a large packet or image buffer in a loop and the copies start to cost real memory and time. What a memoryview does instead is expose the same underlying buffer, copy-free. A writable view even writes straight through:

packet = bytearray(16)
header = memoryview(packet)[:4]
header[0] = 0xFF      # packet[0] is now 0xFF

Two caveats keep this honest. Performance gains are workload-specific, so measure before celebrating. There’s a sharper edge as well: an exported view pins the buffer. Try to resize a bytearray while a view is alive and Python raises BufferError until you call release(). That behavior is a feature in disguise, since it catches lifetime bugs loudly instead of corrupting data.

4. Keep Concurrent Failures Together with ExceptionGroup

When a batch of independent tasks fails three different ways, the classic model forces a choice between reporting the first error and losing the rest. Since Python 3.11, exception groups carry all of them:

raise ExceptionGroup("batch failed", [ValueError("row 3"), OSError("disk"), ValueError("row 9")])

The matching except* syntax then routes each subgroup separately, so the ValueError handler sees both row failures while the OSError handler sees the disk problem. And what about failures no handler matches? They keep propagating, which is exactly the fate an unhandled error deserves. Save the whole mechanism for cases where several failures genuinely coexist — concurrent tasks and batch validation being the classic two. A single failure with a known cause still deserves a plain raise.

5. Layer Configuration Dictionaries with ChainMap

Configuration precedence is usually implemented as a merge nobody can un-merge. ChainMap keeps the layers separate and searches them in order:

cfg = ChainMap(cli_args, env_vars, defaults)
cfg["timeout"]   # finds the env value, falls back to defaults

Because it’s a live view, updating defaults later is instantly visible through cfg, which a merged copy can’t offer. The behavior worth memorizing before shipping it: writes and deletes go to the first mapping only. Assign cfg["retries"] = 5 and the CLI layer gets the key while defaults stays untouched — which is exactly right for override semantics and surprising if you expected a merge.

There’s a bonus for scoped overrides too: new_child() pushes a fresh layer onto the front, so a subtask can carry its own temporary settings while everything beneath stays untouched. When you want a frozen snapshot instead, the | merge operator is the honest tool.

6. Expose a Mapping Without Handing Out Write Access

Returning an internal dictionary from a class hands every caller a remote control for your state. MappingProxyType returns a read-only view instead:

self._registry = {"csv": load_csv}
self.registry = MappingProxyType(self._registry)

Consumers who try registry["json"] = ... get a TypeError, while your own code keeps writing to _registry and every authorized change shows through the proxy immediately. Why not just return a copy? Because a copy goes stale the moment the registry changes, and the proxy stays current for free. Two limits keep expectations calibrated. The protection is shallow, so a mutable value inside the mapping is still mutable. And this is an API-clarity tool, not a security boundary; anyone determined enough can reach the underlying dict.

7. Pre-Fill Any Positional Slot with functools.Placeholder

partial() has always frozen arguments from the left, which is useless when the argument you want to fix sits in the middle. Python 3.14 adds functools.Placeholder to reserve open slots:

send_json = partial(send, Placeholder, "application/json", retries=3)
send_json(payload)   # payload fills the reserved first slot

Open slots fill left to right at call time, so the shape of the final call stays predictable. On anything older than 3.14, the fallback is the one Python developers have used for years:

def send_json(payload):
    return send(payload, "application/json", retries=3)

A small lambda works too. The named function usually wins anyway, since it hands the specialized call a name that reviewers can read and tracebacks can point at.

Learning the Contract, Not Just the Shortcut

Before adopting any of these, run a three-part check. Name the hand-written mechanism being replaced, because a trick that replaces nothing is just novelty. Verify the mutation and lifetime contract, since half the items above come down to who can write, through what, and for how long.

And confirm the minimum version, with 3.11 gating exception groups and 3.14 gating Placeholder. Readers still shoring up decorators or context managers should start with the must-know Python concepts first, and the functools and itertools toolbox pairs well with item 7’s older siblings.

The best trick here is whichever one deletes code you were already maintaining and leaves the behavior easier to explain than before. Everything else is trivia.
 
 

Nahla Davies is a software developer and tech writer. Before devoting her work full time to technical writing, she managed—among other intriguing things—to serve as a lead programmer at an Inc. 5,000 experiential branding organization whose clients include Samsung, Time Warner, Netflix, and Sony.