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

Действие декоратора можно сравнить с тем, как устроены промежуточные слои в любом веб-сервисе. Между клиентом и обработчиком запроса стоит цепочка прослоек — одна проверяет токен авторизации, другая записывает запрос в лог, третья сжимает ответ. Сам обработчик об этих слоях ничего не знает и не менялся. Декоратор в Python устроен так же: он оборачивает функцию, выполняет свой код до или после вызова и возвращает результат.
Как функции устроены в Python
Чтобы понять, как работают декораторы Python, нужно знать одну особенность языка: функции здесь — такие же объекты, как числа или строки. Это значит, что с ними можно делать три важных вещи.
Сохранять в переменную. Функция в Python — объект первого класса, поэтому ее можно присвоить другому имени и вызвать через него:
def get_discount(price):
return price * 0.1
# Присваиваем функцию другой переменной
calculate = get_discount
print(calculate(1000)) # 100.0
Передавать как аргумент другой функции. Это называется функция высшего порядка — именно на этом принципе построены декораторы:
def apply_to_order(func, amount):
"""Применяет переданную функцию к сумме заказа"""
return func(amount)
result = apply_to_order(get_discount, 5000)
print(result) # 500.0
Определять внутри другой функции. Вложенная функция запоминает переменные внешней — это называется замыкание:
def make_discount(percent):
def discount(price):
return price * percent / 100
return discount
vip_discount = make_discount(20)
print(vip_discount(3000)) # 600.0
vip_discount «помнит» значение percent = 20, хотя make_discount уже завершилась. Именно на замыканиях построены декораторы.

Как работает декоратор и синтаксис @
Например, вы хотите видеть в консоли, какие функции API вызываются и что возвращают.
Напишем для этого декоратор log_call:
def log_call(func):
def wrapper(*args, **kwargs):
print(f"Вызов: {func.__name__}")
result = func(*args, **kwargs)
print(f"Результат: {result}")
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() срабатывает он.

Что делает символ @ в 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):
print(f"→ {func.__name__}({args})")
result = func(*args, **kwargs)
print(f"← вернул {result!r}")
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
print(f"{func.__name__}: {elapsed:.4f} сек")
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
print(f"Попытка {attempt}: {e}")
time.sleep(delay)
return wrapper
return decorator
@retry(max_attempts=3, delay=2)
def send_notification(user_id, message):
"""Отправляет уведомление пользователю"""
print(f"Уведомление для {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}
print(get_order.__name__) # wrapper — а не get_order!
При отладке вместо 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}])
print(order.total) # 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
print(f"{self.func.__name__}: вызов #{self.count}")
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 сохраняет метаданные.













