脚本之家，脚本语言编程技术及教程分享平台！
分类导航

Python|VBS|Ruby|Lua|perl|VBA|Golang|PowerShell|Erlang|autoit|Dos|bat|

服务器之家 - 脚本之家 - Python - Python 函数装饰器应用教程

Python 函数装饰器应用教程

2022-03-11 10:05无风听海 Python

函数装饰器是Python提供的一种增强函数功能的标记函数，本文将带大家深入学习一下Python 函数装饰器，感兴趣的同学跟随小编一起学习吧

一、什么是函数装饰器

1.函数装饰器是Python提供的一种增强函数功能的标记函数；

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

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

二、函数装饰器的执行时机

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

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

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

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

三、变量作用域

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

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

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

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

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

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

四、闭包

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

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

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

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

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

五、保留函数的元数据

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

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

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

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

七、使用lru_cache缓存函数执行结果

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

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

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

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

八、使用singledispatch实现泛型函数

python不支持方法或者函数的重载，我们无法单独定义不同参数类型的同名函数；

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

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

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

九、通过参数控制函数装饰器的行为

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

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

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

以上就是Python 函数装饰器应用教程的详细内容，更多关于Python 函数装饰器的资料请关注服务器之家其它相关文章！

原文链接：https://www.cnblogs.com/wufengtinghai/p/15631730.html

  • Python
  • 函数
  • 装饰器

    • 延伸 · 阅读

    精彩推荐
    最近更新
    编辑推荐
    阅读排行
    热门标签
    2048 　 6006 　 contextlib 　 SLOTS 　 MELIAE 　 FEEDPARSER 　 暂存 　 持久性管理 　 pickle模块 　 THREADING 　 reduce 　 nignx 　 装饰器 　 函数式编程 　 兔子毒药 　 监控文件 　 流量监控 　 Web框架 　 办公工具 　 PIL库 　 高斯模糊 　 wxPython 　 import 　 自定义模块 　 Python开发 　 元类 　 metaclass 　 魔术方法 　 DNSPod 　 动态解析域名 　
    © 2019-2023 脚本之家 | 服务器之家(www.zzvips.com)旗下站点 版权所有关于我们联系我们版权申明网站地图