Python装饰器（python装饰器的作用和功能）

1.函数基础知识

在Python中函数为一等公民，我们可以：

把函数赋值给变量

在函数中定义函数

在函数中返回函数

把函数传递给函数

1.1 把函数赋值给变量

在Python里，函数是对象，因此可以把它赋值给变量，如下所示：

def hello(name="Surpass"):

return "Hello,"+name.capitalize()

上述代码定义了一个函数hello()，具体功能是把对输入的姓名打招呼，并将姓名首字母转换为大写。下面将函数赋值给变量，如下所示：

func=hello

print(func)

其输出结果如下所示：

在上述代码中，将hello赋值给func并输出打印结果。从结果上来看，当不带括号使用hello时，仅输出函数对象，而非调用函数，当带上括号时，则表示调用函数，如下所示：

func=hello

print(func())

其输出结果如下所示：

Hello,Surpass

既然函数是对象，那是不是可以尝试删除对象，来看看以下代码：

def hello(name="Surpass"):

return "Hello,"+name.capitalize()

func=hello

del hello

try:

print(hello())

except Exception as ex:

print(ex)

print(func())

其输出结果如下所示：

name 'hello' is not defined

Hello,Surpass

在上面代码中，虽然hello函数已经删除，但在删除之前，已经赋值给变量func，所以不影响func的功能。因此可以得出以下总结：

函数是对象，可以将基赋值给其他变量variable，在调用时，需要添加括号variable()

1.2 在函数中定义函数

在Python中，可以在函数中定义函数，示例代码如下所示：

def hello(name="Surpass"):

def welcome(country="China"):

return "Hello,"+name.capitalize()+",Welcome to "+country

print(welcome())

hello()

其输出结果如下所示：

Hello,Surpass,Welcome to China

上述示例中，内部函数welcome表示欢迎来到某个国家，而且这个函数位于hello函数内部，只有通过调用hello函数时才能生效，测试代码如下所示：

def hello(name="Surpass"):

def welcome(country="China"):

return "Hello,"+name.capitalize()+",Welcome to "+country

print(welcome())

try:

print(welcome())

except Exception as ex:

print(ex)

其输出结果如下所示：

name 'welcome' is not defined

通过上面的示例代码可以得到以下总结：

在函数funcA中可以定义函数funcB，但funcB无法在函数funcA之外进行调用

1.3 在函数中返回函数

通过前面两个示例，函数即可以返回其值，也可以返回其函数对象，示例代码如下所示：

def hello(type=1):

def name(name="Surpass"):

return "My name is "+name

def welcome(country="China"):

return " Welcome to "+country

def occupation(occupation="engineer"):

return " I am "+occupation

if type==1:

return name

elif type==2:

return welcome

else:

return occupation

在函数hello中定义了3个函数，然后根据type参数来返回不同的信息，在hello函数中，返回都为函数对象，可视为变量，运行以下代码：

print(hello(1))

print(hello(1)())

func=hello(1)

print(func())

其输出结果如下所示：

.name at 0x000001D65783D5E8>

My name is Surpass

My name is Surpass

注意上面在写代码上的区别，如果不加括号，则代表仅返回函数对象，添加括号则代表调用函数，总结如下所示：

在函数funcA中可以定义多个函数funcB...，并且可以把funcB当成对象进行返回

1.4 把函数传递给函数

在Python中，既然一切都为对象，那函数也可以做参数传递给另一个函数，示例代码如下所示：

import datetime

import time

def hello(name="Surpass"):

print(f"Hello,{name}")

def testFunc(func):

print(f"current time is {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")

hello()

time.sleep(2)

print(f"current time is {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")

testFunc(hello)

其输出结果如下所示：

current time is 2020-05-17 14:58:56

Hello,Surpass

current time is 2020-05-17 14:58:58

在函数testFunc中接收参数为函数类型的函数hello，而且并未改变函数hello的任何内容，且实现在函数hello前后增加一些内容。因此我们可以总结如下所示：

函数funcA传递到函数funcB，函数funcB仅在函数funcA运行前后有操作，但不改变funcA，这就是装饰器的锥形。

2.装饰器

2.1 闭包

维基的解释如下所示：

在计算机科学中，闭包（Closure），又称词法闭包（Lexical Closure）或函数闭包（function closures），是引用了自由变量的函数。这个被引用的自由变量将和这个函数一同存在，即使已经离开了创造它的环境也不例外。所以，有另一种说法认为闭包是由函数和与其相关的引用环境组合而成的实体。闭包在运行时可以有多个实例，不同的引用环境和相同的函数组合可以产生不同的实例。

Python里面的闭包是一种高阶函数，返回值为函数对象，简单来讲就是一个函数定义中引用了函数外定义的变量，并且该函数可以在其定义环境外执行，这种函数称之为闭包。详细如下图所示：

在函数make_averager中，series为make_averager函数的局部变量，在averager函数中series称之为自由变量（未在本地作用域中绑定的变量）

示例如下所示：

def outter(name):

def inner():

print(f"para is {name}")

return inner

内部函数inner()可以使用外部函数outter()的参数name，最后返回内部函数对象inner。可以按照在函数中返回函数进行调用。现在我们将outter换成decorator，inner换成wrapper，如下所示：

def decorator(name):

def wrapper():

print(f"para is {name}")

return wrapper

以上这种形式就是装饰器，返回值为wrapper对象并等候调用，一旦被调用就运行 print(f"para is {name}")输出结果。对于装饰器而言，严格定义来讲，参数是函数而不是变量，常用形式如下所示：

def decorator(func):

def wrapper():

return func()

return wrapper

2.2 装饰器初体验

我们先来看看一个简单的示例，代码如下所示：

def hello():

print("call hello function")

def decorator(func):

def wrapper():

return func()

return wrapper

tmp=decorator(hello)

tmp()

其输出结果如下所示：

call hello function

装饰器的特性就是给原函数做装饰，但不改变原函数的内容，在以下代码中，希望在运行原函数func()之前，输出原函数的名字：

def hello():

print("call hello function")

def decorator(func):

def wrapper():

print(f"before call func name is {func.__name__}")

return func()

return wrapper

tmp=decorator(hello)

tmp()

其输出结果如下所示：

before call func name is hello

call hello function

经过前面的不断学习，相信已经初步掌握了装饰器的原理，如果每次都这样调用是不是太麻烦了，于是Python提供了一种语法糖@装饰函数写在被装饰函数上面即可。如下所示：

def decorator(func):

def wrapper():

print(f"before call func name is {func.__name__}")

return func()

return wrapper

@decorator

def hello():

print("call hello function")

hello()

其输出结果如下所示：

before call func name is hello

call hello function

上面这种写法等价于

tmp=decorator(hello)

tmp()

语法糖 (syntactic sugar)：指计算机语言中添加的某种语法，对语言的功能没有影响，但是让程序员更方便地使用。

2.3 装饰器知识点

2.3.1 多个装饰器

即装饰器的特性是给函数进行装饰，那是不是一个函数可以被多个函数进行装饰，定义一个函数如下所示：

def hello(name="Surpass"):

return f"Hello,{name}"

针对以上这个函数，我们希望能完成以下功能：

字符串全部大写

将返回的字符串拆分成单个单词列表

为完成以上功能，我们定义两个装饰器如下所示：

# 装饰器一：

def toUpper(func):

def wrapper():

return func().upper()

return wrapper

# 装饰器二：

def splitStr(func):

def wrapper():

return func().split(",")

return wrapper

@splitStr

@toUpper

def hello(name="Surpass"):

return f"Hello,{name}"

print(hello())

其输出结果如下所示：

['HELLO', 'SURPASS']

以下代码等价于：

print(splitStr(toUpper(hello))())

总结一下：一个函数存在多个装饰器，顺序是按照就近原则，即哪个函数靠近被装饰函数，则优先进行装饰，上面示例中@toUpper离被装饰函数hello最近，优先运行，依次类推。

2.3.2 传递参数给装饰函数

装饰函数就是wrapper()，因为要调用原函数func，一旦它有参数，则需要将这些参数传递给wrapper()，示例如下所示：

1.没有参数的wrapper()

def decorator(func):

def wrapper():

funcName=func.__name__

print(f"Befor call {funcName}")

func()

print(f"After call {funcName}")

return wrapper

@decorator

def testFunc():

print(f"call function is testFunc")

testFunc()

其输出结果如下所示：

Befor call testFunc

call function is testFunc

After call testFunc

2.传固定参数个数的wrapper()

如果被装饰函数有传入参数，则在装饰函数添加参数即可。

def decorator(func):

def wrapper(args1,args2):

funcName=func.__name__

print(f"Befor call {funcName}")

func(args1,args2)

print(f"After call {funcName}")

return wrapper

@decorator

def testFunc(name,age):

print(f"Name is {name},age is {str(age)}")

testFunc("Surpass",28)

其输出结果如下所示：

Befor call testFunc

Name is Surpass,age is 28

After call testFunc

3.带返回值的wrapper()

如果被装饰函数有返回，则在装饰函数中将被装饰函数的结果赋给变量返回即可。

def decorator(func):

def wrapper(args1,args2):

funcName=func.__name__

print(f"Befor call {funcName}")

result=func(args1,args2)

print(f"After call {funcName}")

return result

return wrapper

@decorator

def testFunc(name,age):

return f"Name is {name},age is {str(age)}"

print(testFunc("Surpass",28))

其输出结果如下所示：

Befor call testFunc

After call testFunc

Name is Surpass,age is 28

4.无固定参数个数的wrapper()

    在学习Python函数时，如果参数较多或无法确定参数个数，可以使用位置参数(*agrs)也可以使用关键字参数(**kwargs)，示例代码如下所示：

def decorator(func):

def wrapper(*args,**kwargs):

funcName=func.__name__

print(f"Befor call {funcName}")

result=func(*args,**kwargs)

print(f"After call {funcName}")

return result

return wrapper

@decorator

def testFunc(*args,**kwargs):

sum,dicSum=0,0

for item in args:

sum+=item

for k,v in kwargs.items():

dicSum+=v

return sum,dicSum

print(testFunc(1,2,3,4,5,key1=1,key2=2,key3=5,key4=1000))

其输出结果如下所示：

Befor call testFunc

After call testFunc

(15, 1008)

2.3.3 functools.wrap

在装饰器中，装饰之后的函数名称会变乱，如一个函数为hello()，其名称为hello

def hello():

pass

hello.__name__

其最终的函数名为：

'hello'

而在装饰器中，在使用@装饰函数名称之后，其名称已经变成wrapper，原因也非常简单，因为我们最终的调用形式都是decorator(被装饰函数)，而这个函数返回的是wrapper()函数，因此名称为wrapper。示例代码如下所示：

def decorator(func):

def wrapper():

return func()

return wrapper

@decorator

def testFunc():

pass

print(testFunc.__name__)

其输出结果如下所示：

wrapper

这种情况下，多种情况下应该不需要关注，但如果需要根据函数名来进行一些操作（如反射）则会出错。如果仍然希望保持函数的原名，可以使用functools.wraps，示例代码如下所示：

from functools import wraps

def decorator(func):

@wraps(func)

def wrapper():

return func()

return wrapper

@decorator

def testFunc():

pass

print(testFunc.__name__)

其输出结果如下所示：

testFunc

仔细看上面代码，是不是装饰函数又被装饰了一次？

2.3.4 传递参数给装饰器

除了可以传递参数给装饰函数(wapper)，也可以传递参数给装饰函数(decorator)。来看看以下示例，在示例中，只有装饰函数有参数，装饰器将数值保留2位小数，如下所示：

def digitalFormat(func):

def wrapper(*args,**kwargs):

result=func(*args,**kwargs)

formatResult=round(result,

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。