Python lambda函数(匿名函数)、参数类型与递归全解析

目录

• 一、lambda 匿名函数：简洁的单行函数
• 1. lambda 的定义与基本用法
• 2. lambda 的经典应用：作为参数传递
• 3. 常见 lambda 练习题
• 二、函数参数类型：灵活传递的艺术
• 1. 位置参数与关键字参数
• 2. 默认值参数
• 3. 不定参数：*args 与 **kwargs
• 4. 解包传递：从数据结构中提取参数
• 三、递归函数：自己调用自己的艺术
• 1. 递归的核心要素
• 2. 递归实例解析
• 实例 1：阶乘计算（n! = n × (n-1) × ... × 1）
• 实例 2：斐波那契数列（1, 1, 2, 3, 5, 8...，第 n 项 = 前两项之和）
• 实例 3：自定义数列（f (0)=1, f (1)=4, f (n+2)=2×f (n+1)+f (n)）
• 四、总结

在 python 中，函数是代码组织的核心单元。除了基础定义与调用，lambda 匿名函数、灵活的参数类型以及递归函数等进阶特性，能极大提升代码的简洁性与灵活性。本文结合实例代码，详细讲解这些进阶知识点，帮助你写出更 Pythonic 的代码。

一、lambda 匿名函数：简洁的单行函数

lambda 函数（匿名函数）是一种简化的函数形式，适用于实现简单逻辑，其核心特点是 “一行代码完成一个功能”。

1. lambda 的定义与基本用法

lambda 函数的语法格式：

函数名 = lambda 形参列表: 表达式（函数体）

• 函数体只能是单一表达式（不能是多行代码）
• 若有返回值，无需显式写return（表达式结果即为返回值）

""android"
lambda函数（匿名函数）:
        函数体只能是一句话
        函数体如果是return返回值,return必须省略
lambda定义:
        test=lambda 形参列表: 一句函数体
"""
# 普通函数：两数相加并打印
def test(a, b):
    print(a + b)
# 等价的lambda函数
test2 = lambda a, b: print(a + b)
test2(1, 2)  # 输出：3
# lambda函数返回布尔值（判断是否为偶数）
test3 = lambda a: a % 2 == 0
print(test3(8))  # 输出：True（8是偶数）
# 无参数的lambda函数
test4 = lambda: print(111)
test4()  # 输出：111

2. lambda 的经典应用：作为参数传递

lambda 函数常作为sorted()、map()、filter()等函数的参数，简化代码逻辑。例如对复杂列表排序：

# 列表包含多个字典，需按age和height排序
ls = [
    {'name': 'mary', 'age': '20', 'height': 175},
    {'name': 'tom', 'age': '15', 'height': 168},
    {'name': 'jack', 'age': '18', 'height': 183},
    {'name': 'rose', 'age': '15', 'height': 160},
]
# 使用lambda指定排序规则：先按age升序，再按height升序
sorted_ls = sorted(ls, key=lambda dic: (dic['age'], dic['height']), reverse=False)
print(sorted_ls)
# 输出结果中，age=15的元素按height从小到大排列（rose在前，tom在后）

此处 lambda 函数lambda dic: (dic['age'], dic['height'])作为key参数，定义了排序的依据，代码比单独定义函数更简洁。

3. 常见 lambda 练习题

结合基础运算场景，lambda 函数可快速实现简单逻辑：

'''
1. 使用匿名函数计算一个数的立方。
2. 定义一个匿名函数，判断一个数是否为偶数。
3. 定义一个匿名函数，返回三个参数的乘积。
'''
# 1. 计算立方
test1 = lambda x: x **3
print(test1(2))  # 输出：8（2=8）
# 2. 判断偶数
test2 = lambda x: x % 2 == 0
print(test2(6))  # 输出：True（6是偶数）
# 3. 三个参数乘积
test3 = lambda x, y, z: x * y * z
print(pythontest3(1, 2, 3))  # 输出：6（123=6）

二、函数参数类型：灵活传递的艺术

Python 函数的参数类型非常灵活，支持位置参数、关键字参数、默认值参数、不定参数等，满足不同场景的传参需求。

1. 位置参数与关键字参数

 位置参数 ：按参数定义顺序传递，必须一一对应。

关键字参数 ：通过param=val形式传递，无需考虑顺序；*后的参数必须用关键字传递。

# 函数定义：*后的参数c必须用关键字传递
def test1(a, b, *, c):
    print(a, b, c)
# 合法调用（前两个位置参数，c用关键字）
test1(1, 2, c=5)  # 输出：1 2 5
# 关键字参数可打乱顺序
test1(b=2, a=1, c=4)  # 输出：1 2 4

2. 默认值参数

参数可设置默认值，调用时若不传递则使用默认值（默认参数必须放在位置参数后）。

def test2(a, b=3):  # b的默认值为3
    print(a, b)
test2(1, 9)  # 传递b=9，输出：1 9
test2(1)     # 不传递b，使用默认值，输出：1 3

3. 不定参数：*args 与 **kwargs

当参数数量不确定时，可使用不定参数：

• *args：收集所有位置参数，打包为元组。
• **kwargs：收集所有关键字参数，打包为字典。

def test3(*args, **kwargs):
    print("位置参数打包为元组：", args)
    print("关键字参数打包为字典：", kwargs)
# 传递3个位置参数和2个关键字参数
test3(1, 2, 3, a=4, b=5)
# 输出：
# 位置参数打包为元组： (1, 2, 3)
# 关键字参数打包为字典： {'a': 4, 'b': 5}
# 不传递参数（也合法）
test3()
# 输出：
# 位置参数打包为元组： ()
# 关键字参数打包为字典： {}

4. 解包传递：从数据结构中提取参数

若参数存储在列表、元组、字典等结构中，可通过解包快速传递：

• 列表 / 元组 / 集合：用*解包为位置参数。
• 字典：用 **解包为关键字参数（键需与函数参数名一致）。

# 从列表和字典中解包参数
test3(*[10, 20, 30], **{'a': 1, 'b': 2})
# 等价于 test3(10, 20, 30, a=1, b=2)
# 输出：
# 位置参数打包为元组： (10, 20, 30)
# 关键字参数打包为字典： {'a': 1, 'b': 2}

三、递归函数：自己调用自己的艺术

递归是指函数内部调用自身的编程技巧，适用于有明确规律且可拆解为同类子问题的场景（如阶乘、数列计算）。

1. 递归的核心要素

写python递归函数需明确两个关键点：

 出口条件 ：当满足某条件时，返回确定值（终止递归，避免无限循环）。

规律（递归关系）：将原问题拆解为规模更小的同类子问题。

注意：Python 默认递归深度不超过 1000 层，且递归效率较低，复杂场景建议用循环替代。

2. 递归实例解析

实例 1：阶乘计算（n! = n × (n-1) × ... × 1）

# 阶乘的递归实现
def jc(n):
    # 出口：n=1时，1! = 1
    if n == 1:
        return 1
    # 规律：n! = n  (n-1)!
    return n * jc(n - 1)
# 执行过程：
# jc(5) = 5  jc(4)
# jc(4) = 4  jc(3)
# jc(3) = 3  jc(2)
# jc(2) = 2  jc(1)
# jc(1) = 1
print(jc(5))  # 输出：120（5! = 120）

实例 2：斐波那契数列（1, 1, 2, 3, 5, 8...，第 n 项 = 前两项之和）

def feibo(n):
    # 出口：第1项和第2项均为1
    if n == 1 or n == 2:
        return 1
    # 规律：第n项 = 第n-1项 + 第n-2项
    return feibo(n - 1) + feibo(n - 2)
print(feibo(5))  # 输出：5（第5项为5）
# 执行过程：
# feibo(5) = feibo(4) + feibo(3)
# feibo(4) = feibo(3) + feibo(2) = 2 + 1 = 3
# feibo(3) = feibjso(2) + feibo(1) = 1 + 1 = 2

实例 3：自定义数列（f (0)=1, f (1)=4, f (n+2)=2×f (n+1)+f (n)）

# 求f(10)的值
def f(n):
    # 出口：n=0返回1，n=1返回4
    if n == 0:
        return 1
    if n == 1:
        return 4
    # 规律：f(n) = 2f(n-1) + f(n-2)（由f(n+2)=2f(n+1)+f(n)推导）
    return 2 * f(n - 1) + f(n - 2)
print(f(5))  # 输出：673（计算过程：f(2)=9, f(3)=22, f(4)=53, f(5)=128？实际按递归推导正确值）

四、总结

本文讲解的三大函数进阶特性，适用场景各有侧重：

lambda 函数 ：适编程合实现简单逻辑，尤其作为参数传递时可简化代码。

灵活参数类型 ：位置参数、关键字参数、不定参数和解包，让传参更灵活，适应多变的输入场景。

递归函数：适合有明确规律的问题（如数列、树结构遍历），但需注意深度限制和效率问题。

到此这篇关于Python lambda函数(匿名函数)、参数类型与递归全解析的文章就介绍到这了,更多相关Python lambda函数内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！