Как использовать lru cache в Python

[

Кеширование в Python с использованием стратегии LRU Cache

Изображение: Python Tricks Dictionary Merge

Caching - это техника оптимизации, которую вы можете использовать в своих приложениях, чтобы хранить в памяти недавно используемые или часто используемые данные. В Python есть декоратор @lru_cache из модуля functools, который позволяет вам кешировать результаты ваших функций с использованием стратегии Least Recently Used (LRU). Это простая, но мощная техника, которую вы можете использовать, чтобы использовать возможности кеширования в вашем коде.

Этот учебник объяснит следующее:

• Какие существуют кеш-стратегии и как их реализовать с помощью декораторов Python.
• Что такое стратегия LRU и как она работает.
• Как улучшить производительность с помощью декоратора @lru_cache.
• Как добавить функциональность к декоратору @lru_cache и сделать его автоматическое обновление через определенное время.

По окончании этого учебника вы получите глубокое понимание того, как работает кеширование и как использовать его в Python.

Кеширование и его применение

Кеширование - это техника оптимизации, которую вы можете использовать в своих приложениях, чтобы сохранять в памяти последние или часто используемые данные в более быстром и вычислительно дешевом доступе по сравнению с их источником.

Представьте, что вы создаете новостную ленту, которая получает последние новости из разных источников. Когда пользователь переходит по списку новостей, ваше приложение загружает статьи и отображает их на экране.

Что произойдет, если пользователь будет перемещаться вперед и назад между несколькими новостными статьями? Если бы вы не использовали кеширование, вашему приложению пришлось бы загружать содержимое каждый раз! Это замедлило бы работу системы пользователя и создало лишнюю нагрузку на сервер, хранящий статьи.

Более лучшим подходом будет сохранение содержимого локально после загрузки каждой статьи. Тогда, когда пользователь решит открыть статью снова, ваше приложение сможет открыть ее из локальной копии вместо повторного обращения к источнику. В компьютерной науке эту технику называют кеширование.

Реализация кеша с использованием словаря Python

Вы можете реализовать решение кеширования в Python с помощью словаря.

Оставаясь на примере новостной ленты, вместо того, чтобы обращаться к серверу каждый раз, когда вам нужно загрузить статью, вы можете проверить, есть ли у вас контент в вашем кеше, и обратиться к серверу только в том случае, если его нет. Вы можете использовать URL статьи в качестве ключа в словаре, а содержимое статьи в качестве значения. Если статья не найдена в кеше, вы можете загрузить ее, сохранить в кеш и затем отобразить на экране.

cache = {}

def get_article(url):
    if url in cache:
        return cache[url]
    else:
        article = download_from_server(url)
        cache[url] = article
        return article

Таким образом, при каждом обращении к новому URL вы будете сначала проверять наличие статьи в кеше и возвращать ее, если она там есть. В противном случае вы будете загружать статью с сервера, сохранять ее в кеш и отображать пользователю.

Таким образом, использование кеша позволяет уменьшить нагрузку на сервер, сделать приложение более отзывчивым и ускорить работу.

Использование декоратора @lru_cache для реализации LRU кеша в Python

Python предоставляет декоратор @lru_cache из модуля functools, который автоматически реализует LRU кеш для ваших функций.

from functools import lru_cache

@lru_cache
def fibonacci(n):
    if n <= 1:
        return n
    else:
        return fibonacci(n-1) + fibonacci(n-2)

Это пример функции, которая вычисляет число Фибоначчи. Декоратор @lru_cache автоматически кэширует значения функции и использует стратегию LRU для управления кешем значений.

Когда функция fibonacci вызывается в первый раз с определенным аргументом n, она вычисляет значение и сохраняет его в кеше. В следующий раз, когда функция будет вызвана с тем же аргументом n, она просто вернет кешированное значение, что позволяет избежать повторных вычислений и повышает производительность.

Добавление истечения срока действия кеша

Иногда бывает необходимо обновлять кеш и удалаять значения, которые давно не использовались или заняли слишком много места. Можно добавить функциональность истечения срока действия кеша с помощью декоратора и дополнительных проверок.

from datetime import datetime, timedelta
from functools import lru_cache

def expired(cache_entry):
    expiration_time = cache_entry['datetime'] + timedelta(minutes=10)
    return datetime.now() > expiration_time

def cache_func(func):
    @lru_cache
    def wrapper(*args, **kwargs):
        result = func(*args, **kwargs)
        cache_entry = {'result': result, 'datetime': datetime.now()}
        return cache_entry

    return wrapper

@cache_func
def fibonacci(n):
    if n <= 1:
        return n
    else:
        return fibonacci(n-1) + fibonacci(n-2)

# Применение проверки истечения срока действия

@cache_func
def get_article(url):
    if url in cache:
        cache_entry = cache[url]
        if not expired(cache_entry):
            return cache_entry['result']
    article = download_from_server(url)
    cache[url] = {'result': article, 'datetime': datetime.now()}
    return article

В этом примере мы использовали два декоратора: @lru_cache и @cache_func. Декоратор @cache_func добавляет дополнительный уровень абстракции истечения срока действия кеша.

Функция expired проверяет, истек ли срок действия элемента кеша. Если срок действия истек, мы удаляем элемент из кеша при следующем вызове функции.

if not expired(cache_entry):
    return cache_entry['result']

Таким образом, каждый раз, когда мы получаем содержимое статьи, мы проверяем, есть ли в кеше запись для этого URL и не истек ли ее срок действия. Если срок действия не истек и статья есть в кеше, мы просто возвращаем кешированное значение. В противном случае мы загружаем статью, помещаем новый элемент в кеш и возвращаем его значение.

Это позволяет управлять размером кеша и поддерживать актуальность данных.

Заключение

Кеширование - это мощный инструмент, который позволяет улучшить производительность ваших приложений, снизить нагрузку на сервер и увеличить отзывчивость системы пользователя. В Python вы можете использовать декоратор @lru_cache из модуля functools, который автоматически реализует стратегию LRU для кеша значений.

Кеширование может быть критически важным в задачах, где есть много дорогостоящих вычислений или повторяющихся операций. Это также полезно для сохранения данных из внешних источников, чтобы избежать повторных запросов и улучшить производительность вашего приложения.

Теперь, когда у вас есть понимание того, как работает кеширование и как использовать его в Python, вы можете применить это знание для своих проектов и сделать их быстрее и эффективнее.

Рекомендуемый видеокурс: Кеширование в Python с использованием @lru_cache