闭包定义

在函数嵌套（函数里面再定义函数）的前提下，内部函数使用了外部函数的变量或参数，并且外部函数返回了内部函数。于是将这个使用外部函数变量或参数的内部函数称为闭包

• 可以保存外部函数内的变量

参数和变量

# coding=utf-8
def func_out():                                  # 定义一个外部函数
    num1 = 10                                    # 外部函数变量
    def func_inner(num2):                        # 定义一个内部函数
        result =  num1 + num2                    # 内部函数使用外部函数的变量，可以将外部函数变量暂时保存
        print(result)
    return func_inner                            # 外部函数返回内部函数
result = func_out()                              # 结果是内部函数  result = func_inner
result(1)                                        # 函数调用，因为返回的是函数
----------------------------------------------------------------------------------------------
>>> 11

# coding=utf-8
def conf_name(name):                             
    def inner(msg):                              
        print(name + ':' + msg)                # 内部函数调用外部函数参数
    return inner
kuma = conf_name('kuma')
jerry = conf_name('jerry')
kuma('小姐姐过来玩呀')
jerry('滚犊子')
--------------------------------------
>>> kuma:小姐姐过来玩呀
>>> jerry:滚犊子

修改外部变量

# coding=utf-8
def func_out():
    num1 = 10
    def func_inner():
        nonlocal num1                   # 闭包中使用关键字 nonlocal 声明全局变量
        num1 = 20
        result = num1 + 10
        print(result)
    return func_inner
result = func_out()
result()
----------------------------------
>>> 30

装饰器

就是给已有函数增加额外功能的函数，本质就是一个闭包函数

• 不能修改已有函数的源代码
• 不修改已有函数的调用方式
• 给已有函数增加额外的功能
• @装饰器名字，完成对已有函数的装饰 （装饰器的语法糖写法） ```python

  coding=utf-8

def decorator(func): def inner(): func() # 内部函数使用外部有且仅有一个并且是函数类型的参数 print(‘恭喜您登录成功’) return inner

@decorator # 要写在已有函数前（后面不能写其他代码），相当于 comment = decorator(comment)

def comment(): print(‘请您输入密码’)

comment = decorator(comment) # 如果不写语法糖写法

comment()

请您输入密码 恭喜您登录成功 ```

被装饰函数有参数

# coding=utf-8
def decorate(func):
    def inner(a, b):
        print('正在执行运算')           # 对已有函数进行装饰
        func(a, b)
    return inner
@decorate                             # 等价于 add_num = decorate(add_num)
def add_num(num1, num2):
    result = num1 + num2
    print(result)
add_num(1, 2)

内部函数的类型和被装饰的函数的类型是保持一致的

被装饰函数有返回值

# coding=utf-8
def decorate(func):
    def inner(a, b):
        print('正在执行运算')
        num = func(a, b)                
        return num                      # 内部函数的类型和被装饰的函数的类型是保持一致的，即被装饰函数有返回值内部函数也要有
    return inner
@decorate
def add_num(num1, num2):
    result = num1 + num2
    return result
result = add_num(1, 2)
print(result)

被装饰函数有缺省参数

# coding=utf-8
def decorate(func):
    def inner(*args, **kwargs):
        print('正在执行运算')
        num = func(*args, **kwargs)
        return num
    return inner
@decorate
def add_num(*args, **kwargs):
    result = 0
    for i in args:
        result += i
    for i in kwargs.values():
        result += i
    return result
result = add_num(1, 2, age=20)
print(result)

多装饰器

# coding-utf-8
def make_p(func):
    def inner():
        result = '<p>' + func() + '</p>'
        return result
    return inner
def make_div(func):
    def inner():
        result = '<div>' + func() + '</div>'
        return result
    return inner
@make_div
@make_p
def content():
    return 'happy kuma'
result = content()
print(result)

由内到外的装饰过程，即 make_div(make_p(content))

装饰器带有参数

# coding=utf-8
def return_decorate(flag):
    def decorate(func):
        def inner(a, b):
            if flag == "+":
                print('正在执行加法运算')
            else:
                print('正在执行减法运算')
            func(a, b)
        return inner
    return decorate
@return_decorate("+")
def add_num(a, b):
    result = a + b
    print(result)
add_num(1, 2)
@return_decorate("-")
def add_num(a, b):
    result = a - b
    print(result)
add_num(1, 2)

区别

闭包一定是装饰器，但装饰器不一定是闭包的原因：如果外部函数的参数有且只有一个。并且是函数类型在内部函数使用，那么这个闭包函数就是装饰器。