python重难点之装饰器详解

曾经终败给现在 2022-06-04 02:49 128阅读 0赞

# 背景 #

虽然之前看过装饰器的相关内容，但是今天想起来，一直没有好好总结一下，所以特地记录下关于装饰器的一系列用法。  
要想理解装饰器首先要明确颇python中的三个概念：  
**1.一切函数皆为对象**  
**2.高阶函数**  
**3.嵌套函数**  
然后才能理解：  
**4.什么是装饰器？**  
**5.装饰器如何实现？**  
**6.装饰器有什么用？**

# 详细解释 #

## 一切函数皆为对象 ##

准确来说在Python，一切皆为对象，此处说的点与函数相关所以将范围缩小了一下。看一个最基本的例子，我们可以发现我们可以直接将test1像变量一样赋值给a,然后a可以像函数一样使用。

def test1():
        print('i am test1')
    
    # 可将test1想变量一样赋值给a,然后a便可以像函数一样使用
    a = test1
    a()
    # output:
    # i am test1

## 高阶函数 ##

**函数参数可以接受变量，那么一个函数可以接受另一个函数作为参数，或者返回值为函数（这个稍后再说），那这种函数称之为高阶函数**,如下面这段代码：

def add (a, b, f):
    	return f(a) + f(b)
    res = add(3, -6, abs)
    print(res)

在这段代码代码中，add()就是一个高阶函数，可以看见在add()中的参数中有将abs()这个取绝对值函数做为参数。

## 嵌套函数 ##

**在一个函数的函数体内用def去申明一个函数，这样的函数叫做嵌套函数**，如下面这段代码：

def foo():
        print('in the foo')
        def bar():
            print('in the bar')
        bar()
    foo()
    # outputs:
    # in the foo
    # in the bar

通过调用foo(),将在foo()内部定义并且调用bar()。我们是稍微改动一下代码：

def foo():
        print('in the foo')
        def bar():
            print('in the bar')
        return bar # 将bar作为foo()的返回值
    a = foo()

上面这段代码稍微改了一下foo的返回值，即将bar作为foo的返回值返回了，还记得上面所说的高阶函数的定义么？这就是将函数返回的类型，然后我们将foo()赋值给变量a,这不就是我们呢所说的函数即变量的概念么？  
最后得到输出：

in the foo

如果我们在后面再加一句：

a()

将会输出：

in the bar

这表明现在这个a已经是个函数类型了，他的功能就是foo()函数里面bar()的功能。

## 什么是装饰器？ ##

说了这么多铺垫，那到底什么是装饰器呢?  
**其实装饰器的本质还是函数，它是为了装饰其他函数的，说白了就是为其他函数添加附加功能的**  
具体什么意思呢？比如我们我们之前写了一个函数，我们现在想在这个函数上添加一些功能，但是我们又不能改变在原来的函数基本上修改，而且还不能修改它的调用方式，因为它可能在很多地方已经被调用了，所以我们就必须要搞一个装饰器，来给原来的函数装饰一下，便于实现新的功能。  
那装饰器应该怎么弄？我用一个公式来概括一下：  
**高阶函数 + 嵌套函数 ----> 装饰器**  
即通过高阶函数和嵌套函数我们就可以实现一个装饰器

## 如何实现一个装饰器 ##

假设我们有一个函数func()如下，我现在想知道这个函数总共运行了多长时间，并且打印出来，而且我不能修改func()本身，并且不可以该变它的调用方式，那怎么办？

import time
    
    def func():
        time.sleep(2) #模拟一系列的操作
        print('i am func in 1')

我们经过思考，结合上文可以写下如下的函数：

def func_time(func):
        start_time = time.time()
        func()
        end_time = time.time()
        print('func time is ',end_time - start_time)
    
    func_time(func) 
    # outputs:
    # i am func in 1
    # func time is  2.0014798641204834

我们可以发现func\_time()是可以统计func()的运行时间的，但是我想要的结果是直接使用func()就可以出现这样的效果，而且以后每次这么用，都会有这样的效果啊。  
于是我们想起一切函数皆为对象，以及嵌套函数、高阶函数的用法，再改一改，得到如下的代码：

def func_time(func):
        def wrapper():
            start_time = time.time()
            func()
            end_time = time.time()
            print('func time is ',end_time - start_time)
        return wrapper
    
    func = func_time(func)
    func()

**我们在func\_time()中使用嵌套函数定义了一个wrapper()函数，然后将刚才的操作都放在这个wrapper()中了，最后我们将wrapper作为func\_time()的返回值返回了，在函数外面我们将func\_time(func)又赋值给了func(),即将wrapper赋值给了func(),也就是说func()其实是实现的wrapper()的功能，而在wrapper中不但有func()的功能而且还有计算func()运行时间的功能。最后我们每次调用func()就会实现计时的功能了。**  
到这里其实我们已经手动的实现了python的装饰器功能了，但是有没有更简单的方法呢？是有的，在python中提供了一个装饰器语法，在上面的这个例子中，我们只需在func()函数前面加上一句@func\_time。  
**@ 符号就是装饰器的语法糖，它放在函数开始定义的地方，这样就可以省略最后一步再次赋值的操作。什么是语法糖？就是计算机添加的某种语法，对语言的功能没有影响，但方便程序员使用**  
然后我们直接就可以使用func()即可，完整的也就是：

@func_time
    def func():
        time.sleep(2)
        print('i am func in 1')

也就是说@func\_time其实就是等价于

func = func_time(func)

还有一点需要注意的是**func\_time()这个函数的定义一定要写在func()定义前面**，要不然使用@func\_time,python在内存中是找不到func\_time()的位置的。  
完整的代码是这样的:

import time
    
    def func_time(func):
        def wrapper():
            start_time = time.time()
            func()
            end_time = time.time()
            print('func time is ',end_time - start_time)
        return wrapper
    
    @func_time
    def func():
        time.sleep(2)
        print('i am func in 1')
    
    func()

到此你就实现了一个基本的装饰器，但是如果你还不满足，请继续向下看。

**-------------------------------------华丽的分割线------------------------------------------**

## 如何实现一个装饰器(进阶) ##

装饰器还可以怎么用？首先第一个就是装饰器可以累计使用  
现在我有一个函数：

def say():
       return "Hello"

我希望它可以根据不同的需要实现以下两种输出，不定时切换：

Hello
 Hello

我们可以用装饰器很轻易的实现,我们先实现两个装饰器：

# 用来装饰say()产生
 def makebold(fn):
 def wrapper():
 return "" + fn() + ""
 return wrapper
 
 # 用来装饰say()产生
 def makeitalic(fn):
 def wrapper():
 return "" + fn() + ""
 return wrapper

然后我们来装饰say():

@makebold
    @makeitalic
    def say():
        return "hello"
        
    print(say())

通过上面的装饰我们可以输出:

hello

如果我们将两个装饰器的位置改变一下即:

@makeitalic
    @makebold
    def say():
        return "hello"
        
    print(say())

我们就可以输出:

hello

## 如何实现一个装饰器(高阶) ##

**我们应该如何给一个被修饰的函数传递参数呢？**  
其实当你调用被装饰器返回的函数时，实际你是在调用封装函数 ,向封装函数传递参数可以让封装函数把参数传递给被装饰的函数。  
我们先来看看在最开始统计函数运行时间的小程序上做的一点改变后的样子：

def count(func):
        def sleep_time(name): # 传入参数
            start_time = time.time()
            func(name)
            stop_time = time.time()
            print(stop_time - start_time)
        return sleep_time
    
    @count
    def sleep2(name):
        time.sleep(2)
        print(name, 'sleepping in 2') #打印参数
    
    sleep2('sty')
    # outputs:
    # sty sleepping in 2
    # 2.002162218093872

我们可以看到’sty’已经作为参数传进入了，但是如果我们有的时候我们对有的被装饰函数我们不需要参数，或者我们不确定有多少个参数该怎么办？我们总不能再重复的写装饰器吧？这个时候我们就需要使用到\*args,\*\*kwargs了，**在python中参数有四类：必选参数、默认参数、可变参数和关键字参数，这4种参数都可以一起使用，或者只用其中某些，但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数和关键字参数**，关于具体的详细介绍点[这里][Link 1]。

*args:接受N个位置参数，转换为元组的形式
    **kwargs:接受N个位置参数，转换为字典的形式

这样我们就可以对我们的装饰器进行一定的改进了，如下面的代码：

import time
    
    def count(func):
        def sleep_time(*args,**kwargs):
            start_time = time.time()
            func(*args,*kwargs)
            stop_time = time.time()
            print(stop_time - start_time)
        return sleep_time
    @count
    def sleep1():
        time.sleep(2)
        print('i am sleepping in 1')
    
    @count
    def sleep2(name):
        time.sleep(2)
        print(name, 'sleepping in 2')
    
    
    sleep1()
    sleep2('sty')
    # outputs:
    # i am sleepping in 1
    # 2.0013535022735596
    # sty sleepping in 2
    # 2.0010647773742676

在这段代码中我们利用装饰器装饰了两个函数sleep()和sleep1(),sleep()没有传参数，sleep1()传了一个参数，发现都可以完好运行。

**一个问题需要引起你的注意：**  
在上面的代码最后添加下面的两行，我们打印下sleep1()和sleep2()的名字

print('sleep1 name is :', sleep1.__name__)
    print('sleep2 name is :', sleep2.__name__)

得到的结果是：

sleep1 name is : sleep_time
    sleep2 name is : sleep_time

虽然我们知道sleep1()和sleep2()就是执行的sleep\_time()的功能，但是我们还是不愿意看见它的真实名字改变。这并不是我们想要的！我们希望的结果输出应该是：

sleep1 name is : sleep1
    sleep2 name is : sleep2

这里的函数被sleep\_time()替代了。它重写了我们函数的名字和注释文档(docstring)。幸运的是Python提供给我们一个简单的函数来解决这个问题，那就是functools.wraps。我们修改一下上例, 在封装函数前加上@wraps(func),可以得到：

from functools import wraps
    import time
    
    def count(func):
        @wraps(func)    #在封装函数前加上
        def sleep_time(*args,**kwargs):
            start_time = time.time()
            func(*args,*kwargs)
            stop_time = time.time()
            print(stop_time - start_time)
        return sleep_time
    @count
    def sleep1():
        time.sleep(2)
        print('i am sleepping in 1')
    
    @count
    def sleep2(name):
        time.sleep(2)
        print(name, 'sleepping in 2')
    
    
    sleep1()
    sleep2('sty')
    print('sleep1 name is :', sleep1.__name__)
    print('sleep2 name is :', sleep2.__name__)
    #Outputs:
    # i am sleepping in 1
    # 2.0020651817321777
    # sty sleepping in 2
    # 2.002112627029419
    # sleep1 name is : sleep1
    # sleep2 name is : sleep2

## 装饰器实战之授权认证 ##

### 需求：假如现在一个网站有三个页面，index, home, bbs, 其中index页面是你不需要登录就可以查看的，而home，bbs是需要登录才能查看的，并且告诉我登录授权形式，有local和remote两种可以选择，我们应该怎么做？ ###

**解决方法：装饰器高阶用法，需要给装饰器一开始就传参数，需要在装饰器中再写一个函数传递被装饰函数。说的可能有点绕，具体查看下面的代码：**

from functools import wraps
    
    user, passwd = 'sty', '1234'  # 定义一个默认的用户名和密码
    def auth(auth_type):
        print('now auth_type is:', auth_type)
        def outer_wrapper(func): # 又设了一层函数,来传递被装饰函数的
            @wraps(func)
            def wrapper(*args, **kwargs):
                user_name = input("UserName:").strip()
                pass_word = input("PassWord:").strip()
    
                if user == user_name and passwd == pass_word:
                    print("\033[32;1mUser has passed authentication\033[0m")  #让打印带颜色显示
                    func(*args, **kwargs)
                else:
                    print("\033[31;1mInvalid username or passward\033[0m")
            return wrapper  
        return outer_wrapper
    
    def index():
        print("welcome to the index page")
    
    @auth(auth_type='local') #等价于home = auth(auth_type='local')(home)
    def home():
        print("welcome to the home page")
    
    @auth(auth_type='remote') #等价于home = auth(auth_type='ldap')(home)
    def bbs():
        print("welcome to the bbs page")
    
    index()
    print('login in home, input name and password:')
    home()
    print('login in bbs: input name and password:')
    bbs()

我们注意到：  
**@auth(auth\_type=‘local’) 等价于home = auth(auth\_type=‘local’)(home)**  
**@auth(auth\_type=‘remote’) 等价于home = auth(auth\_type=‘ldap’)(home)**  
当这样看的时候我们就不难理解它是如何实现的了  
到此装饰器的几乎大部分功能就差不多了，其他的一些具体用法还需要你逐渐去探索

## 最后提一句 ##

**在学习装饰器的时候，如果你还想从更加深入的去理解，那你就得需要知道’闭包’，关于什么是闭包？以及它和装饰器的关系？有时间将在接下来的博客中提到。**

# 参考文档： #

https://stackoverflow.com/questions/739654/how-to-make-a-chain-of-function-decorators  
https://stackoverflow.com/questions/13857/can-you-explain-closures-as-they-relate-to-python  
https://segmentfault.com/a/1190000004461404  
http://www.cnblogs.com/itech/archive/2011/12/31/2308640.html  
http://www.cnblogs.com/vamei/archive/2012/12/15/2772451.html

**转载请注明出处：**  
CSDN:楼上小宇\_home:http://blog.csdn.net/sty945  
简书：楼上小宇：http://www.jianshu.com/u/1621b29625df

[Link 1]: https://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000/001374738449338c8a122a7f2e047899fc162f4a7205ea3000#0