Python中的函数修饰符@

首先，什么是函数修饰符？函数修饰符就是对原有函数做一层包装。比如有以下两个函数：

复制代码

1. def func1():
2.     print 'I am function func1'
4. def func2():
5.     print 'I am function func2'

现在我们想为这两个函数增加一段共同的操作，这时就可以使用函数修饰符。首先我们定义一个修饰函数，先不做任何处理，仅仅打印一条横线：

复制代码

1. def de( f )
2.     def call_():
3.         print '-------------------------------'
4.         return f()
5.     return _call_

使用这个修饰符：

复制代码

1. def de( f ):
2.     def _call_():
3.         print '-------------------------------'
4.         return f()
5.     return _call
7. @de
8. def func1():
9.     print 'I am function func1'
11. @de
12. def func2():
13.     print 'I am function func2'
15. if name = '__main__':
16.     func1()
17.     func2()

运行结果为：

复制代码

1. d:我的文档桌面>b.py
2. -------------------------------
3. I am function func1
4. -------------------------------
5. I am function func2
7. d:我的文档桌面>

可以看到，修饰符起作用了。 

注意： 
1.修饰符等价于包装调用：

1. @de
2. def func1:
3. ----- 等价于 ------
4. func1 = de( func1 )

2.修饰函数必须返回一个“可调用对象”：

1. def de( f ):
2.     def call_():
3.         return f()
4.     return _call # 返回的是一个函数体，而非调用_call_()

下一个问题：如果各个被修饰函数有不同的参数，怎么处理呢？例如：

1. def func1( lst1, lst2 ):
2.     # 合并两个list，并打印各项
3.     for item in lst1+lst2:
4.         print item
6. def func2( dic ):
7.     # 循环dict，打印各key-value
8.     for k, v in dic.items():
9.         print k, v

这两个函数参数不同，又都没有异常处理，现在我们想增加上，使用修饰符这样处理：

1. import sys
2. import traceback
4. def de( f ):
5.     def call_( *args, **kwargs ):
6.         try:
7.             return f( *args , **kwargs )
8.         except:
9.             print 'param type error'
10.     return _call
12. @de
13. def func1( lst1, lst2 ):
14.     for item in lst1+lst2:
15.         print item
17. @de
18. def func2( dic ):
19.     for k, v in dic.items():
20.         print k, v
22. if name = '__main__':
23.     func1( [1,2], [3,4] )
24.     func2( [1,2] )

这里使用了可变参数*args和**kwargs，这样会把所有接收来的参数，原样不动的再转给原函数，是惯用法。 
以上程序运行结果： 
复制代码

1. d:我的文档桌面>b.py
2. 1
3. 2
4. 3
5. 4
6. param type error
8. d:我的文档桌面>