python学习之【第十四篇】：Python中的装饰器

1.什么是装饰器？

器即函数

装饰即修饰，意指为其他函数添加新功能

装饰器定义：本质就是函数，功能是为其他函数添加新功能

2.遵循的原则

装饰器必须遵循以下两个原则：

• 不修改被装饰函数的源代码（开放封闭原则）
• 为被装饰函数添加新功能后，不修改被修饰函数的调用方式

3.一步一步剖析Python中装饰器原理

我们知道，装饰器就是给其他函数动态增加功能的函数。其本质还是函数。下面我们就依据装饰器必须遵循的两个原则，手动实现一个装饰器，以此来剖析装饰器的内部原理。

前置知识储备：

装饰器=高阶函数+函数嵌套+闭包

3.1需求

假设我们需要给test函数增加一个计算该函数运行时间功能，即在函数运行完毕后输出该函数运行的时间，但又不希望修改原本函数的定义，此时，我们要定义一个能计算函数运行时间的装饰器timer。

test函数如下：

def test():
    res = 0
    for i in range(100):
        res += i
    print(res)

OK,需求有了，我们现在试着动手实现一下。

3.2 低级版实现

import time

# 定义timer函数，用来计算test函数的运行时间
def timer(func):
    start_time = time.time()
    func()
    end_time = time.time()
    print('函数运行时间为：%s' %(start_time-end_time))

def test():
    res = 0
    for i in range(100):
        res += i
    print(res)

timer(test)

以上代码中，当我们想运行test函数并计算该函数的运行时间时，我们只需调用timer(test)函数即可，虽然这样算是实现了需求，但是却违反了装饰器第二条原则：为被装饰函数添加新功能后，不修改被修饰函数的调用方式。最初调用test函数只需test()即可，而现在增加了新功能后必须timer(test)这样调用才行，显然这样是不行的，代码还需要继续改进！

3.3 进阶版实现

试想一下，如果我们像timer(test)这样调用timer()函数时，并不让timer()函数直接执行，而是让它返回一个函数的地址，然后我们在把这个地址赋值给一个变量，然后再以变量( )的方式调用。这样做的好处就是：这个变量名我们可以自定义，假如我们把这个变量名还叫test，那么后续调用test()就等于调用了上面代码中的timer(test)。这样我们就遵循了装饰器的两大原则：既不修改原函数的代码，也没有修改原函数的调用方式。

话不多说，来试试看：

import time

def timer(func):
    def wrapper():
        start_time = time.time()
        func()
        end_time = time.time()
        print('函数运行时间为：%s' % (start_time - end_time))

    return wrapper

def test():
    res = 0
    for i in range(100):
        res += i
    print(res)

# timer(test)返回函数地址wrapper，将地址赋值给变量test
test = timer(test)
# 调用test()即执行了返回的函数地址wrapper函数
test()

3.4 高阶版完美实现

通过进阶版的实现，我们想计算哪个函数的运行时间，只需在该函数调用之前加一行函数名=timer(函数名)代码即可。

但如果函数非常多的话，这样还是有些繁琐。其实这个问题Python早就替我们想到了，Python提供一个语法糖@，有了这个语法糖，我们只需在被装饰函数定义前加@timer(函数名)即可，@timer(函数名)就等于函数名=timer(函数名)。

import time

def timer(func):
    def wrapper():
        start_time = time.time()
        func()
        end_time = time.time()
        print('函数运行时间为：%s' % (start_time - end_time))

    return wrapper

@timer     # @timer等同于test = timer(test)
def test():
    res = 0
    for i in range(100):
        res += i
    print(res)

test()

3.5 总结

通过以上三步实现，我们即可总结出装饰器原理：

把@timer放到被装饰函数test的定义之前，就相当于执行了test = timer(test)，由于timer()是一个高阶函数，它返回一个函数地址，所以原来的test函数仍然存在，只是现在同名的test变量指向了新的函数，于是调用test()将执行在timer()函数中返回的wrapper()函数，在wrapper()函数内，首先执行原始函数，再计算函数运行时间。

4. 装饰器执行时机

# 定义装饰器
def timer(func):
    print('----正在装饰----')
    def wrapper():
        start_time = time.time()
        func()
        end_time = time.time()
        print('函数运行时间为：%s' % (start_time - end_time))

    return wrapper

@timer     # @timer等同于test = timer(test)
def test():
    res = 0
    for i in range(100):
        res += i
    print(res)

执行以上代码，我们可以发现，当没有调用test()函数时，装饰器也会执行，也就是说，只要python解释器执行到了@timer这句代码，那么就会自动进行装饰，而不是等到调用的时候才装饰，在函数调用之前就已经对函数装饰完毕了.

5. 多个装饰器执行顺序

如果一个函数被多个装饰器装饰时，那么装饰顺序是怎样的呢？看以下代码：

# 定义装饰器1：加粗
def makeBold(func):
    print('-----准备装饰1-----')
    def wrapper():
        print('-----装饰中1-----')
        return '<b>' + func() + '</b>'
    return wrapper

# 定义装饰器2：斜体
def makeItalic(func):
    print('-----准备装饰2-----')
    def wrapper():
        print('-----装饰中2-----')
        return '<i>' + func() + '</i>'
    return wrapper

@makeBold
@makeItalic
def test():
    return 'Hello World'

print(test())
# 输出
# -----准备装饰2-----
# -----准备装饰1-----
# -----装饰中1-----
# -----装饰中2-----
# <b><i>Hello World</i></b>

运行以上代码，从输出结果上来看，当一个函数被多个装饰器装饰时，装饰的时候是从里往外装，装饰的结果也是一层一层往外套，但是装饰器执行时却是从外往里执行。

6.装饰器基本框架

# 装饰器基本框架
def decorator(func):
    def wrapper():
        func()
    return wrapper

7.被装饰函数有参数

# 被装饰函数有参数
def decorator(func):
    def wrapper(a,b):
        print('---装饰器---')
        func(a,b)
    return wrapper

@decorator
def test(a,b):
    print('----test--%s+%s' %(a,b))

test(1,2)

我们知道，当调用test(1,2)函数时，其实是调用了wrapper函数，所以要给wrapper函数传入相应的参数,而wrapper函数内部的func函数才是真正调用test函数，所以也要给func传入相应的参数。

8. 被装饰函数有return

如果被装饰的函数有返回值，那么我们需要在装饰器中将返回值接收一下。

# 被装饰函数有参数
def decorator(func):
    def wrapper(a,b):
        print('---装饰器---')
        ret = func(a,b)
        return ret
    return wrapper

@decorator
def test(a,b):
    return a + b

test(1,2)

通常情况下，为了装饰器的通用性，无论被装饰函数是否有返回值，都会在装饰器中加上return。

9. 通用装饰器

无论被装饰函数是否有return，有多少个参数，均可以适用的通用装饰器。

# 通用装饰器

def decorator(func):
    def wrapper(*args, **kwargs):
        ret = func(*args, **kwargs)
        return ret

    return wrapper

# 被装饰函数无参数，无返回值
@decorator
def test1():
    print('----test--')

# 被装饰函数有参数，无返回值
@decorator
def test2(a, b):
    print('----test--%s+%s' % (a, b))

# 被装饰函数无参数，有返回值
@decorator
def test3():
    return 'test'

# 被装饰函数有参数，有返回值
@decorator
def test4(a, b):
    return a + b

test1()             # 输出----test--
test2(1, 2)         # 输出----test--1+2
print(test3())      # 输出test
print(test4(1, 2))  # 输出3

10. 装饰器本身带有参数

如果装饰器本身需要传入参数，那就需要编写一个返回装饰器的高阶函数。

# 装饰器本身带有参数

def decorator(text):
    def wrapper(func):
        def inner(*args, **kwargs):
            print('--%s是装饰器的参数---' %text)
            ret = func(*args, **kwargs)
            return ret
        return inner
    return wrapper

@decorator('execute')
def test(a, b):
    return a + b

print(test(1, 2))
# 输出
# --execute是装饰器的参数---
# 3

和两层嵌套的装饰器相比，3层嵌套的效果是这样的：

把@decorator放到test()函数的定义处，相当于执行了语句：

test = decorator('execute')(test)(),首先执行decorator('execute')，返回的是wrapper函数，再调用返回的函数，参数是test函数，返回值最终是inner函数。最后再执行inner函数。

11.装饰器应用

我们可以编写一个验证用户是否登录的装饰器，在用户调用函数之前，先验证用户是否登录，如果登录，则可正常访问，如果未登录，则提示用户先登录。

# 装饰器应用实例：验证是否登录
user_list = [
    {'name': 'haha', 'password': '123'}
]

current_user = {'name': None, 'login': False}

def auth_dec(func):
    def wrapper(*args, **kwargs):
        if current_user['name'] and current_user['login']:
            ret = func(*args, **kwargs)
            return ret
        else:
            print('您还未登录，请您先登录，再访问页面！')
            username = input('请输入用户名：')
            pw = input('请输入密码：')

            for user_dic in user_list:
                if username == user_dic['name'] and pw == user_dic['password']:
                    current_user['name'] = username
                    current_user['login'] = True
                    ret = func(*args, **kwargs)
                    return ret
                    break
            print('用户名或密码错误')

    return wrapper

@auth_dec
def index():
    print('欢迎来到主界面')

def home():
    print('欢迎来到家园')

index()
home()

(完)