Speeding Up Python: Practical Tips for Writing Faster Code

Why Python Gets a Bad Rap (and Why It’s Not Always Fair)

One of the most common criticisms of Python is that it’s “too slow.” But here’s the truth: performance isn’t just about the language—it’s about how the code is written. A well‑optimized Python program can run surprisingly fast, and a poorly written one in any language can crawl.

So instead of blaming the language, let’s dig into how we can make Python code run faster—sometimes up to 30% faster—with smart profiling and a few practical adjustments.

Step One: Find the Bottlenecks

Before you start tweaking anything, you need to know where your code is actually slowing down. Sometimes the culprit is obvious. Other times, it’s buried in a function you didn’t expect.

Here are a few ways to pinpoint performance issues:

🐢 The Quick-and-Dirty Method: time Command

If you just want a rough idea of how long your entire script takes to run, the Unix time command is a simple option. It’s not very precise, but it’s a start.

🔬 The Deep Dive: cProfile

For detailed insights, Python’s built‑in cProfile module is your best friend. It shows you how much time each function takes, sorted by cumulative time (cumtime). You’ll get a lot of output, but it’s worth it—especially when you need to identify slow functions like math.exp or other heavy hitters.

⏱️ Zooming In: Timing Individual Functions

Once you’ve found the slow spots, you can time specific functions using a decorator:

python

import time

def timer(func):
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        end = time.perf_counter()
        print(f"{func.__name__} took {end - start:.4f} seconds")
        return result
    return wrapper

Apply it to any function you want to measure. Just remember: time.perf_counter() includes system delays, while time.process_time() focuses only on CPU time used by your program.

Step Two: Make It Faster

Now that you know where the slowdowns are, let’s talk about how to fix them. These aren’t magic tricks—they’re practical strategies that can make a real difference.

⚡ Use Built-In Data Types

Python’s built‑in types like lists, sets, and dictionaries are implemented in C, which makes them much faster than custom classes or data structures. Stick with them whenever possible.

🧠 Cache Results with lru_cache

If your function does heavy lifting and gets called repeatedly with the same arguments, caching can save you a ton of time:

python

from functools import lru_cache
import time

@lru_cache(maxsize=None)
def slow_function(x):
    time.sleep(2)
    return x * x

The first call takes time. The second? Instant.

📍 Prefer Local Variables

Variable lookup speed matters. Local variables are the fastest, followed by class attributes (self.name), and then globals like time.time. If you’re using a global repeatedly, assign it to a local variable first.

🧩 Wrap Code in Functions

It might seem counterintuitive, but wrapping your code in functions can actually speed things up. Why? Because it avoids global variable lookups and keeps things scoped and efficient.

python

def main():
    # your code here

main()

🚫 Minimize Attribute Access

Accessing object attributes with the dot operator (obj.attr) triggers a dictionary lookup via __getattribute__, which adds overhead. If you need the value multiple times, store it in a local variable.

🔤 Optimize String Operations

String formatting can be a hidden performance drain. According to Python expert Raymond Hettinger, f‑strings are the fastest and cleanest option:

python

name = "Olatunji"
print(f"Hello, {name}")

Avoid %s and .format() in performance‑critical loops.

🔄 Use Generators for Large Data

Generators don’t speed up computation directly, but they save memory—and that can lead to faster execution. If your dataset is large, using generators helps avoid cache overflow and keeps your program snappy.

Final Thoughts: Optimize With Care

The golden rule of optimization? Don’t do it—unless you really need to. Performance tweaks can make your code harder to read and maintain, so always weigh the trade‑offs.

But when speed matters, these techniques can help you write Python that’s not just clean and readable—but fast enough to silence the critics.