利用装饰器对函数参数强制执行类型检查

在给出解决方案之前，本节的目标是提供一种手段对函数的输入参数类型做强制性的类型检查。下面这个简短的示例说明了这种思想：

>>> @typeassert(int, int)

... def add(x, y):

... return x + y

...

>>>

>>> add (2, 3)

5

>>> add(2， ‘HELLO')

Traceback (most recent call last):

File "", line 1, in

TypeError: Arguement y must be

>>>

现在，让我们看看装饰器@typeassert的实现：

from inspect import signature

from functools import wraps

def typeassert(*ty_args, **ty_kwargs):

def decorate(func):

# If in optimized mode, disable type checking

if not __debug__:

return func

# Map function argument names to supplied types

sig = signature(func)

bound_types = sig.bind_partial(*ty_args, **ty_kwargs).arguments

@wraps(func)

def wrapper(*args, **kwargs):

bound_values = sig.bind(*args, **kwargs)

# Enforce type assertions across supplied arguments

for name, value in bound_values.arguments.items():

if name in bound_types:

if not isinstance(value, bound_types[name]):

raise TypeError(

'Argument{}must be{}'.format(name, bound_types[name]))

return func(*args, **kwargs)

return wrapper

return decorate

@typeassert(int, int)

def add(x, y):

return x + y

我们会发现这个装饰器相当灵活，既允许指定函数参数的所有类型，也可以只指定一部分子集。此外，类型既可以通过位置参数来指定，也可以通过关键字参数来指定。

@typeassert(int, list)

def bar(x, items=None):

if items is None:

items = []

items.append(x)

return items

bar(2)

bar(2, [1, 2, 3])

这一节展示了一个高级的装饰器的例子，这里面有一些重要并且非常有用的概念。

首先，装饰器的一个特性就是它们只会在函数定义的时候应用一次。在某些情况下，我们可能想禁止由装饰器添加的功能。为了做到这点，我们只需要让装饰器函数返回那个未经过包装的函数就好

在类中定义装饰器

我们想在类中定义一个装饰器，但是首先我们需要理清装饰器将以什么方式来应用，看下面这个示例：

from functools import wraps

class A:

# Decorator as an instance method

def decorator1(self, func):

@wraps(func)

def wrapper(*args, **kwargs):

print('Decorator 1')

return func(*args, **kwargs)

return wrapper

# Decorator as a class method

@classmethod

def decorator2(cls, func):

@wraps(func)

def wrapper(*args, **kwargs):

print('Decorator 2')

return func(*args, **kwargs)

return wrapper

在类中定义装饰器看起来可能有点古怪，但是在标准库中也可以找到这样的例子。特别是当内建的装饰器@property实际上是一个拥有getter(), setter()和deleter()方法的类，每个方法都可以作为装饰器：

class Person:

# Create a property instance

first_name = property()

# Apply decorator methods

@first_name.getter

def first_name(self):

return self._first_name

@first_name.setter

def first_name(self, value):

if not isinstance(value, str):

raise TypeError('Expected a string')

self._first_name = value

至于为什么要定义成这样的形式，关键原因就在于这里的多个装饰器方法都在操纵property实例的状态。因此，如果需要装饰器在背后记录或者合并信息，这就是一个非常好的方法。

在类中定义装饰器有个难理解的地方就是对于额外参数 self 或 cls 的正确使用。 尽管最外层的装饰器函数比如 decorator1() 或 decorator2() 需要提供一个 self 或 cls 参数， 但是在两个装饰器内部被创建的 wrapper() 函数并不需要包含这个 self 参数。 你唯一需要这个参数是在你确实要访问包装器中这个实例的某些部分的时候。其他情况下都不用去管它。

对于类里面定义的包装器还有一点比较难理解，就是在涉及到继承的时候。 例如，假设你想让在A中定义的装饰器作用在子类B中。你需要像下面这样写：

class B(A):

@A.decorator2

def bar(self):

pass

也就是说，装饰器要被定义成类方法并且你必须显式的使用父类名去调用它。 你不能使用 @B.decorator2 ，因为在方法定义时，这个类B还没有被创建。

把装饰器定义为类

我们想用装饰器来包装函数，但是希望得到的结果是一个可以调用的实例。为了将装饰器定义成一个实例，我们需要确保它实现了__call__()和__get__()方法。 例如，下面的代码定义了一个类，它在其他函数上放置一个简单的记录层：

import types

from functools import wraps

class Profiled:

def __init__(self, func):

wraps(func)(self)

self.ncalls = 0

def __call__(self, *args, **kwargs):

self.ncalls += 1

return self.__wrapped__(*args, **kwargs)

def __get__(self, instance, cls):

if instance is None:

return self

else:

return types.MethodType(self, instance)

你可以将它当做一个普通的装饰器来使用，在类里面或外面都可以：

@Profiled

def add(x, y):

return x + y

class Spam:

@Profiled

def bar(self, x):

print(self, x)

在Shell中：

>>> add(2, 3)

5

>>> add(4, 5)

9

>>> add.ncalls

2

>>> s = Spam()

>>> s.bar(1)

<__main__.spam object at> 1

>>> s.bar(2)

<__main__.spam object at> 2

>>> s.bar(3)

<__main__.spam object at> 3

>>> Spam.bar.ncalls

3

将装饰器定义成类通常是很简单的。但是这里还是有一些细节需要解释下，特别是当你想将它作用在实例方法上的时候。

首先，使用 functools.wraps() 函数的作用跟之前还是一样，将被包装函数的元信息复制到可调用实例中去。

其次，通常很容易会忽视上面的 __get__() 方法。如果你忽略它，保持其他代码不变再次运行， 你会发现当你去调用被装饰实例方法时出现很奇怪的问题。例如：

>>> s = Spam()

>>> s.bar(3)

Traceback (most recent call last):

...

TypeError: bar() missing 1 required positional argument: 'x'

出错原因是当方法函数在一个类中被查找时，它们的__get__()方法依据描述器协议被调用， 在前面的小节已经讲述过描述器协议了。在这里，__get__()的目的是创建一个绑定方法对象 (最终会给这个方法传递self参数)。下面是一个例子来演示底层原理：

>>> s = Spam()

>>> def grok(self, x):

... pass

...

>>> grok.__get__(s, Spam)

>

>>>

__get__() 方法是为了确保绑定方法对象能被正确的创建。 type.MethodType() 手动创建一个绑定方法来使用。只有当实例被使用的时候绑定方法才会被创建。 如果这个方法是在类上面来访问， 那么 __get__() 中的instance参数会被设置成None并直接返回 Profiled 实例本身。 这样的话我们就可以提取它的 ncalls 属性了。

如果你想避免一些混乱，也可以考虑另外一个使用闭包和 nonlocal 变量实现的装饰器，这个在之前几节有讲到。例如：

import types

from functools import wraps

def profiled(func):

ncalls = 0

@wraps(func)

def wrapper(*args, **kwargs):

nonlocal ncalls

ncalls += 1

return func(*args, **kwargs)

wrapper.ncalls = lambda: ncalls

return wrapper

# Example

@profiled

def add(x, y):

return x + y

这个方式跟之前的效果几乎一样，除了对于ncalls的访问现在是通过一个被绑定为属性的函数来实现

参考书目：

《Python CookBook》作者：【美】 David Beazley, Brian K. Jones

Github地址：yidao620c/python3-cookbook​github.com