How can I implement LFU caching in Python?

How can I implement LFU caching in Python?

To implement LFU (Least Frequently Used) caching in Python, you can use a combination of a dictionary and a priority queue. Would you like a code example?

Yes, please provide a code example.

Here's a simple LFU cache implementation:

class LFUCache:
    def __init__(self, capacity: int):
        self.capacity = capacity
        self.cache = {}  # key -> (value, frequency)
        self.freq = {}   # frequency -> keys
        self.min_freq = 0

    def get(self, key: int) -> int:
        if key not in self.cache:
            return -1
        value, freq = self.cache[key]
        self.cache[key] = (value, freq + 1)
        self.freq[freq].remove(key)
        if not self.freq[freq]:
            del self.freq[freq]
            if self.min_freq == freq:
                self.min_freq += 1
        self.freq.setdefault(freq + 1, []).append(key)
        return value

    def put(self, key: int, value: int) -> None:
        if self.capacity <= 0:
            return
        if key in self.cache:
            self.cache[key] = (value, self.cache[key][1])
            self.get(key)  # Update frequency
            return
        if len(self.cache) >= self.capacity:
            lfu_key = self.freq[self.min_freq][0]
            del self.cache[lfu_key]
            self.freq[self.min_freq].pop(0)
            if not self.freq[self.min_freq]:
                del self.freq[self.min_freq]
        self.cache[key] = (value, 1)
        self.freq.setdefault(1, []).append(key)
        self.min_freq = 1

What are the advantages of using LFU caching?

LFU caching is beneficial because it efficiently manages memory by keeping frequently accessed items, reducing cache misses, and improving performance for read-heavy workloads.