Python Tricks: The Secret to Mastering the Art of Coding

squares = []
for x in range(100):
    squares.append(x ** 2)

squares = [x ** 2 for x in range(100)]

Most people think mastering Python means memorizing every function in the standard library. That’s not it. The real secret? It’s the little tricks that turn slow, clunky code into smooth, elegant solutions-things you won’t find in beginner tutorials, but every experienced Python developer uses daily.

Use List Comprehensions Instead of Loops

Writing a loop to create a list of squared numbers? Stop. List comprehensions are faster, cleaner, and more readable. Instead of this:

squares = []
for x in range(10):
    squares.append(x ** 2)

Write this:

squares = [x ** 2 for x in range(10)]

It’s not just about saving lines. List comprehensions run 20-30% faster in most cases because they’re optimized at the C level. And when you need to filter? Add a condition:

even_squares = [x ** 2 for x in range(10) if x % 2 == 0]

That’s one line replacing five. And it’s still easy to read once you get used to the syntax.

Unpack Values Without Temporary Variables

How many times have you written code like this?

temp = a
a = b
b = temp

It works, but it’s ugly. Python lets you swap variables in one line:

a, b = b, a

Same goes for unpacking. If you have a list of three values and only need the first and last:

values = [10, 25, 42]
first, _, last = values

The underscore _ is a Python convention meaning “I don’t care about this value.” It’s not magic-it’s just a variable name-but it makes your intent crystal clear. No more cluttered code full of unused variables.

Use enumerate() When You Need Indexes

Don’t do this:

items = ['apple', 'banana', 'cherry']
for i in range(len(items)):
    print(i, items[i])

It’s unnecessary. Python gives you enumerate():

for index, item in enumerate(items):
    print(index, item)

It’s cleaner, safer (no off-by-one errors), and faster. And if you need to start counting from 1? Just add start=1:

for index, item in enumerate(items, start=1):
    print(index, item)

Now your output reads like a numbered list-perfect for logs, reports, or user-facing output.

Chain Comparisons Like a Pro

Python lets you chain comparisons in a way that feels natural. Instead of writing:

if x > 0 and x < 100:

Write this:

if 0 < x < 100:

It’s not just shorter-it’s more readable. And it works with any number of comparisons:

if 0 <= age < 18:
    print("Minor")
elif 18 <= age < 65:
    print("Adult")
else:
    print("Senior")

No and needed. No parentheses. Just clean, mathematical logic. This is Python thinking like a human, not a machine.

Use get() for Safe Dictionary Access

Trying to access a key that might not exist? This is a common cause of crashes:

user = {"name": "Alice", "age": 30}
print(user["email"])  # KeyError: 'email'

Instead, use get():

email = user.get("email", "No email provided")

It returns the value if the key exists, or the default you specify if it doesn’t. No try-except blocks needed. And if you want to avoid defaults entirely, get() returns None by default:

email = user.get("email")
if email:
    send_notification(email)

It’s a small change, but it prevents a whole class of bugs that trip up even experienced devs.

Use collections.defaultdict for Clean Data Aggregation

Counting occurrences? Grouping data? Don’t check if a key exists every time. Use defaultdict:

from collections import defaultdict

word_counts = defaultdict(int)
words = ["apple", "banana", "apple", "cherry", "banana"]

for word in words:
    word_counts[word] += 1

Without defaultdict, you’d have to write:

if word in word_counts:
    word_counts[word] += 1
else:
    word_counts[word] = 1

That’s three lines instead of one. And it’s easy to forget. defaultdict removes the friction. You can also use list as the default to group items:

groups = defaultdict(list)
for name, score in students:
    groups[score].append(name)

Suddenly, you’ve grouped all students by their scores in three lines. No loops, no conditionals.

Use itertools for Advanced Iteration

Python’s itertools module is like a Swiss Army knife for looping. Need to cycle through a list forever? Use cycle():

from itertools import cycle

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

Need to group items into chunks of 3? Use grouper():

from itertools import zip_longest

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

numbers = [1, 2, 3, 4, 5, 6, 7, 8]
for chunk in grouper(numbers, 3):
    print(chunk)

# Output:
# (1, 2, 3)
# (4, 5, 6)
# (7, 8, None)

It’s not always needed, but when you’re processing large datasets or streams, these tools cut down on boilerplate and memory use.

Use pathlib Instead of os.path

File paths are messy. os.path.join(), os.path.exists(), os.listdir()-it’s a jungle. pathlib fixes that:

from pathlib import Path

# Instead of:
# path = os.path.join("data", "reports", "output.txt")

path = Path("data") / "reports" / "output.txt"

if path.exists():
    content = path.read_text()

for file in path.parent.glob("*.txt"):
    print(file.name)

It’s object-oriented. You don’t need to remember function names. You just use methods like .read_text(), .write_text(), .exists(), .glob(). And it works the same on Windows, macOS, and Linux. No more backslash vs. forward slash headaches.

Use __slots__ to Reduce Memory Usage

When you’re creating thousands of objects-like in data processing or simulations-Python’s default object structure is heavy. Each object carries a dictionary for attributes. That adds up.

Use __slots__ to lock down what attributes an object can have:

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

Now your Point objects use 30-40% less memory. And attribute access is faster. It’s not for every class-but if you’re building a simulation, game, or data pipeline with hundreds of thousands of instances, this trick saves real resources.

Write Functions That Return Multiple Values (Without Tuples)

You can return multiple values from a function using tuples:

def get_stats(data):
    return min(data), max(data), sum(data) / len(data)

lowest, highest, avg = get_stats([1, 5, 10, 15])

But what if you want to be more explicit? Use namedtuple:

from collections import namedtuple

Stats = namedtuple('Stats', ['min', 'max', 'avg'])

def get_stats(data):
    return Stats(min(data), max(data), sum(data) / len(data))

stats = get_stats([1, 5, 10, 15])
print(stats.min)  # 1
print(stats.avg)  # 7.75

It’s still a tuple under the hood, but now your code is self-documenting. No more guessing what the third value means.

Use Context Managers for Resource Handling

Always close files? Always release locks? Use with:

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

It’s not just for files. You can write your own context managers with __enter__ and __exit__, or use built-ins like threading.Lock() or tempfile.NamedTemporaryFile(). The point? Don’t rely on memory or discipline to clean up. Let Python do it for you.

Master the if __name__ == "__main__": Pattern

Why do some Python files have this line?

if __name__ == "__main__":
    main()

It means: "Only run this code if this file is the main program, not if it’s imported as a module."

It lets you write code that works both as a script and as a library. You can test functions inside the file, import them elsewhere, and never accidentally run the whole script. It’s a small thing-but it’s what separates amateur scripts from professional modules.

Final Tip: Write Code That Reads Like English

The best Python code doesn’t just run-it communicates. Use meaningful names. Break complex logic into small functions. Don’t be clever for the sake of being clever. A trick isn’t useful if the next person (or future you) can’t understand it.

These tricks aren’t magic. They’re habits. The difference between a good Python developer and a great one isn’t how many libraries they know-it’s how cleanly they write the code they already know how to use.