【问题标题】:Python decorator makes function forget that it belongs to a classPython装饰器使函数忘记它属于一个类
【发布时间】:2010-09-23 07:07:51
【问题描述】:

我正在尝试编写一个装饰器来进行日志记录:

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):
    @logger
    def f():
        pass

C().f()

我想打印这个:

Entering C.f

但我收到了以下错误消息:

AttributeError: 'function' object has no attribute 'im_class'

大概这与 'logger' 中的 'myFunc' 的范围有关,但我不知道是什么。

【问题讨论】:

  • 不完全是答案,但发现这篇文章深入探讨了一些事情bit.ly/1NsBLmx

标签: python reflection metaprogramming


【解决方案1】:

Claudiu 的回答是正确的,但您也可以通过从 self 参数中获取类名来作弊。这会在继承的情况下给出误导性的日志语句,但会告诉您正在调用其方法的对象的类。例如:

from functools import wraps  # use this to preserve function signatures and docstrings
def logger(func):
    @wraps(func)
    def with_logging(*args, **kwargs):
        print "Entering %s.%s" % (args[0].__class__.__name__, func.__name__)
        return func(*args, **kwargs)
    return with_logging

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

C().f()

正如我所说,这在您从父类继承函数的情况下将无法正常工作;在这种情况下你可能会说

class B(C):
    pass

b = B()
b.f()

并获取消息Entering B.f,因为这是正确的类。另一方面,这可能是可以接受的,在这种情况下,我会推荐这种方法而不是 Claudiu 的建议。

【讨论】:

  • 错字:你忘了return with_logging在记录器功能。
  • 顺便说一句,functools.wraps 不保留 im_* 属性。你认为这个遗漏可以被认为是一个错误吗?
  • 我还不能假装我完全理解 @wraps 发生了什么,但它确实解决了我的问题。非常感谢。
  • Piotr:感谢您指出缺少的回报;我编辑了我的帖子来解决这个问题。至于 im_* 属性,在说这绝对是一个错误之前,我必须考虑复制这些属性的所有含义。但是,我想不出一个很好的理由来忽略它们。
  • Charles:我在 Stack Overflow 上发布了另一个问题,解释了包装的使用:stackoverflow.com/questions/308999/what-does-functoolswraps-do
【解决方案2】:

函数仅在运行时成为方法。也就是说,当你得到C.f 时,你得到一个绑定函数(和C.f.im_class is C)。在定义您的函数时,它只是一个普通函数,它不绑定到任何类。这个未绑定和分离的函数就是 logger 修饰的。

self.__class__.__name__ 将为您提供类的名称,但您也可以使用描述符以更通用的方式完成此操作。这个模式被描述为in a blog post on Decorators and Descriptors,你的 logger 装饰器的具体实现如下所示:

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)),但这种通用模式适用于方法和函数。但是它适用于旧式类(但不要使用那些;)

【讨论】:

  • 对于任何其他寻找提供TypeError: foo takes exactly x argumentsattribute missing 的函数并意识到self 参数未传递给您的装饰函数的人,这是解决方案,谢谢@ianb
  • 这种方法需要不同的记录器来记录绑定方法、未绑定方法和函数记录。
  • @KeatsKelleher 怎么样?在我的测试中,装饰和调用函数似乎工作正常......
【解决方案3】:

这里提出的想法非常好,但也有一些缺点:

  1. inspect.getouterframesargs[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):
    # ...

full unit-tests for usage details

这里只是 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__()

【讨论】:

  • 这是唯一对我有用的方法。我需要对象实例引用
【解决方案4】:

似乎在创建类时,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)

【讨论】:

  • 由于静态方法,wrapclass应该小心。
  • 这看起来像是类装饰器的一个很好的用例(Python 2.6 中的新功能)。它们的工作方式与函数装饰器完全相同。
【解决方案5】:

类函数应始终将 self 作为其第一个参数,因此您可以使用它来代替 im_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__ 来获取类的名称。

【讨论】:

    【解决方案6】:

    我使用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 库文档中保留对框架的引用。

    【讨论】:

    • 这正是我想要的——关于方法和它将绑定到的类的信息第一次被调用之前。
    【解决方案7】:

    Asa Ayers' answer所示,不需要访问类对象。值得知道的是,从 Python 3.3 开始,您还可以使用 __qualname__,它会为您提供完全限定名称:

    >>> def logger(myFunc):
    ...     def new(*args, **keyargs):
    ...         print('Entering %s' % myFunc.__qualname__)
    ...         return myFunc(*args, **keyargs)
    ... 
    ...     return new
    ... 
    >>> class C(object):
    ...     @logger
    ...     def f(self):
    ...         pass
    ... 
    >>> C().f()
    Entering C.f
    

    这具有在嵌套类的情况下也可以工作的额外优势,如本示例所示,取自PEP 3155

    >>> class C:
    ...   def f(): pass
    ...   class D:
    ...     def g(): pass
    ...
    >>> C.__qualname__
    'C'
    >>> C.f.__qualname__
    'C.f'
    >>> C.D.__qualname__
    'C.D'
    >>> C.D.g.__qualname__
    'C.D.g'
    

    还请注意,在 Python 3 中,im_class 属性已消失,因此如果您真的希望在装饰器中访问该类,则需要其他方法。我目前使用的方法涉及object.__set_name__,详见my answer to "Can a Python decorator of an instance method access the class?"

    【讨论】:

      【解决方案8】:

      您还可以使用new.instancemethod() 从函数创建实例方法(绑定或未绑定)。

      【讨论】:

        【解决方案9】:

        当函数不知道它的类时,不要在定义时注入装饰代码,而是延迟运行此代码,直到函数被访问/调用。描述符对象有助于在访问/调用时后期注入自己的代码:

        class decorated(object):
            def __init__(self, func, type_=None):
                self.func = func
                self.type = type_
        
            def __get__(self, obj, type_=None):
                return self.__class__(self.func.__get__(obj, type_), type_)
        
            def __call__(self, *args, **kwargs):
                name = '%s.%s' % (self.type.__name__, self.func.__name__)
                print('called %s with args=%s kwargs=%s' % (name, args, kwargs))
                return self.func(*args, **kwargs)
        
        class Foo(object):
            @decorated
            def foo(self, a, b):
                pass
        

        现在我们可以在访问时(__get__)和调用时(__call__)检查类。这种机制适用于普通方法以及静态|类方法:

        >>> Foo().foo(1, b=2)
        called Foo.foo with args=(1,) kwargs={'b': 2}
        

        完整示例位于:https://github.com/aurzenligl/study/blob/master/python-robotwrap/Example4.py

        【讨论】:

          猜你喜欢
          • 1970-01-01
          • 2014-04-28
          • 1970-01-01
          • 2021-08-21
          • 2011-12-02
          • 1970-01-01
          • 2016-09-11
          • 2015-10-23
          • 2017-01-06
          相关资源
          最近更新 更多