闭包和装饰器

Posted 2020-12-23 tanhuan-share

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...