How can I implement an LFU cache in Python?

How can I implement an LFU cache in Python?

To implement an LFU (Least Frequently Used) cache 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 implementation:

from collections import defaultdict, OrderedDict

class LFUCache:
    def __init__(self, capacity: int):
        self.capacity = capacity
        self.min_freq = 0
        self.freq_map = defaultdict(OrderedDict)
        self.key_map = {}

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

    def put(self, key: int, value: int) -> None:
        if self.capacity <= 0:
            return
        if key in self.key_map:
            self.key_map[key] = (value, self.key_map[key][1])
            self.get(key)  # Update frequency
            return
        if len(self.key_map) >= self.capacity:
            lfu_key, _ = self.freq_map[self.min_freq].popitem(last=False)
            del self.key_map[lfu_key]
        self.key_map[key] = (value, 1)
        self.freq_map[1][key] = value
        self.min_freq = 1

What are the key features of this LFU cache implementation?

The key features include:

1. Capacity Management: It maintains a fixed capacity and evicts the least frequently used item when full.
2. Frequency Tracking: It uses a frequency map to track how often each key is accessed.
3. Efficient Access: Both get and put operations are efficient, typically O(1) time complexity.