This Forgotten Python Command Makes Code 14,000 Times Faster

Are you writing slow Python loops? Recalculating the same values over and over? If so, you're wasting time! But there’s a simple trick that can instantly speed up your code—without rewriting everything from scratch.

Let’s explore Python’s built-in memoization feature and see how it can make your code 14,000x faster!

The Problem: Slow Recursive Functions

Consider this basic Python project with a recursive function to compute the Fibonacci sequence:

# Regular Fibonacci function
def fib(n):
    if n <= 1:
        return n
    return fib(n - 1) + fib(n - 2)

This works—but for large values of n, it’s painfully slow. Why?

Every time fib(n-1) and fib(n-2) are called, they recalculate values that have already been computed. This results in an exponential number of function calls!

For example, calculating fib(30) requires over 1 million recursive calls. That’s a performance nightmare.

How can we fix this?

The Forgotten Trick: @lru_cache

The solution is memoization—a technique that stores previously computed values so they don’t have to be recalculated.

And the best part? Python has a built-in way to do this with just one line.

Simply add @lru_cache from functools, and watch the magic happen:

from functools import lru_cache

@lru_cache(maxsize=None)  # Automatically caches results
def fib(n):
    if n <= 1:
        return n
    return fib(n - 1) + fib(n - 2)

Why This Works

• Python now remembers past results, avoiding redundant calculations.
• Drastically reduces execution time (especially for large n).
• Requires zero extra logic—just a single decorator!

Benchmarking: How Much Faster Is It?

Let’s compare the performance of the regular vs cached Fibonacci functions using Python’s timeit module. Fire up your Python editor and follow along with me:

import timeit
from functools import lru_cache

# Regular Fibonacci function
def fib(n):
    if n <= 1:
        return n
    return fib(n - 1) + fib(n - 2)

# Cached Fibonacci function
@lru_cache(maxsize=None)
def cached_fib(n):
    if n <= 1:
        return n
    return cached_fib(n - 1) + cached_fib(n - 2)

# Measure execution time
normal_time = timeit.timeit("fib(30)", globals={"fib": fib}, number=1)
cached_time = timeit.timeit("cached_fib(30)", globals={"cached_fib": cached_fib}, number=1)

# Prevent division by zero error
if cached_time > 0:
    speedup_factor = normal_time / cached_time
    print(f"Without lru_cache: {normal_time:.5f} seconds")
    print(f"With lru_cache: {cached_time:.10f} seconds")
    print(f"Speedup: ~{speedup_factor:.2f}x faster!")
else:
    print(f"Without lru_cache: {normal_time:.5f} seconds")
    print("With lru_cache: Too fast to measure!")
    print("Speedup: Easily 100000x+ faster!")

Results

Without lru_cache: 0.13654 seconds
With lru_cache: 0.0000092090 seconds
Speedup: ~14826.82x faster!

For fib(30), @lru_cache makes the function more than 14,000x faster! In some cases, the execution time becomes so small it’s too fast to measure.

This optimization can make a huge difference when working with expensive computations in real-world applications.

Video Walkthrough

Wrapping Up

Whenever you have a function with repeated calculations, just slap @lru_cache on it!

- Your code runs faster.
- Your CPU works less.
- And you look like a Python genius!

Have a favorite Python performance trick? Drop it in the comments below! And if you found this helpful, don’t forget to share it with your fellow coders.