Python Tricks: Essential Coding Shortcuts Every Pro Uses

Most Python tutorials teach you how to write code. But the real pros? They write less code-and get more done. If you’ve ever stared at a 20-line function when a one-liner could do the job, you’re not alone. The difference between good Python and great Python isn’t just about logic. It’s about knowing the little tricks that make your code faster, cleaner, and smarter.

Use List Comprehensions Instead of Loops

Looping to build a list is the beginner’s habit. Pros use list comprehensions. They’re not just shorter-they’re faster. Take this common task: filtering even numbers from a range.

Beginner way:

evens = []
for i in range(100):
    if i % 2 == 0:
        evens.append(i)

Pro way:

evens = [i for i in range(100) if i % 2 == 0]

One line. Half the typing. And it runs about 30% faster in real-world tests. You can do the same with dictionaries, sets, and even nested structures. Want to create a dictionary of squares? Just do: squares = {n: n**2 for n in range(10)}. No for loops. No append(). Just clean, readable, efficient code.

Unpack Everything-Even When It’s Not Obvious

Unpacking isn’t just for tuples. It’s your secret weapon for cleaning up messy data. Instead of writing:

first = data[0]
second = data[1]
rest = data[2:]

Do this:

first, second, *rest = data

It works with strings, lists, tuples, even generator outputs. And if you’re pulling values from a function that returns multiple items? No need for temporary variables. Just unpack directly:

name, age, city = get_user_info(user_id)

Want to swap two variables without a temp? Done. a, b = b, a. That’s it. No third variable. No fuss. Python lets you treat data like Lego blocks-snap them apart and reassemble however you need.

Use enumerate() When You Need the Index

Ever written a loop like this?

i = 0
for item in items:
    print(f"{i}: {item}")
    i += 1

That’s not just verbose-it’s error-prone. You could forget to increment i. Or start at the wrong number. The pro move? Use enumerate().

for i, item in enumerate(items):
    print(f"{i}: {item}")

It’s cleaner. Safer. And you can even start counting from 1 if you want: enumerate(items, 1). No manual counters. No bugs. Just the data you need, right when you need it.

Chain Comparisons Like a Boss

Python lets you chain comparisons in a way most languages don’t. Instead of writing:

if x >= 0 and x <= 100:

Write this:

if 0 <= x <= 100:

It reads like natural language. And it’s more efficient-Python stops evaluating as soon as one part fails. Try it with dates, prices, or scores. min_age <= user.age <= max_age is instantly clear. No parentheses. No and clutter. Just clean, logical flow.

Use get() and setdefault() for Safe Dictionary Access

Trying to access a key that doesn’t exist? You’ll get a KeyError. Pros avoid that with get().

Instead of:

if 'email' in user:
    email = user['email']
else:
    email = '[email protected]'

Do this:

email = user.get('email', '[email protected]')

One line. No conditionals. No risk. And if you need to set a default value only if the key doesn’t exist? Use setdefault():

user.setdefault('last_login', datetime.now())

This won’t overwrite an existing value. It only adds it if it’s missing. Perfect for initializing configs, user profiles, or cache entries.

Use collections.defaultdict() for Automatic Defaults

Building a dictionary that groups items? You’ll hate writing if key not in dict: every time. Use defaultdict.

from collections import defaultdict

word_counts = defaultdict(int)
for word in text.split():
    word_counts[word] += 1

No need to check if the word exists. int() returns 0 by default. Want a list instead? defaultdict(list). Now you can append without checking. No more KeyErrors. Just clean, predictable code.

Use contextlib.suppress() to Silence Errors Gracefully

Ever wrapped a block in try/except just to ignore one error? Like this?

try:
    os.remove('temp_file.txt')
except FileNotFoundError:
    pass

It works-but it’s noisy. The pro way? Use suppress():

from contextlib import suppress

with suppress(FileNotFoundError):
    os.remove('temp_file.txt')

It’s one line. No boilerplate. And you can suppress multiple exceptions at once: suppress(FileNotFoundError, PermissionError). Use it for cleanup code, optional files, or noisy APIs. Less code. Fewer distractions.

Use itertools for Advanced Iteration

Need to loop over pairs of items? Group items in chunks? Cycle through a list endlessly? Python’s itertools has tools for this-and they’re built for speed.

Group items in threes:

from itertools import zip_longest

def chunk(iterable, n):
    args = [iter(iterable)] * n
    return zip_longest(*args, fillvalue=None)

for group in chunk([1,2,3,4,5,6,7], 3):
    print(group)
# Output: (1, 2, 3), (4, 5, 6), (7, None, None)

Cycle through a list forever:

from itertools import cycle

colors = cycle(['red', 'green', 'blue'])
for _ in range(10):
    print(next(colors))

These aren’t just neat tricks-they’re memory-efficient. No copying data. No extra loops. Just pure iteration magic.

Use __slots__ to Cut Memory Usage

Running a Python app with thousands of objects? Memory adds up fast. If you’re using classes with simple attributes, __slots__ can cut memory use by up to 40%.

Regular class:

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

With slots:

class Point:
    __slots__ = ['x', 'y']
    def __init__(self, x, y):
        self.x = x
        self.y = y

Why? Normal classes store attributes in a dictionary. That’s flexible-but heavy. __slots__ tells Python: "Only allow these fields. No extra junk." Perfect for data-heavy apps: simulations, game objects, or API response handlers. Just don’t use it if you need dynamic attributes.

Use typing Even If You Don’t Need It

Python is dynamic. But that doesn’t mean you should write code like it’s 2005. Use type hints-even in small scripts.

def calculate_tax(income: float, rate: float = 0.15) -> float:
    return income * rate

Why? It’s not for the interpreter. It’s for you-and your teammates. IDEs like PyCharm and VS Code use these hints to catch bugs before you run the code. Tools like mypy can scan your whole project for type mismatches. And when you come back to this code in six months? You’ll instantly know what each parameter expects. It’s not magic. It’s just better documentation that actually works.

Use pathlib Instead of os.path

Still using os.path.join()? Time to upgrade. pathlib makes file paths feel natural.

Old way:

import os
path = os.path.join('data', 'logs', 'app.log')
if os.path.exists(path):
    with open(path, 'r') as f:
        content = f.read()

New way:

from pathlib import Path

path = Path('data') / 'logs' / 'app.log'
if path.exists():
    content = path.read_text()

No more string concatenation. No more backslashes. You can use / like you would in a shell. And methods like .read_text(), .write_text(), .mkdir() make file operations dead simple. It’s not just cleaner-it’s harder to mess up.

Use functools.lru_cache() to Avoid Repeating Work

Ever had a function that recalculates the same thing over and over? Like a recursive Fibonacci function? Add caching.

from functools import lru_cache

@lru_cache(maxsize=128)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

Now the first time you call fibonacci(50), it computes it. The second time? It pulls from memory. Instant. No extra code. Just add the decorator. Works for any pure function-data lookups, API calls, heavy math. Set maxsize to limit memory use. Perfect for web apps or data pipelines.

Use __name__ == "__main__" to Make Scripts Reusable

Write a script that does something useful? Don’t just run it. Make it importable.

def main():
    print("Doing something important...")

if __name__ == "__main__":
    main()

Now you can import this file in another script without running the code. No globals. No side effects. Just clean, testable, reusable logic. It’s the standard for every serious Python project. Use it even for small tools.

Final Tip: Write Less Code, Not More

The best Python code isn’t the most complex. It’s the one that does the job with the fewest lines-and the clearest intent. Every trick here isn’t about showing off. It’s about removing friction. Less typing. Fewer bugs. Faster execution. More time to focus on the real problem.

Start with one. Pick the one that saves you the most time this week. Use it. Then move to the next. In a month, you won’t even think about writing loops the old way. You’ll just write Python.