Python基础(十六)——Lambda 表达式

目录

  • 1、Lambda 表达式是什么
  • 2、和def所定义的python函数的区别
  • 3、Lambda 表达式的定义
  • 3、Lambda 表达式的特点
  • 4、Lambda 表达式中用三目运算语句
  • 5、lambda的参数形式
    • 5.1、Lambda 表达式直接调用。
    • 5.2、无参数
    • 5.3、一个参数
    • 5.3、默认参数
    • 5.4、可变参数:**args
    • 5.5、可变参数:**kwargs
  • 6、排序中使用lambda表达式
    • 6.1、列表排序(使用 Lambda 表达式)
      • 6.1.1、列表排序(不指定 key)
      • 6.1.2、列表排序(指定 key)
      • 6.1.3、列表排序
      • 6.1.4、列表内嵌套列表排序(使用 Lambda 表达式)。
    • 6.2、字典排序
      • 6.2.1、字典排序(键(key)排序)
      • 6.2.2、字典排序(值(value)排序)(使用 Lambda 表达式)
      • 6.2.3、字典内嵌套字典排序(使用 Lambda 表达式)
  • 7、lambda表达式作为map ()的第一参数
  • 8、lambda表达式作为filter ()的第一参数

1、Lambda 表达式是什么

lambda表达式其实就是Python的一个函数语法一样。所以也称为匿名函数。
所谓匿名函数,通俗地说就是没有名字的函数。
基本功能跟使用def所定义的python函数是一样的。
但是、和def所定义的区别是:

lambda表达式基本在一行以内就完整的表达了整个函数的运算逻辑。

我们直接看 和def的对应关系你就明白了。

2、和def所定义的python函数的区别

具体的,我们看一下def语句的函数定义与相应的lambda表达式之间的对应关系,你就能明白。

def 函数名(参数1, 参数2, ...):
    return 返回值

函数名 = lambda 参数1, 参数2, ...: 返回值

注意:Lambda 表达式中 lambda 在oython中是个关键字。

我们看实例:

# def定义的加法函数
def add_def(a, b=1):
    return a + b

# Lambda 表达式:定义的加法函数
# 这里为了区分方便阅读,函数名不太一致。
add_lambda = lambda a, b=1: a + b

实际的代码结果:

def add_def(a, b=1):
    return a + b

add_lambda = lambda a, b=1: a + b

print(add_def(4, 4))      # 8

print(add_def(4))         # 5

print(add_lambda(4, 4))   # 8

print(add_lambda(4))      # 5

对应关系你很清楚理解 Lambda 表达式是什么了。
现在我们看看 Lambda 表达式的定义。

3、Lambda 表达式的定义

lambda parameters: expression
  • lambda:关键字
  • parameters:参数列表,是可选的。参数列表的参数个数可以是零个或者多个,如果有多个,则用逗号分隔;其规则跟普通函数的规则一致,但不需要用括号。
  • expression是一个估值表达式,这个表达式的估值结果就是lambda函数的返回值。expression不能包含分支或者循环(但可以是三目运算语句),也不能包含return或者yield语句。

所谓估值表达式,就是最终能被运算成一个值的表达,例如常量、变量、运算表达式、函数调用、列表切片,等等。

※关于【3、Lambda 表达式的定义】内容来自知乎作者:Python3基础:lambda表达式

虽然 Lambda 表达式 和def定义的函数 是一样的,但是Lambda 表达式 的使用是根据自己特点有限制的。
我们接下来看一下Lambda 表达式的特点。

3、Lambda 表达式的特点

  1. 参数不受限,以接收任意多个参数 (包括可选参数)
    参数列表的参数个数可以是零个或者多个,如果有多个,则用逗号分隔;其规则跟普通函数的规则一致,但不需要用括号。

例:有四个参数,逗号隔开

add_lambda = lambda a, b, c=1, d=2: a + b + c + d

print(add_lambda(4, 4))           # 11

print(add_lambda(4, 4, 4, 4))     # 16
  1. 功能简单。
    单行expression决定了lambda函数不可能完成复杂的逻辑,只能完成非常简单的功能。所有的函数逻辑必须一行之内完成。

  2. 表达式有唯一性。
    lambda表达式只允许包含一个表达式,不能包含复杂语句,该表达式的运算结果就是函数的返回值。
    因为最终结果一定要被运算成一个值,例如常量、变量、运算表达式、函数调用、列表切片,等等。

也真因为第三个特点:最终结果一定要被运算成一个值
因此基于这个特点,Lambda 表达式中可以包含三目运算语句,因为三目运算语句的结果就是一个值。

4、Lambda 表达式中用三目运算语句

关于三目运算语句请参照:三目运算语句

直接上代码:

get_odd_even = lambda x: '偶数' if x % 2 == 0 else '奇数'

print(get_odd_even(3))
# 奇数

print(get_odd_even(4))
# 偶数

等价以下语句:

def get_odd_even(x):
    if x % 2 == 0:
        str = "偶数"
    else:
        str = "奇数"
    return str

print(get_odd_even(3))
# 奇数

print(get_odd_even(4))
# 偶数

5、lambda的参数形式

5.1、Lambda 表达式直接调用。

直接看示例:

print((lambda a, b: a + b)(1, 2))    # 3

5.2、无参数

print((lambda: 100)())     # 100

5.3、一个参数

print((lambda a: a)('hello world'))    # hello world

5.3、默认参数

print((lambda a, b, c=100: a + b + c)(10, 20))    # 130

5.4、可变参数:**args

返回值是个元组。

print((lambda *args: args)(10, 20, 30))    # (10, 20, 30)

5.5、可变参数:**kwargs

返回值是个字典。

print((lambda **kwargs: kwargs)(name='python', age=20))     # {'name': 'python', 'age': 20}

主要介绍 sorted(),sort(),max(),min()参数key中使用 Lambda 表达式。

6、排序中使用lambda表达式

6.1、列表排序(使用 Lambda 表达式)

6.1.1、列表排序(不指定 key)

TestList = ['Charle', 'Bob', 'Alice']

TestListSorted = sorted(TestList)

print(TestListSorted)
# ['Alice', 'Bob', 'Charle']

6.1.2、列表排序(指定 key)

本例:在参数key中指定返回字符数的内置函数 len(),从而按字符数降序排序。

TestList = ['Charle', 'Bob', 'Alice']

TestListSorted = sorted(TestList, key=len)

print(TestListSorted)
# ['Bob', 'Alice', 'Charle']

6.1.3、列表排序

这时我们把 key 执行成 Lambda 表达式。可以将任意函数应用于各元素,并根据其结果进行排序。
例如,当将用于获取第二个字符的lambda表达式【lambda x: x[1]】指定为key时,按照第二个字符的字母顺序进行排序。
下面示例可以看的更清楚:
1、首先我们要知道:

lambda x: x[0]

是在取列表各个元素对应下标的值。

print((lambda x: x[0])([1, 2, 3]))     # 1
print((lambda x: x[1])([1, 2, 3]))     # 2
print((lambda x: x[2])([1, 2, 3]))     # 3

print((lambda x: x[0])('ABC'))         # A
print((lambda x: x[1])('ABC'))         # B
print((lambda x: x[2])('ABC'))         # C

2、所以我们直接看例子:

TestList = ['CEG', 'BFH', 'ADI']

# 以列表中列表的第一个字母排序
print(sorted(TestList, key=lambda x: x[0]))
# ['ADI', 'BFH', 'CEG']

# 以列表中列表的第二个字母排序
print(sorted(TestList, key=lambda x: x[1]))
# ['ADI', 'CEG', 'BFH']

# 以列表中列表的第三个字母排序
print(sorted(TestList, key=lambda x: x[2]))
# ['CEG', 'BFH', 'ADI']

6.1.4、列表内嵌套列表排序(使用 Lambda 表达式)。

Testlist = [
    [4, 2, 9], 
    [1, 5, 6], 
    [7, 8, 3]
]

# 以列表中列表的第一个数排序
print(sorted(Testlist, key=lambda x: x[0]))
# [[1, 5, 6], [4, 2, 9], [7, 8, 3]]

# 以列表中列表的第二个数排序
print(sorted(Testlist, key=lambda x: x[1]))
# [[4, 2, 9], [1, 5, 6], [7, 8, 3]]

# 以列表中列表的第三个数排序
print(sorted(Testlist, key=lambda x: x[2]))
# [[7, 8, 3], [1, 5, 6], [4, 2, 9]]

# 以列表中列表的第一个数排序,且降序
print(sorted(Testlist, key=lambda x: x[0], reverse=True))
# [[7, 8, 3], [4, 2, 9], [1, 5, 6]]

6.2、字典排序

6.2.1、字典排序(键(key)排序)

dict = {'c': 1, 'b': 2, 'a': 3}

print(sorted(dict))
# ['a', 'b', 'c']

print(sorted(dict, reverse=True))
# ['c', 'b', 'a']

6.2.2、字典排序(值(value)排序)(使用 Lambda 表达式)

dict = {'c': 1, 'b': 2, 'a': 3}

print(sorted(dict, key=lambda x: dict[x]))
# ['c', 'b', 'a']

print(sorted(dict, key=lambda x: dict[x], reverse=True))
# ['a', 'b', 'c']

6.2.3、字典内嵌套字典排序(使用 Lambda 表达式)

dict = {
        'a': {'x': 3, 'y': 2, 'z': 1},
        'b': {'x': 2, 'y': 1, 'z': 3},
        'c': {'x': 1, 'y': 3, 'z': 2}
        }

# 以内部字典的'x'对应的值排序
print(sorted(dict, key=lambda x: dict[x]['x']))
# ['c', 'b', 'a']

# 以内部字典的'y'对应的值排序
print(sorted(dict, key=lambda x: dict[x]['y']))
# ['b', 'a', 'c']

# 以内部字典的'z'对应的值排序
print(sorted(dict, key=lambda x: dict[x]['z']))
# ['a', 'c', 'b']

# 以内部字典的'x'对应的值排序,并降序
print(sorted(dict, key=lambda x: dict[x]['x'], reverse=True))
# ['a', 'b', 'c']

7、lambda表达式作为map ()的第一参数

list = [0, 1, 2, 3]

map_square = map(lambda x: x**2, list)

print(map_square)
# 

print(list(map_square))
# [0, 1, 4, 9]

等同于以下语句:

list = [0, 1, 2, 3]

l_square = [x**2 for x in list]

print(l_square)
# [0, 1, 4, 9]

8、lambda表达式作为filter ()的第一参数

list = [0, 1, 2, 3]

filter_even = filter(lambda x: x % 2 == 0, list)

print(list(filter_even))
# [0, 2]

等同于:

list = [0, 1, 2, 3]

l_even = [x for x in list if x % 2 == 0]

print(l_even)
# [0, 2]

如果有问题,请指出,或者copy了谁的,也请指出。
会及时更正。

你可能感兴趣的:(Python,python,Lambda表达式)