05.13 修饰符的使用
修饰符的使用
@classmethod 修饰符
在 Python 标准库中，有很多自带的修饰符，例如 classmethod 将一个对象方法转换了类方法：
1class Foo(object):
2 @classmethod
3 def bar(cls, x):
4 print 'the input is', x
5
6 def __init__(self):
7 pass
类方法可以通过 类名.方法 来调用：
1Foo.bar(12)
the input is 12
@property 修饰符
有时候，我们希望像 Java 一样支持 getters 和 setters 的方法，这时候就可以使用 property 修饰符：
1class Foo(object):
2 def __init__(self, data):
3 self.data = data
4
5 @property
6 def x(self):
7 return self.data
此时可以使用 .x 这个属性查看数据（不需要加上括号）：
1foo = Foo(23)
2foo.x
23
这样做的好处在于，这个属性是只读的：
1foo.x = 1
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-5-e5e7e6c675ef> in <module>()
----> 1 foo.x = 1
AttributeError: can't set attribute
如果想让它变成可读写，可以加上一个修饰符 @x.setter：
1class 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
1foo = Foo(23)
2print foo.x
23
可以通过属性改变它的值：
1foo.x = 1
2print foo.x
1
Numpy 的 @vectorize 修饰符
numpy 的 vectorize 函数讲一个函数转换为 ufunc，事实上它也是一个修饰符：
1from numpy import vectorize, arange
2
3@vectorize
4def f(x):
5 if x <= 0:
6 return x
7 else:
8 return 0
9
10f(arange(-10.0,10.0))
array([-10., -9., -8., -7., -6., -5., -4., -3., -2., -1., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0.])
注册一个函数
来看这样的一个例子，定义一个类：
1class 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 方法接受一个函数，将这个函数名作为属性注册到对象中。
产生该类的一个对象：
1registry = Registry()
使用该对象的 register 方法作为修饰符：
1@registry.register
2def greeting():
3 print "hello world"
这样这个函数就被注册到 registry 这个对象中去了：
1registry._data
{'greeting': <function __main__.greeting>}
1registry.greeting
<function __main__.greeting>
flask ，一个常用的网络应用，处理 url 的机制跟这个类似。
使用 @wraps
一个通常的问题在于：
1def 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
8def square(x):
9 '''
10 square function.
11 '''
12 return x ** 2
13
14print square.__doc__, square.__name__
None wrapper
我们使用修饰符之后，square 的 metadata 完全丢失了，返回的函数名与函数的 docstring 都不对。
一个解决的方法是从 functools 模块导入 wraps 修饰符来修饰我们的修饰符：
1import functools
2
3def 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
11def square(x):
12 '''
13 square function.
14 '''
15 return x ** 2
16
17print square.__doc__, square.__name__
square function.
square
现在这个问题解决了，所以在自定义修饰符方法的时候为了避免出现不必要的麻烦，尽量使用 wraps 来修饰修饰符！
Class 修饰符
与函数修饰符类似，类修饰符是这样一类函数，接受一个类作为参数，通常返回一个新的类。