首页 > 编程语言 >Python装饰器

Python装饰器

时间：2023-12-05 21:44:06浏览次数：34  
标签：index 函数 Python func time print 装饰 def

一、核心思想

在不改变被装饰对象内部代码和原有调用方式的基础之上在添加额外的功能

二、装饰器的实现过程

根据实际需要，一步一步满足需求，完成对装饰器的理解

1、简易版本

给index函数添加统计执行时间的功能

复制代码 
import time

def index():
    time.sleep(3)
    print('from index')

def home():
    time.sleep(2)
    print('from home')

def func():
    time.sleep(2)
    print('from home')

def outer(func): # 外层函数
    def get_time(): # 内层函数
 
        # 1. 在函数执行之前打一个时间点
        start_time = time.time()
        
        func()  # index() 

        # 2. 在函数执行完毕之后在打一个时间点
        end_time = time.time()

        # 3. 两个时间的差值就是函数的实际执行时间
        print("函数执行了：%s秒" % (end_time - start_time))

    return get_time  # 返回内层函数


# 利用闭包的形式来传参
# res = outer(index)  # res:get_time的内存地址
# res()  # get_time()

home = outer(home)
home()
复制代码

2、解决参数的问题

当执行不同的函数，计算不同函数的执行时间，有的函数有参数，有的函数没参数

复制代码 
def index(name, username):
    time.sleep(3)
    print('from index')

def home(name):
    time.sleep(2)
    print('from home', name)

def outer(func):
    def get_time(*args, **kwargs):
        
        # 1. 在函数执行之前打一个时间点
        start_time = time.time()
        
        func(*args, **kwargs)  # 原有函数
        
        # 2. 在函数执行完毕之后在打一个时间点
        end_time = time.time()

        # 3. 两个时间的差值就是函数的实际执行时间
        print("函数执行了：%s秒" % (end_time - start_time))

    return get_time
index = outer(index)
index('tony', username='tank')
复制代码

3、解决返回值问题

复制代码 
def home(name):
    time.sleep(2)
    print('from home', name)

def index():
    time.sleep(3)
    print('from index')
    return 'from index'

def outer(func):
    # func = index
    def get_time(*args, **kwargs):
        # func:index
        # 1. 在函数执行之前打一个时间点
        start_time = time.time()
        res=func(*args, **kwargs)  # index()  func('tony')
        # 2. 在函数执行完毕之后在打一个时间点
        end_time = time.time()

        # 3. 两个时间的差值就是函数的实际执行时间
        print("函数执行了：%s秒" % (end_time - start_time))
        return res
    return get_time
index = outer(index)
res=index()
print(res)
复制代码

4、装饰器模板

复制代码 
def outer(func):
    def inner(*args, **kwargs):
        print('这个是函数执行之前可以添加的功能')
        res = func(*args, **kwargs)
        print('这个是函数执行之后可以添加的功能')
        return res

    return inner


def index():
    print('from index')


index = outer(index)
index()
复制代码

5、装饰器的语法糖

复制代码 
'''
只要有一个函数认证成功，其他函数就不用验证了
需要一个变量来保存登录用户登录成功的标志
'''
is_login = {'is_login': False}

# 使用闭包函数实现装饰器
def login(func):
    def auth(*args, **kwargs):  # 可变长参数：接受多余的位置参数和关键字参数，没有参数则接受为空，不报错，正常执行，满足有参和无参两种使用场景
        if is_login.get('is_login'):  # 字典 get 方法取值为 False，表示 if False：条件不成立时不执行
            # 前一个函数执行完，is_login赋值为 True，执行下面的代码
            res = func(*args, **kwargs)  # 调用函数，函数的返回值赋值给 res，再返回 res 给到 auth 函数
            return res
            # 简易登录认证系统
        username = input("Enter username: ").strip()
        passwd = input("Enter password: ").strip()
        # 验证用户名密码
        if username == 'jingzhiz' and passwd == '123':
            print('登录成功！')  # 函数执行前的操作
            res = func(*args, **kwargs)  # 要执行的函数
            is_login['is_login'] = True
            return res  # 函数执行后的操作
        else:
            print('认证失败！')

    return auth

'''
 语法糖需要定义在装饰器的下方，函数的上方紧贴着
 去掉语法糖可以实现原函数的正常调用
 语法糖格式@+装饰器外层函数名
 @login的理解 
   index=login(),index 只是一个变量名，也可以是res，只是为了满足装饰器思想：不改变原函数的调用方式写成原函数名，打印内存地址于原函数不是一个
   login()会返回 auth 的（函数名）即内存地址，实现 index = auth 即 index()=auth()。
'''
@login
def index(name):
    print('from index', name)
    return '返回值测试'

@login
def home():
    print('from home')

# 装饰器的最终效果：保持函数的原始调用方式的同时，增加新的功能
res = index('jinghiz')
print(res)
home()
复制代码

6、装饰器修复技术

functools.wraps函数可以拷贝原函数的属性信息。warps源码中通过使用partial函数复制了原函数的信息。

使用修复技术的效果：函数 view_all_employees 运行时间：0.0018458366394042969 秒"。

未使用：函数 wrapper 运行时间：0.0018458366394042969 秒"。

import time
import functools
 
def time_count(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        run_time = end_time - start_time
        print(f"函数 {func.__name__} 运行时间：{run_time} 秒")
        return result
 
    return wrapper
 
def admin_required(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        global current_user
        if current_user['role'] == 'admin':
            return func(*args, **kwargs)
        else:
            print("只有管理员才能执行此操作！")
            return None
 
    return wrapper
 
@time_count
@admin_required
def view_all_employees():
    with open('employee_data_file', "r") as f:
        print("所有员工信息：")
        for line in f:
            employee_data = line.strip().split(",")
            print(f"员工姓名：{employee_data[0]}，年龄：{employee_data[1]}，职位：{employee_data[2]}")
 
view_all_employees()  # 执行被装饰的函数

 

7、双层语法糖

使用场景：将登录验证、计算函数执行时间两个功能附加给一个原函数

复制代码 
# 双层语法糖
import time

# 登录验证功能
def login_auth(func):
    # func = index
    def auth(*args, **kwargs):
        # 写登录功能
        # 1.
        username = input('username：').strip()
        password = input('password：').strip()

        # 2. 验证用户名和密码是否正确
        if username == 'kevin' and password == '123':
            print('登录成功')
            res = func(*args, **kwargs)
            return res
        else:
            print('用户名或者密码错误')
    return auth

# 计算函数执行时间
def get_time(func):
    # func = index
    def inner(*args, **kwargs):
        # func:index
        # 1. 在函数执行之前打一个时间点
        start_time = time.time()
        res = func(*args, **kwargs)  # index()  func('tony')
        # 2. 在函数执行完毕之后在打一个时间点
        end_time = time.time()

        # 3. 两个时间的差值就是函数的实际执行时间
        print("函数执行了：%s秒" % (end_time - start_time))
        return res
    return inner

@login_auth  # index=login_auth(get_time内部的inner函数名)
@get_time  # get_time内部的inner函数名，等价于get_time(index)
def index():
    time.sleep(2)
    print('from index')

index()  # auth()
复制代码

从下往上执行，最外层语法糖使用下面的函数名，即index = login_auth(inner)

下面是代码的执行顺序：
  1. 首先，装饰器 @get_time 被执行，它将函数 index 作为参数传递给装饰器函数 get_time。因为 get_time 是一个装饰器函数，它会返回一个新的函数 inner 来替换原来的函数 index。
  2. 接着，装饰器 @login_auth 被执行，它将函数 inner 作为参数传递给装饰器函数 login_auth。因为 login_auth 也是一个装饰器函数，它会返回一个新的函数 auth 来替换原来的函数 inner。
  3. 现在，函数 index 已经被装饰成 auth 函数，即 index = login_auth(get_time(index))。
  4. 当我们调用函数 index() 时，实际上是调用被装饰后的 auth 函数。auth 函数首先执行登录验证，验证通过后再执行原始函数 inner。
  5. 函数 inner 中，先记录下函数执行之前的时间，然后再执行原始函数 index（即被装饰的函数）。在执行完原始函数后，再记录下函数执行之后的时间，并计算出函数实际执行的时间。
  6. 最后，函数 auth 返回原始函数 inner 的返回值，即函数 index 的返回值。
因此，整个过程中，函数 index 实际上被双重装饰了，首先是被装饰成计算函数执行时间的函数 inner，然后再被装饰成登录验证的函数 auth。这种双重装饰的方式可以让多个装饰器按照特定顺序依次作用于同一个函数上，从而实现更加复杂的功能。

8、三层语法糖

复制代码 
def outter1(func1):
    print('加载了outter1')
    def wrapper1(*args, **kwargs):
        print('执行了wrapper1')
        res1 = func1(*args, **kwargs)
        return res1

    return wrapper1

def outter2(func2):
    print('加载了outter2')

    def wrapper2(*args, **kwargs):
        print('执行了wrapper2')
        res2 = func2(*args, **kwargs)
        return res2

    return wrapper2

def outter3(func3):
    print('加载了outter3')

    def wrapper3(*args, **kwargs):
        print('执行了wrapper3')
        res3 = func3(*args, **kwargs)
        return res3

    return wrapper3

@outter1  # index =  outter1(wrapper2) = wrapper1
@outter2  # wrapper2 = outter2(wrapper3)
@outter3  # wrapper3 = outter3(index)
def index():
    print('from index')

index()  # wrapper1 被index 调用。index() 函数执行等于 wrapper1()函数执行
复制代码

执行顺序的理解：

1、outter3 首选会被执行 ------> 加载了outter3 -------> 返回 wrapper3 给到 outter2 作为 func2 传参

2、outter2 接着会被执行------> 加载了outter2 -------> 返回 wrapper2 给到 outter1 作为 func2 传参

3、outter1 接着会被执行------> 加载了outter1 -------> 返回 wrapper1 给到 index ，此时 index = wrapper1

4、index()调用相当于wrapper1(), 此时调用wrapper1()-------> 执行了wrapper1----->func1为wrapper2，

wrapper2()被调用 ---------------------------------->执行了wrapper2----->func2为wrapper3，

wrapper3()被调用---------------------------------->执行了wrapper3----->func3为index 

index()被调用---------------------------------->‘from index’

执行结果与过程过程分析

9、有参装饰器

有参装饰器与无参装饰器对比：

1、最外层多了一层函数的嵌套，这一层带上形参。

　　第二层和第三层和之前一样，接受函数名参数和变量

2、语法糖部分：带上实参

　　无参情况，@outter就行。有参数@outter('实参')

复制代码 
# 有参装饰器就是带参数的装饰器
# 先前我们学习的装饰器就是无参装饰器：不到参数的装饰器

def outter(type):
    def login_auth(func):
        def auth(*args, **kwargs):
            # 写登录功能
            # 1.接收用户输入账号密码
            username = input('username：').strip()
            password = input('password：').strip()

            # 2. 验证用户名和密码是否正确
            # with open('')
            """
                根据不同的参数用户名和密码来自于不同的位置
            """
            if type == 'file':
                print('用户名和密码来自于文件')
            elif type == 'mysql':
                print('用户名和密码来自于MySQL')
            elif type == 'oracle':
                print('用户名和密码来自于Oracle')

            # if username == 'kevin' and password == '123':
            #     print('登录成功')
            #     res = func(*args, **kwargs)
            #     return res
            # else:
            #     print('用户名或者密码错误')
        return auth
    return login_auth

# 语法糖处添加带上参数，无参装饰器这里不用带()
@outter('file')  # @login_auth
# 如果是index函数认证，用户名和密码来自于文件  login_auth(index, 1)
def index():
    print('from index')


@outter('mysql')
# 如果是home函数认证，用户名和密码来MySQL
def home():
    print('from home')


@outter('oracle')
# 如果是func函数认证，用户名和密码来oracle
def func():
    print('from func')


# 调用函数，原有的调用方式不变
index()
home()
func() 
复制代码

10、函数版的员工管理系统

要求：

  1. 有注册、登录功能，所有数据存在文件中

  2. 添加员工、查看员工需要管理员权限

  1. 封装成函数并使用装饰器，接收参数

复制代码 
# staff直译为工作人员，且是个统称，一般用复数形式staffs。
# employee直译为雇员的意思，一般指合同工

# 全局变量
login_status = False  # 登录状态
current_user = None  # 当前的用户
user_data_file = "user_data.txt"  # 存登录系统用的账号密码
employee_data_file = "employee_data.txt"  # 员工信息

# 管理员认证功能
def admin_required(func):
    def wrapper(*args, **kwargs):
        global current_user
        if current_user['role'] == "admin":
            return func(*args, **kwargs)
        else:
            print("只有管理员才能执行此操作！")
            return None

    return wrapper

# 注册功能
def register(username, password, role):
    with open(user_data_file, "r", encoding='utf-8') as f:
        res = f.readlines()
        for zh in res:
            if username == zh.split(',')[0]:
                print('用户已经注册过了！')
                break
        else:
            with open(user_data_file, "a", encoding='utf-8') as f:
                f.write(f"{username},{password},{role}\n")
                print(f"用户 {username} 已成功注册！")

# 登录功能
def login(username, password):
    global login_status, current_user
    with open(user_data_file, "r", encoding="utf-8") as f:
        for line in f:
            user_data = line.strip().split(",")
            if username == user_data[0] and password == user_data[1]:
                login_status = True
                current_user = {"username": user_data[0], "role": user_data[2]}
                print(f"欢迎 {current_user['username']} 登录！")
                return
    print("登录失败，请检查用户名和密码！")

# 添加员工信息
@admin_required
def add_employee(name, age, position):
    with open(employee_data_file, "r", encoding="utf-8") as f:
        res = f.readlines()
        for user_info in res:
            if name == user_info.split(',')[0]:
                print(f'{name}已经添加过了！')
                break
        else:
            with open(employee_data_file, "a", encoding="utf-8") as f:
                f.write(f"{name},{age},{position}\n")
                print(f"已成功添加员工 {name}！")

# 查看指定的员工
@admin_required
def view_employee(name):
    with open(employee_data_file, "r") as f:
        for line in f:
            employee_data = line.strip().split(",")
            if name == employee_data[0]:
                print(f"员工姓名：{employee_data[0]}，年龄：{employee_data[1]}，职位：{employee_data[2]}")
                return
    print("未找到指定员工！")

# 查看所有员工
@admin_required
def view_all_employees():
    with open(employee_data_file, "r") as f:
        print("所有员工信息：")
        for line in f:
            employee_data = line.strip().split(",")
            print(f"员工姓名：{employee_data[0]}，年龄：{employee_data[1]}，职位：{employee_data[2]}")

if __name__ == "__main__":
    # # 模拟用户注册、登录和执行操作的过程
    register("admin", "admin123", "admin")
    register("jingzhiz", "user123", "common")

    # 只有在添加、查看功能之前添加login功能才能将全局变量修改，登录状态改为 True、当前用户去文本文件读取
    # login_status = True
    # current_user = {"username": user_data[0], "role": user_data[2]}
    login("jingzhiz", "jingzhiz123")

    # # 添加员工
    add_employee("张三2", 26, "工程师")
    add_employee("李四2", 22, "设计师")

    # # 查看员工
    view_employee('张三1')
    view_all_employees()
    #
    login("user", "user123")
    add_employee("王五", 30, "产品经理")
复制代码

 

标签：index,函数,Python,func,time,print,装饰,def
From： https://www.cnblogs.com/Jessica-Jmm/p/17878351.html

相关文章

  • 聪明办法学Python Talk02 debug
    Talk02如何为Python程序debug摆正心态：机器肯定是对的，程序有bug是自己的原因调试理论：“软件”的两层含义：​ 1.人类需求在信息世界的投影​ 理解错需求->bug​ 2.计算过程的精确（数学）描述​ 实现错误->bug调试：bug的触发：需求->设计->代码->Fault(bug)->Error->Failure......
  • How to use Python Decorators_2
    类也可以用来构建装饰器；现在以一个类而不是一个函数的方式，来重新构建logit；fromfunctoolsimportwrapsclasslogit(object):def__init__(self,logfile='out.log'):self.logfile=logfiledef__call__(self,func):@wraps(func)de......
  • 软件测试/人工智能|Python算术运算符：入门指南
    前言在编写程序时，可以使用算术运算符来进行基本的数学计算。Python中的算术运算符包括加法、减法、乘法、除法、取模和幂运算。本文就给大家介绍一下Python算术运算符的使用。加法运算符+加法运算符用于将两个数值相加，例如，a+b表示将a和b相加的结果。如果a和b都是数字，则加法......
  • Python数字处理：掌握核心函数与技巧
    在数据分析、科学计算和自动化脚本中，数字处理是Python编程的一个核心部分。Python提供了一系列内建函数和标准库，使得数字处理变得既简单又强大。在本篇博客中，我们将深入探讨Python中的数字处理函数，并提供一些实用的技巧，以帮助你提高编程效率和精度。1.基本数学函数Python的内建函......
  • 软件测试/人工智能|Python Pip 常用命令大全
    前言我们在使用Python进行编程时，难免需要用到Python的各种包，我们在不同的项目中需要用到不同的库，甚至需要用到同一个库的不同版本等，这些库，都是需要我们通过Python的库管理工具——pip来实现的，而pip这个工具也是Python初学者必须要学习掌握的一个工具，本文就来给大家介绍一下pip的......
  • 软件测试/人工智能|Python运算符：初学者指南
    什么是运算符？运算符是用于进行各种运算操作的符号或关键词。在数学和计算机编程中，运算符被用来表示不同的运算操作，例如加法、减法、乘法、除法等。比如:1+2，其中，1和2为操作数，+为运算符。a=18，其中，a和18为操作数，=为运算符。print(),其中，print为操作数，()为运算符。Pyt......
  • 代码随想训练营第五十六天（Python）｜ 583. 两个字符串的删除操作、72. 编辑距离
    583.两个字符串的删除操作classSolution:defminDistance(self,word1:str,word2:str)->int:n,m=len(word1),len(word2)#dp数组代表使得word1以i-1结尾和word2以j-1结尾相同的最小步数dp=[[0]*(m+1)for_inrange(n+......
  • How to use Python Decorators_0
    AuthorizationLogging通过装饰器可以来打印日志：fromfunctoolsimportwrapsdeflogit(func):@wraps(func)defwith_logging(*args,**kwargs):print(func.__name__+"wascalled")returnfunc(*args,**kwargs)returnwith_loggin......
  • Python一点通: ‘python -m pip install’ 和 ‘pip install‘ 什么区别？
    在Python中安装包可以使用包管理器pip。有两种方法运行pip来安装包：python-mpipinstall和pipinstall。在本文中，我们将讨论这两者的区别。python-mpipinstallpython-mpipinstall命令使用python可执行文件将pip模块作为脚本运行。-m选项代表“模块”，它告诉......
  • How to use Python Decorators_1
    加入了写入Log文件的Decorators：fromfunctoolsimportwrapsdeflogit(logfile='out.log'):deflogging_decorator(func):@wraps(func)defwrapped_function(*args,**kwargs):log_string=func.__name__+"wascalled&qu......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99