Question

以下代码中的注释是否正确？特别是“instance = ...”一个？

# This does nothing.

class donothing(object):
    def __init__(self, func):
        """
        The 'func' argument is the function being decorated because in this
        case, we're not instantiating the decorator class. Instead we are just
        using the class object as a callable (a class is always callable as this
        is how an instance is returned) to use as a decorator, which means that
        it is being instantiated upon definition of the decorated function and
        the decorated function is being passed in as an argument to the class's
        __init__ method.
        """
        self.func = func

    def __call__(self, *args, **kwargs):
        """
        The __call__ function is called when the decorated function is called
        because the function has be eaten by the decorator class. Now it's up to
        the this method to return a call to the original function. The arguments
        are passed in as args, kwargs to be manipulated.
        """
        # Returns original function call with original arguments.
        return self.func(*args, **kwargs)

@donothing
def printer(text):
    print(text)

printer('hello world')

# The printer function is now an alias for the donothing instance created, so
# the preceding was the same as:
#
# instance = donothing(printer)
# instance('hello world')
#


# Next example:

class checkforkeysinparams(object):
    def __init__(self, required):
        self.required = set(required)

    def __call__(self, params):
        def wrapper(params):
            missing = self.required.difference(params)
            if missing:
                raise TypeError('Missing from "params" argument: %s' % ', '.join(sorted(missing)))
        return wrapper


# Apply decorator class, passing in the __init__'s 'required' argument.

@checkforkeysinparams(['name', 'pass', 'code'])
def complex_function(params):
    # Obviously these three are needed or a KeyError will be raised.
    print(params['name'])
    print(params['pass'])
    print(params['code'])


# Create params to pass in. Note, I've commented out one of the required params.

params = {
    'name': 'John Doe',
    'pass': 'OpenSesame',
    #'code': '1134',
}

# This call will output: TypeError: Missing from "params" argument: code

complex_function(params=params)

Answer 1

是完美描述，装饰器donothing装饰函数printer并返回类donothing的对象，所以装饰器简单归结为此

x = donothing(func) # donothing is a class not function

如果你想避免使用@deco语法，你可以像这样使用它。

所以现在x是一个对象，当你执行x（）时，调用该对象的__call__并在那里调用__init__中传递的函数

修改第二个装饰器是错误的，因为它只检查参数但从不调用正在传递的函数并且传递给装饰器的函数是名称params，但应该是名称类似于func或更好的名称

你可以通过传递正确的参数来测试它什么都不做

params = { 'name': 'John Doe', 'pass': 'OpenSesame', 'code': '1134', } complex_function(params=params)

它不会像complex_function那样打印参数。

所以正确的装饰者是

class checkforkeysinparams(object): def __init__(self, required): self.required = set(required) def __call__(self, func): def wrapper(params): missing = self.required.difference(params) if missing: raise TypeError('Missing from "params" argument: %s' % ', '.join(sorted(missing))) func(params) return wrapper

在第一个示例中，Class被用作装饰器本身，这里使用类checkforkeysinparams的对象作为deocrator 因此函数被传递给该对象的__call__

Python：装饰器：以下代码如何工作？

1 个答案: