python闭包和装饰器

最新推荐文章于 2021-01-14 06:16:20 发布
最新推荐文章于 2021-01-14 06:16:20 发布
阅读量225 收藏 1
点赞数 1
分类专栏： python 文章标签： python 闭包 装饰器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zjbyough/article/details/96907715
版权

DAY 9. 闭包和装饰器

9.1 闭包

闭包就是内部函数对外部函数作用域内变量的引用

可以看出

  • 闭包是针对函数的，还有两个函数，内部函数和外部函数
  • 闭包是为了让内部函数引用外部函数作用域内的变量的

我们先写两个函数

def fun1():
    print("我是fun1")

    def fun2():
        print("我是fun2")

这样fun2就作为fun1的内部函数，此时在函数外部是无法调用Fun2的，因为

  1. fun2实际上相当于fun1的一个属性(方法)，作用域是fun1的块作用域，全局作用域中无法找到，
  2. 函数内属性的生命周期是在函数运行期间，在fun1中只是定义了fun2，并没有调用它

为了让fun2跳出fun1的生命周期，我们需要返回fun2，这样在外部获取到的fun1的返回值就是fun2，这样调用fun1的返回值就是调用了fun2,如：

def fun1():
    print("我是fun1")
    def fun2():
        print("我是fun2")
    return fun2

var = fun1()
var()
# 我是fun1
# 我是fun2

当然，这还不是一个闭包，闭包是引用了自由变量的函数，所谓自由变量可以理解为局部变量，如果fun2调用了fun1中的变量，那么fun2就是一个闭包了。如

def fun1(var1):
    def fun2():
        print(f"var1 = {var1}")
    return fun2

var = fun1(1)
var()  # var1 = 1
闭包的作用

闭包私有化了变量，实现了数据的封装，类似于面向对象

def fun1(obj):
    def fun2():
        obj[0] += 1
        print(obj)
    return fun2


if __name__ == '__main__':
    mylist = [i for i in range(5)]
    var = fun1(mylist)
    var()
    var()
    var()
    # [1, 1, 2, 3, 4]
    # [2, 1, 2, 3, 4]
    # [3, 1, 2, 3, 4]

9.2 装饰器

闭包在python中有一个重要的用途就是装饰器，装饰器接受被装饰的函数作为参数并执行一次调用，装饰器的本质还是一个闭包

def func1(func):
    def func2():
        print("func2")
        return func()
    return func2


@func1
def Demo():
    print("Demo")


if __name__ == '__main__':
    Demo()
    # func2
    # Demo
  • 首先，@func1是一颗语法糖，等价于func1(Demo)()
  • 外部函数必须能接收一个参数，也只能接受一个参数，如果有多个参数，必须再套一个函数，因为在使用@语法糖时，会自动把被修饰函数作为参数传递给装饰器
  • 内部函数必须返回被装饰函数的调用

运行流程：

  1. 把被修饰函数作为参数传递给装饰器,这时函数返回的是闭包函数func2
  2. 隐式地调用func2,相当于func2()，执行函数体，输出func2,这时函数返回值是func(),返回的直接是被修饰函数的调用，相当于直接执行被修饰函数，输出Demo

相当于：

def func1(func):
    def func2():
        print("func2")
        return func()
    return func2


# @func1
def Demo():
    print("Demo")


if __name__ == '__main__':
    # s = Demo()
    # 先把被修饰函数作为参数传递给修饰器，这里的s就是func2
    s = func1(Demo)
    # 调用闭包函数
    s()
    print(s)

    # func2
    # Demo
    # <function func1.<locals>.func2 at 0x00000117F163AD90>
9.2.1 装饰器带参数
def func1(num):
    def func2(func):
        def func3():
            if num >10:
                print("大于10")
            else:
                print("小于10")
            return func()
        return func3
    return func2


@func1(num=12)
def Demo():
    print("Demo")


if __name__ == '__main__':
    Demo()b

执行流程

  1. 将装饰器的参数传递给第一层函数，并返回第二层函数func2
  2. 将被修饰函数作为参数传递给第二层函数func2,隐式调用func2，返回闭包函数
  3. 执行闭包函数，并返回被修饰函数的调用（执行被修饰函数）
9.2.2 被修饰函数带参数

如果被修饰函数带有参数，需要把参数传递给内层闭包函数,返回被修饰函数的调用时记得加参数

def func1(func):
    def func2(arg):
        arg += 1
        # 记得加参数
        return func(arg)
    return func2

@func1
def Demo(arg):
    print(arg)

if __name__ == '__main__':
    Demo(11)  # 12
9.2.3 例
  1. 求斐波那契数列任意一项的值
import time

def code_time(func):
    '''
    修饰器，用来打印函数运行时间
    :param func: 被修饰函数
    :return: func
    '''
    start_time = time.time()
    def closer(*args,**kwargs):
        result = func(*args,**kwargs)
        codeTime = time.time() - start_time
        print(f"This code runs at:{codeTime}")
        return result
    return closer

def _Fibonacci(n):
    if n <= 1:
        return 1
    else:
        return _Fibonacci(n-1) + _Fibonacci(n-2)

@code_time
def Fibonacci(n):
    return _Fibonacci(n)


if __name__ == '__main__':
    var = Fibonacci(40)
    print(var)
    # This code runs at:61.738335609436035
    # 165580141

发现代码效率非常低，输出第四十个值需要一分多钟，这是应为每计算一个值，需要计算前两个值，这里有很多重复的，如

            10
            |
    |-----------------|
    9                 8
|--------|       |--------|
8        7       7        6

7，8被重复计算多次

所以需要把已经计算过的储存起来，计算之前先判断有没有计算过，没计算过再计算，修改程序为：

import time

def code_time(func):
    '''
    修饰器，用来打印函数运行时间
    :param func:
    :return:
    '''
    start_time = time.time()
    def closer(*args,**kwargs):
        result = func(*args,**kwargs)
        codeTime = time.time() - start_time
        print(f"This code runs at:{codeTime}")
        return result
    return closer
resultList = {0:1,1:1}
def _Fibonacci(n):
    if n <= 1:
        return 1
    else:
        if n-1 in resultList:
            a = resultList[n-1]
        else:
            a = _Fibonacci(n-1)
            resultList[n-1] = a
        if n-2 in resultList:
            b = resultList[n-2]
        else:
            b = _Fibonacci(n-2)
            resultList[n-2] = b
        return a + b

@code_time
def Fibonacci(n):
    return _Fibonacci(n)


if __name__ == '__main__':
    var = Fibonacci(40)
    print(var)

    # This code runs at:0.0
    # 165580141

速度快了很多，但重复的代码是不能忍受的，使用修饰器重新一下：

import time


def code_time(func):
    start_time = time.time()

    def closer(*args, **kwargs):
        result = func(*args, **kwargs)
        codeTime = time.time() - start_time
        print(f"This code runs at:{codeTime}")
        return result

    return closer


def modify(func):
    catch = {0: 1, 1: 1}

    def closer(*args):
        if args not in catch:
            catch[args] = func(*args)
        return catch[args]
    return closer


@modify
def _Fibonacci(n):
    if n <= 1:
        return 1
    else:
        return _Fibonacci(n - 1) + _Fibonacci(n - 2)


@code_time
def Fibonacci(n):
    return _Fibonacci(n)


if __name__ == '__main__':
    var = Fibonacci(40)
    print(var)

有20节楼梯，一次可以走1，2，3，4级，总共有多少种走法

from my_python_package import code_time


def Modify(c = None):
    if c == None:
        c = {}
    def modify(func):
        catch = c
        def closer(*args):
            if args[0] not in catch:
                catch[args[0]] = func(*args)
            return catch[args[0]]
        return closer
    return modify

@Modify()
def _Stairs(num, steps):
    count = 0
    if num == 0:
        count = 1
    elif num > 0:
        for step in steps:
            count += _Stairs(num-step,steps)
    return count

@code_time
def Stairs(num,steps):
   count = _Stairs(num,steps)
   return count

if __name__ == '__main__':
    num = 20
    steps = [step for step in range(1,5)]
    count = Stairs(num, steps)
    print(count)

    # Stairs runs at: 0.0 s
    # 283953

9.3 总结

  • 闭包：内部函数调用了外部函数作用域内的变量

    • 针对函数
    • 要有自由变量（私有变量）
    • 要点：内部函数要跳出外部函数的生命周期，需要外部函数把他return出来

  • 装饰器：

    • 基础：闭包
    • 作用：不修改原来代码的基础上拓展原函数功能
    • 用处：修改API功能，AOP编程
    • 要点：@语法糖，函数执行顺序

  • 参考链接

Python高级编程技巧（进阶）(已完结)

Python的闭包与装饰器

Junebao
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
python闭包和装饰器的区别_python中闭包和装饰器
weixin_34431283的博客
02-11 1989
前言：编程语言发展的过程中，我们为了提高代码利用率，发明了函数式编程。函数将代码封装起来，我们需要用到此功能函数的时候，调用一下就可以了。但是使用的过程中，也遇到了一些问题，比如函数实现的功能不够，或者跟我们要实现的功能有些差别。肿么办呢？打开函数内部代码，重新写？可以吗？可以！但是这就违背了函数式编程思想的初衷，代码没有重复利用，而且还破坏了原有函数代码。怎么办？聪明的人类思想的灯泡再次闪亮，咔...
Python闭包和装饰器用法实例详解
09-19
主要介绍了Python闭包和装饰器用法,结合实例形式详细分析了Python闭包和装饰器的相关概念、原理、使用技巧与相关操作注意事项,需要的朋友可以参考下
python闭包与装饰器
夜夜夜夜
05-17 550
在一些语言中，在函数中可以（嵌套）定义另一个函数时，如果内部的函数引用了外部的函数的变量，则可能产生闭包。闭包可以用来在一个函数与一组“私有”变量之间创建关联关系。在给定函数被多次调用的过程中，这些私有变量能够保持其持久性。 ——维基百科 def make_printer(msg): def printer(): print msg # 夹带私货（外部变量） ...
python 闭包与装饰器（真的很详细）
百雨的博客
01-03 3352
https://www.cnblogs.com/huchong/p/7725564.html#_label1
python中的闭包与装饰器
bitcarmanlee的博客
11-20 3727
1.Python中一切皆对象这恐怕是学习Python最有用的一句话。想必你已经知道Python中的list, tuple, dict等内置数据结构，当你执行：alist = [1, 2, 3]时，你就创建了一个列表对象，并且用alist这个变量引用它： 当然你也可以自己定义一个类：class House(object): def __init__(self, area, city):
python 闭包和装饰器
qq_41755706的博客
10-14 162
参考引用 函数和闭包：https://www.zhihu.com/question/25950466/answer/31731502 闭包和装饰器的理解：https://www.cnblogs.com/3me-linux/p/6761635.html 一、函数概念理解 1、函数对象vs函数调用 说明：无论是把函数赋值给新的标识符，还是作为参数传递给新的函数，针对的都是函数对象本身，而不是函数的调用。 def add(): return 3 print(add, type(add)) print
python 闭包和装饰器详解
shine的博客
05-09 2万+
python 闭包，装饰器 一 闭包 如果在一个函数的内部定义了另一个函数，外部的函数叫它外函数，内部的函数叫它内函数。 1 闭包条件 　　 1 在一个外函数中定义了一个内函数。 2 内函数里运用了外函数的临时变量。 3 并且外函数的返回值是内函数的引用。 一般情况下，如果一个函数结束，函数的内部所有东西都会释放掉，还给内存，局部变量都会消失。但是闭包...
Python 闭包和装饰器学习
qyf__123的博客
12-24 401
装饰器 def out_func(func): """ functools.wraps 可以将原函数对象的指定属性复制个包装函数对象 """ @functools.wraps(func) def inner_func(func, *args, **kwargs): return func() return inner_func @out_func def foo(): pr...
python闭包和装饰器的关系_python 闭包和装饰器
weixin_39685836的博客
11-28 117
一、闭包定义：内层函数对外层函数非全局变量的引用，就会形成闭包，闭包只存在于嵌套函数中被引用的非全局变量也称为自由变量，这个自由变量会与内层函数产生一个绑定关系自由变量不会再内存中消失闭包的作用，保证数据的安全 （返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域）# 默认情况下inner函数是没有办法被外层执行的def ...
python闭包和装饰器详解_python中闭包和装饰器
weixin_42635849的博客
01-14 189
闭包的定义：定义一个函数，在函数的内部再定义一个内部函数，并且这个函数用到了外部函数的变量，那么将内部函数和用到的变量称之为闭包。闭包的定义示例:# 定义一个外部函数def decorator(func):# 再函数内部再定义一个内部函数def inner():print("这是一个闭包")# 内部函数引用了外部函数的变量func()# 返回内部函数的函数名指向的地址，即返回闭包return in...
深入理解python中的闭包和装饰器
09-21
下面小编就为大家带来一篇深入理解python中的闭包和装饰器。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
简析Python的闭包和装饰器
09-21
主要为大家详细介绍了Python的闭包和装饰器，何为闭包？何为装饰器？感兴趣的小伙伴们可以参考一下
python格式化字符串的三种方法（%，format，f-string)
热门推荐
面向对象的笔记
07-18 13万+
DAY 7. 格式化字符串 到目前为止，我所知道的，python格式化字符串有三种方法，第一是早期就有的%，其次是2.5之后的format(),还有就是3.6添加的f字符串调试 7.1 %格式化字符串 %格式化字符串是python最早的，也是能兼容所有版本的一种字符串格式化方法，在一些python早期的库中，建议使用%格式化方式，他会把字符串中的格式化符按顺序后面参数替换，格式是 "xxxxxx ...
Django，Ajax，Vue实现文章评论功能
面向对象的笔记
08-19 4185
Django评论 评论复杂的地方在于需要实现点击提交评论后评论内容需要立刻出现在下面，还要保持页面位置不变，所以提交后不能整体刷新页面，因为刷新以后页面肯定在最上面，而评论一般都在最下面，所以要用到Ajax 整个过程用到了Django，Vue.js,reqwest,REST_framework,ajax 展示评论内容 展示评论内容可以直接用Django从数据库中取出数据，然后在view中渲染到...
python实现哈希表
面向对象的笔记
09-06 2829
# python 实现哈希表 class HashTable: """ 哈希函数的构造 解决冲突 """ def __init__(self, source): self.source = source self._index = [] self._val = [] self.table =...
python多进程
面向对象的笔记
04-19 1405
多进程 多进程比起多线程更加稳定，如果一个进程死掉了，并不会影响别的进程，但如果一个线程挂了，整个程序就挂了，当然，主进程要是挂了也没办法，python中multiprocessing用来支持多线程编程，他提供了Process、Queue、Pipe、Lock等组件 1.进程的创建与管理 Process类用来创建和管理进程，另外，可以使用Pool进行进程并发操作，调用Process()时必须放在if...
python自省与反射
面向对象的笔记
07-15 1273
DAY 5. python自省 In computing, type introspection is the ability of a program to examine the type or properties of an object at runtime. Some programming languages possess this capability. 在计算机科学中，内省是...
python中函数的参数传递（传值还是传引用）
面向对象的笔记
07-11 1250
函数的参数传递 函数参数传递有两种方式，传值和传引用，传值只是把变量的值复制一份给了实参，函数内部的操作不会改变函数外部变量的值，而传引用传递的是外部变量的地址，函数内部直接操作函数外部变量的储存空间，在调用函数之后，函数外部变量的值一般会改变 def Demo(a): a = a + 1 print(id(a)) if __name__ == '__main__': a...
python闭包和装饰器详解
最新发布
08-14
闭包是一个函数对象，它引用了一些在其定义时外部环境的变量。在Python中，闭包常常用来创建装饰器。装饰器其实就是一个闭包，它接受一个函数作为参数，并返回一个替代版函数。闭包允许我们在不修改原始函数的情况下，添加一些额外的功能或逻辑。 一个典型的装饰器的例子可以是这样的：在一个函数外面定义一个装饰器函数，然后通过在要装饰的函数之前添加@装饰器名称的语法糖，来应用装饰器。 闭包和装饰器的实现机制是类似的，都是通过嵌套函数的方式来实现的。在闭包中，内部函数引用了外部函数的变量。而在装饰器中，装饰器函数接受一个函数作为参数，并返回一个内部函数，内部函数可以访问外部函数的变量。 在闭包和装饰器的实现过程中，都需要注意作用域的规则。在闭包中，内部函数可以访问外部函数的局部变量，而在装饰器中，装饰器函数可以访问被装饰函数的变量。 闭包和装饰器提供了一种灵活的方式来扩展函数的功能，使得我们可以在不修改原始函数的情况下，添加一些额外的逻辑。它们是Python中非常强大而且常用的特性。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* [python中的闭包和装饰器解释](https://blog.csdn.net/qq_39567748/article/details/99596644)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT0_1"}}] [.reference_item style="max-width: 50%"] - *3* [python高级之装饰器](https://blog.csdn.net/qq_35396496/article/details/109147229)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT0_1"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Junebao

如果你碰巧财力雄厚的话...

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值