Python 编程——函数式编程（装饰器）

最新推荐文章于 2022-05-24 16:18:20 发布

偶尔偶尔

最新推荐文章于 2022-05-24 16:18:20 发布

阅读量321

点赞数

分类专栏： Python 编程文章标签： decorator 多个装饰器的执行顺序

本文链接：https://blog.csdn.net/weixin_44209804/article/details/88774438

版权

Python 编程专栏收录该内容

23 篇文章 1 订阅

订阅专栏

一、装饰器

1.什么是装饰器？

想要增强函数的功能，比如，在函数调用前后自动打印日志，但又不希望修改函数的定义，这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。

装饰器：
概念： 把一个函数当作参数，返回一个替代版的函数；本质上就是一个返回函数的函数
“在不改变原函数的基础上，给函数增加功能”
其实简单的理解装饰器，就是一个化妆师，给函数化妆

简单示例：

def outer(func):
    def inner():
        print('***************')
        func()
    return inner   #inner其实是我们装饰后的新函数

@outer    ##语法糖（可以不用重新定义函数名）
def func1():
    print('have a nice day')
@outer
def func2():
    print('welcome')

func1()
func2()

注意：
outer()就相当于一个‘化妆师’
将传进来的‘参数’装饰，然后返回‘一个装饰好的函数’
在这里插入图片描述
不使用语法糖时的调用：
func1 = outer(func1)
func1()

需求1：

def outer(func):
     def inner(age):
         if age<0:
             age = 0
         func(age)
     return inner

@outer
def say(age):
     print('name is %d years old' %(age))
say(-10)

需求2：当多个参数时

def outer(func):
    # 不定长参数
    def inner(*args):
      #添加功能
        print('#################')
        func(*args)
    return inner
@outer
def say(name,age):
    print('my name is %s,I am %d years old' %(name,age))

say('tom',18)

简单示例：

def desc(fun): #需要传递的函数(要装饰的函数)
    def add_info():
        print('儿童节快乐～～～')	#函数执行前打印
        fun()
        print('欢迎来学习～')		#函数执行后打印
    return add_info
@desc
def login():
    print('login...')
@desc
def logout():
    print('logout...')
def savemoney():
    print('save money...')
def transfermoney():
    print('transfermoney...')
login()
logout()

二、函数实现一个计时器

import random
import string
import time      #计时所用的函数模块
li = [random.choice(string.ascii_letters) for i in range(100)]

def timeit(fun):
    def wapper(*args,**kwargs):
        #args:元组  kwargs:字典
        #在函数执行之前
        start_time = time.time()
        #执行函数
        fun(*args,**kwargs)
        #在函数执行之后
        end_time = time.time()
        print('运行时间为: %.6f' %(end_time - start_time))
    return wapper

@timeit
def con_add():
    s = ''
    for i in li:
        s += (i + ',')
    print(s)
@timeit
def join_add():
    print(','.join(li))

con_add()
join_add()

在这里插入图片描述
问题1：被装饰的函数有返回值的时候怎么办？

import random
import string
import time      #计时所用的函数模块
li = [random.choice(string.ascii_letters) for i in range(100)]

def timeit(fun):
    def wapper(*args,**kwargs):
        #args:元组  kwargs:字典
        #在函数执行之前
        start_time = time.time()
        #执行函数
        fun(*args,**kwargs)
        #在函数执行之后
        end_time = time.time()
        print('运行时间为: %.6f' %(end_time - start_time))
    return wapper
@timeit
def fun_list(n):
    return [2 * i for i in range(n)]
@timeit
def fun_map(n):
    return list(map(lambda x:x*2,range(n)))

print(fun_list(5000))
print(fun_map(5000))

"""
此情况显示不出返回值
"""

解决办法：

"""
解决办法:
在装饰器函数里，将返回值赋予给一个变量res，结束时return res
def timeit(fun):
    def wapper(*args,**kwargs):
        #args:元组  kwargs:字典
        #在函数执行之前
        start_time = time.time()
        #执行函数
        res = fun(*args,**kwargs)
        #在函数执行之后
        end_time = time.time()
        print('运行时间为: %.6f' %(end_time - start_time))
        return res
    return wapper
"""

import random
import string
import time      #计时所用的函数模块
li = [random.choice(string.ascii_letters) for i in range(100)]

def timeit(fun):
    def wapper(*args,**kwargs):
        #args:元组  kwargs:字典
        #在函数执行之前
        start_time = time.time()
        #执行函数
        res = fun(*args,**kwargs)
        #在函数执行之后
        end_time = time.time()
        print('运行时间为: %.6f' %(end_time - start_time))
        return res
    return wapper

@timeit
def fun_list(n):
    return [2 * i for i in range(n)]
@timeit
def fun_map(n):
    return list(map(lambda x:x*2,range(n)))

print(fun_list(5000))
print(fun_map(5000))

在这里插入图片描述
问题2：如何保留被装饰函数的函数名和帮助信息文档

import random
import string
import time      #计时所用的函数模块
li = [random.choice(string.ascii_letters) for i in range(100)]

def timeit(fun):
    def wapper(*args,**kwargs):
        #args:元组  kwargs:字典
        #在函数执行之前
        start_time = time.time()
        #执行函数
        fun(*args,**kwargs)
        #在函数执行之后
        end_time = time.time()
        print('运行时间为: %.6f' %(end_time - start_time))
    return wapper

@timeit
def fun_list(n):
    """这是fun_list函数，被timeit装饰"""
    return [2 * i for i in range(n)]
@timeit
def fun_map(n):
    """这是fun_map函数，被timeit装饰"""
    return list(map(lambda x:x*2,range(n)))

print(fun_list.__name__)
print(fun_list.__doc__)
print(fun_map.__name__)
print(fun_map.__doc__)
"""
此情况下不显示函数名，也不显示函数的帮助信息文档
"""

在这里插入图片描述
解决办法：

"""
解决方法:
在装饰器函数里再加装饰器:
import functools
li = [random.choice(string.ascii_letters) for i in range(100)]

def timeit(fun):
    @functools.wraps(fun)
    def wapper(*args,**kwargs):
        #args:元组  kwargs:字典
        #在函数执行之前
        start_time = time.time()
        #执行函数
        fun(*args,**kwargs)
        #在函数执行之后
        end_time = time.time()
        print('运行时间为: %.6f' %(end_time - start_time))
    return wapper

"""

import random
import string
import time      #计时所用的函数模块
import functools
li = [random.choice(string.ascii_letters) for i in range(100)]

def timeit(fun):
    @functools.wraps(fun)
    def wapper(*args,**kwargs):
        #args:元组  kwargs:字典
        #在函数执行之前
        start_time = time.time()
        #执行函数
        fun(*args,**kwargs)
        #在函数执行之后
        end_time = time.time()
        print('运行时间为: %.6f' %(end_time - start_time))
    return wapper

@timeit
def fun_list(n):
    """这是fun_list函数，被timeit装饰"""
    return [2 * i for i in range(n)]
@timeit
def fun_map(n):
    """这是fun_map函数，被timeit装饰"""
    return list(map(lambda x:x*2,range(n)))

print(fun_list.__name__)
print(fun_list.__doc__)
print(fun_map.__name__)
print(fun_map.__doc__)

在这里插入图片描述
练习题：
创建装饰器，要求如下：
#1. 创建add_log装饰器，被装饰的函数打印日志信息；
#2. 日志格式为: [字符串时间] 函数名: xxx，运行时间：xxx, 运行返回值结果:xxx

import time

def add_log(func):
    def wrapper(*args,**kwargs):
        start_time = time.time()
        res = func(*args,**kwargs)
        end_time = time.time()
        print('[%s] 函数名:%s,运行时间:%.6f,运行返回值结果:%d' %(
            time.ctime(),func.__name__,end_time-start_time,res
        ))
        return res
    return wrapper

@add_log
def add(x,y):
    time.sleep(1)
    return x+y

add(1,10)

在这里插入图片描述

三、装饰器的运行顺序

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

"""
当有多个装饰器的时候，从下到上调用
真实的wapper内容是从上到下执行的
"""
@decorator_a
@decorator_b
def f(x):
    print('Get in f')
    return x*2
f(1)

在这里插入图片描述

四、多个装饰器应用

需求：
[‘root’,‘admin’,‘redhat’]
多个装饰器的应用场景：
会采用多个装饰器先验证是否登陆成功，再验证权限是否足够

import inspect
def is_admin(fun):
    def wrapper(*args,**kwargs):
        # inspect.getcallargs会返回一个字典，key值：形参 value值：对应的实参
        inspect_res = inspect.getcallargs(fun,*args,**kwargs)
        print('inspect的返回值是：%s' %(inspect_res))
        if inspect_res.get('name') == 'root':
            temp = fun(*args,**kwargs)
            return temp
        else:
            print('not root user,no permisson add student')
    return wrapper

login_session = ['root','admin','redhat']
def is_login(fun):
    def wrapper(*args,**kwargs):
        if args[0] in login_session:
            temp = fun(*args,**kwargs)
            return temp
        else:
            print('Error:%s未登陆' %(args[0]))
    return wrapper

@is_login
@is_admin
def add_student(name):
    print('添加学生信息～')
add_student('westos')

五、带参数的装饰器

众多函数调用了你写的装饰器，但客户有需求说，我想实现我可以随之控制装饰器是否生效。
例如打印日志时，需要的不是全部的日志，而是有需求的进行打印某类日志。

简单示例：

import functools
import time

def log(kind):
    def add_log(func):
        @functools.wraps(func)
        def wrapper(*args,**kwargs):
            start_time = time.time()
            res = func(*args,**kwargs)
            end_time = time.time()
            print('<%s> [%s] 函数名: %s ,运行时间: %.5f ,运行返回值结果: %d'
                  %(kind,time.ctime(),func.__name__,(end_time-start_time),res))
            return res
        return wrapper
    return add_log

@log('debug')
def add(x,y):
    time.sleep(1)
    return x+y
print(add(1,2))

在这里插入图片描述
当语法糖调用时参数改变：

@log('local1')
def add(x,y):
    time.sleep(1)
    return x+y
print(add(1,2))

在这里插入图片描述
练习题：
编写装饰器required_types, 条件如下:
1). 当装饰器为@required_types(int,float)确保函数接收到的每一个参数都是int或者float类型;
2). 当装饰器为@required_types(list)确保函数接收到的每一个参数都是list类型;
3). 当装饰器为@required_types(str,int)确保函数接收到的每一个参数都是str或者int类型;
4). 如果参数不满足条件，打印 TypeError:参数必须为xxxx类型

import functools
def required_types(*kinds):
    def required(func):
        @functools.wraps(func)
        def wrapper(*args,**kwargs):
            for i in args:
                #判断被装饰函数的参数是不是我们定义的数据类型
                if not isinstance(i,kinds):
                    print('TypeError:参数必须为',kinds)
            else:
                res = func(*args,**kwargs)
                return res
        return wrapper
    return required

@required_types(str)
def mymax(a,b,c,d):
    return max(a,b,c,d)

print(mymax(1,2.5,8,9))

在这里插入图片描述

偶尔偶尔

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Python 编程——函数式编程（装饰器）

一、装饰器1.什么是装饰器？想要增强函数的功能，比如，在函数调用前后自动打印日志，但又不希望修改函数的定义，这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。装饰器：概念：把一个函数当作参数，返回一个替代版的函数；本质上就是一个返回函数的函数“在不改变原函数的基础上，给函数增加功能”其实简单的理解装饰器，就是一个化妆师，给函数化妆简单示例：def ou...
复制链接

扫一扫

专栏目录