Обзор Python Декорирование функций с помощью собаки

В Python декораторы – это мощный инструмент для изменения поведения функций без изменения их исходного кода. Символ @, часто называемый «собакой», позволяет применять декораторы к функциям. Например, если вы хотите добавить логирование к функции, используйте декоратор @log. Это упрощает код и делает его более читаемым.

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

Используйте встроенные декораторы, такие как @staticmethod или @classmethod, для работы с методами классов. Они позволяют изменять поведение методов без изменения их реализации. Например, @staticmethod делает метод независимым от экземпляра класса, что полезно для утилитарных функций.

Декораторы также можно комбинировать. Например, примените @cache и @log к одной функции, чтобы кэшировать её результаты и логировать вызовы. Это делает код более гибким и функциональным. Убедитесь, что порядок декораторов соответствует вашим требованиям, так как они применяются сверху вниз.

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

Пример простого декоратора:

def my_decorator(func):
def wrapper():
print("До вызова функции")
func()
print("После вызова функции")
return wrapper
@my_decorator
def say_hello():
print("Привет!")
say_hello()

Декораторы часто применяются в веб-фреймворках, таких как Flask или Django, для управления маршрутами и проверкой аутентификации. Они упрощают поддержку кода и делают его более читаемым, разделяя логику на уровни.

Определение и принцип работы декораторов

Декораторы работают по принципу обёртки. Когда вы применяете декоратор к функции, он заменяет её на новую функцию, которая включает дополнительную логику. Например, декоратор может добавить логирование, проверку данных или измерение времени выполнения.

Рассмотрим пример:

python

def my_decorator(func):

def wrapper():

print(«Действие до вызова функции»)

func()

print(«Действие после вызова функции»)

return wrapper

@my_decorator

def say_hello():

print(«Привет!»)

say_hello()

При вызове say_hello() будет выведено:

Действие до вызова функции

Привет!

Действие после вызова функции

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

python

def repeat(num_times):

def decorator(func):

def wrapper(*args, **kwargs):

for _ in range(num_times):

func(*args, **kwargs)

return wrapper

return decorator

@repeat(3)

def greet(name):

print(f»Привет, {name}!»)

greet(«Анна»)

Результат выполнения:

Привет, Анна!

Привет, Анна!

Привет, Анна!

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

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

Основные виды декораторов

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

• Декораторы функций – используются для изменения поведения отдельных функций. Например, декоратор может добавлять логирование или проверку аргументов перед выполнением функции.
• Декораторы классов – применяются для изменения поведения целых классов. Они могут добавлять методы, изменять атрибуты или управлять созданием экземпляров.
• Декораторы с параметрами – позволяют передавать аргументы в сам декоратор. Это полезно, когда нужно настроить поведение декоратора в зависимости от внешних условий.
• Встроенные декораторы – Python предоставляет несколько встроенных декораторов, таких как @staticmethod, @classmethod и @property, которые упрощают работу с методами и атрибутами.

Для создания собственного декоратора функции используйте следующий шаблон:

def my_decorator(func):
def wrapper(*args, **kwargs):
# Дополнительные действия перед вызовом функции
result = func(*args, **kwargs)
# Дополнительные действия после вызова функции
return result
return wrapper
@my_decorator
def my_function():
print("Выполнение функции")

Декораторы классов создаются аналогично, но принимают класс вместо функции:

def my_class_decorator(cls):
# Изменение или добавление атрибутов класса
return cls
@my_class_decorator
class MyClass:
pass

Декораторы с параметрами требуют дополнительного уровня вложенности:

def decorator_with_args(param):
def actual_decorator(func):
def wrapper(*args, **kwargs):
# Использование параметра
print(f"Параметр: {param}")
return func(*args, **kwargs)
return wrapper
return actual_decorator
@decorator_with_args("example")
def my_function():
print("Выполнение функции")

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

Когда следует использовать декораторы?

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

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

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

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

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

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

Практическое применение декораторов в проектах

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

Применяйте декораторы для проверки прав доступа. Например, @admin_required может проверять, имеет ли пользователь права администратора перед выполнением функции. Это помогает защитить критически важные части приложения.

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

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

Создание простого декоратора

Создайте функцию, которая принимает другую функцию в качестве аргумента. Это основа декоратора. Например:

def my_decorator(func):
def wrapper():
print("Действие перед вызовом функции")
func()
print("Действие после вызова функции")
return wrapper

Примените декоратор к функции с помощью символа @:

@my_decorator
def say_hello():
print("Привет!")

Теперь при вызове say_hello() вы увидите:

Действие перед вызовом функции
Привет!
Действие после вызова функции

Чтобы декоратор работал с функциями, принимающими аргументы, используйте *args и **kwargs:

def my_decorator(func):
def wrapper(*args, **kwargs):
print("Действие перед вызовом функции")
func(*args, **kwargs)
print("Действие после вызова функции")
return wrapper

Пример использования:

@my_decorator
def greet(name):
print(f"Привет, {name}!")
greet("Анна")

Этот подход позволяет гибко расширять функциональность без изменения исходного кода.

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

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

Внутри декоратора создайте обёртку, которая зафиксирует время до вызова функции и после. Используйте time.time() для получения текущего времени в секундах. Разница между этими значениями покажет время выполнения.

Пример кода:

import time
def measure_time(func):
def wrapper(*args, **kwargs):
start_time = time.time()
result = func(*args, **kwargs)
end_time = time.time()
print(f"Функция {func.__name__} выполнилась за {end_time - start_time:.4f} секунд")
return result
return wrapper
@measure_time
def example_function():
time.sleep(2)
example_function()

Этот декоратор выведет время выполнения функции example_function. Вы можете применить его к любой функции, добавив @measure_time перед её определением.

Для более точного измерения используйте time.perf_counter(), который предоставляет высокоточные временные метки. Это особенно полезно для функций с коротким временем выполнения.

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

Использование декораторов для проверки прав доступа

Создайте декоратор, который проверяет права доступа пользователя перед выполнением функции. Например, для веб-приложения можно реализовать проверку роли пользователя. Определите функцию-декоратор, которая принимает список допустимых ролей и проверяет, соответствует ли текущий пользователь этим ролям.

Пример реализации:

def requires_roles(allowed_roles):
def decorator(func):
def wrapper(user, *args, **kwargs):
if user.role not in allowed_roles:
raise PermissionError("Доступ запрещен")
return func(user, *args, **kwargs)
return wrapper
return decorator

Примените декоратор к функции, которая требует определенных прав доступа. Например, функция для изменения настроек системы может быть доступна только администраторам:

@requires_roles(['admin'])
def update_system_settings(user, settings):
# Логика обновления настроек
pass

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

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