Lambda详细用法，传说中的语法糖并不甜。

Lambda 表达式是一种匿名函数，它可以在运行时动态创建。它通常由一个单独的表达式组成，该表达式的结果就是 Lambda 函数的返回值。Lambda 表达式常用于函数式编程和一些简单的函数中。 感觉有点像，函数太简单，懒得起名子的时候用一下。。。

Lambda 表达式的语法如下：
lambda argument_list: expression
其中，argument_list 是逗号分隔的参数列表，expression 是返回结果的单个表达式。Lambda 表达式会自动返回该表达式的结果，无需使用 return 语句。

下面是一个简单的 Lambda 函数示例：

add = lambda x, y: x + y
print(add(1, 2))  # 输出 3

这个 Lambda 函数接受两个参数 x 和 y，返回它们的和。可以通过 lambda 关键字定义这个函数，并将其赋值给变量 add。调用该函数时，可以像调用其他函数一样传入参数。

另一个常见的用途是在高阶函数中使用lambda函数。

高阶函数是指可以接收一个或多个函数作为参数，也可以将函数作为返回值返回的函数。换句话说，它们把函数作为一等公民来对待，能够处理函数并产生函数。

在 Python 中，常见的高阶函数包括 map()、filter()、reduce() 等。这些函数接受一个或多个函数作为参数，并对列表、字典等进行处理，返回新的列表、字典等。这样的函数可以使代码更加简洁、优雅，也能提高代码的复用性和可维护性。

1.map()函数：
将一个函数应用于一个序列中的每个元素，并返回一个结果列表。可以使用lambda函数来定义映射函数。例如，以下代码将对列表中的每个元素进行平方操作：

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

在这个例子中，map函数接受两个参数，
第一个参数是Lambda表达式，表示对列表中的每个元素进行的操作；
第二个参数是要操作的列表。
map函数将Lambda表达式应用到列表中的每个元素上，并返回一个迭代对象，所以需要list转换一下。否则输出<map object at ？？？？？？？>

2.filter()函数：
从序列中过滤出符合条件的元素，并返回一个新的序列(一个迭代对象)。
可以使用lambda函数来定义过滤条件。例如，以下代码将从列表中过滤出所有的偶数：

nums = [1, 2, 3, 4, 5]
even_nums = list(filter(lambda x: x % 2 == 0, nums))
print(even_nums)  # 输出 [2, 4]

在这个例子中，filter函数接受两个参数，
第一个参数是Lambda表达式，表示用于过滤的条件；
第二个参数是要过滤的列表。
filter函数将Lambda表达式应用到列表中的每个元素上，如果返回值为True，则该元素被保留，否则被过滤掉。最终filter函数返回一个新的迭代对象，包含所有被保留的元素。

3.reduce()函数：
对一个序列中的元素进行累积操作，返回一个单一的结果。可以使用lambda函数来定义累积操作。例如，以下代码将计算列表中所有元素的累积积：

​​​​​​​from functools import reduce
nums = [1, 2, 3, 4, 5]
product = reduce(lambda x, y: x * y, nums)
print(product)  # 输出 120

reduce函数接受两个参数，
第一个是一个函数，
第二个是一个可迭代对象。
函数需要接受两个参数，并将它们合并成一个返回值。reduce() 函数会将可迭代对象中的元素两两传递给函数，并将函数的返回值作为下一次调用函数的第一个参数，直到遍历完整个可迭代对象，最后返回一个合并后的值。

在这个例子中，lambda 表达式接受两个参数，将它们相乘并返回乘积。然后 reduce() 函数将列表中的元素两两传递给 lambda 表达式，并返回它们的乘积。因此，最终的结果是列表中所有元素的乘积，即 120。
 

4.sorted()
用于对可迭代对象进行排序，返回一个新的已排序的列表。

# 按照字符串长度排序
lst = ['a', 'aaa', 'aa', 'b', 'bbb']
sorted_lst = sorted(lst, key=lambda x: len(x))
print(sorted_lst)
# 输出 ['a', 'b', 'aa', 'aaa', 'bbb']

sorted()是Python内置的一个函数，用于对可迭代对象进行排序，返回一个新的已排序的列表。
这段代码使用 sorted 函数对列表 lst 进行排序，并指定了 key 参数，
其作用是指定排序的关键字。这里使用了一个 lambda 函数，
函数的参数是列表中的每个元素，函数的返回值是该元素的长度，即 len(x)。
这样，sorted 函数就会根据每个元素的长度进行排序，最终输出的排序后的列表为 ['a', 'b', 'aa', 'aaa', 'bbb']。
而且，sorted()函数会返回一个新的已排序的列表，不会修改原来的可迭代对象。
 

5.max()函数和lambda表达式可以一起使用来获取一个可迭代对象中的最大值。
例如：

lst = [1, 5, 2, 9, 6]
max_num = max(lst, key=lambda x: x)
print(max_num)  # 输出 9

这里，max()函数接受一个可迭代对象lst和一个关键字参数key。key参数是一个函数，用于从lst中的每个元素中提取比较值。在这个例子中，我们使用了一个lambda表达式，它返回每个元素的值本身。因此，max()函数比较每个元素的值并返回最大值。

而且，如果要比较一组字符串的长度并返回最长的字符串，可以这样写：

strings = ['apple', 'banana', 'orange', 'watermelon']
longest_string = max(strings, key=lambda s: len(s))

与之相对应的，min也可以使用。

最后举个例子，冒泡法排序。
一般来说是这个样子的:

def bubble_sort(lst):
    # 外层循环控制排序的轮数
    for i in range(len(lst)-1):
        # 内层循环控制每一轮的比较次数
        for j in range(len(lst)-1-i):
            # 如果当前元素比下一个元素大，交换它们的位置
            if lst[j] > lst[j+1]:
                lst[j], lst[j+1] = lst[j+1], lst[j]
    return lst

 下面的写法就比较pythonic了，但是我觉得可读性并不好。

sorted_nums = reduce(lambda lst, _: [(lst.append(lst.pop(0)) if lst[0] > lst[1] else lst)[0] for i in range(len(lst) - 1)], range(len(nums) - 1), nums)

第一个参数是操作函数，它接收两个参数，第一个参数 lst 是当前列表，第二个参数 _ 是当前循环的计数器。
reduce 函数的作用是重复执行操作函数，将当前的列表传入，将两个元素比较并按升序交换位置。循环执行次数是列表长度减 1。最后返回排好序的列表。
匿名函数：它的作用是对传入的列表进行冒泡排序，将相邻的元素比较，交换位置。如果列表前一个元素大于后一个元素，则交换它们的位置。循环次数是列表长度减 1。
推导式：这里用了列表推导式来实现 reduce 函数，即将当前列表传入，循环执行操作函数，每次返回排好序的列表。