Декораторы в Python: Руководство и примеры использования

Декораторы в Python: Руководство и примеры использования

Марк Игнатьев
Автор / Редактор
166
Содержание показать

1 Способ: Декораторы как функции

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

Введение в декораторы

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

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

Чтобы создать декоратор, вам нужно определить функцию, которая принимает в качестве аргумента другую функцию. Внутри этой функции вы можете определить новую функцию, которая будет оберткой для исходной функции. Затем вам нужно вернуть эту обертку в качестве результата.

Вот пример простого декоратора, который добавляет логирование перед выполнением функции:

def log_decorator(func):
    def wrapper(*args, **kwargs):
        print(f"Вызов функции: {func.__name__}")
        result = func(*args, **kwargs)
        print(f"Функция {func.__name__} выполнена")
        return result
    return wrapper

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

Логирование

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

@log_decorator
def calculate_sum(a, b):
    result = a + b
    return result

Теперь каждый раз, когда мы вызываем функцию calculate_sum, она будет автоматически логировать информацию о вызове и выполнении.

Замер времени выполнения

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

import time

def time_decorator(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} секунды")
        return result
    return wrapper

@time_decorator
def calculate_factorial(n):
    result = 1
    for i in range(1, n+1):
        result *= i
    return result

Теперь мы можем вызвать функцию calculate_factorial и она автоматически выведет время, затраченное на ее выполнение.

Кэширование

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

def cache_decorator(func):
    cache = {}
    def wrapper(*args):
        if args in cache:
            return cache[args]
        result = func(*args)
        cache[args] = result
        return result
    return wrapper

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

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

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

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

def log_decorator(separator='-'):
    def decorator(func):
        def wrapper(*args, **kwargs):
            print(separator * 20)
            print(f"Вызов функции: {func.__name__}")
            result = func(*args, **kwargs)
            print(f"Функция {func.__name__} выполнена")
            print(separator * 20)
            return result
        return wrapper
    return decorator

Теперь мы можем использовать наш декоратор в следующем формате: @log_decorator(separator='*'). Это позволяет нам передавать аргументы в декоратор и настраивать его поведение.

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

2 Способ: Декораторы в виде классов

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

Классы как декораторы

Определение декоратора в виде класса требует наличия методов __init__ и __call__. Метод __init__ выполняется при создании экземпляра класса и позволяет настроить его параметры. Метод __call__ вызывается при попытке вызвать экземпляр класса, то есть когда мы пытаемся “вызвать” декорированную функцию.

Читайте так же  Как определить четное или нечетное число в Python

Создание классовых декораторов

Давайте рассмотрим создание простого классового декоратора. Ниже приведен пример класса LogDecorator, который выполняет логирование перед и после вызова функции:

class LogDecorator:
    def __init__(self, func):
        self.func = func

    def __call__(self, *args, **kwargs):
        print(f"Вызов функции: {self.func.__name__}")
        result = self.func(*args, **kwargs)
        print(f"Функция {self.func.__name__} выполнена")
        return result

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

@LogDecorator
def calculate_sum(a, b):
    result = a + b
    return result

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

Практические примеры использования классовых декораторов

Валидация входных данных

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

class ValidateDecorator:
    def __init__(self, func):
        self.func = func

    def __call__(self, *args, **kwargs):
        for arg in args:
            if not isinstance(arg, (int, float)):
                raise TypeError("Аргументы должны быть числами")
        return self.func(*args, **kwargs)

Теперь мы можем применить этот декоратор к функции, чтобы автоматически выполнять проверку перед ее выполнением:

@ValidateDecorator
def calculate_product(a, b):
    result = a * b
    return result

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

Классовые декораторы также позволяют нам передавать аргументы и настраивать их поведение. Вот пример декоратора TimeDecorator, который принимает в качестве аргумента максимальное время выполнения:

import time

class TimeDecorator:
    def __init__(self, max_time):
        self.max_time = max_time

    def __call__(self, func):
        def wrapper(*args, **kwargs):
            start_time = time.time()
            result = func(*args, **kwargs)
            end_time = time.time()
            execution_time = end_time - start_time
            if execution_time > self.max_time:
                print("Время выполнения функции превысило максимальное значение")
            return result
        return wrapper

Теперь мы можем создать экземпляр класса TimeDecorator с определенным максимальным временем и применить его к функции:

@TimeDecorator(max_time=1)
def calculate_square(n):
    result = n ** 2
    return result

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

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

3 Способ: Использование встроенных декораторов

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

Обзор встроенных декораторов в Python

Python предоставляет несколько полезных встроенных декораторов, которые облегчают написание кода. Некоторые из них включают:

  • @property: декоратор, позволяющий управлять доступом к атрибутам классов
  • @staticmethod и @classmethod: декораторы, используемые для работы с методами класса
  • @lru_cache: декоратор, предоставляющий механизм кэширования результатов функций

@property: декоратор для управления доступом к атрибутам

Декоратор @property позволяет определить методы доступа (геттер и сеттер) к атрибуту класса. Вот пример:

class Circle:
    def __init__(self, radius):
        self._radius = radius

    @property
    def radius(self):
        return self._radius

    @radius.setter
    def radius(self, value):
        if value > 0:
            self._radius = value
        else:
            raise ValueError("Радиус должен быть положительным числом")

Теперь мы можем обращаться к атрибуту radius объекта Circle как к обычной переменной. Использование @property позволяет нам контролировать и валидировать доступ к этому атрибуту.

@staticmethod и @classmethod: декораторы для работы с методами класса

Декораторы @staticmethod и @classmethod позволяют работать с методами класса. @staticmethod представляет статический метод, который не требует доступа к атрибутам объекта или класса. @classmethod представляет метод класса, который имеет доступ к атрибутам класса.

Вот пример использования @staticmethod и @classmethod:

class MathUtils:
    @staticmethod
    def multiply(a, b):
        return a * b

    @classmethod
    def add(cls, a, b):
        return cls.multiply(a, b) + cls.multiply(a, b)

Мы можем вызывать статический метод MathUtils.multiply без создания экземпляра класса MathUtils. Метод класса MathUtils.add имеет доступ к статическому методу multiply и выполняет вычисления на основе него.

@lru_cache: декоратор для кэширования результатов функций

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

Вот пример использования @lru_cache:

from functools import lru_cache

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

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

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

4 Способ: Декораторы на уровне класса и методов

Декораторы можно применять не только к функциям, но и к классам и их методам. В этом разделе мы рассмотрим использование декораторов на уровне класса и методов, а также предоставим вам примеры их применения.

Декораторы для классов

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

Вот простой пример декоратора LogAttributes, который позволяет вывести все атрибуты класса при его определении:

def LogAttributes(cls):
    print(f"Атрибуты класса {cls.__name__}:")
    for attribute_name, _ in cls.__dict__.items():
        print(attribute_name)
    return cls

@LogAttributes
class MyClass:
    attribute1 = 1
    attribute2 = 2

В результате выполнения этого кода мы увидим вывод всех атрибутов класса MyClass.

Декораторы для методов класса

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

Читайте так же  Python и веб-скрейпинг: сбор данных с интернет-страниц

Вот пример декоратора LogExecutionTime, который замеряет время выполнения метода класса:

import time

def LogExecutionTime(method):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = method(*args, **kwargs)
        end_time = time.time()
        execution_time = end_time - start_time
        print(f"Время выполнения метода {method.__name__}: {execution_time:.2f} секунды")
        return result
    return wrapper

class MathUtils:
    @LogExecutionTime
    def calculate_sum(self, a, b):
        result = a + b
        return result

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

Практические примеры использования декораторов на уровне класса и методов

Авторизация и аутентификация

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

def AuthenticationRequired(method):
    def wrapper(self, *args, **kwargs):
        if self.isAuthenticated():
            return method(self, *args, **kwargs)
        else:
            raise PermissionError("Необходима аутентификация для выполнения этого метода")
    return wrapper

Теперь мы можем применить этот декоратор к методам, требующим аутентификацию:

class BankAccount:
    def __init__(self, balance):
        self.__balance = balance
        self.__authenticated = False

    def isAuthenticated(self):
        return self.__authenticated

    def authenticate(self):
        # логика аутентификации

    @AuthenticationRequired
    def withdraw(self, amount):
        # логика снятия денег со счета

Теперь при попытке выполнить метод withdraw без аутентификации будет возбуждено исключение PermissionError.

Кэширование результатов методов

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

def Memoize(method):
    cache = {}

    def wrapper(self, *args, **kwargs):
        key = (method, args, frozenset(kwargs.items()))
        if key not in cache:
            cache[key] = method(self, *args, **kwargs)
        return cache[key]

    return wrapper

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

class Fibonaccis:
    @Memoize
    def fibonacci(self, n):
        if n <= 1:
            return n
        return self.fibonacci(n - 1) + self.fibonacci(n - 2)

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

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

5 Способ: Использование сторонних библиотек с декораторами

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

Популярные библиотеки с декораторами

Библиотека Описание
Flask Микрофреймворк для создания веб-приложений. Включает декораторы для определения маршрутов и других функций.
Django Полноценный фреймворк для создания веб-приложений. Использует декораторы для определения представлений (views) и других функций.
SQLAlchemy Библиотека для работы с базами данных. Предоставляет декораторы для создания и управления моделями данных.
Pytest Библиотека для написания и запуска тестов. Использует декораторы для определения тестовых функций.
Celery Распределенная система выполнения задач. Использует декораторы для определения задач и обработчиков.
Twisted Фреймворк для разработки сетевых приложений. Использует декораторы для определения обработчиков событий и протоколов.

Примеры использования сторонних декораторов

Flask

Flask – популярный микрофреймворк для создания веб-приложений на Python. Он предоставляет множество встроенных декораторов для определения маршрутов, авторизации, логирования и других функций. Ниже приведен пример использования декоратора @app.route для определения маршрута:

from flask import Flask

app = Flask(__name__)

@app.route("/")
def home():
    return "Добро пожаловать на главную страницу"

@app.route("/user/<username>")
def user_profile(username):
    return f"Профиль пользователя {username}"

В этом примере декоратор @app.route определяет URL-путь и связывает его с соответствующей функцией-обработчиком.

Pytest

Pytest – гибкая и простая в использовании библиотека для написания и запуска тестов на Python. Она предоставляет различные декораторы для определения тестов, параметризации и других функций. Вот пример использования декоратора @pytest.mark.parametrize для параметризации тестов:

import pytest

def sum(a, b):
    return a + b

@pytest.mark.parametrize("a, b, expected", [
    (1, 2, 3),
    (5, 5, 10),
    (-1, 1, 0)
])
def test_sum(a, b, expected):
    assert sum(a, b) == expected

В этом примере декоратор @pytest.mark.parametrize позволяет определить набор тестовых данных и ожидаемые результаты для функции test_sum.

SQLAlchemy

SQLAlchemy – мощная библиотека для работы с базами данных на Python. Она предоставляет декораторы и другие инструменты для создания и управления моделями данных. Вот пример использования декоратора @sqlalchemy.orm.relation для определения отношения в базе данных:

from sqlalchemy import Column, Integer, String, ForeignKey
from sqlalchemy.orm import relationship

class User(Base):
    __tablename__ = "users"

    id = Column(Integer, primary_key=True)
    name = Column(String)
    posts = relationship("Post", back_populates="user")

class Post(Base):
    __tablename__ = "posts"

    id = Column(Integer, primary_key=True)
    title = Column(String)
    user_id = Column(Integer, ForeignKey("users.id"))
    user = relationship("User", back_populates="posts")

В этом примере декоратор @sqlalchemy.orm.relation определяет отношение “один-ко-многим” между моделями User и Post.

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

6 Способ: Декораторы и аспектно-ориентированное программирование (АОП)

Аспектно-ориентированное программирование (АОП) – это парадигма программирования, которая позволяет разделять основную логику программы и дополнительные аспекты, такие как логирование, аутентификация, транзакции и другие перекрывающие аспекты. Декораторы в Python позволяют реализовать принципы АОП и облегчить модулярность и повторное использование кода. В этом разделе мы рассмотрим использование декораторов в контексте АОП и предоставим примеры их применения.

Читайте так же  Обнаружение последнего элемента в списке с использованием цикла for в Python

Введение в аспектно-ориентированное программирование

АОП предлагает способ выделить логические аспекты, которые перекрывают или дополняют базовую функциональность программы. Эти аспекты могут включать в себя логирование, отладку, безопасность, кэширование и другие функции, которые не относятся непосредственно к ключевым возможностям программы. АОП позволяет легко добавлять и управлять такими аспектами без изменения основного кода.

Как использовать декораторы для реализации АОП

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

  1. Определите декоратор, который реализует нужный аспект, такой как логирование или управление транзакцией.
  2. Примените этот декоратор к функциям или методам, где требуется включить дополнительную функциональность.

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

Примеры применения АОП с помощью декораторов

Логирование

Логирование – распространенный аспект, который требуется во многих приложениях. Мы можем создать декоратор @log, который будет автоматически регистрировать вызовы декорированных функций и методов:

import logging

def log(func):
    def wrapper(*args, **kwargs):
        logging.info(f"Вызов функции {func.__name__}")
        return func(*args, **kwargs)
    return wrapper

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

@log
def calculate_sum(a, b):
    return a + b

Транзакции

Управление транзакциями – еще один распространенный аспект в приложениях, работающих с базами данных. Мы можем создать декоратор @transaction, который будет автоматически обрамлять выполнение декорированных методов в транзакции:

import functools

def transaction(method):
    @functools.wraps(method)
    def wrapper(self, *args, **kwargs):
        begin_transaction()
        result = method(self, *args, **kwargs)
        commit_transaction()
        return result
    return wrapper

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

class BankAccount:
    @transaction
    def withdraw(self, amount):
        # логика снятия денег со счета

Аутентификация

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

def authentication_required(method):
    @functools.wraps(method)
    def wrapper(self, *args, **kwargs):
        if is_authenticated():
            return method(self, *args, **kwargs)
        else:
            raise PermissionError("Необходима аутентификация для выполнения этого метода")
    return wrapper

Теперь мы можем применять этот декоратор к методам, чтобы автоматически проверять аутентификацию пользователя:

class BankAccount:
    @authentication_required
    def withdraw(self, amount):
        # логика снятия денег со счета

В этом разделе мы рассмотрели использование декораторов для реализации принципов АОП. Декораторы позволяют легко добавлять дополнительную функциональность и конкретные аспекты к функциям и методам без необходимости изменения основного кода. Это позволяет достичь модульности и повторного использования кода в различных контекстах.

7 Способ: Создание собственных декораторов

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

Руководство по созданию пользовательских декораторов

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

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

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

@my_decorator
def my_function():
    # Логика функции
    pass

@my_decorator
class MyClass:
    # Логика класса
    pass

Часто используемые паттерны и подходы при написании пользовательских декораторов

При создании пользовательских декораторов существует несколько часто используемых паттернов и подходов:

  • Декораторы с аргументами: Вы можете расширить возможности декораторов, позволив им принимать аргументы. Например, для создания декоратора, который пропускает функцию, если переданный аргумент не соответствует условию:
def conditional_decorator(condition):
    def decorator(func):
        def wrapper(*args, **kwargs):
            if condition:
                return func(*args, **kwargs)
        return wrapper
    return decorator
  • Декораторы классов: Декораторы также могут быть применены к классам для модификации их поведения или атрибутов. Например, для создания декоратора, который добавляет новый метод класса:
def add_method(method):
    def decorator(cls):
        setattr(cls, method.__name__, method)
        return cls
    return decorator
  • Декораторы с аргументами класса: Вы можете создавать декораторы, которые принимают аргументы на уровне класса, а не только на уровне метода или функции. Например, для создания декоратора, который добавляет статический атрибут к классу:
def add_static_attribute(attribute, value):
    def decorator(cls):
        setattr(cls, attribute, value)
        return cls
    return decorator
  • Декораторы, основанные на классах: Вместо определения декоратора как функции, вы можете определить его как класс с методом __call__. Это дает вам большую гибкость при создании декораторов, так как вы можете использовать состояние объекта класса. Например, для создания декоратора, который считает количество вызовов функции:
class CountCalls:
    def __init__(self, func):
        self.func = func
        self.calls = 0

    def __call__(self, *args, **kwargs):
        self.calls += 1
        return self.func(*args, **kwargs)

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