Перейти на PRO

Какие существуют способы реализации lazy loading (ленивой загрузки) в Python?

Тип вопроса: Паттерны Вероятность: 10% Категория: Python Разработчик

Ответ

Lazy loading (ленивая загрузка) — это паттерн, при котором инициализация объекта откладывается до момента первого обращения к нему. Это оптимизирует производительность и экономит память, особенно при работе с ресурсоемкими объектами.

В Python его можно реализовать несколькими способами:

  1. С помощью декоратора @property Самый распространенный подход. Значение вычисляется только при первом доступе к свойству и затем кэшируется в приватном атрибуте объекта.

    class DataProcessor:
    def __init__(self, source_file):
        self._source_file = source_file
        self._heavy_data = None

    @property
    def heavy_data(self):
        if self._heavy_data is None:
            print(f"Loading data from {self._source_file}...")
            # Здесь происходит ресурсоемкая операция
            self._heavy_data = [i for i in range(10**6)]
        return self._heavy_data

processor = DataProcessor("my_file.csv")
# 'heavy_data' еще не загружены
print(len(processor.heavy_data)) # Произойдет загрузка
print(len(processor.heavy_data)) # Используется кэшированное значение

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

    class LazyLoader:
    def __init__(self, data_loader_func):
        self._data_loader_func = data_loader_func
        self._loaded_object = None

    def __getattr__(self, name):
        if self._loaded_object is None:
            print("Initializing object...")
            self._loaded_object = self._data_loader_func()
        return getattr(self._loaded_object, name)

# Пример: ленивая загрузка объекта list
lazy_list = LazyLoader(lambda: [1, 2, 3])
lazy_list.append(4) # Объект будет создан здесь
print(lazy_list._loaded_object) # [1, 2, 3, 4]

  3. Использование генераторов Генераторы по своей природе ленивы — они вычисляют следующее значение в последовательности только по запросу (например, в цикле for или через next()), не храня все значения в памяти.

    # Эта функция не создает список сразу
def lazy_range(n):
    print("Generator started")
    i = 0
    while i < n:
        yield i
        i += 1

# Значения вычисляются по одному при итерации
for num in lazy_range(5):
    print(num)

  4. Готовые решения в библиотеках Многие фреймворки предоставляют готовые реализации. Например, cached_property в Django и Werkzeug (библиотека Flask) работает аналогично примеру с декоратором, но является более надежным и протестированным решением.

Ответ 18+ 🔞

А, ленивая загрузка, говоришь? Ну это ж, блядь, классика, как Герасим с Муму! Смысл в чём, ёпта? Не грузить всё сразу, как дурак, а тянуть из закромов только когда реально приперло. Как будто тебе нахуй не срочно, а потом — ой, бля, надо!

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

Первый способ — через @property, хитрая жопа. Ты делаешь вид, что у тебя есть крутое свойство, а на самом деле там пусто, блядь, None. Но как только кто-то к нему лезет — бац! — оно само себя инициализирует и больше уже не парится. Чистая магия, в рот меня чих-пых!

class DataProcessor:
    def __init__(self, source_file):
        self._source_file = source_file
        self._heavy_data = None  # Пока нихуя нет, расслабься

    @property
    def heavy_data(self):
        if self._heavy_data is None:  # Ага, первый раз наступили!
            print(f"Loading data from {self._source_file}...")
            # Тут какая-нибудь ебучяя операция, которая полдня грузится
            self._heavy_data = [i for i in range(10**6)]
        return self._heavy_data  # А дальше уже по накатанной

processor = DataProcessor("my_file.csv")
# Тут ещё тишина, птички поют, 'heavy_data' не трогали
print(len(processor.heavy_data)) # А тут — БАМ! — пошла загрузка, сука!
print(len(processor.heavy_data)) # А тут уже из кэша, как из печки, горяченькое.

Второй способ — __getattr__, вообще огонь. Это когда ты такой: «О, а у меня такого атрибута вроде нет... А щас будет!» Перехватываешь обращение к чёрту лысому и подсовываешь объект, который только что создал. Полный распиздяйский подход, но работает.

class LazyLoader:
    def __init__(self, data_loader_func):
        self._data_loader_func = data_loader_func
        self._loaded_object = None  # Опять пусто, как в твоей голове после пятницы

    def __getattr__(self, name):
        if self._loaded_object is None:  # Опа, кто-то полез!
            print("Initializing object...")
            self._loaded_object = self._data_loader_func()  # Ща родим
        return getattr(self._loaded_object, name)  # И отдадим, что просили

# Пример: ленивая загрузка объекта list
lazy_list = LazyLoader(lambda: [1, 2, 3])
lazy_list.append(4) # Объект, блядь, создастся прямо тут, на лету!
print(lazy_list._loaded_object) # [1, 2, 3, 4]

Третий — генераторы, они от природы ленивые, как твой кот. Они не пашут заранее, а выдают результат поштучно, когда их дёргают. Экономия памяти — овердохуища!

# Эта функция не создаёт список сразу, не дури
def lazy_range(n):
    print("Generator started")
    i = 0
    while i < n:
        yield i  # Держи, на, одно число, и не пизди
        i += 1

# Значения вычисляются по одному, когда в цикле просим
for num in lazy_range(5):
    print(num)

Ну и четвёртый — готовые решения, чтоб не изобретать велосипед. В Django или Flask есть cached_property — это тот же @property, но, блядь, с гарантиями и без костылей. Бери и пользуйся, не хуй голову морочить.

Короче, суть в чём: не грузи всё сразу, если не уверен, что пригодится. Как в жизни — зачем покупать целый торт, если ты, может, только кусочек съешь? Хотя... ладно, с тортом я погорячился, его всегда надо целиком. Но с кодом — точно так!

© ХакСобесов, 2026
support@hacksobesov.com