How can I implement an LRU cache in Python?

How can I implement an LRU cache in Python?

You can use a dictionary to store the cache and a doubly linked list to maintain the order of usage. Would you like a code example?

Yes, please provide a code example.

Here's a simple implementation:

class Node:
    def __init__(self, key, value):
        self.key = key
        self.value = value
        self.prev = None
        self.next = None

class LRUCache:
    def __init__(self, capacity: int):
        self.capacity = capacity
        self.cache = {}  # key -> Node
        self.head = Node(0, 0)
        self.tail = Node(0, 0)
        self.head.next = self.tail
        self.tail.prev = self.head

    def _remove(self, node):
        prev, nxt = node.prev, node.next
        prev.next, nxt.prev = nxt, prev

    def _add(self, node):
        prev = self.tail.prev
        prev.next = node
        node.prev = prev
        node.next = self.tail
        self.tail.prev = node

    def get(self, key: int) -> int:
        if key in self.cache:
            node = self.cache[key]
            self._remove(node)
            self._add(node)
            return node.value
        return -1

    def put(self, key: int, value: int) -> None:
        if key in self.cache:
            self._remove(self.cache[key])
        node = Node(key, value)
        self.cache[key] = node
        self._add(node)
        if len(self.cache) > self.capacity:
            lru = self.head.next
            self._remove(lru)
            del self.cache[lru.key]

Can you explain how this code works?

Sure! The LRUCache class maintains a fixed capacity. It uses a dictionary for fast access and a doubly linked list to track the order of usage. When you access or add an item, it's moved to the end of the list. If the cache exceeds capacity, the least recently used item (the head's next node) is removed.