修饰符的使用¶

@classmethod 修饰符¶

在 Python 标准库中，有很多自带的修饰符，例如 classmethod 将一个对象方法转换了类方法：

In [1]:

  1. class Foo(object):
  2.     @classmethod
  3.     def bar(cls, x):
  4.         print 'the input is', x
  5.  
  6.     def __init__(self):
  7.         pass

类方法可以通过 类名.方法 来调用：

In [2]:

  1. Foo.bar(12)
  1. the input is 12

@property 修饰符¶

有时候，我们希望像 Java 一样支持 getters 和 setters 的方法，这时候就可以使用 property 修饰符：

In [3]:

  1. class Foo(object):
  2.     def __init__(self, data):
  3.         self.data = data
  4.  
  5.     @property
  6.     def x(self):
  7.         return self.data

此时可以使用 .x 这个属性查看数据（不需要加上括号）：

In [4]:

  1. foo = Foo(23)
  2. foo.x

Out[4]:

  1. 23

这样做的好处在于，这个属性是只读的：

In [5]:

  1. foo.x = 1
  1. ---------------------------------------------------------------------------
  2. AttributeError                            Traceback (most recent call last)
  3. <ipython-input-5-e5e7e6c675ef> in <module>()
  4. ----> 1 foo.x = 1
  5.  
  6. AttributeError: can't set attribute

如果想让它变成可读写，可以加上一个修饰符 @x.setter：

In [6]:

  1. class Foo(object):
  2.     def __init__(self, data):
  3.         self.data = data
  4.  
  5.     @property
  6.     def x(self):
  7.         return self.data
  8.  
  9.     @x.setter
  10.     def x(self, value):
  11.         self.data = value

In [7]:

  1. foo = Foo(23)
  2. print foo.x
  1. 23

可以通过属性改变它的值：

In [8]:

  1. foo.x = 1
  2. print foo.x
  1. 1

Numpy 的 @vectorize 修饰符¶

numpy 的 vectorize 函数讲一个函数转换为 ufunc，事实上它也是一个修饰符：

In [9]:

  1. from numpy import vectorize, arange
  2.  
  3. @vectorize
  4. def f(x):
  5.     if x <= 0:
  6.         return x
  7.     else:
  8.         return 0
  9.  
  10. f(arange(-10.0,10.0))

Out[9]:

  1. array([-10.,  -9.,  -8.,  -7.,  -6.,  -5.,  -4.,  -3.,  -2.,  -1.,   0.,
  2.          0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.])

注册一个函数¶

来看这样的一个例子，定义一个类：

In [10]:

  1. class Registry(object):
  2.     def __init__(self):
  3.         self._data = {}
  4.     def register(self, f, name=None):
  5.         if name == None:
  6.             name = f.__name__
  7.         self._data[name] = f
  8.         setattr(self, name, f)

register 方法接受一个函数，将这个函数名作为属性注册到对象中。

产生该类的一个对象：

In [11]:

  1. registry = Registry()

使用该对象的 register 方法作为修饰符：

In [12]:

  1. @registry.register
  2. def greeting():
  3.     print "hello world"

这样这个函数就被注册到 registry 这个对象中去了：

In [13]:

  1. registry._data

Out[13]:

  1. {'greeting': <function __main__.greeting>}

In [14]:

  1. registry.greeting

Out[14]:

  1. <function __main__.greeting>

flask ，一个常用的网络应用，处理 url 的机制跟这个类似。

使用 @wraps

一个通常的问题在于：

In [15]:

  1. def logging_call(f):
  2.     def wrapper(*a, **kw):
  3.         print 'calling {}'.format(f.__name__)
  4.         return f(*a, **kw)
  5.     return wrapper
  6.  
  7. @logging_call
  8. def square(x):
  9.     '''
  10.     square function.
  11.     '''
  12.     return x ** 2
  13.  
  14. print square.__doc__, square.__name__
  1. None wrapper

我们使用修饰符之后，square 的 metadata 完全丢失了，返回的函数名与函数的 docstring 都不对。

一个解决的方法是从 functools 模块导入 wraps 修饰符来修饰我们的修饰符：

In [16]:

  1. import functools
  2.  
  3. def logging_call(f):
  4.     @functools.wraps(f)
  5.     def wrapper(*a, **kw):
  6.         print 'calling {}'.format(f.__name__)
  7.         return f(*a, **kw)
  8.     return wrapper
  9.  
  10. @logging_call
  11. def square(x):
  12.     '''
  13.     square function.
  14.     '''
  15.     return x ** 2
  16.  
  17. print square.__doc__, square.__name__
  1.     square function.
  2.      square

现在这个问题解决了，所以在自定义修饰符方法的时候为了避免出现不必要的麻烦，尽量使用 wraps 来修饰修饰符！

Class 修饰符¶

与函数修饰符类似，类修饰符是这样一类函数，接受一个类作为参数，通常返回一个新的类。

原文: https://nbviewer.jupyter.org/github/lijin-THU/notes-python/blob/master/05-advanced-python/05.13-decorator-usage.ipynb