闭包函数，装饰器详解

最新推荐文章于 2024-09-26 11:55:47 发布
最新推荐文章于 2024-09-26 11:55:47 发布
阅读量676 收藏 7
点赞数 15
文章标签： python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41936563/article/details/141424833
版权

闭包函数

【1】闭包函数两大特征

1.闭：定义在函数内部的函数

2.包：内部函数使用了外层函数名称空间中的名字

【2】在代码中怎么走

def outer():
    def inner():
        print(f'真简单')
    return inner

res = outer()

在上述代码中怎么走

  • 第一步定义outer函数,什么时候执行这个函数里的代码，要遇到outer()才会执行，
  • 第二步到res = outer()，=是赋值符号所以先看outer()
  • 第三步有了outer()才会执行里面的代码，进入到里面执行def inner():
  • 第四步因为没有inner()所以inner函数里面的代码不会执行，只会返回一个inner函数名
  • 第五步，然后把inner这个函数名给了res这个变量，使得res指向了inner函数里的函数体
    • 然后res()就相当于inner()
def outer():
    def inner():
        print(f'真简单')
    return inner

res = outer()
res() # 真简单

现在inner()是不是闭包函数

def outer():
    def inner():
        print(f'真简单')
    return inner
# 现在只是只是在outer函数内部，并没有使用了外层函数名称空间中的名字

def outer():
    x = 741
    def inner():
        print(f'真简单'，x)
    return inner
# 现在inner算是真正的闭包函数

执行代码顺序

# 最后输出999还是741
def outer():
    x = 741
    def inner():
        print(f'真简单',x)
    return inner
x=999
res = outer()
res()  # 真简单 741
# inner是在outer 局部里面的的局部里面的，inner本身没有x，所以他会往上找，就找到outer局部里面的x=741，跟x=999无关

【3】闭包函数实际应用

闭包函数是给函数整体传参的另一种方式

函数体传参方式一：形参


def index(username):
    print(username)   
 
# 函数体代码需要什么就可以在形参中写什么
index('silence')  # silence # 在调用index这个函数时就必须给他一个username参数

函数体传参方式二：闭包

def outer():
    username = 'silence'
    def index():
        print(username) # 永远使用的都是silence
    return index

res = outer()
res()    # silence

多个传递

def outer(username):
    # username = 'silence'
    def index():
        print(username)
    return index

res = outer('silence')
#形参username与值silence临时绑定>>>放在了outer局部名称空间中
res()  # silence
rest = outer('happy')
rest() # happy

代码执行顺序图

装饰器

【1】简介

装饰器是由名称空间，函数名，闭包函数等整合到一起的产物

【2】装饰器定义

在不改变被装饰对象原有的调用方式和内部代码的情况下

给被装饰对象添加新功能

【3】装饰器原则

对扩展开发，对修改封闭

【4】装饰器了解

import  time
print(time.time()) #1713259590.5478706
# 上述数字是时间戳：1970年1月1日0时0分0秒距离刚刚代码运行的秒数


import  time
time.sleep(4)  # 让程序原地等待四秒
print("你真棒")


import  time

def index():
    time.sleep(3)
    print('from index')
star_time = time.time() # 函数执行之前获得一个时间戳
index()
end_time = time.time() # 函数执行之后获得一个时间戳
print(end_time - star_time)  # 两个时间戳的差值就是函数的执行时间
# from index 3.000314950942993

【5】代码怎么生成一个装饰器

封装成函数之后，调用方式改变了，不符合装饰器原则

#缺陷一:
    # 代码写死了，无法统计其他函数的执行时间 只有index()
    # 如何解决：----> 将函数名通过形参的形式传入，例如get_time(in)
# 缺陷二：    
    # 封装成函数后 以下代码中 index()调用方式改变成了get_time(index)
    # 通过形参的形式传入解决不掉
import  time

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

def get_time():
    star_time = time.time() # 函数执行之前获得一个时间戳
    index()
    end_time = time.time() # 函数执行之后获得一个时间戳
    print(end_time - star_time)  # 两个时间戳的差值就是函数的执行时间

get_time()

装饰器简易版本（无参装饰器）

import  time
def index():
    time.sleep(3)
    print('from index')
def outer(func):
    def get_time():
        star_time = time.time() # 函数执行之前获得一个时间戳
        func()  # 调用了真正的index函数
        end_time = time.time() # 函数执行之后获得一个时间戳
        print(end_time - star_time)  # 两个时间戳的差值就是函数的执行时间
    return get_time  

index = outer(index)
index() # 看似调用的是index其实调用的是get_time
print(index)  # 全局名称空间中的index指向的是get_time函数体代码

执行顺序

装饰器进阶版本（有参装饰器）

解决的是参数问题

程序报错

import  time
def home(a):
    time.sleep(3)
    print('from home')
def outer(func_name):
    def get_time():
        star_time = time.time()
        func_name()
        end_time = time.time()
        print(end_time - star_time)
    return get_time

home = outer(home)
home() # 报错 home() missing 1 required positional argument: 'a'

函数体代码里需要一个参数，有两种办法

  • 方式一：直接形参传
  • 方式二：再进行一次闭包操作
import  time
def home(a):
    time.sleep(3)
    print('from home')
def outer(func_name):
    def get_time(a):     # 意思就是在调用get_time时候也要给他传递一个参数
        star_time = time.time()
        func_name(a)
        end_time = time.time()
        print(end_time - star_time)
    return get_time

home = outer(home)
home('silence')     # home就是调用的get_time 所以需要一个参数'silence'
# from home
# 3.011603593826294

我们根本不知道即将执行的函数是否需要参数但是还想让他正常运行，于是


import  time
def index():
    time.sleep(2)
    print("from index")
def home(a):
    time.sleep(3)
    print('from home')
def outer(func_name):
    def get_time(*arga,**kwargs):
        star_time = time.time()
        func_name(*arga,**kwargs)
        end_time = time.time()
        print(end_time - star_time)
    return get_time

home = outer(home)
home('silence')
index = outer(index)
index()
# from home
# 3.008333921432495
# from index
# 2.011590003967285

图解

完整版解释器

解决的是返回值问题

import  time
def index(a,b):
    time.sleep(2)
    print(a, b, "from index")
    return '加油！'

def outer(func_name):
    def get_time(*arga,**kwargs):
        star_time = time.time()
        func_name(*arga,**kwargs)
        end_time = time.time()
        print(end_time - star_time)
    return get_time


index = outer(index) # 接收函数的返回值
res = index(11,22)
print(res)
# 11 22 from index
# 2.0102128982543945
# None

为什么是返回None,其实是拿到的是get_time的返回值，但是get_time没有返回值，所以是None

想让index有返回值怎么办

import  time
def index(a,b):
    time.sleep(2)
    print(a, b, "from index")
    return '加油！'

def outer(func_name):
    def get_time(*arga,**kwargs):
        star_time = time.time()
        res=func_name(*arga,**kwargs)  # 执行真正的index函数
        end_time = time.time()
        print(end_time - star_time)
        return res
    return get_time


index = outer(index) # 接收函数的返回值
res = index(11,22)
print(res)

装饰器模板

# 万能模板
def outer(func_name): # func_name 用于接收被装饰的对象（函数）
    def inner(*args, **kwargs):
        print('执行被装饰函数之前，可以做的额外操作')
        res = func_name(*args, **kwargs) # 执行真正的被装饰函数
        print('执行被装饰函数后，可以做的额外操作')
        return res # 返回真正函数的返回值
    return inner

例题：验证登陆

def home(*args, **kwargs):
    print('我是home函数，只有silence才能调用')

def outer(func_name):
    def inner(*args, **kwargs):
        # 执行home前先获取用户数据
        username = input('username>>>:').strip()
        password = input('password>>>:').strip()
        if username == 'silence' and password == '741':
            res = func_name(*args, **kwargs) # 执行真正的被装饰函数
            return res  # 返回真正函数的返回值
        else:
            print('你没有资格执行')
    return inner
home = outer(home)
home()
# username>>>:silence
# password>>>:741
# 我是home函数，只有silence才能调用

或者是

def index():
    print("Hello")


def outer(func_name):
    def inner(*args, **kwargs):
        # 执行home前先获取用户数据
        username = input('username>>>:').strip()
        password = input('password>>>:').strip()
        if username == 'silence' and password == '741':
            res = func_name(*args, **kwargs) # 执行真正的被装饰函数
            return res  # 返回真正函数的返回值
        else:
            print('你没有资格执行')
    return inner
# home = outer(home)
# home()
index = outer(index)
index()
# username>>>:silence
# password>>>:741
# Hello

装饰器语法糖

仅仅是让代码编写的更加好看，简洁

def outer(func_name):
    def inner(*args, **kwargs):
        print('执行函数之前的操作')
        res = func_name(*args, **kwargs)
        return res
    return inner


@outer   # 写在想要装饰的函数的头上   等价于index = outer(index)
def index(*args, **kwargs):
    print('from index')
@outer   # 等价于home = outer(home)
def home():
    print('from home')
# index = outer(index)  # 总感觉这一行代码有些low
index()
home()
# 执行函数之前的操作
# from index
# 执行函数之前的操作
# from home

语法糖内部原理

1.使用时最好跟在被装饰对象的上方

2.语法糖会自动将下面紧挨着的函数名传给@后面的函数调用

装饰器修复技术

1. help可以查看指定函数的注释信息

ef outer(func_name):
    def inner(*args, **kwargs):
        print('执行被装饰器之前可以做的操作')
        res = func_name(*args, **kwargs)
        return res
    return inner


@outer   # 写在想要装饰的函数的头上   等价于index = outer(index)
def index(*args, **kwargs):
    print('from index')
   # 等价于home = outer(home)
def home():
    '''这是一个注释'''
    print('from home')
print(help(home)) 
help(len)
# home()
    # 这是一个注释
    
# len(obj, /)
    # Return the number of items in a container.

2. 装饰器修复

语法固定搭配

  • from functools import wraps
    • @wraps(func_name)
from functools import wraps
def outer(func_name):  # func_name 用于接收被装饰的对象（函数）
    @wraps(func_name)
    def inner(*args, **kwargs):
        print('执行被装饰器之前可以做的操作')
        res = func_name(*args, **kwargs)
        return res
    return inner


@outer   # 写在想要装饰的函数的头上   等价于index = outer(index)
def index(*args, **kwargs):
    print('from index')
   # 等价于home = outer(home)
@outer
def home():
    print('from home')

index()
home()
.訨.
关注
Python高级特性之闭包与装饰器实例详解
01-02
本文实例讲述了Python高级特性之闭包与装饰器。分享给大家供大家参考，具体如下： 闭包 1.函数参数： (1)函数名存放的是函数的地址 (2)函数名()存放的是函数内的代码 (3)函数名只是函数代码空间的引用，当函数名...
Python闭包和装饰器用法实例详解
01-20
本文实例讲述了Python闭包和装饰器用法。分享给大家供大家参考，具体如下： Python的装饰器的英文名叫Decorator，作用是完成对一些模块的修饰。所谓修饰工作就是想给现有的模块加上一些小装饰（一些小功能，这些小...
函数，闭包，装饰器详解
边缘拼命划水的小陈
08-24 170
再讲装饰器之前先说一下函数，首先看下面的例子（只适合初学者阅读）： def func(): pass print('in func') #可以把函数内存地址赋值给另一个对象，导致另一个对象也指向了函数代码 f=func f() 输出的结果为：in func 结果说明可以把内存地址传给别的对象 def func(): print('in func') def fu...
python 闭包和装饰器详解
热门推荐
shine的博客
05-09 2万+
python 闭包，装饰器 一 闭包 如果在一个函数的内部定义了另一个函数，外部的函数叫它外函数，内部的函数叫它内函数。 1 闭包条件 　　 1 在一个外函数中定义了一个内函数。 2 内函数里运用了外函数的临时变量。 3 并且外函数的返回值是内函数的引用。 一般情况下，如果一个函数结束，函数的内部所有东西都会释放掉，还给内存，局部变量都会消失。但是闭包...
python闭包和装饰器详解_python中闭包和装饰器
weixin_42635849的博客
01-14 646
闭包的定义：定义一个函数，在函数的内部再定义一个内部函数，并且这个函数用到了外部函数的变量，那么将内部函数和用到的变量称之为闭包。闭包的定义示例:# 定义一个外部函数def decorator(func):# 再函数内部再定义一个内部函数def inner():print("这是一个闭包")# 内部函数引用了外部函数的变量func()# 返回内部函数的函数名指向的地址，即返回闭包return in...
python 闭包和装饰器详解_Python闭包与装饰器原理及实例解析
weixin_39851279的博客
11-29 136
一、闭包闭包相当于函数中，嵌套另一个函数，并返回。代码如下：def func(name): # 定义外层函数def inner_func(age): # 内层函数print('name: ', name, ', age: ', age)return inner_func # 注意此处要返回，才能体现闭包bb = func('jayson') # 将字符串传给func函数，返回inner_func并...
python闭包和装饰器详解_轻松理解python中的闭包和装饰器 (下)
weixin_42443651的博客
02-11 213
在上篇我们讲了python将函数做为返回值和闭包的概念，下面我们继续讲解函数做参数和装饰器，这个功能相当方便实用，可以极大地简化代码，就让我们go on吧！能接受函数做参数的函数我们称之为高阶函数，例如filter, map, reduce这些函数可以定义一个函数作为高阶函数例如：def func(x, y, f):return f(x)+f(y)可以这样调用func(2,-1,abs)函数...
python闭包和装饰器详解,Python闭包和装饰器
weixin_35572363的博客
03-27 180
闭包闭包的定义在函数嵌套的前提下，内部函数使用了外部函数的变量，并且外部函数返回了内部函数，我们把这个使用外部函数变量的内部函数称为闭包。闭包的构成构成条件：在函数嵌套(函数里面再定义函数)的前提下内部函数使用了外部函数的变量(还包括外部函数的参数)外部函数返回了内部函数# 定义一个外部函数def func_out(num1):# 定义一个内部函数def func_inner(num2):# 内部...
python闭包和装饰器详解_Python高级特性之闭包与装饰器实例详解
weixin_35025136的博客
02-11 149
本文实例讲述了Python高级特性之闭包与装饰器。分享给大家供大家参考，具体如下：闭包1.函数参数：(1)函数名存放的是函数的地址(2)函数名()存放的是函数内的代码(3)函数名只是函数代码空间的引用，当函数名赋值给一个对象的时候，就是引用传递def func01():print("func01 is show")test = func01print(func01)print(test)test(...
Python闭包和装饰器详解（以及区别）
weixin_64476458的博客
02-19 6762
闭包与装饰器
python 闭包和装饰器详解_Python 函数（类）的装饰器与闭包
weixin_39881167的博客
11-29 95
装饰器是在函数调用上的修饰。这些修饰仅是当声明一个函数或者方法的时候，才会应用的额外调用。装饰器的语法看起来像是这个样子：def decorator(func2bedecorated):#定义装饰器```return wrappedFunc@decorator([dec_opt_args])#使用装饰器def func2bedecorated([func_opt_args]):#定义被装饰的函数`...
Python高阶函数、闭包和装饰器详解
一个野生自学的运维狗
05-10 342
高阶函数 filter() 匿名函数 lambda map() sort() sorted() 闭包 求多个数的平均值 形成闭包的要件 装饰器
python中函数总结之装饰器闭包详解
12-24
装饰器就是包装原来的函数，从而在不需要修改原来代码的基础之上，可以做更多的事情。 装饰器语法如下： @deco2 @deco1 def func(arg1,arg2...): pass 这个表示了有两个装饰器的函数，那么表示的含义为：func = ...
简单题101. 对称二叉树 （python）20240922
Sep21m_wyy的博客
09-22 316
【代码】简单题101. 对称二叉树 （python）20240922。
【工具】Windows｜两款开源桌面窗口管理小工具Deskpins和WindowTop
qq_46106285的博客
09-21 870
写这篇的初衷是怕自己忘了这两个工具的名字。
Python精选200Tips：171-175
最新发布
AnFany
09-26 560
Python深度学习的项目
ubuntu安装libtorch
meng_152634的博客
09-25 562
nouveau是由第三方为NVIDIA显卡开发的一个开源3D驱动，ubuntu默认集成了nouveau驱动，安装NVIDIA驱动前必须禁用系统自带的显卡驱动nouveau，否则安装NVIDIA驱动时会报错。，一定要确定好安装的CUDA版本是否支持显卡的算力，否则安装成功也无法使用GPU加速。如果cmake版本低于3.18，会出现下面的报错，这是由于低于3.18的cmake不支持CUDA17的编译，需要更新cmake版本。因为安装的CUDA版本为12.1，这里选择最新版的CUDNN 9.4.0进行安装。
Python 类class的用法详解
十七次方
09-22 719
在 Python 中，使用 class 关键字来定义一个类。类定义通常包括类变量、实例变量和方法。
python获取滑块验证码需要滑动的距离
qq_62975494的博客
09-20 571
我们发现图片是base64格式通过API直接发送。
Python闭包与装饰器详解
"本文主要介绍了Python中的闭包和装饰器，包括它们的概念、使用方法以及如何从闭包引申出装饰器。通过示例代码详细解释了闭包和装饰器的工作原理，帮助读者掌握这两种重要的编程技巧。" 闭包是Python编程中的一种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值