Python functools.wraps等效于类

| 当使用类定义装饰器时，如何自动传递__name__，__module__和__doc__？通常，我会使用functools中的@wraps装饰器。这是我为一个类所做的事情（这不完全是我的代码）：

class memoized:
    \"\"\"Decorator that caches a function\'s return value each time it is called.
    If called later with the same arguments, the cached value is returned, and
    not re-evaluated.
    \"\"\"
    def __init__(self, func):
        super().__init__()
        self.func = func
        self.cache = {}

    def __call__(self, *args):
        try:
            return self.cache[args]
        except KeyError:
            value = self.func(*args)
            self.cache[args] = value
            return value
        except TypeError:
            # uncacheable -- for instance, passing a list as an argument.
            # Better to not cache than to blow up entirely.
            return self.func(*args)

    def __repr__(self):
        return self.func.__repr__()

    def __get__(self, obj, objtype):
        return functools.partial(self.__call__, obj)

    __doc__ = property(lambda self:self.func.__doc__)
    __module__ = property(lambda self:self.func.__module__)
    __name__ = property(lambda self:self.func.__name__)

是否有一个标准的装饰器来自动创建名称模块和文档？另外，要自动执行get方法（我假设这是用于创建绑定方法？）是否缺少任何方法？

已邀请:

5 个回复

蹄渭信妥扳

每个人似乎都错过了显而易见的解决方案。

>>> import functools
>>> class memoized(object):
    \"\"\"Decorator that caches a function\'s return value each time it is called.
    If called later with the same arguments, the cached value is returned, and
    not re-evaluated.
    \"\"\"
    def __init__(self, func):
        self.func = func
        self.cache = {}
        functools.update_wrapper(self, func)  ## TA-DA! ##
    def __call__(self, *args):
        pass  # Not needed for this demo.

>>> @memoized
def fibonacci(n):
    \"\"\"fibonacci docstring\"\"\"
    pass  # Not needed for this demo.

>>> fibonacci
<__main__.memoized object at 0x0156DE30>
>>> fibonacci.__name__
\'fibonacci\'
>>> fibonacci.__doc__
\'fibonacci docstring\'

勘掸府迫路

我不了解stdlib中的此类内容，但是如果需要，我们可以创建自己的东西。这样的事情可以工作：

from functools import WRAPPER_ASSIGNMENTS


def class_wraps(cls):
    \"\"\"Update a wrapper class `cls` to look like the wrapped.\"\"\"

    class Wrapper(cls):
        \"\"\"New wrapper that will extend the wrapper `cls` to make it look like `wrapped`.

        wrapped: Original function or class that is beign decorated.
        assigned: A list of attribute to assign to the the wrapper, by default they are:
             [\'__doc__\', \'__name__\', \'__module__\', \'__annotations__\'].

        \"\"\"

        def __init__(self, wrapped, assigned=WRAPPER_ASSIGNMENTS):
            self.__wrapped = wrapped
            for attr in assigned:
                setattr(self, attr, getattr(wrapped, attr))

            super().__init__(wrapped)

        def __repr__(self):
            return repr(self.__wrapped)

    return Wrapper

用法：

@class_wraps
class memoized:
    \"\"\"Decorator that caches a function\'s return value each time it is called.
    If called later with the same arguments, the cached value is returned, and
    not re-evaluated.
    \"\"\"

    def __init__(self, func):
        super().__init__()
        self.func = func
        self.cache = {}

    def __call__(self, *args):
        try:
            return self.cache[args]
        except KeyError:
            value = self.func(*args)
            self.cache[args] = value
            return value
        except TypeError:
            # uncacheable -- for instance, passing a list as an argument.
            # Better to not cache than to blow up entirely.
            return self.func(*args)

    def __get__(self, obj, objtype):
        return functools.partial(self.__call__, obj)


@memoized
def fibonacci(n):
    \"\"\"fibonacci docstring\"\"\"
    if n in (0, 1):
       return n
    return fibonacci(n-1) + fibonacci(n-2)


print(fibonacci)
print(\"__doc__: \", fibonacci.__doc__)
print(\"__name__: \", fibonacci.__name__)

输出：

<function fibonacci at 0x14627c0>
__doc__:  fibonacci docstring
__name__:  fibonacci

编辑：如果您想知道为什么未包含在stdlib中是因为您可以将您的类装饰器包装在函数装饰器中，并使用functools.wraps像这样：

def wrapper(f):

    memoize = memoized(f)

    @functools.wraps(f)
    def helper(*args, **kws):
        return memoize(*args, **kws)

    return helper


@wrapper
def fibonacci(n):
    \"\"\"fibonacci docstring\"\"\"
    if n <= 1:
       return n
    return fibonacci(n-1) + fibonacci(n-2)

联海

我需要一些可以包装类和函数的东西，并写成这样：

def wrap_is_timeout(base):
    \'\'\'Adds `.is_timeout=True` attribute to objects returned by `base()`.

    When `base` is class, it returns a subclass with same name and adds read-only property.
    Otherwise, it returns a function that sets `.is_timeout` attribute on result of `base()` call.

    Wrappers make best effort to be transparent.
    \'\'\'
    if inspect.isclass(base):
        class wrapped(base):
            is_timeout = property(lambda _: True)

        for k in functools.WRAPPER_ASSIGNMENTS:
            v = getattr(base, k, _MISSING)
            if v is not _MISSING:
                try:
                    setattr(wrapped, k, v)
                except AttributeError:
                    pass
        return wrapped

    @functools.wraps(base)
    def fun(*args, **kwargs):
        ex = base(*args, **kwargs)
        ex.is_timeout = True
        return ex
    return fun

公藕

我们真正需要做的就是修改装饰器的行为，使其“卫生”，即保持属性。

#!/usr/bin/python3

def hygienic(decorator):
    def new_decorator(original):
        wrapped = decorator(original)
        wrapped.__name__ = original.__name__
        wrapped.__doc__ = original.__doc__
        wrapped.__module__ = original.__module__
        return wrapped
    return new_decorator

这就是您所需要的。一般来说。它不会保留签名，但是如果您确实希望可以使用库来执行此操作。我还继续重写了记忆代码，以便它也适用于关键字参数。还有一个错误，即无法将其转换为可哈希的元组将导致它无法在100％的情况下运行。用@hygienic修改其行为的重写memoized装饰器演示。 memoized现在是一个包装原始类的函数，尽管您可以（像其他答案一样）编写一个包装类，或者甚至更好地，它可以检测出它是否是一个类，并且是否包装了s15ѭ方法。

@hygienic
class memoized:
    def __init__(self, func):
        self.func = func
        self.cache = {}

    def __call__(self, *args, **kw):
        try:
            key = (tuple(args), frozenset(kw.items()))
            if not key in self.cache:
                self.cache[key] = self.func(*args,**kw)
            return self.cache[key]
        except TypeError:
            # uncacheable -- for instance, passing a list as an argument.
            # Better to not cache than to blow up entirely.
            return self.func(*args,**kw)

实际上：

@memoized
def f(a, b=5, *args, keyword=10):
    \"\"\"Intact docstring!\"\"\"
    print(\'f was called!\')
    return {\'a\':a, \'b\':b, \'args\':args, \'keyword\':10}

x=f(0)  
#OUTPUT: f was called!
print(x)
#OUTPUT: {\'a\': 0, \'b\': 5, \'keyword\': 10, \'args\': ()}                 

y=f(0)
#NO OUTPUT - MEANS MEMOIZATION IS WORKING
print(y)
#OUTPUT: {\'a\': 0, \'b\': 5, \'keyword\': 10, \'args\': ()}          

print(f.__name__)
#OUTPUT: \'f\'
print(f.__doc__)
#OUTPUT: \'Intact docstring!\'

攫怂绵十

使用继承的另一种解决方案：

import functools
import types

class CallableClassDecorator:
    \"\"\"Base class that extracts attributes and assigns them to self.

    By default the extracted attributes are:
         [\'__doc__\', \'__name__\', \'__module__\'].
    \"\"\"

    def __init__(self, wrapped, assigned=functools.WRAPPER_ASSIGNMENTS):
        for attr in assigned:
            setattr(self, attr, getattr(wrapped, attr))
        super().__init__()

    def __get__(self, obj, objtype):
        return types.MethodType(self.__call__, obj)

并且，用法：

class memoized(CallableClassDecorator):
    \"\"\"Decorator that caches a function\'s return value each time it is called.
    If called later with the same arguments, the cached value is returned, and
    not re-evaluated.
    \"\"\"
    def __init__(self, function):
        super().__init__(function)
        self.function = function
        self.cache = {}

    def __call__(self, *args):
        try:
            return self.cache[args]
        except KeyError:
            value = self.function(*args)
            self.cache[args] = value
            return value
        except TypeError:
            # uncacheable -- for instance, passing a list as an argument.
            # Better to not cache than to blow up entirely.
            return self.function(*args)

要回复问题请先登录或注册

Python functools.wraps等效于类

5 个回复

发起人

python

decorator

问题状态

Python functools.wraps等效于类

与内容相关的链接

5 个回复

发起人

python

decorator

问题状态