常用内置函数：map、filter、reduce 的用法

狼影

发布时间：2025-09-03 18:16:01

928人浏览过

来源于php中文网

原创

map、filter和reduce是Python中处理可迭代对象的核心函数式编程工具。map用于对每个元素应用函数进行转换，filter根据条件筛选元素，reduce则将元素累积计算为单一结果。它们返回迭代器，支持惰性求值，适合构建高效的数据处理管道。相较于列表推导式，它们在逻辑复杂或需函数复用时更简洁；相比循环，代码更声明式、意图明确。常用于数据清洗、转换和聚合场景，尤其reduce在自定义累积操作中具有不可替代的优势。

常用内置函数：map、filter、reduce 的用法

map

、

filter

和

reduce

这三个内置函数，在我看来，是Python中处理序列数据非常强大且优雅的工具。它们的核心作用分别是：对序列中的每个元素应用一个函数进行转换（

map

），根据某个条件筛选序列中的元素（

filter

），以及将序列中的元素逐个累积计算，最终得到一个单一结果（

reduce

）。它们代表了一种函数式编程的思路，能让代码更简洁、意图更清晰。

解决方案

这三个函数各有侧重，但都围绕着“处理可迭代对象”这个核心任务展开。

map(function, iterable, ...)

map

函数会根据提供的函数对指定序列（或多个序列）的每个元素进行处理，并返回一个迭代器，其中包含所有处理后的结果。它不会改变原始序列。

用途: 当你需要对一个序列中的所有元素执行相同的转换操作时，
```
map
```
非常合适。

示例:

# 场景：将一个整数列表中的每个数字都平方
numbers = [1, 2, 3, 4, 5]

# 使用匿名函数（lambda）
squared_numbers_map = map(lambda x: x * x, numbers)
print(f"使用map平方后的结果（迭代器）：{list(squared_numbers_map)}")
# 输出：使用map平方后的结果（迭代器）：[1, 4, 9, 16, 25]

# 也可以使用已定义的函数
def multiply_by_two(num):
    return num * 2

doubled_numbers = map(multiply_by_two, numbers)
print(f"使用map乘以2后的结果：{list(doubled_numbers)}")
# 输出：使用map乘以2后的结果：[2, 4, 6, 8, 10]

我个人觉得，当转换逻辑比较简单，或者已经有一个现成的函数可以直接用时，

map

写起来特别顺手。

filter(function, iterable)

filter

函数会根据一个判断函数（返回布尔值）来筛选序列中的元素，只保留那些使判断函数返回

True

的元素，同样返回一个迭代器。

用途: 当你需要从一个序列中筛选出符合特定条件的元素时，
```
filter
```
是理想选择。

示例:

# 场景：从一个列表中筛选出所有的偶数
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 使用匿名函数判断是否为偶数
even_numbers_filter = filter(lambda x: x % 2 == 0, numbers)
print(f"使用filter筛选出的偶数：{list(even_numbers_filter)}")
# 输出：使用filter筛选出的偶数：[2, 4, 6, 8, 10]

# 也可以用None作为function，此时会移除所有“假值”（False, 0, None, "", []等）
mixed_list = [0, 1, '', 'hello', [], [1, 2], None]
truthy_values = filter(None, mixed_list)
print(f"使用filter(None)筛选出的真值：{list(truthy_values)}")
# 输出：使用filter(None)筛选出的真值：[1, 'hello', [1, 2]]

我发现

filter(None, ...)

这个小技巧在清理数据时特别实用，能快速剔除那些被Python认为是“假”的元素。

reduce(function, iterable[, initializer])

reduce

函数（位于

functools

模块中）会将一个函数连续地应用于序列的元素，每次应用的结果都会作为下一次应用的一个参数。它最终会把一个序列“规约”成一个单一的值。

用途: 当你需要对序列中的元素进行累积计算，比如求和、求积、找出最大值等，
```
reduce
```
非常强大。

示例:

from functools import reduce

# 场景：计算一个列表所有元素的和
numbers = [1, 2, 3, 4, 5]

# 使用匿名函数实现累加
sum_of_numbers = reduce(lambda x, y: x + y, numbers)
print(f"使用reduce计算列表和：{sum_of_numbers}")
# 输出：使用reduce计算列表和：15

# 场景：找出列表中最大的数字
max_number = reduce(lambda x, y: x if x > y else y, numbers)
print(f"使用reduce找出列表中最大值：{max_number}")
# 输出：使用reduce找出列表中最大值：5

# 带初始值（initializer）的reduce，在空序列时尤其有用，或者想从某个特定值开始累积
product_with_initial = reduce(lambda x, y: x * y, [1, 2, 3], 10) # 从10开始乘以1*2*3
print(f"带初始值reduce计算乘积：{product_with_initial}")
# 输出：带初始值reduce计算乘积：60

reduce

的逻辑理解起来可能比

map

和

filter

稍微需要一点点时间，但一旦掌握，它在处理某些累积性问题上简直是神器。记住，它需要从

functools

模块导入，这和另外两个内置函数有点不同。

map、filter、reduce与列表推导式、循环有何不同？何时选择它们？

这确实是一个非常核心的问题，我在日常开发中也常常思考。在我看来，

map

、

filter

和

reduce

与列表推导式（List Comprehensions）、生成器表达式（Generator Expressions）以及传统的

for

循环，它们之间更多的是一种互补关系，而非简单的替代。

可读性与简洁性:
- 对于简单的元素转换（
```
map
```
  ）或筛选（
```
filter
```
  ），列表推导式往往更具Pythonic风格，也更容易阅读。比如，
```
[x * x for x in numbers]
```
  通常比
```
list(map(lambda x: x * x, numbers))
```
  更直观。
- 但当转换或筛选逻辑本身就是一个已定义的函数时，
```
map
```
  和
```
filter
```
  能让代码更简洁，直接传递函数名即可，避免了在列表推导式中重复写
```
lambda
```
  。
- ```
reduce
```
  在处理累积操作时，其简洁性是无与伦比的，虽然初学者可能需要适应它的思维模式。传统的
```
for
```
  循环实现累积操作往往需要额外的变量和多行代码。
性能考量:

意兔-AI漫画相机
照片变漫画手绘，做周边好物

下载
- ```
map
```
  和
```
filter
```
  返回的是迭代器，这意味着它们是“惰性”计算的，只在需要时才生成下一个元素。这在处理大型数据集时非常高效，可以节省内存。列表推导式则会一次性生成所有结果，占用更多内存。
- 在C语言层面实现的
```
map
```
  和
```
filter
```
  ，在某些情况下可能会比等效的Python循环或列表推导式略快，但这通常不是我们选择它们的首要原因，除非是在性能瓶颈处。
- ```
reduce
```
  的性能通常也很好，因为它避免了显式的循环和中间列表的创建。
函数式编程风格:
- ```
map
```
  、
```
filter
```
  、
```
reduce
```
  是函数式编程的基石。它们鼓励我们思考“做什么”而不是“如何做”，将数据转换和处理视为一系列函数的组合。这种风格有助于编写无副作用、更易于测试和理解的代码。
- 列表推导式虽然也很简洁，但它更像是Python对函数式概念的一种“语法糖”实现，本质上还是基于迭代。

何时选择？

选择列表推导式/生成器表达式:
- 当转换或筛选逻辑非常简单，一行代码就能清晰表达时。
- 当你需要立即得到一个完整的列表或生成器时。
- 在我看来，大多数简单的转换和筛选，列表推导式是首选，因为它更符合Python的直觉。
选择
```
map
```
/
filter
:
- 当转换或筛选逻辑已经封装在一个独立的函数中，或者是一个比较复杂的
```
lambda
```
  表达式，直接传递函数名能让代码更清晰。
- 当你需要处理非常大的数据集，希望利用迭代器的惰性计算来节省内存时。
- 当你倾向于函数式编程风格，希望将数据处理看作一系列函数管道时。
选择
```
reduce
```
:
- 当你需要将一个序列中的所有元素“归纳”成一个单一的结果时（求和、求积、连接字符串、查找最大最小等）。
- 这是它最独特的应用场景，通常没有其他内置函数能直接替代其功能，
```
for
```
  循环是唯一的替代方案，但代码会显得冗长。

我发现，一个好的实践是：如果列表推导式能清晰地表达意图，就用它；如果涉及函数应用或需要惰性计算，就考虑

map

filter

；而对于累积操作，

reduce

几乎总是我的首选。

如何结合使用map、filter实现复杂数据处理？

将

map

和

filter

结合使用，是构建数据处理管道的常见模式，尤其是在处理数据清洗、转换和分析任务时。由于它们都返回迭代器，所以可以非常自然地进行链式调用，前一个函数的输出可以直接作为后一个函数的输入，这在我看来，是它们设计上的一个亮点。

想象一个场景：我们有一个包含用户年龄和姓名的列表，我们想找出所有年龄大于30岁的用户，并把他们的姓名转换成大写。

users_data = [
    {"name": "Alice", "age": 25},
    {"name": "Bob", "age": 32},
    {"name": "Charlie", "age": 40},
    {"name": "David", "age": 28},
    {"name": "Eve", "age": 35},
]

# 步骤1：筛选出年龄大于30岁的用户
# filter的function需要接收一个字典，并返回布尔值
older_users_iterator = filter(lambda user: user["age"] > 30, users_data)

# 步骤2：从筛选出的用户中提取姓名，并转换为大写
# map的function需要接收一个字典（来自filter的输出），并返回处理后的姓名
uppercase_names_iterator = map(lambda user: user["name"].upper(), older_users_iterator)

# 最终结果
result_names = list(uppercase_names_iterator)
print(f"年龄大于30岁的用户姓名（大写）：{result_names}")
# 输出：年龄大于30岁的用户姓名（大写）：['BOB', 'CHARLIE', 'EVE']

这个例子展示了如何通过链式调用将筛选和转换操作结合起来。

filter

先筛选出符合条件的数据，然后

map

再对这些筛选后的数据进行进一步的转换。这种方式非常清晰，每一步都只做一件事，符合单一职责原则。

更进一步，你甚至可以在这些函数中嵌套使用其他函数，或者将更复杂的逻辑封装成独立的函数再传入。

# 稍微复杂一点的场景：
# 找出所有包含特定关键词的字符串，然后将它们的首字母大写
words = ["apple", "banana", "grape", "orange", "pineapple", "pear"]
keyword = "ap"

# 1. 筛选出包含关键词的单词
filtered_words = filter(lambda w: keyword in w, words)

# 2. 将筛选出的单词首字母大写
capitalized_words = map(lambda w: w.capitalize(), filtered_words)

print(f"包含 '{keyword}' 且首字母大写的单词：{list(capitalized_words)}")
# 输出：包含 'ap' 且首字母大写的单词：['Apple', 'Grape', 'Pineapple']

这种管道式的处理方式，不仅代码简洁，而且由于

filter

和

map

都返回迭代器，整个过程是惰性计算的。这意味着在处理大量数据时，它不会一次性在内存中创建所有的中间列表，从而有效地节省了内存资源。我个人觉得，当数据量大、处理步骤多时，这种链式调用带来的内存效率提升是非常显著的。

reduce在哪些场景下能发挥独特优势？

reduce

的独特优势主要体现在“聚合”和“累积”操作上，也就是将一个序列最终归结为一个单一的值。虽然许多简单的累积操作Python有内置函数（如

sum()

、

max()

、

min()

），但

reduce

的灵活性在于它允许你定义任何你想要的累积逻辑。

这里有一些

reduce

能发挥独特优势的场景：

自定义累加/累乘： 当需要进行的累积操作不是简单的加法或乘法时，

reduce

的优势就体现出来了。

from functools import reduce

# 场景：计算列表中所有偶数的乘积
numbers = [1, 2, 3, 4, 5, 6]
# 先筛选出偶数，再计算乘积
even_numbers = filter(lambda x: x % 2 == 0, numbers)
product_of_evens = reduce(lambda x, y: x * y, even_numbers)
print(f"所有偶数的乘积：{product_of_evens}")
# 输出：所有偶数的乘积：48 (2 * 4 * 6)

这里就结合了

filter

和

reduce

，先筛选再聚合。

扁平化嵌套列表： 当有一个包含子列表的列表，需要将其扁平化成一个单一的列表时，
```
reduce
```
可以非常优雅地完成。
```
from functools import reduce

nested_list = [[1, 2], [3, 4], [5, 6]]
flattened_list = reduce(lambda acc, sublist: acc + sublist, nested_list, [])
print(f"扁平化后的列表：{flattened_list}")
# 输出：扁平化后的列表：[1, 2, 3, 4, 5, 6]
```
这里的
```
acc
```
（accumulator）是累积器，它会不断地将子列表添加到自身。初始值
```
[]
```
在这里非常关键，它定义了累积的起点。

字符串拼接： 虽然

"".join(list_of_strings)

是Python中拼接字符串的首选，但在某些需要更复杂逻辑拼接的场景下，

reduce

也能派上用场。

from functools import reduce

words = ["Hello", "world", "Python", "is", "great"]
# 拼接成一个句子，并在每个单词后加一个空格（除了最后一个）
sentence = reduce(lambda acc, word: acc + word + " ", words[:-1], "") + words[-1]
print(f"拼接后的句子：{sentence}")
# 输出：拼接后的句子：Hello world Python is great

当然，这个例子有点刻意，

join

通常更优，但它展示了

reduce

处理字符串的能力。

构建复杂数据结构：

reduce

可以用来将一个序列的数据“折叠”成一个更复杂的单一数据结构，比如字典。

from functools import reduce

data = [("a", 1), ("b", 2), ("c", 3)]
# 将列表中的元组转换为字典
result_dict = reduce(lambda acc, item: {**acc, item[0]: item[1]}, data, {})
print(f"reduce构建的字典：{result_dict}")
# 输出：reduce构建的字典：{'a': 1, 'b': 2, 'c': 3}

这里，