python（5）lambda表达式（匿名函数）及比较函数cmp_to_key

一、lambda

• lambda表达式，通常是在需要一个函数，但是又不想去命名一个函数的场合下使用，也就是指匿名函数。
• lambda所表示的匿名函数的内容应该是很简单的，如果复杂的话，干脆就重新定义一个函数了，使用lambda就有点过于执拗了。
• lambda就是用来定义一个匿名函数的，如果还要给他绑定一个名字的话，就会显得有点画蛇添足，通常是直接使用lambda函数。
• 匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。
• 可以把匿名函数作为返回值返回

如下所示：

add = lambda x, y : x+y
add(1,2)  # 结果为3

那么到底要如何使用lambda表达式呢？
1、应用在函数式编程中

Python提供了很多函数式编程的特性，如：map、reduce、filter、sorted等这些函数都支持函数作为参数，lambda函数就可以应用在函数式编程中。如下：

需求：将列表中的元素按照绝对值大小进行升序排列

list1 = [3,5,-4,-1,0,-2,-6]
sorted(list1, key=lambda x: abs(x))

当然，也可以如下：

list1 = [3,5,-4,-1,0,-2,-6]
def get_abs(x):
    return abs(x)
sorted(list1,key=get_abs)

只不过这种方式的代码看起来不够Pythonic
2、应用在闭包中

def get_y(a,b):
     return lambda x:ax+b
y1 = get_y(1,1)
y1(1) # 结果为2

当然，也可以用常规函数实现闭包，如下：

def get_y(a,b):
    def func(x):
        return ax+b
    return func
y1 = get_y(1,1)
y1(1) # 结果为2

只不过这种方式显得有点啰嗦。
3、练习
请用匿名函数改造下面的代码：

def is_odd(n):
    return n % 2 == 1

L = list(filter(is_odd, range(1, 20)))

>>>L = list(filter(lambda x:x%2 == 1, range(1, 20)))
>>>L
>>>[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

二、比较函数：functools.cmp_to_key(func)

cmp_to_key （比较函数）是可调用的，接受两个参数，比较这两个参数并根据他们的大小关系返回负值、零或正值中的某一个。关键字函数也是可调用的，接受一个参数，同时返回一个可以用作排序关键字的值。

举个例子：

from functools import cmp_to_key 
L=[9,2,23,1,2]
 
sorted(L,key=cmp_to_key(lambda x,y:y-x))
输出：
[23, 9, 2, 2, 1]
 
sorted(L,key=cmp_to_key(lambda x,y:x-y))
输出：
[1, 2, 2, 9, 23]

leetcode经常用到该函数，记录一下。

435. 无重叠区间

该题需要把二维数组arr[…][i]从小到大排序，再把arr[i][…]从小到大排序。code:

import functools
def compareRule(a, b):
    if a[1] == b[1]: return a[0] - b[0]
    return a[1] - b[1]

intervals = [[1,2], [2,3], [3,4], [1,3]]
intervals.sort(key=functools.cmp_to_key(compareRule))
print(intervals)
# ---------------output---------------------- #
#[[1, 2], [1, 3], [2, 3], [3, 4]]

1288. 删除被覆盖区间

该题需要把二维数组arr[i][…]从小到大排序，再把arr[…][i]从大到小排序。code:

import functools
def compareRule(a, b):
    if (a[0] == b[0]):
        return b[1] - a[1]
    return a[0] - b[0]
intervals = [[1,4],[3,6],[2,8],[1,6]]
intervals.sort(key=functools.cmp_to_key(compareRule))
print(intervals)
# ---------------output---------------------- #
#[[1, 6], [1, 4], [2, 8], [3, 6]]