Python中lambda表达式的使用——完整通透版

文章目录

  • 一、前言
  • 二、 基本语法
  • 三、举个简单的例子:
  • 四、常见应用场景
  • 1. 用于排序函数
  • `sort()` 方法简介
  • `lambda` 表达式的作用
  • 详细解释
  • 进一步扩展
  • 总结
  • 2、与 `map`、`filter`、`reduce` 等函数结合
  • 1、 `map()` 函数
  • 示例:将列表中的每个数字平方
  • 2、 `filter()` 函数
  • 示例:筛选出列表中的偶数
  • 3、 `reduce()` 函数
  • 示例:计算列表所有元素的累加和
  • 总结
  • 3、 用于函数内部或一次性使用的函数
  • 五、总结
  • 一、前言

    lambda 表达式是Python中的一种简洁的匿名函数表达方式,它用于创建简单的函数,通常在不需要定义完整函数的情况下使用。lambda 表达式的语法非常简洁,适合编写一行的小函数。
    接下来我们从具体的例子出发,由浅入深理解如何使用lambda表达式。


    二、 基本语法

    lambda 参数1, 参数2, ... : 表达式
    
  • lambda 引导关键字,表示这是一个匿名函数。
  • 后面紧跟参数,参数之间用逗号分隔。
  • 冒号后是函数的表达式,也就是返回值。
  • 相当于简写形式的 def 函数定义。

    三、举个简单的例子:

    # 普通函数
    def add(x, y):
        return x + y
    
    # 用 lambda 表达式写成
    add_lambda = lambda x, y: x + y
    
    # 调用
    print(add(2, 3))         # 输出: 5
    print(add_lambda(2, 3))  # 输出: 5
    

    在这个例子中,add_lambda 是一个等价于 add 的匿名函数,但它使用了 lambda 表达式来定义。

    四、常见应用场景

    1. 用于排序函数

    当我们需要排序一个包含元组、字典等复杂数据类型的列表时,通常会使用 lambda 来定义排序的规则。

    例如在列表的.sort排序函数的参数中,使用key=一个lambda表达式指定排序规则。

    # 按照元组中的第二个元素排序
    points = [(1, 2), (3, 1), (5, 4)]
    points.sort(key=lambda x: x[1])
    print(points)  # 输出: [(3, 1), (1, 2), (5, 4)]
    

    在排序函数的示例中,我们使用了 lambda 表达式和列表的 sort 方法,对一个包含元组的列表进行排序。下面我将逐步讲解这个例子的工作原理。

    sort() 方法简介

    sort() 是 Python 中列表的一个内置方法,用于就地对列表进行排序(即会直接修改原始列表)。它可以根据默认顺序(即数字从小到大,字符串按字典顺序)对列表元素排序。

    我们可以使用 key 参数来自定义排序规则。key 接受一个函数,这个函数用于生成用于比较的值。

    例如,默认情况下,sort() 方法是基于元素的值排序:

    numbers = [3, 1, 2]
    numbers.sort()
    print(numbers)  # 输出: [1, 2, 3]
    

    但是,如果我们想要按自定义规则排序,例如根据元组的某个元素(例如第二个元素)进行排序,我们就可以使用 key 参数。

    lambda 表达式的作用

    在这个例子中,我们要对一个包含多个元组的列表 points 进行排序,而排序的依据是每个元组的第二个元素(索引为1的元素)。要实现这个功能,我们使用 lambda 表达式:

    key=lambda x: x[1]
    

    这里 x 是列表中的每个元组,x[1] 表示元组的第二个元素。我们告诉 sort 方法,应该根据每个元组的第二个元素来排序。

    详细解释

    1. 数据结构points = [(1, 2), (3, 1), (5, 4)]
      这是一个包含三个元组的列表,每个元组包含两个数字。例如,(1, 2) 表示一个点的坐标,1x 坐标,2y 坐标。

    2. lambda 表达式key=lambda x: x[1]

    3. x 代表列表中的每个元组。
    4. x[1] 提取元组的第二个元素。
    5. lambda 表达式的作用是告诉 sort 方法,只需要考虑每个元组的第二个元素进行比较排序。
    6. 排序过程

    7. sort() 方法从列表的第一个元组开始,对每个元组调用 lambda x: x[1],返回第二个元素的值,作为排序的依据。

    8. 对元组 (1, 2)lambda 返回 2。对元组 (3, 1),返回 1。对元组 (5, 4),返回 4

    9. 然后,sort() 方法按照 1, 2, 4 的顺序对元组排序,结果是:[(3, 1), (1, 2), (5, 4)]

    10. 最终结果
      排序后的列表 points[(3, 1), (1, 2), (5, 4)]。这个结果是根据每个元组的第二个元素从小到大排序的。

    进一步扩展

    如果我们想按元组的第一个元素排序,只需要将 x[1] 改为 x[0]

    points.sort(key=lambda x: x[0])
    print(points)  # 输出: [(1, 2), (3, 1), (5, 4)]
    

    如果你想实现降序排序,可以设置 reverse=True

    points.sort(key=lambda x: x[1], reverse=True)
    print(points)  # 输出: [(5, 4), (1, 2), (3, 1)]
    

    总结

    lambda 表达式在排序函数中用于简洁地定义排序的依据。通过传递 key 参数,我们可以轻松自定义排序规则,比如按元组中的某个特定元素排序。

    2、与 mapfilterreduce 等函数结合

    lambda 表达式与 mapfilterreduce 等高阶函数结合使用是 Python 编程中的一个强大工具。接下来我们会详细解释这三种函数及其结合 lambda 的用法。

    1、 map() 函数

    map() 函数用于对可迭代对象中的每个元素应用一个函数,并返回一个新的迭代器。它可以接受一个函数和一个或多个可迭代对象(如列表、元组)。

    语法:

    map(function, iterable)
    
  • function 是要应用于每个元素的函数。
  • iterable 是可迭代对象(例如列表、元组等)。
  • 当结合 lambda 使用时,lambda 表达式作为匿名函数传递给 map()

    示例:将列表中的每个数字平方
    nums = [1, 2, 3, 4, 5]
    
    # 使用 lambda 表达式和 map
    squared = map(lambda x: x**2, nums)
    
    # 将结果转换为列表并打印
    print(list(squared))  # 输出: [1, 4, 9, 16, 25]
    

    解释:

  • lambda x: x**2 是一个匿名函数,用来计算每个数字的平方。
  • map() 函数依次将 lambda 应用于 nums 列表中的每个元素,即 1, 2, 3, 4, 5,然后返回每个元素平方后的结果。
  • 等价的普通函数写法:

    def square(x):
        return x ** 2
    
    squared = map(square, nums)
    print(list(squared))  # 输出: [1, 4, 9, 16, 25]
    

    2、 filter() 函数

    filter() 函数用于筛选可迭代对象中的元素,保留那些使函数返回 True 的元素。它也返回一个迭代器。

    语法:

    filter(function, iterable)
    
  • function 是用于测试每个元素的函数,返回 TrueFalse
  • iterable 是需要过滤的可迭代对象。
  • 当与 lambda 表达式结合使用时,lambda 可以作为过滤条件。

    示例:筛选出列表中的偶数
    nums = [1, 2, 3, 4, 5]
    
    # 使用 lambda 表达式和 filter
    evens = filter(lambda x: x % 2 == 0, nums)
    
    # 将结果转换为列表并打印
    print(list(evens))  # 输出: [2, 4]
    

    解释:

  • lambda x: x % 2 == 0 是一个匿名函数,用来判断 x 是否为偶数。
  • filter() 函数依次将 lambda 应用于 nums 列表中的每个元素,返回 True 的元素保留,返回 False 的元素被过滤掉。因此,最终结果是保留偶数 24
  • 等价的普通函数写法:

    def is_even(x):
        return x % 2 == 0
    
    evens = filter(is_even, nums)
    print(list(evens))  # 输出: [2, 4]
    

    3、 reduce() 函数

    reduce() 函数用于对可迭代对象中的元素进行累积操作,最终合并为一个值。它需要导入 functools 模块,因为它不属于 Python 的内置函数。

    语法:

    from functools import reduce
    reduce(function, iterable)
    
  • function 是一个需要两个参数的函数,用来将前一个计算结果与下一个元素进行合并。
  • iterable 是可迭代对象。
  • 当与 lambda 表达式结合时,lambda 用来定义累积的规则。

    示例:计算列表所有元素的累加和
    from functools import reduce
    
    nums = [1, 2, 3, 4, 5]
    
    # 使用 lambda 表达式和 reduce
    total = reduce(lambda x, y: x + y, nums)
    
    print(total)  # 输出: 15
    

    解释:

  • lambda x, y: x + y 是一个匿名函数,接受两个参数 xy,并返回它们的和。
  • reduce() 函数首先将前两个元素 12 相加得到 3,然后将 33 相加得到 6,以此类推,直到处理完所有元素。最后返回累加结果 15
  • 等价的普通函数写法:

    def add(x, y):
        return x + y
    
    total = reduce(add, nums)
    print(total)  # 输出: 15
    

    总结

    1. map():对每个元素应用函数,返回每个元素的变换结果。适合批量操作。
    2. filter():根据条件过滤元素,保留符合条件的元素。
    3. reduce():对序列中的元素进行累积操作,适合需要归约为单一值的场景。

    lambda 表达式可以方便地与这些高阶函数结合,减少代码的冗余和函数的显式定义。

    3、 用于函数内部或一次性使用的函数

    当函数只需要使用一次,可以直接用 lambda 表达式,而无需定义新的函数名。

    def apply_operation(x, operation):
        return operation(x)
    
    # 使用 lambda 传递匿名函数
    result = apply_operation(5, lambda x: x * 2)
    print(result)  # 输出: 10
    

    五、总结

    lambda 表达式用于简化代码,尤其适用于短小的函数,避免显式定义完整函数。虽然它方便,但当函数较为复杂时,还是建议使用普通函数定义,以提高代码的可读性。


    感谢的关注与点赞!

    作者:.别止步春天.

    物联沃分享整理
    物联沃-IOTWORD物联网 » Python中lambda表达式的使用——完整通透版

    发表回复