Cache in Python !

Exploring Python's functools: Cache, Cached Property, and LRU Cache Python's functools module is a treasure trove for functional programming enthusiasts, offering tools to make your code more efficient and elegant. In this post, we'll dive into three powerful functions—cache, cached_property, and lru_cache—that help optimize performance by storing results of expensive computations. Whether you're speeding up recursive algorithms or simplifying class-based calculations, these tools have you covered. Let’s explore each one with clear explanations and practical examples. 1. cache: Simple, Unbounded Memoization The cache decorator is a lightweight way to memoize function results, storing them for reuse when the same inputs occur again. It’s like a sticky note for your function’s outputs—no recomputation needed! How It Works What it does: Stores function results in an unbounded dictionary, using arguments as keys. When to use it: Ideal for pure functions (same input, same output) that are computationally expensive. Key feature: It’s equivalent to lru_cache(maxsize=None) but faster due to its simplicity. Example from functools import cache @cache def factorial(n): return n * factorial(n-1) if n else 1 print(factorial(10)) # Computes: 3628800 print(factorial(10)) # Returns cached result, no recomputation Why It’s Awesome Speed: Avoids redundant calculations, making recursive functions like factorial lightning-fast. Simplicity: No configuration needed—just slap on the decorator. Caveat: The cache grows indefinitely, so monitor memory usage for functions with many unique inputs. 2. cached_property: One-Time Property Computation The cached_property decorator transforms a class method into a property that computes its value once and caches it for the instance. Think of it as a lazy-loaded attribute that sticks around. How It Works What it does: Runs the method the first time it’s accessed, caches the result as an instance attribute, and returns the cached value on subsequent calls. When to use it: Perfect for expensive calculations in classes that don’t change after the first computation. Key feature: Works only with instance methods (requires self). Example from functools import cached_property class Circle: def __init__(self, radius): self.radius = radius @cached_property def area(self): print("Computing area") return 3.14159 * self.radius ** 2 c = Circle(5) print(c.area) # Prints: Computing area, then 78.53975 print(c.area) # Prints: 78.53975 (cached, no recomputation) Why It’s Awesome Efficiency: Computes only once per instance, saving CPU cycles. Clean code: Reads like a property (c.area vs. c.area()), blending seamlessly into class design. Caveat: The cached value can be overridden (e.g., c.area = 0), so use it for immutable data. 3. lru_cache: Flexible, Bounded Memoization The lru_cache decorator is the heavy hitter of memoization, offering a Least Recently Used (LRU) cache with configurable size. It’s thread-safe and packed with introspection features, making it a go-to for optimizing complex functions. How It Works What it does: Caches up to maxsize results, evicting the least recently used entry when full. Supports a typed option to treat different types (e.g., 3 vs. 3.0) as distinct keys. When to use it: Great for recursive algorithms, dynamic programming, or any function with repetitive calls. Key feature: Provides cache_info() to inspect hits, misses, and cache size. Example from functools import lru_cache @lru_cache(maxsize=32) def fib(n): if n

from functools import cache

@cache
def factorial(n):
    return n * factorial(n-1) if n else 1

print(factorial(10))  # Computes: 3628800
print(factorial(10))  # Returns cached result, no recomputation

from functools import cached_property

class Circle:
    def __init__(self, radius):
        self.radius = radius

    @cached_property
    def area(self):
        print("Computing area")
        return 3.14159 * self.radius ** 2

c = Circle(5)
print(c.area)  # Prints: Computing area, then 78.53975
print(c.area)  # Prints: 78.53975 (cached, no recomputation)

from functools import lru_cache

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

print(fib(10))  # Computes: 55
print(fib.cache_info())  # Shows: CacheInfo(hits=8, misses=11, maxsize=32, currsize=11)

Related Posts

Getting Started with Pandas: The Power Tool for Data An...

Apr 5, 2025  0

Byte-Pair Tokenization: The Basic Principle Behind Larg...

Feb 19, 2025  0

Edge AI Breakthrough: Multi-Device Neural Networks Boos...

Mar 21, 2025  0