03 окт 2026
clock 7 минут

Декораторы в Python: что это и как применять

Python

В API типичного онлайн-сервиса — десятки функций: авторизация, обработка заказов, отправка уведомлений. К каждой нужно добавить логирование, проверку прав доступа, замер времени ответа. Копировать один и тот же блок в каждую функцию — путь к ошибкам и дублированию. Декораторы в Python решают эту задачу: одна строчка с символом @ добавляет функции новое поведение, не затрагивая ее код. Разберем, как они устроены и где применяются.

Что такое декоратор в Python

Декоратор в Python — это обертка, которая добавляет функции дополнительное поведение без изменения ее кода. Вы пишете функцию как обычно, а декоратор надстраивает над ней нужную логику: проверку доступа, запись в лог, замер скорости.

Схема работы декоратора в Python: декоратор выполняет дополнительную логику до и после вызова исходной функции и возвращает результат

Действие декоратора можно сравнить с тем, как устроены промежуточные слои в любом веб-сервисе. Между клиентом и обработчиком запроса стоит цепочка прослоек — одна проверяет токен авторизации, другая записывает запрос в лог, третья сжимает ответ. Сам обработчик об этих слоях ничего не знает и не менялся. Декоратор в Python устроен так же: он оборачивает функцию, выполняет свой код до или после вызова и возвращает результат.

Как функции устроены в Python

Чтобы понять, как работают декораторы Python, нужно знать одну особенность языка: функции здесь — такие же объекты, как числа или строки. Это значит, что с ними можно делать три важных вещи.

  1. Сохранять в переменную. Функция в Python — объект первого класса, поэтому ее можно присвоить другому имени и вызвать через него:

def get_discount(price):

    return price * 0.1

# Присваиваем функцию другой переменной

calculate = get_discount

  1. Передавать как аргумент другой функции. Это называется функция высшего порядка — именно на этом принципе построены декораторы:

def apply_to_order(func, amount):

    """Применяет переданную функцию к сумме заказа"""

    return func(amount)

result = apply_to_order(get_discount, 5000)

  1. Определять внутри другой функции. Вложенная функция запоминает переменные внешней — это называется замыкание:

def make_discount(percent):

    def discount(price):

        return price * percent / 100

    return discount

vip_discount = make_discount(20)

vip_discount «помнит» значение percent = 20, хотя make_discount уже завершилась. Именно на замыканиях построены декораторы.

Три способа работы с функциями в Python: сохранить функцию в переменную, передать как аргумент и вернуть из другой функции

Как работает декоратор и синтаксис @

Например, вы хотите видеть в консоли, какие функции API вызываются и что возвращают. 

Напишем для этого декоратор log_call:

def log_call(func):

    def wrapper(*args, **kwargs):

        result = func(*args, **kwargs)

        return result

    return wrapper

@log_call

def get_order(order_id):

    """Возвращает данные заказа по ID"""

    return {"id": order_id, "status": "delivered"}

get_order(42)

# Вызов: get_order

# Результат: {'id': 42, 'status': 'delivered'}

log_call создает внутри себя функцию wrapper, которая печатает имя вызова, запускает оригинал и печатает результат. Наружу возвращается wrapper — теперь при каждом вызове get_order() срабатывает он.

Запись с @log_call эквивалентна явному применению декоратора к функции get_order

Что делает символ @ в Python? Запись @log_call — это удобное сокращение, которое в Python называют синтаксическим сахаром. Суть простая: вместо длинной строки get_order = log_call(get_order) вы пишете одну строчку с @ — результат тот же, но код чище. 

Как написать свой декоратор

Простой декоратор-обертка

Разберемся, как написать свой декоратор в Python. 

Базовый шаблон выглядит так:

import functools

def my_decorator(func):

    @functools.wraps(func)

    def wrapper(*args, **kwargs):

        # Код до вызова

        result = func(*args, **kwargs)

        # Код после вызова

        return result

    return wrapper

Обертка wrapper принимает *args и **kwargs — это способ сказать Python: «принимай вообще любые аргументы». Не важно, сколько их и как они переданы — через запятую (42,"кофе") или по имени (status="paid"). Благодаря этому один и тот же декоратор подойдет к любой функции.

Декоратор для логирования

Допустим, в API вашего онлайн-сервиса нужно отслеживать, кто какие заказы создает. Вместо того чтобы добавлять print в каждую функцию, напишем декоратор:

import functools

def log(func):

    @functools.wraps(func)

    def wrapper(*args, **kwargs):

        result = func(*args, **kwargs)

        return result

    return wrapper


 

@log

def create_order(user_id, items):

    """Создает новый заказ"""

    return {"user": user_id, "items": items}


 

create_order(7, ["кофе", "круассан"])

# → create_order((7, ['кофе', 'круассан']))

# ← вернул {'user': 7, 'items': ['кофе', 'круассан']}


 

Декоратор для замера времени выполнения

Допустим, вы заметили, что API стал отвечать медленнее. Чтобы найти узкое место, нужно измерить время выполнения каждой функции. 

Вот как написать декоратор Python для этой задачи:

import functools

import time


 

def timer(func):

    @functools.wraps(func)

    def wrapper(*args, **kwargs):

        start = time.perf_counter()

        result = func(*args, **kwargs)

        elapsed = time.perf_counter() - start

        return result

    return wrapper


 

@timer

def process_payment(order_id):

    """Обрабатывает платеж"""

    time.sleep(0.5)  # Имитация запроса к платежной системе

    return {"order": order_id, "paid": True}

Декораторы с аргументами

Схема работы декоратора с аргументами: параметры создают декоратор, он формирует обертку и возвращает декорированную функцию

Бывают ситуации, когда декоратору нужно передать настройки. Например, при сбое внешнего API вы хотите повторить запрос — но сколько раз? Для разных функций это число может быть разным: для отправки уведомлений — 3 попытки, для платежей — 5.

Как декоратор принимает аргументы функции — через *args и **kwargs в обертке. А чтобы передать параметры самому декоратору, создают фабрику — функцию, которая принимает настройки и возвращает готовый декоратор:

import functools

import time

def retry(max_attempts=3, delay=1):

    """Повторяет вызов функции при ошибке"""

    def decorator(func):

        @functools.wraps(func)

        def wrapper(*args, **kwargs):

            for attempt in range(1, max_attempts + 1):

                try:

                    return func(*args, **kwargs)

                except Exception as e:

                    if attempt == max_attempts:

                        raise

                    time.sleep(delay)

        return wrapper

    return decorator


 

@retry(max_attempts=3, delay=2)

def send_notification(user_id, message):

    """Отправляет уведомление пользователю"""


 

Вызов @retry(max_attempts=3) сначала создает декоратор с нужными настройками, а затем применяет его к функции.

Сохранение метаданных функции с functools.wraps

После декорирования функция теряет свое имя и документацию — Python подменяет ее оберткой wrapper:

def simple_decorator(func):

    def wrapper(*args, **kwargs):

        return func(*args, **kwargs)

    return wrapper


 

@simple_decorator

def get_order(order_id):

    """Возвращает данные заказа"""

    return {"id": order_id}


 

При отладке вместо get_order вы увидите wrapper, а help() покажет пустоту вместо описания. Чем больше декораторов в проекте, тем сложнее разобраться, какая функция сломалась.

Как сохранить имя функции при декорировании? Добавьте @functools.wraps(func) к обертке. Functools.wraps перенесет имя, описание и сигнатуру из оригинальной функции в wrapper. После этого help() и отладчик покажут правильное имя, а не wrapper. 

В реальных проектах добавляйте functools.wraps в каждый декоратор — это упростит отладку и сэкономит время.

Встроенные декораторы Python: staticmethod, classmethod, property

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

 

Title: Встроенные декораторы Python

Alt: Сравнение встроенных декораторов Python

Что делает декоратор staticmethod в классе Python — создает метод, который не привязан ни к экземпляру, ни к классу. Он не получает self или cls и работает как обычная функция, просто размещенная внутри класса для логической группировки:

class OrderService:

    @staticmethod

    def validate_email(email):

        """Проверяет формат email"""

        return "@" in email and "." in email


 

OrderService.validate_email("ivan@example.com")  # True


 

Что делает декоратор classmethod — создает метод, который первым аргументом получает сам класс (cls). Это удобно, когда объект нужно создать не обычным способом через init, а, например, из словаря или JSON-ответа API:

class Order:

    def __init__(self, order_id, items):

        self.order_id = order_id

        self.items = items


 

    @classmethod

    def from_dict(cls, data):

        """Создает заказ из словаря"""

        return cls(data["id"], data["items"])


 

Декоратор property превращает метод класса в атрибут — к нему обращаются без скобок:

class Order:

    def __init__(self, items):

        self.items = items


 

    @property

    def total(self):

        return sum(item["price"] for item in self.items)


 

order = Order([{"name": "кофе", "price": 350}])

Декораторы на классах

Чем декоратор класса отличается от декоратора функции — он хранит состояние в атрибутах экземпляра через метод call. Это удобно, когда нужно отслеживать данные между вызовами:

import functools

class CountCalls:

    def __init__(self, func):

        functools.update_wrapper(self, func)

        self.func = func

        self.count = 0


 

    def __call__(self, *args, **kwargs):

        self.count += 1

        return self.func(*args, **kwargs)


 

@CountCalls

def process_payment(order_id):

    return {"order": order_id, "paid": True}


 

process_payment(1)  # process_payment: вызов #1

process_payment(2)  # process_payment: вызов #2

Где применяют декораторы на практике

Если вы работали с Flask, Django или FastAPI — вы уже использовали декораторы. @app.route("/orders") во Flask привязывает функцию к URL-адресу, @login_required в Django закрывает страницу от неавторизованных пользователей, а @app.get в FastAPI одновременно задает маршрут и валидацию входных данных. Фреймворки активно используют декораторы, потому что они позволяют добавить поведение одной строкой, не перегружая основной код.

В стандартной библиотеке Python тоже есть готовые декораторы. Один из самых полезных — @functools.lru_cache. Он запоминает результат функции для каждого набора аргументов и при повторном вызове возвращает его из кэша без повторного вычисления. Это удобно для тяжелых запросов к базе данных или сложных вычислений.

В собственных проектах декораторы чаще всего решают такие задачи:

Задача

Декоратор

Пример

Логирование

@log

Записать аргументы и результат вызова API

Кэширование

@functools.lru_cache

Сохранить результат запроса к базе

Контроль доступа

@require_auth

Проверить токен авторизации

Измерение времени

@timer

Отслеживать время ответа эндпоинтов

Повтор при ошибке

@retry

Повторить запрос при сбое внешнего API

Маршрутизация

@app.route

Привязать функцию к URL во Flask

Заключение

Декораторы отделяют служебную логику от основного кода. Вместо копирования проверок, логов и замеров в каждую функцию — одна строчка с @. Начните с простых оберток для логирования и замера времени, затем переходите к декораторам с аргументами и классам-декораторам.

Если вы хотите глубже разобраться в Python и научиться применять декораторы в реальных проектах, обратите внимание на курсы от ProductStar. Подробнее о программах и вариантах обучения — в каталоге курсов на сайте.

FAQ

Для чего нужны декораторы в Python?

Декораторы добавляют функциям поведение без изменения их кода: логирование, кэширование, проверку доступа, замер производительности. Один декоратор можно применить к десяткам функций вместо копирования блоков.

Как работает декоратор в Python?

Декоратор принимает функцию, создает обертку с дополнительной логикой и возвращает ее. При вызове срабатывает обертка, которая выполняет свой код и вызывает оригинал.

Какие встроенные декораторы есть в Python?

@staticmethod создает метод без привязки к экземпляру, @classmethod передает класс первым аргументом, @property превращает метод в атрибут, @functools.lru_cache кэширует результаты, @functools.wraps сохраняет метаданные.

Поделиться
star1

Вам может также понравиться

Tableau: обзор программы, возможности и принципы работы
Аналитика
Tableau: обзор программы, возможности и принципы работы
Kanban: полное руководство по методологии визуального управления проектами
Менеджмент
Kanban: полное руководство по методологии визуального управления проектами
Топ нейросетей для генерации схем, диаграмм и графиков
Разное
Топ нейросетей для генерации схем, диаграмм и графиков
Галлюцинации ИИ: что это такое и как с этим работать на практике
Галлюцинации ИИ: что это такое и как с этим работать на практике
star2

Курсы, которые выбирают чаще всего