Python decorator лучшая практика, используя класс против функции

Я в основном согласен с jsbueno: нет ни одного правильного пути. Это зависит от ситуации. Но я думаю, что def, вероятно, лучше в большинстве случаев, потому что если вы идете с классом, большая часть "реальной" работы будет выполнена в __call__ в любом случае. Кроме того, вызываемые объекты, которые не являются функциями, довольно редки (за заметным исключением создания экземпляра класса), и люди обычно не ожидают этого. Кроме того, локальные переменные обычно легче отслеживать по сравнению с переменными экземпляра, просто потому, что они имеют более ограниченную область применения, хотя в этом случае переменные экземпляра, вероятно, используются только в __call__ (с __init__ простым копированием их из аргументов).

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

Тангенс: независимо от того, идет ли речь о классе или функции, вы должны использовать functools.wraps, что само по себе и должно быть используется как декоратор (надо идти глубже!) вот так:

import functools

def require_authorization(f):
    @functools.wraps(f)
    def decorated(user, *args, **kwargs):
        if not is_authorized(user):
            raise UserIsNotAuthorized
        return f(user, *args, **kwargs)
    return decorated

@require_authorization
def check_email(user, etc):
    # etc.

Это делает decorated похожим на check_email, например, изменяя его атрибут func_name.

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

def require_authorization(action):
    def decorate(f):
        @functools.wraps(f):
        def decorated(user, *args, **kwargs):
            if not is_allowed_to(user, action):
                raise UserIsNotAuthorized(action, user)
            return f(user, *args, **kwargs)
        return decorated
    return decorate

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

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

def log_call(f):
    @functools.wraps(f)
    def decorated(*args, **kwargs):
        logging.debug('call being made: %s(*%r, **%r)',
                      f.func_name, args, kwargs)
        return f(*args, **kwargs)
    return decorated

Более экстремальный подход для сохранения треков стека в норме заключается в том, чтобы декоратор вернул объект декорации неизмененным, например:

import threading

DEPRECATED_LOCK = threading.Lock()
DEPRECATED = set()

def deprecated(f):
    with DEPRECATED_LOCK:
        DEPRECATED.add(f)
    return f

@deprecated
def old_hack():
    # etc.

Это полезно, если функция вызывается в рамках структуры, которая знает о декораторе deprecated. Например,

class MyLamerFramework(object):
    def register_handler(self, maybe_deprecated):
        if not self.allow_deprecated and is_deprecated(f):
            raise ValueError(
                'Attempted to register deprecated function %s as a handler.'
                % f.func_name)
        self._handlers.add(maybe_deprecated)

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

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

import logging
import time
import pymongo
import hashlib
import random

DEBUG_MODE = True

class logger(object):

        def __new__(cls, *args, **kwargs):
                if DEBUG_MODE:
                        return object.__new__(cls, *args, **kwargs)
                else:
                        return args[0]

        def __init__(self, foo):
                self.foo = foo
                logging.basicConfig(filename='exceptions.log', format='%(levelname)s %   (asctime)s: %(message)s')
                self.log = logging.getLogger(__name__)

        def __call__(self, *args, **kwargs):
                def _log():
                        try:
                               t = time.time()
                               func_hash = self._make_hash(t)
                               col = self._make_db_connection()
                               log_record = {'func_name':self.foo.__name__, 'start_time':t, 'func_hash':func_hash}
                               col.insert(log_record)
                               res = self.foo(*args, **kwargs)
                               log_record = {'func_name':self.foo.__name__, 'exc_time':round(time.time() - t,4), 'end_time':time.time(),'func_hash':func_hash}
                               col.insert(log_record)
                               return res
                        except Exception as e:
                               self.log.error(e)
                return _log()

        def _make_db_connection(self):
                connection = pymongo.Connection()
                db = connection.logger
                collection = db.log
                return collection

        def _make_hash(self, t):
                m = hashlib.md5()
                m.update(str(t)+str(random.randrange(1,10)))
                return m.hexdigest()