装饰器python3菜鸟教程_认识Python装饰器

Python中的装饰器用来给Python中的函数添加一些辅助功能。比如我们可以把【输出日志】这个辅助功能写到一个装饰器里。只要我们在某个函数A之前添加了这个【输出日志】的装饰器，那么执行函数A的时候，就会自动地把关于函数A的日志输出出来。

这篇文章我们会一起学习Python装饰器的原理和使用方法，再进入装饰器的正题之前，我们先来回顾一些Python中的相关知识。

本文纲要预备知识将一个函数赋给一个变量

在函数中定义函数

在函数中返回函数

将函数作为参数传给另一个函数

装饰器的基本说明创建我们第一个装饰器

使用@符号来装饰一个函数

使用场景介绍(日志)

装饰器的拓展说明带参数的装饰器

装饰器类

在同一个函数上定义多个装饰器

参考资料

预备知识

将一个函数赋给一个变量

Python是一门面向对象的语言。在Python中，我们可以把函数当成对象来赋给某个变量。

# 定义一个函数hi

def hi(name="joey"):

return "hi " + name

# 将函数hi赋值给一个变量greet。

# 我们这里没有在使用小括号，因为我们并不是在调用hi函数

# 而是在将它放在greet变量里头。

greet = hi

print(greet())

# output：hi joey

在函数中定义函数

在Python中，我们可以在一个函数中定义另一个函数。

# 在函数中定义函数

def hi():

print("hi function begin.")

def greet2():

return "greet2 function."

def welcome():

return "welcome function."

print(greet2())

print(welcome())

print("hi function end.")

# 执行hi函数。

hi()

# output:

# hi function begin.

# greet2 function.

# welcome function.

# hi function end.

# 函数内的函数不能被直接访问到。

# 执行下面的方法时系统会报错。

greet2()

在函数中返回函数

在Python中，我们可以把函数当成返回值来返回。

# 我们将一个函数A放在另一个函数B当中，

# 并且把函数A作为函数B的返回值返回。

def hi(name="joey"):

# 定义greet子函数。

def greet():

return "greet function"

# 定义welcome子函数。

def welcome():

return "welcome function"

# 在if/else语句中，我们返回greet和welcome函数,

# 而不是greet()和welcome()。

# 因为加上小括号之后，这个函数就会被执行；

# 而不加小括号的时候，函数本身就会被传递出去。

if name == "joey":

return greet

else:

return welcome

将函数作为参数传给另一个函数

在Python中，我们还可以把函数作为一个另一个函数的参数来使用。

# 创建一个普通的函数hi。

def hi():

return "hi joey!"

# 创建一个以函数作为参数的函数doSomethingBeforeFunc。

def doSomethingBeforeFunc(func):

print("Do something before func.")

print(func())

# 把hi函数作为参数传递给doSomethingBeforeFunc函数。

doSomethingBeforeFunc(hi)

# output:

# Do something before func.

# hi joey!

装饰器中大概用到的知识点就是上面这些了。下面我们开始正式学习装饰器的内容。

装饰器的基本说明

创建我们第一个装饰器

Python中的装饰器主要用来补充或者优化某个函数的功能，也就是在某个函数执行之前或者执行之后加上一些操作。比如下面这个例子：

# 创建一个装饰器a_new_decorator，

# 并把某个要被装饰的函数当成参数(a_func)传递到这个装饰器里。

def a_new_decorator(a_func):

def wrapTheFunction():

# 在原函数执行之前补上一些操作。

print("Do something before a_func().")

# 执行原函数。

a_func()

# 在原函数执行之后加上一些操作。

print("Do something after a_func().")

# 把被装饰过得函数作为返回值来返回。

return wrapTheFunction

接下来我们创建一个要被装饰的函数，并且使用上面的装饰器来装饰这个函数。

# 创建一个要被装饰的函数。

def a_function_requiring_decoration():

print("I am the function which needs some decoration.")

# 将上面的函数用a_new_decorator这个函数装饰起来。

a_function_requiring_decoration = a_new_decorator(a_function_requiring_decoration)

# 执行被装饰之后的函数

a_function_requiring_decoration()

# output：

# Do something before a_func().

# I am the function which needs some decoration.

# Do something after a_func().

使用@符号来装饰一个函数

在上面的例子中，我们通过下面的这句代码来装饰函数。

a_function_requiring_decoration = a_new_decorator(a_function_requiring_decoration)

但是这样的写法稍微复杂了一些，在实际应用中，我们通常通过@符号来装饰函数：

# 使用@符号来装饰一个函数

@a_new_decorator

def a_function_requiring_decoration():

print("I am the function which needs some decoration too.")

# 上面的写法等效于下面的3行代码：

# def a_function_requiring_decoration():

# print("I am the function which needs some decoration.")

# a_function_requiring_decoration = a_new_decorator(a_function_requiring_decoration)

# 执行被装饰的函数

a_function_requiring_decoration()

# output:

# Do something before a_func().

# I am the function which needs some decoration too.# Do something after a_func().

可以看到，通过使用@符号，我们简化了装饰器的写法。

但是现在还有一个小问题，函数被装饰器装饰了之后，原函数的名字改变了：

# 我们希望的函数名是a_function_requiring_decoration，

# 但是现在却变成了wrapTheFunction.

print(a_function_requiring_decoration.__name__)

# output:

# wrapTheFunction

此时，我们可以通过functools.wraps这个函数来解决函数名被改变的问题：

# 可以通过functools.wraps这个函数来解决函数名被改变的问题

from functools import wraps

def a_new_decorator(a_func):

# 调用wraps方法，把它作为一个装饰器来使用。

@wraps(a_func)

def wrapTheFunction():

print("Do something before a_func()")

a_func()

print("Do something after a_func()")

return wrapTheFunction

@a_new_decorator

def a_function_requiring_decoration():

print("I am the function which needs some decoration.")

# 此时再输出函数名，我们可以看到它变成了原来的名字。

print(a_function_requiring_decoration.__name__)

# output：

# a_function_requiring_decoration

使用场景介绍(日志)

装饰器可以简化代码，优化程序的处理过程。它可以应用在很多方面，这里简单介绍如何使用装饰器来生成日志。

from functools import wraps

# 创建一个日志装饰器

def logit(func):

@wraps(func)

def with_logging(*args, **kwargs):

print(func.__name__ + "was called.")

return func(*args, **kwargs)

return with_logging

# 生成一个被装饰的加法计算函数。

@logit

def addition_func(x):

return x + x

# 执行被装饰的加法计算函数。

result = addition_func(4)

print("result:{}".format(result))

# output:

# addition_funcwas called.

# result:8

装饰器的拓展说明

带参数的装饰器

我们可以给装饰器的方法里加上参数。带参数的装饰器会比普通的装饰器多一层函数进行包裹，多出来的这一层函数用来传递参数。

我们改写一下上面日志的例子，使得输出的日志能够保存到日志文件当中。

from functools import wraps

# 创建一个带参数logfile的装饰器logit。

# 参数说明：

# logfile: 指定保存日志的文件。

def logit(logfile='out.log'):

def logging_decorator(func):

@wraps(func)

def wrapped_function(*args, **kwargs):

log_string = func.__name__ + " was called."

print(log_string)

# 打开日志文件，并写入内容

# ‘a’: 打开一个文件用于追加。

# 如果该文件已存在，新的内容将会被写入到已有内容之后。

# 如果该文件不存在，创建新文件进行写入。

with open(logfile, 'a') as opened_file:

opened_file.write(log_string + '\n')

return func(*args, **kwargs)

return wrapped_function

return logging_decorator

# 创建一个被日志装饰器装饰的函数。

@logit()

def myfunc1():

pass

# 执行下面的函数之后，可以看到当前目录下生成了一个out.log文件。

myfunc1()

# output:

# myfunc1 was called.

装饰器类

上面的例子中，我们把装饰器写成了函数的形式。事实上，我们还可以把装饰器写成类的形式。

把装饰器写成类的形式之后，我们可以很方便地继承这些装饰器类，从而生成功能更多更丰富的装饰器子类。

比如，我们可以把上面的日志装饰器改写成如下的样子：

from functools import wraps

# 创建一个可以生成日志文件的装饰器类。

class logit(object):

def __init__(self, logfile='out.log'):

self.logfile = logfile

def __call__(self, func):

@wraps(func)

def wrapped_function(*args, **kwargs):

log_string = func.__name__ + " was called"

print(log_string)

# 打开logfile并写入

with open(self.logfile, 'a') as opened_file:

# 现在将日志打到指定的文件

opened_file.write(log_string + '\n')

# 现在，发送一个通知

self.notify()

return func(*args, **kwargs)

return wrapped_function

def notify(self):

print("Notify")

pass

# 创建一个被日志装饰器类所装饰的函数。

@logit()

def myfunc3():

pass

# 执行被装饰的函数。

myfunc3()

# output:

# myfunc3 was called.

# Notify.

我们可以继承上面的日志装饰器类，生成一个可以发送邮件的装饰器子类。

# 给上面的logit创建一个子类

class email_logit(logit):

def __init__(self, email='admin@myproject.com', *args, **kwargs):

self.email = email

super(email_logit, self).__init__(*args, **kwargs)

def notify(self):

# 这里可以用来发送一封邮件

pass

# 生成一个被日志装饰器子类装饰的函数。

@email_logit()

def myfunc5():

pass

myfunc5()

# output：

# myfun5 was called.

在同一个函数上定义多个装饰器

我们可以给同一个函数加上多个装饰器，比如下面的样子：

# 一个函数可以同时定义多个装饰器，比如：

@a

@b

@c

def f():

pass

# 它的执行顺序是从里到外，

# 最先调用最里层的装饰器，

# 最后调用最外层的装饰器，它等效于

# f = a(b(c(f)))

以上就是本文的全部内容。

参考资料菜鸟教程-Python函数装饰器本篇文章中出现的代码