Python函数——装饰器

前言

给下面的函数加上运行时间

def fib(n):
    a, b = 0, 1
    for i in range(n):
        print(b)
        a, b = b, a+b
    return b

a = fib(50)

修改一：改动函数

import  time

def fib(n):
    start = time.time()
    a, b = 0, 1
    for i in range(n):
        print(b)
        a, b = b, a+b
    print(time.time() - start)
    return b

a = fib(50)

修改二：不改动函数

def fib(n):
    a, b = 0, 1
    for i in range(n):
        print(b)
        a, b = b, a+b
    return b

import time
def wrapper(func):
    def inner(*args, **kwargs):
        start = time.time()
        a = func(*args, **kwargs)
        print(time.time() - start)
        return a
    return inner  # 返回函数名

fib = wrapper(fib)
fib(50)

忙活了这么半天，终于初具规模了！现在已经基本上完美了，唯一碍眼的那句话就是还要在做一次赋值调用。。。

装饰器

装饰器的功能：在不修改原函数及其调用方式的情况下对原函数功能进行扩展

装饰器的本质：就是一个闭包函数

满足开放封闭原则

1.对扩展是开放的

2.对修改是封闭的

通过使用装饰器语法糖来解决这个问题！

import time
def wrapper(func):
    def inner(*args, **kwargs):
        start = time.time()
        a = func(*args, **kwargs)
        print(time.time() - start)
        return a
    return inner  # 返回函数名

@wrapper  # fib = wrapper(fib)
def fib(n):
    a, b = 0, 1
    for i in range(n):
        print(b)
        a, b = b, a+b
    return b

fib(100)

上面的装饰器已经非常完美了，但是正常我们情况下查看函数的一些信息的方法在此处都会失效

import time
def wrapper(func):
    def inner(*args, **kwargs):
        start = time.time()
        a = func(*args, **kwargs)
        print(time.time() - start)
        return a
    return inner  # 返回函数名

@wrapper  # fib = wrapper(fib)
def fib(n):
    a, b = 0, 1
    for i in range(n):
        print(b)
        a, b = b, a+b
    return b

fib(100)
print(fib.__doc__)
print(fib.__name__)  # 返回 inner

# 为了不让他们失效，我们还要在装饰器上加上一点来完善它：
import time
from functools import wraps
def wrapper(func):
    @wraps(func)  # 加在最内层函数正上方
    def inner(*args, **kwargs):
        start = time.time()
        a = func(*args, **kwargs)
        print(time.time() - start)
        return a
    return inner  # 返回函数名

@wrapper  # fib = wrapper(fib)
def fib(n):
    a, b = 0, 1
    for i in range(n):
        print(b)
        a, b = b, a+b
    return b

fib(100)
print(fib.__doc__)
print(fib.__name__)  # 返回 fib

带参数的装饰器

带参数的装饰器：就是给装饰器传参

　　　　　　　　用处：就是当加了很多装饰器的时候，现在忽然又不想加装饰器了，想把装饰器给去掉了，但是那么多的代码，一个一个的去闲的麻烦，

                                      那么，我们可以利用带参数的装饰器去装饰它，这就他就像一个开关一样，要的时候就调用了，不用的时候就去掉了。给装饰器里面传个参数，

                                      那么那个语法糖也要带个括号。在语法糖的括号内传参。在这里，我们可以用三层嵌套，弄一个标识 为去标识。如下面的代码示例

import time
from functools import wraps
flag = False

def outer(flag):
    def wrapper(func):
        @wraps(func)  # 加在最内层函数正上方
        def inner(*args, **kwargs):
            start = time.time()
            if flag:
                print('执行fib')
                a = func(*args, **kwargs)
            else:
                print('不执行fib')
                a = ''
            print(time.time() - start)
            return a
        return inner  # 返回函数名
    return wrapper


"""
带参数的装饰器执行过程
fib = outer(False) (fib)
--分解
fib_decorator = outer(False)
fib = fib_decorator(fib)
--分解
fib_decorator = outer(False)
@fib_decorator
def fib(n)
所以，带参数的outer函数首先返回一个decorator函数，
再让这个decorator函数接收fib并返回新函数：
"""
@outer(True)
def fib(n):
    a, b = 0, 1
    for i in range(n):
        print(b)
        a, b = b, a+b
    return b

fib(100)
print(fib.__doc__)
print(fib.__name__)  # 返回 fib

多个装饰器叠加使用

def decorator_a(func):
    print('Get in decorator_a')

    def inner_a(*args, **kwargs):
        print('Get in inner_a')
        return func(*args, **kwargs)
    return inner_a


def decorator_b(func):
    print('Get in decorator_b')
    
    def inner_b(*args, **kwargs):
        print('Get in inner_b')
        return func(*args, **kwargs)
    return inner_b


@decorator_b
@decorator_a
def f(x):
    print('Get in f')
    return x * 2

print(f(1))

输出结果分析

"""
装饰器执行顺序自下而上，内部函数调用顺序自上而下
所以输出
Get in decorator_a
Get in decorator_b
Get in inner_b
Get in inner_a
Get in f
2
分析
当解释器执行下面这段代码时，实际上按照从下到上的顺序已经依次调用了 decorator_a 和 decorator_b ，
这是会输出对应的 Get in decorator_a 和 Get in decorator_b 。 
这时候 f 已经相当于 decorator_b 里的 inner_b 。但因为 f 并没有被调用，
所以 inner_b 并没有调用，依次类推 inner_b 内部的 inner_a 也没有调用，
所以 Get in inner_a 和 Get in inner_b 也不会被输出。
然后最后一行当我们对 f 传入参数1进行调用时， inner_b 被调用了，
它会先打印 Get in inner_b ，然后在 inner_b 内部调用了 inner_a 
所以会再打印 Get in inner_a, 然后再 inner_a 内部调用的原来的 f,
并且将结果作为最终的返回。这时候你该知道为什么输出结果会是那样，
以及对装饰器执行顺序实际发生了什么有一定了解了吧。
"""

装饰器使用举例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2018/4/4 22:38
# @Author  : hyang
# @Site    : 
# @File    : 装饰器练习.py
# @Software: PyCharm

"""
三：编写装饰器，为函数加上认证的功能，即要求认证成功后才能执行函数
四：编写装饰器，为多个函数加上认证的功能（用户的账号密码来源于文件），
要求登录成功一次，后续的函数都无需再输入用户名和密码
提示：从文件中读出字符串形式的字典，可以用eval('{"name":"egon","password":"123"}')转成字典格式
"""

user_data = {
    'user': None,
    'is_authenticated': False
}


def login_required(func):
    # 用户认证装饰器
    def inner(*args, **kwargs):
        if args[0].get('is_authenticated'):
            print('User is authenticated')
            ret = func(*args, **kwargs)
        else:
            exit("User is not authenticated !!!")
        return ret
    return inner


def get_acct_info():
    """
    get acct_info from USER.TXT
    :return: 
    """
    with open(r'USER.TXT', 'r') as f:
        for line in f:
            user_dict = eval(line)
            USER_INFO_LI.append(user_dict)


def auth_user():
    """
    认证用户
    :return: 
    """
    count = 0
    while count < 3:
        user = input('user >>> ').strip()
        pwd = input('pwd >>> ').strip()
        # print(USER_INFO_LI)
        user_flag = False
        pwd_flag = False
        for item in USER_INFO_LI:
            if user == item['name']:
                user_flag = True
                if user_flag:
                    if pwd == item['password']:
                        pwd_flag = True
        if user_flag and pwd_flag:
            # 用户认证成功
            user_data['user'] = user
            user_data['is_authenticated'] = True
            print('account login success')
            return user_data
        elif user_flag:
            # 密码不对
            print('pwd is error')
        else:
            # 用户名不存在
            print('user is not  exists')
        count += 1
    else:
        print("account [%s] too many login attempts" % user)
        exit()


@login_required
def print_info(p_data):
    print(p_data)


@login_required
def enter_x(p_data):
    print('enter_x', p_data['user'])


@login_required
def enter_y(p_data):
    print('enter_x', p_data['user'])


def logout(p_data):
    print('logout', p_data['user'])
    p_data['is_authenticated'] = False


def interactive(p_data):
    """
    interact with user
    :return:
       
    """
    menu = """
       ------- menu ---------
       1.  账户信息(功能已实现)
       2.  进入x(功能已实现)
       3.  进入y(功能已实现)
       4.  退出程序
       """
    print(menu)
    menu_dic = {
        '1': print_info,
        '2': enter_x,
        '3': enter_y,
        '4': logout
       }
    exit_flag = False
    while not exit_flag:
        user_option = input(">>:").strip()
        if user_option in menu_dic:
            menu_dic[user_option](p_data)
        else:
            print("Option does not exist!")


if __name__ == '__main__':
    USER_INFO_LI = []
    get_acct_info()
    acc_data = auth_user()
    interactive(acc_data)