闭包和装饰器

Posted tanhuan-share

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了闭包和装饰器相关的知识,希望对你有一定的参考价值。

1.闭包介绍
闭包的定义:
在函数嵌套的前提下,内部函数使用了外部函数的变量(外部函数的参数也属于外部函数的变量),并且外部函数返回了内部函数的引用,我们把这个使用外部函数变量的内部函数称为闭包。
  • # 定义一个外部函数
    def func_out(num1):
        # 定义一个内部函数
        def func_inner(num2):
            # 内部函数使用了外部函数的变量(num1)
            result = num1 + num2
            print("结果是:", result)
        # 外部函数返回了内部函数,这里返回的内部函数就是闭包
        return func_inner
    
    # 创建闭包实例    
    f = func_out(1)
    # 执行闭包
    f(2)
    f(3)
    闭包可以保存外部函数内的变量,不会随着外部函数调用完而销毁。
    

      

    闭包可以保存外部函数内的变量,不会随着外部函数调用完而销毁。
注意点:
  • 由于闭包引用了外部函数的变量,则外部函数的变量没有及时释放,消耗内存。
2.闭包的使用
  1. 定义外部函数接收不同的配置信息参数,参数是人名
  2. 定义内部函数接收对话信息参数
  3. 在内部函数里面把配置信息和对话信息进行拼接输出
# 外部函数
def config_name(name):
    # 内部函数
    def say_info(info):
        print(name + ": " + info)
    return say_info
tom = config_name("Tom")
tom("你好!")
tom("你好, 在吗?")

  

 
  • 闭包还可以提高代码的可重用性,不需要再手动定义额外的功能函数。
3.修改闭包内使用的外部变量
  • 修改闭包内使用的外部函数变量使用 nonlocal 关键字来完成。
拓展:信息查询顺序————》LEGB: local enclosure golbal Buindin
 
 
# 定义一个外部函数
def func_out(num1):
    # 定义一个内部函数
    def func_inner(num2):
        nonlocal num1  # 告诉解释器,此处使用的是外部变量a
        # 修改外部变量num1
        num1 = 10
        # 内部函数使用了外部函数的变量(num1)
        result = num1 + num2
        print("结果是:", result)
    print(num1)
    func_inner(1)
    print(num1)
    # 外部函数返回了内部函数,这里返回的内部函数就是闭包
    return func_inner
# 创建闭包实例
f = func_out(1)
# 执行闭包
f(2)

  

4.装饰器
装饰器的定义
就是给已有函数增加额外功能的函数,它本质上就是一个闭包函数。
闭包函数有且只有一个参数,必须是函数类型,这样定义的函数才是装饰器。
写代码要遵循开放封闭原则,它规定已经实现的功能代码不允许被修改,但可以被扩展。
装饰器的功能特点:
  1. 不修改已有函数的源代码
  2. 不修改已有函数的调用方式
  3. 给已有函数增加额外的功能
# 添加一个登录验证的功能
def check(fn):
    print("装饰器函数执行了")
    def inner():
        print("请先登录....")
        fn()
    return inner

# 装饰器
def comment():
    print("发表评论")
# 使用装饰器来装饰函数
comment = check(comment)
comment()

# 简写:使用语法糖方式来装饰函数
@check
def comment():
    print("发表评论")
comment()

  

 
5.装饰器的使用
如函数执行时间的统计:
import time
# 装饰器函数
def get_time(func):
    def inner():
        begin = time.time()
        func()
        end = time.time()
        print("函数执行花费%f" % (end-begin))
    return inner
@get_time
def func1():
    for i in range(100000):
        print(i)
func1()

  

 
6.通用装饰器的使用
# 定义一个通用的装饰器(可以适合任何个数的参数)
def outer(func):
    def inner(*args,**kwargs):
        print(‘装饰内容1...‘)
        ret = func(*args, **kwargs)
        print(‘装饰内容2...‘)
        return ret
    return inner

  

7.多个装饰器的使用
  • 多个装饰器的装饰过程是: 离函数最近的装饰器先装饰,然后外面的装饰器再进行装饰,由内到外的装饰过程
def outer1(func):
    def inner():
        print(‘装饰器1-1‘)
        func()
        print(‘装饰器1-2‘)
    return inner
def outer2(func):   
    def inner():
        print(‘装饰器2-1‘)
        func()
        print(‘装饰器2-2‘)
    return inner
@outer1 
@outer2  
def show():
    print(‘Show...‘)
show()

  输出为:

装饰器1-1
装饰器2-1
Show...
装饰器2-2
装饰器1-2

  

 
 
8.带有参数的装饰器
使用带有参数的装饰器,其实是在装饰器外面又包裹了一个函数,使用该函数接收参数,返回是装饰器,因为 @ 符号需要配合装饰器实例使用,语法格式: @装饰器(参数,...)
def set_args(msg):
    def set_func(func):
        def inner():
            print(‘装饰内容 ‘ + msg)
            func()
        return inner
    return set_func
@set_args(‘Hello‘)
def show():
    print(‘Show run...‘)
show()

  输出为

装饰内容 Hello
Show run...

  

‘‘‘
无论闭包函数定义成会什么样,在使用该闭包进行装饰函数时,被装饰的函数,永远指向闭包函数的内函数
9.可调用对象
 
def show():
    print("show")
show()
# 这个函数用来测试参数是否是可调用对象
print(callable(show))
print(callable(1))
print(callable(‘Hello‘))
class Person():
    # 当一个类中实现了下面的 __call__ 函数
    # 那么该类的实例对象就变成了可调用对象, 也就是说,实例对象后面可以加()
    def __call__(self, *args, **kwargs):
        print(‘Call Run....‘)
tom = Person()
print(callable(tom))
tom()

  输出为:

show
True
False
False
True
Call Run....
 
10.类装饰器
  • @Wrapper等价于 comment = Check(comment), 所以需要提供一个init方法,并多增加一个fn参数。
  • 要想类的实例对象能够像函数一样调用,需要在类里面使用call方法,把类的实例变成可调用对象(callable),也就是说可以像调用函数一样进行调用。
  • 在call方法里进行对fn函数的装饰,可以添加额外的功能。
class Wrapper():
    def __init__(self,func):
        self.func = func
    def __call__(self, *args, **kwargs):
        print(‘装饰内容1...‘)
        ret = self.func(*args, **kwargs)
        print(‘装饰内容2...‘)
        return ret

  

# 如果使用的是一个类实现的装饰器,那么该装饰器执行完成后,被装饰函数指向该类的实例对象
# 如果能让被装饰器函数正常执行,那么在该实例对象的类中实现 __call__ 方法,就相当是闭包格式中的内函数
# 一旦被装饰函数执行调用,那么就会去执行实例对象里的 __call__ 函数
@Wrapper   # show = Wrapper(show)
def show():
    print("show run ...")
show()

  输出为:

装饰内容1...
show run ...
装饰内容2...

 

以上是关于闭包和装饰器的主要内容,如果未能解决你的问题,请参考以下文章

python函数下篇装饰器和闭包,外加作用域

装饰器和闭包

闭包函数,装饰器

python-闭包和装饰器-02-装饰器(decorator)

python-闭包和装饰器-02-装饰器(decorator)

9.23闭包函数/装饰器/迭代器/生成器