Python 隐藏的高级技术

Python Advanced Hidden Tricks: __slots__ and functools.lru_cache

Today, we will explore some advanced hidden tricks in Python that can alter the way we solve problems. These are not just tricks but are powerful shifts in thinking that can significantly impact memory and performance efficiency.

Using __slots__ to Reduce Class Memory Footprint

__slots__ is a feature in Python that allows us to define a fixed set of attributes for a class. This prevents the creation of a __dict__ for each instance, which usually consumes a lot of memory. By using __slots__, we can reduce the memory usage, especially when dealing with a large number of instances.

Example:

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

This technique is particularly useful in memory-intensive applications like data processing, simulation, or game development.

Optimizing Costly Function Calls with functools.lru_cache

functools.lru_cache is a powerful decorator that stores the outputs of functions, allowing for quick retrieval when the same arguments are used again, rather than recalculating. This can significantly boost performance, ideal for functions requiring heavy computation or involve time-consuming operations like database queries.

Example:

from functools import lru_cache
import time
@lru_cache(maxsize=128)
def slow_function(x):
    time.sleep(2)
    return x * x
print(slow_function(4))  # Output: 16
print(slow_function(4))  # Output: 16

Key takeaways include performance improvement through avoiding redundant computations, customizable cache size, and transparent behavior of the cached functions.

Recursive Function Example

The lru_cache can be particularly beneficial for optimizing recursive algorithms, caching database query results, or reducing the overhead of expensive I/O-bound operations.

Example:

from functools import lru_cache
@lru_cache(maxsize=None)  # Unlimited cache size
def fibonacci(n):
    # Fibonacci calculation logic