Enrol to start learning
Reading is open to everyone. Enrolling is free, and it is what unlocks the audio lessons, practice tests and progress tracking.
6.4.2. lru_cache
Interactive Audio Lesson
Unlock the classroom podcast
The transcript is above and free to read. A free account plays the conversation back.
Create a free account
Today, we're going to learn about lru_cache, a wonderful decorator in Python. Can someone guess what caching means?
Is it about storing things to use later? Like saving images?
Exactly! Just like images can be cached, lru_cache saves the results of function calls. Why do you think this might be useful?
Because it can save time if you're calling the same function repeatedly!
Right! This is especially handy with recursive functions like calculating Fibonacci numbers. Have you all heard of this sequence?
Yes! Each number is the sum of the two preceding ones!
Correct! Let's look at how we can use lru_cache while calculating Fibonacci numbers.
Does it help with the speed a lot?
It does! Let's explore an example next time. Just remember, lru stands for Least Recently Used, which is how the cache decides what to keep.
Unlock the classroom podcast
The transcript is above and free to read. A free account plays the conversation back.
Create a free account
Here’s a code snippet where we utilize lru_cache. Can someone read this code?
Sure! It defines a function 'fib' that recursively calculates Fibonacci numbers.
Great! Notice how @lru_cache(maxsize=None) is placed before the function. Can someone explain what happens if we call fib(30)?
It calculates the 30th Fibonacci but uses previously cached results, so it runs faster, right?
Exactly! By reusing results from the cache, we avoid recalculating for the same inputs. What’s the output if you run this?
I think it should be 832040!
Correct! Who wants to try modifying the maxsize?
What happens if we set it to a small number?
Good question! If the cache exceeds that size, the oldest cached entries would be discarded. Let's see that in action next session!
Overview
Short Summary
The lru_cache is a decorator in Python's functools module that enhances function performance by caching results for reuse.
Medium Summary
In this section, we learn about the lru_cache decorator from the functools module which allows caching of function results. By storing results of expensive function calls, subsequent calls with the same parameters will utilize the cached result, improving performance significantly. The maxsize parameter controls the cache size.
Detailed Summary
Detailed Summary of lru_cache
The lru_cache decorator from Python's functools module is a powerful tool for optimization, especially in functions that are computationally expensive. The term 'LRU' stands for 'Least Recently Used', which indicates how the cache maintains its size. When the cache reaches its maximum size, the least recently accessed items are purged to make room for new entries. This behavior makes it useful for recursive functions like calculating Fibonacci numbers, where many calls with the same parameters occur.
Key Features of lru_cache:
- Caching Capability: It stores results of expensive function calls and returns the cached result when the same inputs occur again.
- Performance Improvement: Highly beneficial in scenarios of repeated function calls, leading to reduced computation time.
- Customizable Cache Size: You can specify
maxsizeto control how many results to store in the cache. Settingmaxsize=Noneallows unlimited storage but may increase memory usage.
Usage Example:
from functools import lru_cache
@lru_cache(maxsize=None)
def fib(n):
if n < 2:
return n
return fib(n-1) + fib(n-2)
print(fib(30)) # Output: 832040In this example, the fib function computes Fibonacci numbers efficiently using lru_cache, showcasing the decorator's utility in handling recursion and improving performance.
Audio Book
Unlock the audio lesson
The script is above and free to read. A free account plays it back, in the voice you pick.
Create a free accountCaches the results of a function to improve performance.
Detailed Explanation
The lru_cache is a tool provided by the functools module in Python. It is used to store the results of expensive function calls, so that if the function is called again with the same arguments, the stored result can be returned immediately instead of recalculating it. This can greatly enhance performance, especially in recursive functions or functions that are called frequently with the same parameters.
Examples & Analogies
Think of lru_cache like a library where once you borrow a book, the next time you want to read it, instead of ordering it from the publisher again (which takes time), the librarian quickly hands you the same book from the shelf. This saves time and resources, just as lru_cache saves computation time by reusing previous results.
Unlock the audio lesson
The script is above and free to read. A free account plays it back, in the voice you pick.
Create a free accountfrom functools import lru_cache
@lru_cache(maxsize=None)
def fib(n):
if n < 2:
return n
return fib(n-1) + fib(n-2)
print(fib(30))Detailed Explanation
Here, we see a practical application of lru_cache with a function that calculates Fibonacci numbers. The @lru_cache(maxsize=None) decorator is placed above the fib function. This means whenever fib() is called with a specific value of n, if that value has been calculated before, the cached value is returned instead of computing it again. Therefore, for fib(30), lru_cache speeds up the process using previously computed results, making it much faster than a naive implementation.
Examples & Analogies
Imagine if you were solving a complex math problem for the second time. Instead of recalculating everything from scratch, you could simply refer to the solution you found earlier. This is what lru_cache does: it keeps track of previously computed solutions to save on time and effort.
--
Key Concepts
Core takeaways and short definitions to help you quickly recall the key ideas from this section.
lru_cache: A decorator that caches results of function calls to improve performance.
maxsize: An attribute of lru_cache that controls how many results can be stored.
Fibonacci Function: A common example used to illustrate the benefits of caching.
Examples
Step-by-step examples to apply the section's ideas and test your understanding.
Using lru_cache to speed up Fibonacci calculations: Writing a recursive Fibonacci function with lru_cache decorator significantly reduces execution time.
Caching expensive function results: An example of determining prime numbers where previously computed results are reused.
Memory Aids
Interactive tools to help you remember key concepts