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

Функции только становятся методами во времени выполнения. Таким образом, когда Вы добираетесь C.f, Вы получаете связанную функцию (и C.f.im_class is C). В то время, когда Ваша функция определяется, это - просто простая функция, это не связывается ни с каким классом. Эта несвязанная и разъединенная функция - то, что украшено регистратором.

self.__class__.__name__ даст Вам название класса, но можно также использовать дескрипторы для выполнения этого несколько более общим способом. Этот шаблон описан в сообщении в блоге на Декораторах и Дескрипторах , и реализация Вашего декоратора регистратора в особенности была бы похожа:

class logger(object):
    def __init__(self, func):
        self.func = func
    def __get__(self, obj, type=None):
        return self.__class__(self.func.__get__(obj, type))
    def __call__(self, *args, **kw):
        print 'Entering %s' % self.func
        return self.func(*args, **kw)

class C(object):
    @logger
    def f(self, x, y):
        return x+y

C().f(1, 2)
# => Entering <bound method C.f of <__main__.C object at 0x...>>

, Очевидно, вывод может быть улучшен (при помощи, например, getattr(self.func, 'im_class', None)), но этот общий шаблон будет работать и на методы и на функции. Однако это будет не работа для классов старого стиля (но просто не используйте тех;)

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

def logger(myFunc):
    def new(*args, **keyargs):
        print 'Entering %s.%s' % (myFunc.im_class.__name__, myFunc.__name__)
        return myFunc(*args, **keyargs)

    return new

class C(object):
    def f(self):
        pass
C.f = logger(C.f)
C().f()

Это производит желаемый результат.

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

C = wrapClass(C)

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

def logger(myFunc):
    def new(self, *args, **keyargs):
        print 'Entering %s.%s' % (self.__class__.__name__, myFunc.__name__)
        return myFunc(self, *args, **keyargs)

    return new 

class C(object):
    @logger
    def f(self):
        pass
C().f()

сначала я хотел использовать self.__name__, но это не работает, потому что экземпляр не имеет никакого имени. необходимо использовать self.__class__.__name__ для получения названия класса.

Можно также использовать new.instancemethod() для создания метода экземпляра (или связанный или развязанный) от функции.

Я нашел другое решение очень похожей проблемы, используя библиотеку inspect. Когда вызывается декоратор, даже если функция еще не привязана к классу, вы можете просмотреть стек и определить, какой класс вызывает декоратор. Вы можете, по крайней мере, получить строковое имя класса, если это все, что вам нужно (вероятно, вы еще не можете ссылаться на него, поскольку он находится в процессе создания). Тогда вам не нужно будет ничего вызывать после того, как класс будет создан.

import inspect

def logger(myFunc):
    classname = inspect.getouterframes(inspect.currentframe())[1][3]
    def new(*args, **keyargs):
        print 'Entering %s.%s' % (classname, myFunc.__name__)
        return myFunc(*args, **keyargs)
    return new

class C(object):
    @logger
    def f(self):
        pass

C().f()

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

Идеи, предложенные здесь, превосходны, но имеют некоторые недостатки:

1. inspect.getouterframes и args [0] .__ class __.__ name __ не подходят для простого функции и статические методы.
2. __ get __ должен быть в классе, который отклонен @wraps .
3. @wraps должен лучше скрывать следы.

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

В результате method_decorator :

• знает класс, к которому привязан декорированный метод.
• Скрывает трассировки декораторов, отвечая на системные атрибуты более правильно, чем functools.wraps () .
• Охватывается модульными тестами для связанных несвязанных методов экземпляра, методов класса, статических методов и простых функций.

Использование:

pip install method_decorator
from method_decorator import method_decorator

class my_decorator(method_decorator):
    # ...

Подробнее об использовании см. полные юнит-тесты .

А вот только код класса method_decorator :

class method_decorator(object):

    def __init__(self, func, obj=None, cls=None, method_type='function'):
        # These defaults are OK for plain functions
        # and will be changed by __get__() for methods once a method is dot-referenced.
        self.func, self.obj, self.cls, self.method_type = func, obj, cls, method_type

    def __get__(self, obj=None, cls=None):
        # It is executed when decorated func is referenced as a method: cls.func or obj.func.

        if self.obj == obj and self.cls == cls:
            return self # Use the same instance that is already processed by previous call to this __get__().

        method_type = (
            'staticmethod' if isinstance(self.func, staticmethod) else
            'classmethod' if isinstance(self.func, classmethod) else
            'instancemethod'
            # No branch for plain function - correct method_type for it is already set in __init__() defaults.
        )

        return object.__getattribute__(self, '__class__')( # Use specialized method_decorator (or descendant) instance, don't change current instance attributes - it leads to conflicts.
            self.func.__get__(obj, cls), obj, cls, method_type) # Use bound or unbound method with this underlying func.

    def __call__(self, *args, **kwargs):
        return self.func(*args, **kwargs)

    def __getattribute__(self, attr_name): # Hiding traces of decoration.
        if attr_name in ('__init__', '__get__', '__call__', '__getattribute__', 'func', 'obj', 'cls', 'method_type'): # Our known names. '__class__' is not included because is used only with explicit object.__getattribute__().
            return object.__getattribute__(self, attr_name) # Stopping recursion.
        # All other attr_names, including auto-defined by system in self, are searched in decorated self.func, e.g.: __module__, __class__, __name__, __doc__, im_*, func_*, etc.
        return getattr(self.func, attr_name) # Raises correct AttributeError if name is not found in decorated self.func.

    def __repr__(self): # Special case: __repr__ ignores __getattribute__.
        return self.func.__repr__()