【Python零基础到进阶】递归，闭包，匿名函数

---

包含编程资料、学习路线图、源代码、软件安装包等！【[点击这里]】！

---

1.递归

1.什么是递归？

• 递归是指一个函数直接或间接调用自身的编程技巧。就像俄罗斯套娃一样，每层函数都包含下一层的调用结构。

核心思想：

• 将大问题分解为小问题。
• 通过递归调用自身解决小问题。
• 将小问题的结果组合成大问题的解。

2.递归的三要素：

1 def recursion_example(n):
2     # 基例（终止条件）
3     if n == 1:
4         return 1
5     # 递归式（自我调用）
6     return n * recursion_example(n-1)

解析：

• 基例：终止递归的条件（如n==1）
• 递归式：将大问题拆分为子问题的表达式
• 子问题规模：每次调用必须使问题规模减小（n-1）

3.阶乘计算示范

1 def factorial(n):
2     """计算n的阶乘"""
3     if n <= 1:
4         return 1
5     return n * factorial(n-1)
6 
7 print(factorial(5))  # 输出120

演示：

1 factorial(5) → 5*factorial(4)
2              → 5*(4*factorial(3))
3              → 5 * 4*(3*factorial(2))
4              → 5 * 4 * 3*(2*factorial(1))
             → 5 * 4 * 3 * 2 * 1 = 120

4.递归的优缺点

优点：

• 代码简洁，逻辑清晰。
• 适合解决分治问题（如树的遍历、汉诺塔问题）。

缺点：

• 递归调用会消耗大量内存（栈空间）。
• 如果基准条件设置不当，可能导致栈溢出。

2.闭包

1.什么是闭包？

• 闭包是指在函数内部定义了一个内部函数，并且内部函数可以访问外部函数的变量。外部函数返回内部函数的引用，形成闭包。

核心特点：

• 内部函数可以访问外部函数的变量。
• 外部函数返回内部函数的引用。
• 闭包可以“记住”外部函数的状态。
• 【函数嵌套 + 返回内部函数 + 保留外部状态】

2.普通函数 🆚 闭包

• 从普通函数到闭包的变化

1 # 普通函数
2 def func_1():
3     print('你好')
4 
5 def func_2():
6     print('欢迎来到Python课堂')

• 普通函数的特点：独立函数，无法共享状态。

1 # 闭包
2 def func_1():
3     print('你好')
4     
5     def func_2():
6         print('欢迎来到Python课堂')
7     
8     return func_2  # ❗️ 返回内部函数的引用

• 闭包的特点：func_2 捕获了func_1的状态，形成闭包。

闭包的调用方法：

1 f = func_1()    # 获取内部函数的引用
2 f()            # 调用闭包
3 # 或者链式调用：
4 func_1()()      # 直接执行闭包

3.闭包返回值与参数

闭包的灵活用法

1 def func_1(name):
2     subject = 'Python'
3     
4     def func_2(year):
5         return f'{name}在{year}{subject}课堂学习！'
6     
7     return func_2
8 
9 # 调用示例
10 f = func_1('Alice')
11 result = f(2025)
12 print(result)  # 输出：Alice在2025Python课堂学习！

闭包的作用：

• 外部函数func_1的参数name和变量subject被封装在闭包中。
• 内部函数func_2可动态生成带年份和主题的字符串。
  

4.闭包的变量作用域

• 闭包如何"记住"外部变量？

1 def outer():
2     x = 10  # 外部变量
3     print('外部函数')
4     def inner():
5         print(x)  # ❓ 如何访问x？
6 
7     return inner
8 
9 
10 f = outer()
11 f()  # 输出：10  // 如果注释掉这个，不会输出10.

• 原理：闭包形成时，会记录外部函数的作用域链（变量查找路径）。
• 关键点：即使外部函数执行结束，闭包仍保留对x的引用。
  

5.闭包的优缺点

✅ 优点：

• 1.封装性：不需要定义全局变量即可实现通过函数,访问和修改某个值;
• 2.模块化：闭包函数所引用的外部变量,也就是外层函数里定义的变量,作用封闭,不会被错误调用或修改.

⚠️ 缺点：

• 1.占用内存资源: 内部函数一直在引用外部函数里定义的变量,所以会导致这个变量一直占用内存.

3.变量的作用域

Python的变量作用域规则

• 变量查找顺序为 Local（局部）→ Enclosing（嵌套外层）→ Global（全局）→ Built-in（内置）

示例：

1 # 全局作用域
2 name = "Global Name"
3 
4 def outer():
5     # 外层函数作用域
6     name = "Outer Name"
7 
8     def inner():
9         # 内层函数作用域
10         name = "Inner Name"
11         print(name)  # ❓ 输出什么？
12     inner()
13 
14 outer()
15 # 输出：Inner Name

全局变量🆚局部变量

全局变量

• 定义在函数外，模块级作用域。
• 代码示例：

2 
3 def print_global():
4     print(GLOBAL_VAR)  # 直接访问全局变量

局部变量

• 定义在函数内，仅在该函数中有效。
• 代码示例：

1 def print_local():
2     LOCAL_VAR = 42  # 局部变量
3     print(LOCAL_VAR)

修改外层变量的关键字

global 与 nonlocal 的区别

场景1：修改全局变量

1 num = 100  # 全局变量
2 
3 def modify_global():
4     global num  # 声明修改全局变量
5     num += 10
6     print(num)  # 输出：110
7 
8 modify_global()
9 print(num)      # 输出：110

场景2：修改外层函数的局部变量

1 def outer():
2     num = 100  # 外层局部变量
3 
4     def modify_nonlocal():
5         nonlocal num  # 声明修改外层变量
6         num += 10
7         print(num)  # 输出：110
8 
9     modify_nonlocal()
10     print(num)      # 输出：110
11 
12 outer()

闭包中的变量作用域

• 闭包如何"记住"外部变量？见示例：

1 def make_counter():
2     count = 0  # 外层局部变量
3     
4     def inner():
5         nonlocal count  # 必须声明，否则会报错！
6         count += 1
7         return count
8     
9     return inner
10 
11 counter = make_counter()
12 print(counter())  # 输出：1
13 print(counter())  # 输出：2
14 """闭包保存了对外层变量count的引用，即使外层函数已执行完毕。"""

4.匿名函数

1.什么是匿名函数？

• 匿名函数是一种没有名字的函数，用 lambda 关键字定义。它适用于简单的、单行的函数逻辑。
• 语法格式：lambda 参数列表: 表达式

2.匿名函数的使用

普通函数🆚匿名函数

• 示例：

1 # 普通函数
2 def fun_a(x, y):
3     return x * y
4 
5 a = fun_a(4, 5)
6 print(a)  # 输出：20
7 
8 # 匿名函数
9 fun_b = lambda x, y: x * y
10 print(fun_b(4, 5))  # 输出：20

对比优势：

• 简洁性：无需 def 关键字和函数体。
• 即时性：适合临时性、短小的逻辑。
  

Lambda的条件表达式

• 示例：用Lambda实现条件判断

1 # 显式函数实现奇数判断
2 def is_odd(x):
3     return x if x % 2 == 1 else None
4 
5 a = is_odd(9)
6 print(a)  # 输出：9
7 
8 # Lambda简化写法
9 is_odd_lambda = lambda x: x if x % 2 == 1 else None
10 print(is_odd_lambda(9))  # 输出：9

Lambda与map函数：

• 使用lambda和map函数将每个元素平方。

1 numbers = [1, 2, 3, 4, 5]
2 squared = list(map(lambda x: x ** 2, numbers))
3 print(squared)  # 输出：[1, 4, 9, 16, 25]

lambda与filter：

• 使用lambda和filter函数过滤偶数。

1 numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
2 # 使用lambda和filter函数过滤偶数
3 even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
4 print(even_numbers)  # 输出: [2, 4, 6, 8, 10]

lambda与sorted：

• sorted函数以匿名函数为判断标准进行排序。
• 使用sorted函数和lambda匿名函数按年龄排序(以匿名函数的返回值作为判断标准)

1 data = [
2     {"name": "Alice", "age": 25},
3     {"name": "Bob", "age": 30},
4     {"name": "Charlie", "age": 20}
5 ]
6 
7 sorted_data = sorted(data, key=lambda x: x['age'])
8 print(sorted_data)  

• 关键参数：key=lambda x: x[‘age’]指定按字典的 age 字段排序。
  

3.Lambda的嵌套与闭包

1 def haha(n):
2     return lambda x: x ** n  # ❗️ 返回一个闭包
3 
4 # 创建不同次方的函数
5 square = haha(2)    # 平方
6 cube = haha(3)      # 立方
7 
8 print(square(5))   # 输出：25
9 print(cube(5))    # 输出：125

总结

• 最后希望你编程学习上不急不躁,按照计划有条不紊推进,把任何一件事做到极致,都是不容易的,加油,努力！相信自己！

文末福利

• 最后这里免费分享给大家一份Python全套学习资料，希望能帮到那些不满现状，想提升自己却又没有方向的朋友，也可以和我一起来学习交流呀。

包含编程资料、学习路线图、源代码、软件安装包等！【[点击这里]】领取！

• ① Python所有方向的学习路线图，清楚各个方向要学什么东西
• ② 100多节Python课程视频，涵盖必备基础、爬虫和数据分析
• ③ 100多个Python实战案例，学习不再是只会理论
• ④ 华为出品独家Python漫画教程，手机也能学习

可以扫描下方二维码领取【保证100%免费】