python中lambda expression及lambda排序

Anonymous function : lambda
lambda是expression不是statement, 其作用如下：

1， 将函数整体赋值给一个变量

a=lambda x,y:x*y
a(2,3) 
#输出 6
'''x,y作为变量， ':'前的是parameters, ':'后的是函数主体statement '''

x=lambda a:abs(a-3) # abs(parameter)abs只能取一个参数
x(5) #输出2

'''例题 leetCode 658题. Find K Closest用内部函数处理'''
# lst中离4最近的3个元素
lst=[1,2,3,4,5]
sorted(lst,key=lambda x:abs(x-4))
#output : [4, 3, 5, 2, 1]

sorted(sorted(lst, key=lambda a:abs(a-3))[0:3])
#output ： [3, 4, 5]

2， 将函数赋值给一个函数

def lam(*args): 
    for value in args:
        return sum(value)#返回的是一个lambda函数整体
b=lam((2,3)) # lam()原来的函数定义返回x+y
print("b=",b)

# 把lambda函数赋值给函数lam()
lam=lambda x,y:x*y #把x*y函数赋值给lam()函数
a=lam(2,3)
print("a=",a)

3， 作为返回值返回

'''1, function sans parameters'''
def lam(): 
    return lambda x,y:x*y #返回的是一个lambda函数整体
a=lam()
a(2,3)
# 输出 6

'''2, function avec parametre'''

def lam(a,b):
    print(a+b)
    return lambda a,b:a*b #这里的a与b与lam(a,b)函数中的参数无关，
a=lam(50,60)  #这里a是一个函数类型，因为他接受的是return出来的lambda函数
a(2,3)
#输出 110	6


# 上面函数的简单修改
def lam(a,b):
    return a+b    # 函数内部遇到第一个return函数会直接返回打印，第二个return函数不再执行
    return lambda a,b:a*b
a=lam(50,60) 
a # 这里a表示a+b的值，是一个int类型,因为a接收到的是return出来的a+b的结果
#输出  110 

4， 作为参数传递给其他函数

1, filter()

'''1, filter'''
b=filter(lambda x : x**2, [3,4])
list(b),b 
#输出 : ([3, 4], <filter at 0x37de6f8>)

2, map()

'''2, map'''
c=map(lambda x: x % 2 == 0, [1, 2, 3])
list(c),c
# output : ([False, True, False], <map at 0x3808a60>)

3, reduce()

'''3, reduce'''
import functools
lst= [1, 2, 3, 4, 5, 6, 7, 8, 9]
# 将列表lst中的元素从左往右两两以逗号分隔的字符的形式依次结合起来
d=functools.reduce(lambda a, b: '{}, {}'.format(a, b), lst)
type(d), d
# output : (str, '1, 2, 3, 4, 5, 6, 7, 8, 9')

关于"{}".format()

"{},{}".format(3,4)
# output: '3,4'

4, sorted() & sort()
sorted()和sort()用lambda进行排序

sorted(iterable, cmp=None, key=None, reverse=False)

sorted()返回重新排序的列表，不改变原列表

list.sort(cmp=None, key=None, reverse=False)

sort() 无返回值 ，对原列表彻底排序

1, iterable – 可迭代对象。
2, cmp – 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
3, key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
4, reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

4.1 以第一个元素升序排序
没有指明其他元素的排序方式则，其他元素按原来的顺序排序
漏掉’key='会报错

'''排序方法 1'''
#以第一个元素升序排序,没有指明其他元素的排序方式则，其他元素按原来的顺序排序
lst=[[5,8],[4,3],[6,1],[4,2]]
sorted(lst,key=lambda x:x[0])
# output ： [[4, 3], [4, 2], [5, 8], [6, 1]]

4.2 元素的第二个元素升序排列

# 元素的第二个元素升序排列
lst=[[5,8],[4,3],[6,1],[4,2]]
sorted(lst,key=lambda x:x[1]),   lst
#output : ([[6, 1], [4, 2], [4, 3], [5, 8]],
 # [[5, 8], [4, 3], [6, 1], [4, 2]])

4.3 先以第二个元素的升序排序，再以第一个元素的升序排序

#先以第二个元素的升序排序，再以第一个元素的升序排序
lst=[[5,8],[4,3],[6,1],[4,2]]
sorted(lst,key=lambda x: (x[1],x[0]))
# output : [[6, 1], [4, 2], [4, 3], [5, 8]]

4.4 先以第二个元素的倒叙排序，再以第一个元素的降序排序

# 先以第二个元素的倒叙排序，再以第一个元素的降序排序
lst=[[5,8],[4,3],[6,1],[4,2]]
sorted(lst,key=lambda x:(x[1],x[0]), reverse=True)
# output : [[5, 8], [4, 3], [4, 2], [6, 1]]

4.5 先以第二个元素升序排列，再以第一个元素降序排列

#以第二个元素升序排列，再以第一个元素降序排列
lst=[[5,8],[4,3],[6,1],[4,2]]
sorted(lst,key=lambda x:(x[1],-x[0]))
# output : [[6, 1], [4, 2], [4, 3], [5, 8]]