目录
一、什么是函数装饰器
二、函数装饰器的执行时机
三、变量作用域
四、闭包
五、保留函数的元数据
七、使用lru_cache缓存函数执行结果
八、使用singledispatch实现泛型函数
九、通过参数控制函数装饰器的行为
一、什么是函数装饰器
1.函数装饰器是Python提供的一种增强函数功能的标记函数；

2.装饰器是可调用的函数对象，其参数是另一个函数(被装饰的函数)；

我们可以使用修饰器来封装某个函数，从而让程序在执行这个函数之前与执行完这个函数之后，分别运行某些代码。这意味着，调用者传给函数的参数值、函数返回给调用者的值，以及函数抛出的异常，都可以由修饰器访问并修改。这是个很有用的机制，能够确保用户以正确的方式使用函数，也能够用来调试程序或实现函数注册功能，此外还有许多用途。

二、函数装饰器的执行时机
函数装饰器在被装饰函数编译解析之后直接执行，装饰器是按照从上到下执行的；

函数装饰器内部定义的返回函数依附在装饰器的执行环境中；

函数装饰器每次执行都会生成新的返回函数；

  1. import sys
  3. def dec1(m):
  4.     print(f'{sys._getframe().f_code.co_name} is execute, arg {m.__name__}')
  5.     def newm1():
  6.         print(f'{sys._getframe().f_code.co_name}')
  8.     return newm1;
  10. @dec1
  11. def m1():
  12.     print(f'{sys._getframe().f_code.co_name}')
  14. @dec1
  15. def m11():
  16.     print(f'{sys._getframe().f_code.co_name}')
  18. if __name__ == '__main__':
  19.     print(m1)
  20.     print(m11)
  21.     print(f'm1==m11:{m1==m11}')
  23. # dec1 is execute, arg m1
  24. # dec1 is execute, arg m11
  25. # <function dec1.<locals>.newm1 at 0x7fdfa97d9160>
  26. # <function dec1.<locals>.newm1 at 0x7fdfa97d91f0>
  27. # m1==m11:False

三、变量作用域
Python中将变量声明和赋值操作合一，很容易导致函数局部变量覆盖函数外的变量

  1. b=6
  2. def f():
  3.     print(b)
  5. f()
  7. # 6
  1. b=6
  2. def f():
  3.     print(b)
  4.     b = 9
  6. f()
  8. # UnboundLocalError: local variable 'b' referenced before assignment

通过生成的字节码可以看到两者对变量b的处理的差异，前者直接LOAD_GLOBAL，后者是LOAD_FAST，但是给b赋值却在print之后导致报错；

  1. from dis import dis
  3. b=6
  4. def f():
  5.     print(b)
  6.     # b = 9
  8. dis(f)
  10.  # 5           0 LOAD_GLOBAL              0 (print)
  11.  #              2 LOAD_GLOBAL              1 (b)
  12.  #              4 CALL_FUNCTION            1
  13.  #              6 POP_TOP
  14.  #              8 LOAD_CONST               0 (None)
  15.  #             10 RETURN_VALUE
  1. from dis import dis
  3. b=6
  4. def f():
  5.     print(b)
  6.     b = 9
  8. #  5          0 LOAD_GLOBAL              0 (print)
  9. #             2 LOAD_FAST                0 (b)
  10. #             4 CALL_FUNCTION            1
  11. #             6 POP_TOP
  13. #  6          8 LOAD_CONST               1 (9)
  14. #             10 STORE_FAST               0 (b)
  15. #             12 LOAD_CONST               0 (None)
  16. #             14 RETURN_VALUE

可以使用global来强制声明b是全局变量，然后就可以重新赋值了；

  1. b=6
  2. def f():
  3.     global b
  4.     print(b)
  5.     b = 9
  7. f()
  9. # 6

四、闭包
闭包是是指可以访问非在函数体内定义的非全局变量的函数；

通过函数的code及closure可以看到局部变量和自由变量及闭包的情况；

  1. def makesum():
  2.     sum = [0]
  4.     def s(val):
  5.         sum[0] += val
  6.         return sum[0]
  8.     return s
  12. s = makesum()
  13. print(s(1))
  14. print(s(2))
  15. print(s.__code__.co_varnames)
  16. print(s.__code__.co_freevars)
  17. print(s.__closure__)
  18. print(s.__closure__[0].cell_contents)
  21. # 1
  22. # 3
  23. # ('val',)
  24. # ('sum',)
  25. # (<cell at 0x7f63321f1b20: list object at 0x7f63321e8a00>,)
  26. # [3]

基于三中Python变量作用域的缘故，上边的sum只能使用列表对象，python提供的nonlocal关键字可以直接使用int类型的变量；

  1. def makesum():
  2.     sum = 0
  4.     def s(val):
  5.         nonlocal sum
  6.         sum += val
  7.         return sum
  9.     return s
  11. s = makesum()
  12. print(s(1))
  13. print(s(2))
  14. print(s.__code__.co_varnames)
  15. print(s.__code__.co_freevars)
  16. print(s.__closure__)
  17. print(s.__closure__[0].cell_contents)
  20. # 1
  21. # 3
  22. # ('val',)
  23. # ('sum',)
  24. # (<cell at 0x7f73e6a4ab20: int object at 0x7f73e6b47970>,)
  25. # 3

五、保留函数的元数据
函数装饰器默认会使用返回的函数完全取代被装饰的函数，这样可能会导致序列化或者开发工具智能提示的问题；可以使用functools.wraps来保留原始函数的标准属性(name、module、annotations等)；

  1. import functools
  3. def dec(func):
  4.     def real():
  5.         '''this is real function'''
  6.         pass
  7.     return real
  9. def wrapsdec(func):
  10.     @functools.wraps(func)
  11.     def real():
  12.         '''this is real function'''
  13.         pass
  14.     return real
  16. @dec
  17. def max(nums):
  18.     '''this is max function'''
  19.     pass
  21. @wrapsdec
  22. def sum(nums):
  23.     '''this is sum function'''
  25. print(max)
  26. print(max.__name__)
  27. print(max.__doc__)
  28. print(help(max))
  29. print()
  30. print(sum)
  31. print(sum.__name__)
  32. print(sum.__doc__)
  33. print(help(sum))
  36. # <function dec.<locals>.real at 0x7f1bfd4241f0>
  37. # real
  38. # this is real function
  39. # Help on function real in module __main__:
  40. # 
  41. # real()
  42. #     this is real function
  43. # 
  44. # None
  45. # 
  46. # <function sum at 0x7f1bfd424280>
  47. # sum
  48. # this is sum function
  49. # Help on function sum in module __main__:
  50. # 
  51. # sum(nums)
  52. #     this is sum function
  53. # 
  54. # None

六、支持关键字参数、位置参数

  1. def dec(func):
  2.     def real(*args, **kwargs):
  3.         result = func(*args, **kwargs)
  4.         return result
  6.     return real
  8. @dec
  9. def sum(*nums, **kwargs):
  10.     s = 0
  11.     for n in nums:
  12.         s = s + n
  14.     for a in kwargs.values():
  15.         s = s + a
  16.     return s
  18. print(sum(1,2,3,first=1))

七、使用lru_cache缓存函数执行结果
lru_cache内部使用函数的参数作为key，使用dict进行缓存执行结果，减少重复计算；

默认支持缓存128条记录，超过后采用LRU方式丢弃多余记录；

需要注意执行中不要改变参数，否则会影响字典key的有效性；

  1. from functools import lru_cache
  3. @lru_cache()
  4. def fibonacci(n):
  5.     print(f'fibonacci({n})')
  6.     if n<2:
  7.         return n
  8.     return fibonacci(n-1) + fibonacci(n-2)
  10. print(fibonacci(6))
  12. # fibonacci(6)
  13. # fibonacci(5)
  14. # fibonacci(4)
  15. # fibonacci(3)
  16. # fibonacci(2)
  17. # fibonacci(1)
  18. # fibonacci(0)
  19. # 8

八、使用singledispatch实现泛型函数
python不支持方法或者函数的重载，我们无法单独定义不同参数类型的同名函数；

singledispatch提供了这样一种能力，其通过注册具体的参数类型和关联的函数；

我们可以在自己的模块定义自己的类型，并实现自己的自定义函数；

  1. import math
  2. import numbers
  3. from functools import singledispatch
  7. @singledispatch
  8. def absall(obj):
  9.     return abs(obj)
  11. @absall.register(numbers.Number)
  12. def numabs(num):
  13.     return abs(num)
  15. @absall.register(numbers.Complex)
  16. def cabs(c):
  17.     return math.sqrt(c.real*c.real + c.imag* c.imag)
  19. class Line:
  21.     def __init__(self, startx, starty, endx, endy):
  22.         self.startx = startx
  23.         self.starty = starty
  24.         self.endx = endx
  25.         self.endy = endy
  27. @absall.register(Line)
  28. def lineabs(line):
  29.     y =line.endy - line.starty
  30.     x = line.endx - line.startx
  31.     return math.sqrt(x*x + y*y)
  33. print(absall(-1.1))
  34. print(absall(3+4j))
  36. l = Line(1,2,4,6)
  37. print(absall(l))
  39. # 1.1
  40. # 5.0
  41. # 5.0

九、通过参数控制函数装饰器的行为
函数装饰器本身不支持传递参数，解析源代码的时候，python会将被装饰的函数对象作为第一个参数传递给装饰器；

我们可以通过在函数装饰器外再嵌套一个函数工厂来承载装饰特定函数的时候设置的参数； 

  1. def accesscontrol(checkuser=True, updatesession=True):
  3.     def dec(func):
  4.         def checkuserf():
  5.             print('check user')
  6.             return True
  8.         def updatesessionf():
  9.             print('update session')
  10.             return True
  12.         def access():
  13.             if checkuser:
  14.                 checkuserf()
  16.             if updatesession:
  17.                updatesessionf()
  19.             func()
  21.         return access
  23.     return dec
  25. @accesscontrol()
  26. def pushitem():
  27.     print('pushitem')
  28.     return True
  30. @accesscontrol(checkuser=False)
  31. def getitem():
  32.     print('getitem')
  33.     return True
  35. # pushitem()
  36. # print()
  37. # getitem()
  38. # 
  39. # check user
  40. # update session
  41. # pushitem
  42. # 
  43. # update session
  44. # getitem

更多相关文章

  1. ES6 基础语法总结
  2. md5加密与数组函数
  3. 五.Python面向对象
  4. PHP字符运算、类型转换和系统函数
  5. ES6基本语法，Axios异步网络请求介绍
  6. Python的装饰器原来是这么用的
  7. 循环语句 超级全局变量 及 cURL函数
  8. ES6 和异步网络请求
  9. udp数据报从网卡驱动到用户空间流程总结

随机推荐

  1. Android中横竖屏切换的问题
  2. Android 应用程序之间数据共享—ContentP
  3. Android GWES之Android消息系统
  4. 相对布局各种属性说明
  5. Android(安卓)录音实现（AudioRecord）
  6. 解决NestedScrollView中嵌套ViewPager，Vie
  7. ListView去掉分割线
  8. 【Android】gravity、layout_gravity 以
  9. 手把手教学OpenCV-android-sdk 配置以及
  10. Android架构师之路