欢迎来到CILMY23的博客

本篇主题为： Python函数的黑魔法：递归，嵌套函数与装饰器

个人主页：CILMY23-CSDN博客

系列专栏：Python | C++ | C语言 | 数据结构与算法

感谢观看，支持的可以给个一键三连，点赞关注+收藏。

---

写在前头：

本期主要补充上篇未完成的内容，（点击链接跳转）其中包括参数传递中序列解包，递归函数和嵌套函数，以及python中重要的概念————装饰器 ，除此之外还会扩展一些python中的作用域概念

---

目录

一、参数传递的序列解包

二、递归函数和嵌套函数

2.1 递归函数

2.2 嵌套函数

三、装饰器

3.1 装饰器的概念

3.2 装饰器的定义和使用

3.3 装饰器的应用场景

四、变量的作用域

4.1 变量类型

4.2 global关键字和nonlocal

global关键字

nonlocal关键字

---

一、参数传递的序列解包

参数传递的序列解包是指在函数调用时，将一个序列（如列表、元组等）进行解包，然后将解包后的内容作为参数传递给函数。这使得我们可以使用序列中的元素来作为函数的参数，而不必一个个地手动传递。

例如：

def func(x,y,z):
    return x + y +z

print(func(*[1,2,3]))
print(func(*(5,9,8)))

我们在上一篇中说，* args是将接收的多个参数放在一个元组里，那 * 其实是将一个序列中的元素解包出来，分别传递给形参中的各个变量。那 ** 就是将字典的各个元素传递给形参中的多个变量。

 例如：

# 定义函数2
def func2(name, age):
    print(f"Name: {name}, Age: {age}")

# 创建人的字典
person = {'name': 'Alice', 'age': 25}

# 将字典通过**解包传递给函数2
func2(**person)

注意：字典中的"键---值"和形参在名称和个数必须一一对应 

二、递归函数和嵌套函数

 递归函数和嵌套函数，它们都是 Python 编程中非常重要的概念，接下来我们就详细看看吧

2.1 递归函数

如果一个函数在函数体中直接或间接调用自身，那么这个函数就被称为递归函数。简单来说，这个函数在调用的时候会调用自身，直到结束。

Python允许使用递归函数。如果函数 a 中调用函数 a 自身，则称为直接递归。如果函数 a 在内部调用了函数 b，在函数 b 中又调用函数 a，则称为间接递归。

递归函数的思想是"将一个大问题分解为一个或多个与原问题形式相似但规模较小的子问题来解决"。函数会不断地调用自身来解决这些子问题，直到达到了结束条件，从而结束递归的过程。

例如：求斐波那契数列前十项

# 递归函数
def Fib(n):
    if n < 2:
        return 1  # 第1，2个斐波那契数为1
    else:
        return Fib(n-1) + Fib(n-2)  # 递推关系：前两个斐波那契数之和

# 输出前10个斐波那契数
for i in range(10):
    print(Fib(i),end=" ")

结果： 

 

解析：

当使用递归函数来解决斐波那契数列时，可以通过递归的方式来计算第n个斐波那契数。斐波那契数列的定义如下：

• 第1个斐波那契数为1
• 第2个斐波那契数为1
• 从第2个数开始，后续的每个斐波那契数都是前两个斐波那契数之和

练习题：使用递归函数解决1+2+……+n的和。（答案在文章末尾） 

2.2 嵌套函数

嵌套函数指的是在一个函数内部定义另一个函数。其中，外部定义函数称为外函数，内部定义的函数称为内函数，嵌套函数在外部函数中具有局部作用域，它可以访问外部函数的变量。

例如：

# 嵌套函数
def outer_function(x):
    def inner_function(y):
        return y * 2

    return inner_function(x)  # 调用内部函数


result = outer_function(5)  # 调用外部函数
print(result)  # 输出 10

三、装饰器

装饰器是一种Python编程语言的特性，那具体的我们接着往下看吧

3.1 装饰器的概念

装饰器(Decorator)是用来包装函数的函数。装饰器是一种语法，允许在不修改函数原始代码的情况下，动态地添加功能或修改函数的行为。

装饰器基于函数，基本原理是将一个函数作为参数传递给另一个函数，然后返回一个新的函数。这个新函数通常用来包裹原始函数，并在执行原始函数前后执行一些额外的代码。

3.2 装饰器的定义和使用

定义装饰器的一般格式为：

def decorator(func):
    pass

@decorator
def func():
    pass

其中，decorator 为装饰器。@decorator 为函数的装饰器修饰符。func 为装饰器的函数对象参数。装饰器可以返回一个值，也可以返回一个函数，还可以返回一个装饰器或其他对象。

例如：装饰器返回一个函数

# 装饰器返回一个函数
def my_decorator(func):
    def wrapper():
        return func() + 1
    return wrapper

def my_function():
    return 3

my_function = my_decorator(my_function)

result = my_function()
print(result)  # 输出 4

 代码解析：

当调用 my_function() 时，实际上我们是在用装饰器 my_decorator,而 my_function 替代了 func

装饰器中嵌套了 wrapper() 函数，并且返回值是 wrapper ，所以实际上我们就是调用了 wrapper()这个函数，并将这个函数的返回值作为装饰器的返回值传递。

所以计算就是 3+1 = 4

 例如：装饰器返回一个装饰器

# 装饰器返回一个装饰器
def outer_decorator(option):
    if option == "A":
        def inner_decorator(func):
            def wrapper():
                return func()

            return wrapper
    elif option == "B":
        def inner_decorator(func):
            def wrapper():
                return func()

            return wrapper
    else:
        raise ValueError("Invalid option")

    return inner_decorator


@outer_decorator(option="A")
def ret1():
    return "Hello, world!"


@outer_decorator(option="B")
def ret2():
    return "Hello again!"


print(ret1())
print(ret2())

 代码解析：

外部装饰器 outer_decorator 会根据 option 的不同，选择不同的装饰器 inner_decorator(func)，然后将外部函数替换掉 func ， 最后返回装饰器 inner_decorator，像上述案例，如果有装饰器嵌套装饰器，就被称为多重装饰器

3.3 装饰器的应用场景

 例如：修改网页的文本格式

# 修改网页的文本格式
# 定义装饰器
def deco(func):
    # 定义内函数
    def modify_text(str):
        return "<strong>" + func(str) + "</strong>"

    return modify_text


# 使用装饰器修饰函数
@deco
def textFunc(str):
    return str


print(textFunc("text"))

四、变量的作用域

4.1 变量类型

1. 局部变量和局部作用域 L（Local）：定义在函数内部的变量。局部变量的作用域是从函数内定义它的位置到结束。当函数被调用时创建一个新的局部变量，函数调用完成后，局部变量就消失了。

2. 全局变量和全局作用域G（Global）：在模块的函数外定义的变量。在模块文件顶层声明的变量具有全局作用域。从外部看，模块的全局变量就是一个模块对象的属性。全局作用域的作用范围仅限于单个模块文件内。

3. 嵌套变量和嵌套作用域E（Enclosing）：定义在嵌套函数的外函数内、内函数外的变量。嵌套作用域为嵌套函数内定义它的位置开始的整个函数内。

4. 内建变量和内建作用域B（Built-in）：系统内固定模块里定义的变量，一般为预定义在内建模块内的变量。

例如：

# 四、变量作用域
global_v = "我是一个全局变量"


def outer_function():
    enclosing_v = "我是一个嵌套变量"

    def inner_function():
        local_v = "我是一个局部变量"
        print(local_v)
        print(enclosing_v)
        print(global_v)

    inner_function()


outer_function()
print(global_v)

 在Python中，当程序执行中要使用一个语句中的变量时，就会按照 L -> E -> G -> B 的规则在程序中查找这个变量的定义，即在局部范围中找不到，便会去局部范围外查找，然后去全局变量以此类推。

4.2 global关键字和nonlocal

global关键字

当在函数内部想要修改全局作用域的变量时，可以使用global关键字来声明变量。这样就可以在函数内部修改全局变量的值。

# global 关键字

global_var = 10


def modify_global():
    global global_var
    global_var = 20


modify_global()
print(global_var)  # 输出 20

结果：打印20 

nonlocal关键字

nonlocal关键字用于在一个嵌套函数中修改嵌套作用域 E 的变量。当在内部函数中想要修改上一层函数中的变量时，可以使用nonlocal关键字。

# nonlocal 关键字
def outer_function():
    outer_var = 10

    def inner_function():
        nonlocal outer_var
        outer_var = 20

    inner_function()
    print(outer_var)  

outer_function()

 结果：输出20

---

   总结：

• * 用于序列解包，** 用于字典解包
• 递归函数的核心是将一个大问题拆解成无数子问题
• 装饰器本质上是一个函数，它接受一个函数作为参数，并返回一个新的函数。
• 装饰器也可以嵌套装饰器，从而选择不同的效果

---

感谢各位同伴的支持，本期python篇就讲解到这啦，如果你觉得写的不错的话，可以给个一键三连，点赞关注+收藏，若有不足，欢迎各位在评论区讨论。