目录
  • python lambda表达式与sort函数中的key
    • lambda表达式
    • sort函数
  • python匿名函数lambda表达式与sort()、sorted()、min()、max()、map()、reduce()、filter()使用
    • 1. 什么是匿名函数
    • 2. lambda表达式
    • 3. lambda表达式的用途
  • 总结

    python lambda表达式与sort函数中的key

    lambda表达式

    lambda 表达式常用来声明匿名函数，也就是没有函数名字的、临时使用的小函数，常用在临时需要一个类似于函数的功能但又不想定义函数的场合。

    例如，内置函数sorted（）和列表方法sort（）的 key参数，内置函数map（）和filter（）的第一个参数等。当然，也可以使用lambda表达式定义具名函数。

    lambda表达式只可以包含一个表达式，不允许包含复杂语句和结构，但在表达式中可以调用其他函数，该表达式的计算结果相当于函数的返回值。

    下面的代码演示了不同情况下 lambda表达式的应用。

    简言之：

    lambda表达式就是函数的迷你版，如果定义的函数比较简单可以使用lambda代替。

    >>> def func(a,b,c):
    return a+b+c
>>> f = lambda a,b,c:a+b+c  # 与func函数等价
>>> f(1,2,3) # 输出6
>>> s = lambda a,b=5,c=1:a+b+c  # 支持默认参数
>>> s(8)  # 输出14
>>> s = "abcde"
>>> tuple(map(lambda x:x.upper(),s))  # lambda 也可以作为函数参数
('A', 'B', 'C', 'D', 'E')

    咳咳，我说一下map函数，真的太顶了。它有两个参数嘛，第二个参数是一个可迭代对象，列表，元组，字符串，集合，字典那些，第一个参数一般就是一个功能函数来的，map函数大概就是，将迭代对象里面的每一个元素都传那个功能函数进行处理，以上面例子为例，将字符串s里面的每一个小写元素通过lambda表达式函数转换为大写，存到map对象里面，如果要看结果的话要用list，tuple这些数据类型将其强制转换出来显示，不然看不到。

    sort函数

    最后就是经典的与sort函数搭配了。

    假设有一个二维列表，我们以第二维元素值的大小对列表进行排序。

    那么他的写法应该是这样的。

    >>> a = [[1,4],[2,3],[5,1]]
>>> a
[[1, 4], [2, 3], [5, 1]]
>>> sorted(a,key=lambda x:x[1])   # 用sorted是不想修改a
[[5, 1], [2, 3], [1, 4]]     # 可以看到生成了按嵌套列表中第二个元素排序的列表

    或许有些读者跟我刚才一样，知道这样写，但不知道怎么来的。于是我特地找了一些资料，大概的用法就是如果指定key的话就会先遍历一遍可迭代对象，得到每个元素的key值，然后根据这个key值进行排序。

    相当于 for i in a,然后指定对i的某种操作，当然，要写成函数的形式才行。

    如果写成一般函数的话是这种形式。

    >>> a = [[1,4],[2,3],[5,1]]
>>> def func(nums):  # 这里的nums相当于是a中的每个元素 也就是[1,4],[2,3],[5,1]
    return nums[1]
# 注意注意！这里要格外注意，这里的key中func没有括号没有参数只有名字，相当于就是将a中的每个元素[1,4],[2,3],[5,1]分别去调用func函数得到一个key值，最后根据这个k值进行排序。
>>> sorted(a,key=func)  
[[5, 1], [2, 3], [1, 4]]

    当我们大概知道了这个sort如何排序之后，其他多骚的写法都能写得出来，现在我们就试试。

    >>> def func(string):   # 定义一个函数
        res = len(set(string))    #  首先计算这个单词有多少个字母 如“aaabb”算两个字母
        for i in string:
            if i.isupper():  # 如果是大写
                res *=1.15 * ord(i)  # ord表示 i 在 ASCII 对应的值
            else:
                res*=1.05 * ord(i)
        return res 
>>> a = "haHASHSADHn IamaHandsomeBoy  SLSKJlkjSLSjGHUh  iljEILNGLKD".split()
>>> sorted(a,key=func)  # 记住不要括号
['haHASHSADHn', 'iljEILNGLKD', 'IamaHandsomeBoy', 'SLSKJlkjSLSjGHUh']

    骚写法写得出来，简单的写法就迎刃而解了。当然，使用lambda表达式前提是你对排序的定义足够简单，就是按哪个哪个排序的。复杂一点的话就要像上面一样自定义函数了。

    下面看一下使用lambda对字典以值(值噢，而不是键)进行排序。

    >>> a
{1: 5, 2: 3, 7: 6, 5: 2}
>>> sorted(a)  # 如果直接写的话只会对键排序，没有达到我们想要的效果。
[1, 2, 5, 7]
>>> a.sort()   # 如果直接使用sort会报错，因为字典没有这个函数
Traceback (most recent call last): 
  File "<pyshell#47>", line 1, in <module>
    a.sort()
AttributeError: 'dict' object has no attribute 'sort'
>>> sorted(a.items(),key=lambda x:x[1])  # 因为键值我们都要，所以要使用a.items()，然后以每个元素的第二个值作为key值进行排序，得到下面的结果
[(5, 2), (2, 3), (1, 5), (7, 6)]    # 我们想要的应该是排序后的字典，而这个还不是，但是有点像，我们可以直接使用dict函数强制转换成字典。
>>> dict(sorted(a.items(),key=lambda x:x[1]))
{5: 2, 2: 3, 1: 5, 7: 6}   # 搞定

    python匿名函数lambda表达式与sort()、sorted()、min()、max()、map()、reduce()、filter()使用

    1. 什么是匿名函数

    匿名函数，即没有函数名称的函数。学过Python的都知道，Python中函数的定义格式为：（关键字）def（加）（函数名）get_name:（函数体），但是匿名函数没有函数名称，它的定义格式为：lambda [arg1,[arg2,arg3…]]: expression，因此匿名函数又被成为lambda表达式，它只包含一行表达式。

    2. lambda表达式

    定义格式：lambda [arg1,[arg2,arg3…]]: expression，其中lambda为必须的关键字，args表示参数列表，expression表示表达式。

    为便于理解，该语法格式转为普通函数格式如下：

    def fun_name(arg1,[arg2,arg3..]):
	return expression
fun_name(arg1,[arg2,arg3..])

    显然，使用普通方法定义此函数，需要 3 行代码，而使用 lambda 表达式仅需 1 行。

    举个例子：

    def square(x):
	return x ** 2
print(square(5))
# 此处只是为了举例，平常不建议这样将lambda表达式赋值给变量
a = lambda x: x ** 2
print(a(5))

    运行结果

    25

    25

    3. lambda表达式的用途

    lambda表达式只有一行，相比于函数，它具有的优势：

    • 对于单行函数，使用 lambda 表达式可以省去定义函数的过程，让代码更加简洁；
    • 对于不需要多次复用的函数，使用 lambda 表达式可以在用完之后立即释放，提高程序执行的性能。

    那么，lambda表达式的使用方式有哪些呢：

    1.排序，结合sorted() 和sort()方法使用

    # 方式1
list1 = [1, 2, 6, 9, 3, 5, 4, 0]
list1.sort(key=lambda x: x)
# lambda x: x中第一个x为参数，此时是list1中的每个元素，第二个x是表达式，此时也表示list1中的每个元素
# 通过在第二行打断点，然后调试运行，会发现表达式x，会被依次赋值为列表
# list1中的每个值
print(list1)
# 方式2
# list2 中记录名字和他的年龄
list2 = [['小明', 23], ['大美', 22], ['小帅', 18], ['张三', 24]]
list3 = sorted(list2, key=lambda x: x[1])
# lambda x: x[1]中第一个x为参数，此时是list2中的每个元素,此时是列表，
# 即'['小明', 23]'；第二个x[1]是表达式，此时表示列表中第二个值，即23
# 表示按照每个人的年龄排序
print(list3)
# 方式3
list4 = ['3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
t = ['3', '3', '4', '6', '5', '8', '7', '10', '10', 'K', 'A', 'J', 'Q']
t.sort(key=lambda x: list4.index(x))
# lambda x: list4.index(x)中第一个x为参数，此时是t中的每个元素
# list4.index(x)是表达式，表示x在list4中的索引值，表示按照索引值大小排序
print(t)

    输出结果：

    [0, 1, 2, 3, 4, 5, 6, 9]
    [[‘小帅’, 18], [‘大美’, 22], [‘小明’, 23], [‘张三’, 24]]
    [‘3’, ‘3’, ‘4’, ‘5’, ‘6’, ‘7’, ‘8’, ‘10’, ‘10’, ‘J’, ‘Q’, ‘K’, ‘A’]

    2.结合max()、min()使用

    list2 = [['小明', 23], ['大美', 22], ['小帅', 18], ['张三', 24]]
list5 = [2, 10, 4, 3, 1, 2, 6, 8, 7]
res = max(list5, key=lambda x: x)
print(res)
name_age = min(list2, key=lambda x: x[1])
print(name_age)

    输出结果：

    10
    [‘小帅’, 18]

    3.结合map()函数使用

    # ===========一般写法：===========
# 1、计算平方数
list6 = [2,3,6,1,5]
def square(x):
	return x ** 2
s = list(map(square, list6))	# 计算列表各个元素的平方
print(s)
# ===========匿名函数写法：============
# 2、计算平方数，lambda 写法
s1 = list(map(lambda x: x ** 2, list6))
print(s1)
# 3、提供两个列表，将其相同索引位置的列表元素进行相加
list7 = [1,2,34,6]
s2 = list(map(lambda x, y: x + y, list7, list6))
print(s2)

    输出结果：

    [4, 9, 36, 1, 25]
    [4, 9, 36, 1, 25]
    [3, 5, 40, 7]

    4.结合reduce()使用

    reduce函数是Python中的内置函数，用于计算可迭代对象的累积结果。

    reduce 函数的用法和示例：

    reduce(function, iterable[, initializer])

    • 函数定义：对可迭代对象中的元素进行累积操作，返回一个单一的结果。
    • 参数 function：用于累积操作的函数，接受两个参数，必须返回一个值。
    • 参数 iterable：可迭代对象，包含要进行累积操作的元素。
    • 参数 initializer：可选参数，作为累积的初始值。如果提供了初始值，则累积操作从初始值开始；如果未提供初始值，则累积操作从可迭代对象的第一个元素开始。

    from functools import reduce
list8 = [5, 6, 7, 4, 3, 2, 1]
# 此时初始值默认为列表第一个元素，计算元素的和
s3 = reduce(lambda x, y: x + y, list8)
print(s3)
# 定义初始值为0，计算列表元素的平方和
s4 = reduce(lambda x, y: x + y ** 2, list8, 0)
print(s4)
# 计算n的阶乘
n = 5
s5 = reduce(lambda x, y: x * y, range(1, n + 1))
print(s5)
# 计算最大值
s6 = reduce(lambda x, y: x if x > y else y, list8)
print(s6)

    输出结果：

    28
    140
    120
    7

    5.结合filter()使用

    filter函数用于过滤序列，过滤掉不符合条件的元素

    filter(function, iterable)

    • function：用于过滤的函数
    • iterable：可迭代对象

    list9 = [1, 2, 3, 4, 5, 6, 7, 8]
# 保留偶数
s7 = list(filter(lambda x: x % 2 == 0, list9))
print(s7)

    输出结果：

    [2, 4, 6, 8]

    心得：

    1.lambda表达式可直接赋值给变量

    2.lambda表达式可结合函数使用，若函数中带有参数key或这参数function，如sort()、sorted()、min()、max()、map()、reduce()、filter()等

    总结

    以上为个人经验，希望能给大家一个参考，也希望大家多多支持本网站。

    您可能感兴趣的文章:

    • 详解python中的lambda与sorted函数
    • python中sort()函数用法详解
    • Python中 Lambda表达式全面解析