Python闭包和装饰器

Python闭包和装饰器

一、函数的知识

1、函数名的作用

• 函数名存放的是函数所在内存空间的地址
• 函数名()执行函数名所存放空间地址中的代码
• 函数名可以像普通变量一样赋值,赋值后的结果与原函数名作用是一样的

# 1.定义函数
def func():
    print('这是一个函数')

# 2.查看函数的作用
# 2.1 函数名
print(func)  # <function func at 0x0000014CC4AB1000>
# 2.2 调用函数
func()  # 这是一个函数
# 2.3 函数名可以像其他一样赋值
func2 = func
print(func2)  # <function func at 0x0000014CC4AB1000>
# 2.4 变量执行函数
func2()  # 这是一个函数

2、函数作为参数传递

当把函数名直接作为实参进行传递时，本质上传递的是：对应函数的引用地址值。

例如，将函数作为实参来传递：

（1）定义一个无参函数test()；

（2）定义一个有一个参数的函数func()；

（3）把无参函数test()的函数名传递给有参函数func()，并观察效果。

# 定义函数1
def test():
    print('这是一个函数')


# 定义函数2
def func(x):
    x()


# 调用函数
test()  # 这是一个函数
func(test)  # 这是一个函数

---

二、闭包

1、作用域

在Python代码中，作用域分为两种情况：全局作用域和局部作用域

在全局定义的变量 => 全局变量

在局部定义的变量 => 局部变量

2、全局变量与局部变量的访问范围

① 在全局作用域中可以访问全局变量，在局部作用域中可以访问局部变量

示例：

# 全局作用域（全局变量）
num1 = 10
def func():
    # 局部作用域（局部变量）
    num2 = 20
    # ① 在局部访问局部变量
    print(num2)

# ① 在全局访问全局变量
print(num1)  # 10
# 调用函数
func()  # 20

② 在局部作用域中可以访问全局变量

示例：

# 全局作用域（全局变量）
num1 = 10
def func():
    # ② 在局部作用域中可以访问全局变量
    print(num1)

# 调用函数
func()  # 10

③ 在全局作用域中不能访问局部变量

示例：

# 全局作用域（全局变量）
num1 = 10
def func():
    # 局部作用域（局部变量）
    num2 = 20

# 调用函数
func()
# 在全局作用域中调用局部变量num2
print(num2)

'''
NameError: name 'num2' is not defined. Did you mean: 'num1'?
变量num2没有被定义，你是想要num1吗？
'''

3、闭包的构成条件（三步走）

第一步：有嵌套

第二步：有引用

第三步：有返回（return)

闭包的语法：

# 外部函数
def 外部函数名(外部参数):
    # 内部函数
    def 内部函数名(内部参数):
        ...[使用]
    return 内部函数名

概念：在函数嵌套的前提下，内部函数使用了外部函数的变量，并且外部函数返回了内部函数。我们把这个使用外部函数变量的内部函数称为闭包。

快速体验：

# 定义一个用于求和的闭包
def outer(num1):
    def inner(num2):
        sum = num2 + num1
        print(f'两数之和是{sum}')

    return inner


# 调用闭包
fun = outer(10)
fun(20)

'''
两数之和是30
'''

闭包的作用：闭包可以保存函数内的变量，而不会随着调用完函数而被销毁。

4、在闭包的内部实现对外部变量的修改（nonlocal关键字）

nonlocal：声明能够让内部函数去修改外部函数的变量

语法：

nonlocal 变量名

例如，编写一个闭包，让内部函数去访问外部函数内的参数a = 100，修改值，a = a + 1，并观察效果。

def outer():
    a = 100
    def inner():
        nonlocal a
        a=a+1
        print(f'a的取值{a}')
    return inner

f =outer()
f()  # a的取值101

---

三、装饰器

1、什么是装饰器

在不改变现有函数源代码以及函数调用方式的前提下，实现给函数增加额外的功能。

装饰器的构成条件：

• 有嵌套：在函数嵌套的前提下；
• 有引用：内部函数使用了外部函数的变量（参数）；
• 有返回：外部函数返回了内部函数名；
• 有额外功能：给需要装饰的原有函数增加额外功能。

2、使用语法

方式一：传统方式：

语法：

变量名 = outer([外面参数列表])
变量名([内部参数列表])

示例：

'''
例如，发表评论前，都是需要先登录的。
此处，先定义有发表评论的功能函数，然后在不改变原有函数的基础上，需要提示用户要先登录~。
'''
def check(fn):
    def inner():
        # 开发登录功能
        print('登录功能')
        # 调用原函数
        fn()
    return inner


# 评论功能（前提：登录）
def comment():
    print('评论功能')

comment = check(comment)
comment()

'''
登录功能
评论功能
'''

方式二：语法糖

语法：

@outer
def 函数名():
	...

示例：

'''
例如，发表评论前，都是需要先登录的。
此处，先定义有发表评论的功能函数，然后在不改变原有函数的基础上，需要提示用户要先登录~。
'''


def check(fn):
    def inner():
        # 开发登录功能
        print('登录功能')
        # 调用原函数
        fn()

    return inner


# 评论功能（前提：登录）
@check
def comment():
    print('评论功能')


# 调用
comment()

'''
登录功能
评论功能
'''

3、装饰器的使用

函数的分类

无参无返回值的函数
    定义: def 函数名(): ...
    调用: 函数名()

有参无返回值的函数
    定义: def 函数名(形参): ...
    调用: 函数名(实参)
    
无参有返回值的函数
    定义: def 函数名(): ... return 返回值
    调用: 用变量接收返回值 = 函数名()
    
有参有返回值的函数
    定义: def 函数名(形参): ... return 返回值
    调用: 用变量接收返回值 = 函数名(实参)

用法一：装饰无参无返回值的函数

示例：

def func1_01(fn):
    def func_in():
        print('正在计算。。。')
        fn()

    return func_in


@func1_01
def func2_01():
    a = 10
    b = 20
    c = a + b
    print('c-->', c)


func2_01()

'''
正在计算。。。
c--> 30
'''

用法二：装饰有参无返回值的函数

示例：

def func1_02(fn):
    def func_in(a, b):
        print('正在计算。。。')
        fn(a, b)

    return func_in


@func1_02
def func2_02(a, b):
    c = a + b
    print('c-->', c)


func2_02(20, 20)

'''
正在计算。。。
c--> 40
'''

用法三：装饰无参有返回值的函数

示例：

def func1_03(fn):
    def func_in():
        print('正在计算。。。')
        return fn()

    return func_in


@func1_03
def func2_03():
    a = 20
    b = 30
    c = a + b
    print('c-->', c)
    return c


func2_03()

'''
正在计算。。。
c--> 50
'''

用法四：装饰有参有返回值的函数

示例：

def func1_04(fn):
    def func_in(a, b):
        print('正在计算。。。')
        return fn(a, b)

    return func_in


@func1_04
def func2_04(a, b):
    c = a + b
    print('c-->', c)
    return c


func2_04(30, 30)

'''
正在计算。。。
c--> 60
'''

用法五：通用装饰器

示例：

'''
*args: 元组类型
**kwargs: 字典类型
'''
def func1_05(fn):
    def func_in(*args, **kwargs):
        print('正在计算。。。')
        return fn(*args, **kwargs)

    return func_in


@func1_05
def func2_05(*args, **kwargs):
    sum = 0
    for value in args:
        sum += value
    for value in kwargs.values():
        sum += value
    print('位置不定长参数-->', sum)
    return sum


func2_05(30, 30, a=5, b=2, c=8)

'''
正在计算。。。
位置不定长参数--> 75
'''

---

四、装饰器进阶

1、多个装饰器装饰一个函数

多个装饰器的装饰过程是: 离函数最近的装饰器先装饰，然后外面的装饰器再进行装饰，由内到外的装饰过程。

示例：

'''
例如，发表评论前，都是需要先登录用户并进行验证码验证。
先定义有发表评论的功能函数，然后在不改变原有函数的基础上，需要提示用户要先登录和输入验证码
'''
def func_06(func):
    def func_in():
        print('先登录')
        func()

    return func_in


def func_08(func):
    def func_in():
        print('验证码')
        func()

    return func_in


@func_06
@func_08
def func_07():
    print('发表评论')


func_07()

'''
先登录
验证码
发表评论
'''

2、带有参数的装饰器

使用带有参数的装饰器，其实是在装饰器外面又包裹了一个函数，使用该函数接收参数，返回装饰器。

基本语法：

def 装饰器(fn):
    ...

@装饰器('参数')
def 函数():
    # 函数代码

示例：根据传递参数不同，打印不同的日志信息

def logging(flag):
    # flag = + 或 flag = -
    def decorator(fn):
        def inner(*args, **kwargs):
            if flag == '+':
                print('-- 日志信息：正在努力进行加法运算 --')
            elif flag == '-':
                print('-- 日志信息：正在努力进行减法运算 --')
            return fn(*args, **kwargs)
        return inner
    return decorator

@logging('+')
def sum_num(a, b):
    result = a + b
    return result

@logging('-')
def sub_num(a, b):
    result = a - b
    return result


print(sum_num(10, 20))
print(sub_num(100, 80))

'''
-- 日志信息：正在努力进行加法运算 --
30
-- 日志信息：正在努力进行减法运算 --
20
'''

3、扩展：类装饰器（了解）

装饰器还有一种特殊的用法就是类装饰器，就是通过定义一个类来装饰函数。

基本语法：

class 类装饰器():
    # 装饰器代码

@类装饰器名称
def 函数():
    # 函数代码

类装饰器的编写规则：

• 必须有一个__init__初始化方法，用于接收要装饰函数的函数
• 必须把这个类转换为可以调用的函数

问题：如何把一个类当作一个装饰器函数进行调用（把类当作函数）

示例：编写一个Check类装饰器，用于实现用户的权限验证

class Check():
    def __init__(self, fn):
        # fn就是要修饰函数的名称，当Check装饰器类被调用时，系统会自动把comment函数名称传递给fn变量
        self.__fn = fn
    # __call__方法：把一个类转换为函数的形式进行调用
    def __call__(self, *args, **kwargs):
        # 编写装饰器代码
        print('请先登录')
        # 调用comment函数本身
        self.__fn(*args, **kwargs)

# 编写一个函数，用于实现评论功能，底层comment = Check(comment)
@Check
def comment():
    print('评论功能')

# 调用comment函数，实现评论功能
comment()

'''
请先登录
评论功能
'''

@Check 等价于 comment = Check(comment), 所以需要提供一个init方法，并多增加一个fn参数。

要想类的实例对象能够像函数一样调用，需要在类里面使用call方法，把类的实例变成可调用对象(callable)，也就是说可以像调用函数一样进行调用。

在call方法里进行对fn函数的装饰，可以添加额外的功能。