Python Tricks: The Ultimate Guide to Coding Like a Pro

Most Python developers write code that works. But only a few write code that flies. If you’ve ever looked at someone else’s Python script and thought, How did they make this look so clean? - you’re not alone. The difference isn’t talent. It’s tricks. Small, powerful habits that turn ordinary code into something elegant, fast, and maintainable.

Stop Using For Loops for Everything

You learned Python with for loops. You use them for filtering, mapping, summing, grouping - everything. But Python has better tools. They’re faster, clearer, and less error-prone.

Instead of this:

numbers = [1, 2, 3, 4, 5]
squared = []
for n in numbers:
    squared.append(n ** 2)

Do this:

numbers = [1, 2, 3, 4, 5]
squared = [n ** 2 for n in numbers]

It’s called a list comprehension. It’s not just shorter - it runs 20-30% faster in most cases. And it’s immediately obvious what you’re doing.

Same goes for filtering:

even_numbers = [n for n in numbers if n % 2 == 0]

That’s one line. No extra variables. No indentation mess. No if blocks inside loops. And it’s still readable.

For dictionaries? Use dict comprehensions:

names = ["Alice", "Bob", "Charlie"]
name_lengths = {name: len(name) for name in names}
# Result: {'Alice': 5, 'Bob': 3, 'Charlie': 7}

Stop writing loops. Write expressions.

Use Unpacking - It’s Not Just for Tuples

Unpacking lets you assign multiple values at once. Most people know it for swapping variables:

a, b = b, a

But it’s way more powerful. Want to ignore the first item in a list? Use an underscore:

_, day, month, year = ["ignore", 15, "Nov", 2025]

What if you don’t know how many items are in a list? Use the splat operator:

first, *middle, last = ["Alice", "Bob", "Charlie", "Diana"]
# first = "Alice", middle = ["Bob", "Charlie"], last = "Diana"

Unpacking works with function calls too. If you have a list of arguments:

def greet(name, age, city):
    print(f"Hi {name}, {age}, from {city}")

info = ["Sam", 28, "Adelaide"]
greet(*info)

No need to write greet(info[0], info[1], info[2]). That’s fragile. This is clean. And it works with dictionaries too - just use ** instead of *.

Default Values and the Walrus Operator

Default parameters are obvious:

def connect(host="localhost", port=5432):
    ...

But what if you need to assign a value only if it’s not already set? This is common with config files or API responses:

user_input = input("Enter your name: ")
if not user_input:
    user_input = "Guest"

Python 3.8+ gives you the walrus operator (:=). It assigns and returns in one go:

if (user_input := input("Enter your name: ")) == "":
    user_input = "Guest"

Wait - that’s not better. But here’s where it shines:

data = get_data_from_api()
if (length := len(data)) > 100:
    print(f"Too much data: {length} items")

You avoid calling len() twice. That’s a performance win. And it cuts down on temporary variables. Use it when you need to use a value more than once - especially in conditions.

Context Managers for Cleaner Resource Handling

Ever forget to close a file? Or a database connection? This is a classic bug:

f = open("data.txt", "r")
data = f.read()
# Oops - forgot f.close()

Use with:

with open("data.txt", "r") as f:
    data = f.read()
# File automatically closed here

It’s not just for files. You can use it with database connections, network sockets, locks, or even custom objects. Just define __enter__ and __exit__ methods.

Here’s a real example with threading:

from threading import Lock

lock = Lock()

with lock:
    # Critical section
    shared_data.append(new_item)
# Lock automatically released

No more try/finally blocks. No more forgotten releases. Clean, safe, readable.

Use Enumerations, Not Magic Numbers

What does this mean?

status = 1
if status == 1:
    print("Active")

It’s a bug waiting to happen. What’s status 2? 3? Someone reading this code has no idea.

Use Enum:

from enum import Enum

class Status(Enum):
    ACTIVE = 1
    INACTIVE = 2
    PENDING = 3

status = Status.ACTIVE
if status == Status.ACTIVE:
    print("Active")

Now it’s self-documenting. You can even iterate over them:

for status in Status:
    print(status.name, status.value)

And if you accidentally pass a string or number, Python throws an error - instead of silently breaking.

Don’t Concatenate Strings with +

This is slow and ugly:

result = "" + "Hello" + " " + "World" + "!"

Even worse - doing this in a loop:

text = ""
for word in words:
    text += word + " "

Strings are immutable in Python. Every += creates a new string. That’s O(n²) time. For 1000 words? You’re making 500,000 copies.

Use join():

text = " ".join(words)

It’s faster, cleaner, and uses constant memory. Same for formatting:

name = "Alice"
age = 30
message = f"{name} is {age} years old"

Not "{} is {} years old".format(name, age). Not "%s is %d years old" % (name, age). Use f-strings. They’re faster and easier to read.

Use Collections and itertools

Python’s standard library has hidden gems. Most devs never use them.

Need to count items? Use Counter:

from collections import Counter

words = ["apple", "banana", "apple", "cherry", "banana", "apple"]
count = Counter(words)
print(count.most_common(2))
# Output: [('apple', 3), ('banana', 2)]

Need a queue? Use deque instead of a list:

from collections import deque

queue = deque(["first", "second", "third"])
queue.appendleft("new")  # Fast at the front
queue.pop()  # Fast at the back

Lists are slow at the front. Deques are built for it.

Need to group items? Use groupby from itertools:

from itertools import groupby

scores = [("Alice", 85), ("Bob", 92), ("Alice", 78), ("Bob", 88)]
scores.sort(key=lambda x: x[0])  # Must be sorted first

for name, group in groupby(scores, key=lambda x: x[0]):
    avg = sum(score for _, score in group) / len(list(group))
    print(f"{name}: {avg:.1f}")

These aren’t just shortcuts. They’re optimized, tested, and widely used. Learn them.

Write Functions That Do One Thing

One of the biggest signs of an amateur Python script? Functions that do 5 things.

This is bad:

def process_user_data(data):
    # Clean data
    # Validate fields
    # Save to DB
    # Send email
    # Log activity
    return True

That’s a recipe for bugs and impossible testing. Break it up:

def clean_data(data):
    return {k: v.strip() if isinstance(v, str) else v for k, v in data.items()}

def validate_data(data):
    required = {"name", "email"}
    return required.issubset(data.keys())

def save_to_db(data):
    # ... database logic
    pass

def send_welcome_email(email):
    # ... email logic
    pass

def log_activity(user_id, action):
    # ... logging logic
    pass

# Now the main function is simple:
def process_user_data(data):
    cleaned = clean_data(data)
    if not validate_data(cleaned):
        raise ValueError("Invalid data")
    save_to_db(cleaned)
    send_welcome_email(cleaned["email"])
    log_activity(cleaned["id"], "created")

Each function has one job. Easy to test. Easy to reuse. Easy to debug.

Write Tests - Even If You Hate Them

You don’t need fancy frameworks. Start with assert:

def add(a, b):
    return a + b

assert add(2, 3) == 5
assert add(-1, 1) == 0

Put those at the bottom of your script. Run it. If it crashes, you know something’s broken.

For bigger projects, use pytest. Write one test file per module. Name it test_yourmodule.py. Start simple:

# test_utils.py

def test_clean_data():
    result = clean_data({"name": "  Alice  ", "age": "30"})
    assert result["name"] == "Alice"
    assert result["age"] == 30

Run pytest and watch it pass. Now you can refactor with confidence.

Writing tests isn’t about being perfect. It’s about not breaking things when you change them.

Final Tip: Read Other People’s Code

The best way to learn Python tricks? Read code from people who do it well.

Look at open-source projects: Django, Requests, Pandas. See how they structure files. How they name variables. How they handle errors.

Don’t copy. Learn the patterns. Notice how they avoid nested ifs. How they use properties instead of getters. How they document edge cases.

Python isn’t about memorizing syntax. It’s about writing code that feels natural - to you, and to the next person who reads it.