Python快速入門專業版（三十二）：匿名函數：lambda表達式的簡潔用法（結合filter/map）

在這里插入圖片描述

引
一、lambda表達式的基本語法：一行代碼定義函數
- 示例1：lambda表達式與普通函數的對比
二、lambda表達式的應用場景：臨時與靈活
- 1. 臨時使用：無需定義函數名的簡單功能
- 2. 作為參數傳遞給高階函數
三、結合filter()：篩選序列中的元素
- 示例2：篩選列表中的偶數
- 示例3：篩選字符串列表中的長字符串
四、結合map()：對序列元素做映射轉換
- 示例4：將列表元素翻倍
- 示例5：將字符串列表轉換為大寫
五、實戰案例：篩選偶數并翻倍
- 案例代碼實現
- 簡化寫法：鏈式調用
六、lambda表達式的局限性
七、總結與最佳實踐
- 最佳實踐：

引

在Python中，函數不僅可以通過def關鍵字定義，還能以更簡潔的方式創建——這就是lambda表達式（匿名函數）。它不需要函數名，僅用一行代碼就能定義簡單功能，特別適合臨時使用或作為參數傳遞給高階函數。本文將從lambda的基本語法出發，對比其與普通函數的差異，重點講解其與filter()、map()等高階函數的結合用法，并通過實戰案例展示其簡潔高效的特性。

一、lambda表達式的基本語法：一行代碼定義函數

lambda表達式（匿名函數）是一種簡化的函數定義方式，其語法格式為：

lambda 參數: 表達式

參數：與普通函數類似，可接收零個或多個參數（用逗號分隔）。
表達式：函數的返回值，必須是一個單一表達式（不能包含循環、條件語句塊等復雜邏輯）。
特性：無需函數名（匿名），定義即返回函數對象，代碼僅占一行。

示例1：lambda表達式與普通函數的對比

用“兩數相加”功能對比lambda與普通函數的定義方式：

# 普通函數（def定義）
def add(a, b):return a + b# 匿名函數（lambda定義）
add_lambda = lambda a, b: a + b# 兩者功能完全一致
print(add(3, 5))          # 輸出：8
print(add_lambda(3, 5))   # 輸出：8

對比分析：

普通函數用def定義，需要函數名（add）、顯式return語句，適合復雜邏輯。
lambda表達式無需函數名，通過lambda關鍵字直接定義參數和返回表達式，代碼更簡潔，適合簡單邏輯。

lambda的本質是“語法糖”，它創建的函數對象與def定義的函數在功能上沒有區別，只是定義方式更簡潔。

二、lambda表達式的應用場景：臨時與靈活

lambda表達式的匿名特性使其特別適合以下場景：

1. 臨時使用：無需定義函數名的簡單功能

當需要一個簡單函數且僅使用一次時，lambda可以避免“為短功能單獨定義函數”的冗余。

# 臨時計算兩個數的乘積
result = (lambda x, y: x * y)(4, 5)
print(result)  # 輸出：20

這里直接定義lambda表達式并立即調用（類似“一次性函數”），無需提前賦值給變量。

2. 作為參數傳遞給高階函數

高階函數是指“接收函數作為參數”或“返回函數”的函數（如filter()、map()、sorted()等）。lambda表達式作為參數傳遞時，能顯著簡化代碼。

例如，用sorted()對字典列表排序，按指定鍵排序：

# 待排序的字典列表
students = [{"name": "Alice", "age": 20},{"name": "Bob", "age": 18},{"name": "Charlie", "age": 22}
]# 按age字段升序排序（lambda作為key參數）
sorted_students = sorted(students, key=lambda x: x["age"])
print(sorted_students)
# 輸出：[{'name': 'Bob', 'age': 18}, {'name': 'Alice', 'age': 20}, {'name': 'Charlie', 'age': 22}]

這里lambda表達式lambda x: x["age"]作為sorted()的key參數，指定排序依據為字典的"age"字段，無需單獨定義函數。

三、結合filter()：篩選序列中的元素

filter()是Python內置的高階函數，用于篩選序列中滿足條件的元素，其語法為：

filter(函數, 可迭代對象)

參數1（函數）：接收一個參數，返回布爾值（True保留元素，False剔除元素）。
參數2（可迭代對象）：列表、元組等可迭代數據。
返回值：迭代器（需用list()轉換為列表查看結果）。

lambda表達式常作為filter()的第一個參數，定義篩選條件。

示例2：篩選列表中的偶數

# 原始列表
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]# 用filter()和lambda篩選偶數
even_numbers = filter(lambda x: x % 2 == 0, numbers)# 轉換為列表并打印
print(list(even_numbers))  # 輸出：[2, 4, 6, 8, 10]

執行邏輯：

lambda表達式lambda x: x % 2 == 0定義篩選條件：x是偶數時返回True。
filter()遍歷numbers中的每個元素，將元素傳遞給lambda：返回True的元素被保留。
最終通過list()轉換迭代器，得到篩選后的偶數列表。

示例3：篩選字符串列表中的長字符串

# 原始字符串列表
words = ["apple", "banana", "cat", "dog", "elephant"]# 篩選長度大于3的字符串
long_words = filter(lambda s: len(s) > 3, words)
print(list(long_words))  # 輸出：['apple', 'banana', 'elephant']

四、結合map()：對序列元素做映射轉換

map()是另一個常用的高階函數，用于對序列中的每個元素應用相同的轉換操作，其語法為：

map(函數, 可迭代對象)

參數1（函數）：接收一個參數，返回轉換后的結果。
參數2（可迭代對象）：列表、元組等可迭代數據。
返回值：迭代器（需用list()轉換為列表查看結果）。

lambda表達式作為map()的第一個參數時，可簡潔定義轉換邏輯。

示例4：將列表元素翻倍

# 原始列表
numbers = [1, 2, 3, 4, 5]# 用map()和lambda將每個元素翻倍
doubled_numbers = map(lambda x: x * 2, numbers)# 轉換為列表并打印
print(list(doubled_numbers))  # 輸出：[2, 4, 6, 8, 10]

執行邏輯：

lambda表達式lambda x: x * 2定義轉換規則：將輸入x乘以2。
map()遍歷numbers中的每個元素，將元素傳遞給lambda，得到轉換后的結果。
最終通過list()轉換迭代器，得到所有元素翻倍后的列表。

示例5：將字符串列表轉換為大寫

# 原始字符串列表
words = ["hello", "world", "python"]# 轉換為大寫
upper_words = map(lambda s: s.upper(), words)
print(list(upper_words))  # 輸出：['HELLO', 'WORLD', 'PYTHON']

五、實戰案例：篩選偶數并翻倍

結合filter()和map()，實現“先篩選列表中的偶數，再將這些偶數翻倍”的功能，展示lambda表達式在鏈式操作中的簡潔性。

案例代碼實現

# 原始列表
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]# 步驟1：用filter篩選偶數
even_numbers = filter(lambda x: x % 2 == 0, numbers)# 步驟2：用map將偶數翻倍
doubled_evens = map(lambda x: x * 2, even_numbers)# 轉換為列表并打印結果
print(list(doubled_evens))  # 輸出：[4, 8, 12, 16, 20]

執行流程解析：

filter(lambda x: x % 2 == 0, numbers)從原始列表中篩選出偶數[2, 4, 6, 8, 10]。
map(lambda x: x * 2, even_numbers)將篩選出的偶數翻倍，得到[4, 8, 12, 16, 20]。
整個過程用lambda表達式定義篩選和轉換邏輯，無需單獨定義函數，代碼簡潔直觀。

簡化寫法：鏈式調用

由于filter()和map()的返回值都是可迭代對象，可將代碼簡化為鏈式調用：

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
result = list(map(lambda x: x * 2, filter(lambda x: x % 2 == 0, numbers)))
print(result)  # 輸出：[4, 8, 12, 16, 20]