目录

一、 map() —— 高效批量映射

二、 filter() —— 灵活筛选元素

三、 zip() —— 并行迭代多个序列

四、 enumerate() —— 同时获取索引与值

五、 sorted() —— 通用排序利器

六、all() —— 快速判断全真

八、 sum() —— 数值求和极简方式

九、 max() —— 最大值（支持 key）

十、 min() —— 最小值（对称于 max）

十一、总结

前言

写 Python 时，你是否曾这样写过：

python
# 手动累加
total = 0
for num in numbers:
    total += num

# 手动记录索引
for i in range(len(names)):
    print(i, names[i])

这种写法本身没错，但不够Pythonic。Python 提供了大量内置函数，它们经过高度优化，既能提升代码可读性，也能显著提高执行效率。本文将进行一些常见内置函数的介绍，覆盖了映射、筛选、合并、排序、判断、聚合等常见场景。

效率提升的来源：多数内置函数内部用 C 语言实现，避免了 Python 层的循环开销；同时返回迭代器（如 map、filter）或惰性对象（如 reversed），内存占用更低。

下面逐一详解：

一、 map() —— 高效批量映射

基本用法：map(function, iterable, ...)  

将 function 应用于 iterable 的每个元素，返回一个迭代器。

传统低效方式

python
nums = [1, 2, 3, 4, 5]
squared = []
for n in nums:
    squared.append(n ** 2)

使用 map() 提升效率

python
squared = list(map(lambda x: x ** 2, nums))
# 或配合已有函数
squared = list(map(int, nums))          # 类型转换
squared = list(map(str.upper, ['a','b'])) # 字符串大写

效率对比（timeit）

python
import timeit

nums = list(range(10000))

def use_loop():
    res = []
    for n in nums:
        res.append(n * 2)

def use_map():
    res = list(map(lambda x: x * 2, nums))

print(timeit.timeit(use_loop, number=1000))   # ~0.45s
print(timeit.timeit(use_map, number=1000))    # ~0.38s（更快）

注意：map 返回的是迭代器，惰性求值，用 list() 包裹才会立即计算。如果只是遍历，直接for item in map(...): 更省内存。

二、 filter() —— 灵活筛选元素

基本用法：filter(function, iterable) 

保留使 function 返回 True 的元素，返回迭代器。

传统方式

python
nums = [1, 2, 3, 4, 5, 6]
even = []
for n in nums:
    if n % 2 == 0:
        even.append(n)

使用 filter()

python
even = list(filter(lambda x: x % 2 == 0, nums))
# 也可用 None 过滤假值
truthy = list(filter(None, [0, 1, '', 'hello']))  # 得到 [1, 'hello']

效率与可读性
filter 配合列表推导式性能接近，但语义更清晰，能筛选出符合条件的元素。且 filter 配合 None 可一键去除所有“假值”（False, 0, None, ' ' 等），比手动判断简洁得多。

三、 zip() —— 并行迭代多个序列

基本用法：zip(*iterables) 

将多个可迭代对象按位置打包成元组，返回迭代器。

传统索引方式

python
names = ['Alice', 'Bob', 'Charlie']
scores = [95, 82, 77]
for i in range(len(names)):
    print(names[i], scores[i])

使用 zip() 更优雅

python
for name, score in zip(names, scores):
    print(name, score)

高阶用法

python
# 转置矩阵
matrix = [[1,2,3], [4,5,6]]
transposed = list(zip(*matrix))   # [(1,4), (2,5), (3,6)]

# 并行遍历三个列表
for a, b, c in zip(list1, list2, list3):

效率：zip 底层用 C 实现，且不会像索引访问那样重复计算 len()，对长序列提升明显。

四、 enumerate() —— 同时获取索引与值

基本用法：enumerate(iterable, start=0) 

返回 索引、值 的迭代器。

传统 range(len()) 方式

python
fruits = ['apple', 'banana', 'orange']
for i in range(len(fruits)):
    print(i, fruits[i])

使用 enumerate()

python
for i, fruit in enumerate(fruits):
    print(i, fruit)

指定起始索引

for i, fruit in enumerate(fruits, start=1):
    print(f"{i}: {fruit}")

效率对比
enumerate 比 range(len()) 更简洁，且避免了重复属性查找。在大量循环中，性能略有优势（约 5%~10%），更重要的是可读性大幅提升。

五、 sorted() —— 通用排序利器

基本用法：sorted(iterable, key=None, reverse=False) 

返回一个新排序列表，不改变原对象。

传统方式（冒泡/手动排序）不推荐

python
data = [3, 1, 4, 1, 5]
# 手动排序既慢又容易错，直接用 sorted

使用 sorted()

python
sorted([3,1,4,1,5])                # [1,1,3,4,5]
sorted(['a','B','c'], key=str.lower)  # ['a','B','c'] 忽略大小写
sorted(student_list, key=lambda s: s.age, reverse=True)

效率优势
sorted 底层使用 Timsort 算法（时间复杂度 O(n log n)），且完全用 C 实现，比任何手写的 Python 排序快数十倍。同时支持 key 函数，可以高效处理复杂对象排序。

六、all() —— 快速判断全真

基本用法：all(iterable) 

当所有元素为真时返回 True，否则 False。空可迭代对象返回 True。

传统 break 方式

python
def all_positive(nums):
    for n in nums:
        if n <= 0:
            return False
    return True

使用 all() 一行搞定

all_positive = all(n > 0 for n in nums)

实用案例

python
# 检查字符串是否全为字母
if all(c.isalpha() for c in my_str):
    print("纯字母字符串")

# 检查多个条件
conditions = [x > 0, y < 10, z == 5]
if all(conditions):
    print("所有条件满足")

效率：all 会在遇到第一个假值时立即短路返回，比手动循环更高效，且写法更紧凑。

七、any() —— 快速判断任一真

基本用法:  any(iterable)

只要有一个元素为真就返回 True，否则 False。空可迭代对象返回 False。

传统方式

python
def has_negative(nums):
    for n in nums:
        if n < 0:
            return True
    return False

使用 any()

has_negative = any(n < 0 for n in nums)

实用场景

python
# 检查列表中是否存在某个值
if any(x == target for x in huge_list):
    print("找到了")

# 检查多个标志位
flags = [False, False, True, False]
if any(flags):
    print("至少一个标志为真")

同样具备短路特性，一旦找到真值立即停止，适合快速判断。

八、 sum() —— 数值求和极简方式

基本用法:  sum(iterable, start=0)  返回数值总和。

传统累加循环

python
total = 0
for num in numbers:
    total += num

使用 sum()

python
total = sum(numbers)
# 计算平方和
sum_of_squares = sum(x**2 for x in numbers)
# 拼接数字列表（start 参数）
total = sum(numbers, 100)   # 总和再加 100

效率对比

python
import timeit

nums = list(range(1000000))

def loop_sum():
    s = 0
    for n in nums:
        s += n
    return s

def builtin_sum():
    return sum(nums)

print(timeit.timeit(loop_sum, number=100))    # ~4.2s
print(timeit.timeit(builtin_sum, number=100)) # ~0.9s（快 4~5 倍）

sum内部用 C 循环累加，比 Python 级循环快得多。但注意：sum不适用于字符串拼接（应使用''.join()）。

九、 max() —— 最大值（支持 key）

基本用法：max(iterable, *[, key, default]) 或 max(arg1, arg2, ...) 返回最大值。

传统比较

python
# 找出年龄最大的学生
oldest = students[0]
for s in students[1:]:
    if s.age > oldest.age:
        oldest = s

使用 max() + key

python
oldest = max(students, key=lambda s: s.age)
# 或配合 operator.attrgetter
from operator import attrgetter
oldest = max(students, key=attrgetter('age'))

更多例子

python
# 按绝对值取最大
max([-5, 2, -8, 3], key=abs)   # -8

# 最长字符串
words = ['a', 'ab', 'abc']
max(words, key=len)             # 'abc'

# 多个参数直接比较
max(3, 5, 1, 9)                 # 9

max 同样用 C 实现遍历，且 key 函数只计算一次，比手动循环并反复调用比较函数更高效。

十、 min() —— 最小值（对称于 max）

基本用法：min(iterable, *[, key, default]) 

 返回最小值，用法与 max 完全对称。

传统方式 vs 内置方式

python
# 找出价格最低的商品
cheapest = products[0]
for p in products[1:]:
    if p.price < cheapest.price:
        cheapest = p

# 使用 min
cheapest = min(products, key=lambda p: p.price)

实用场景

python
# 数值列表最小值
min([10, 2, 5, 7])          # 2

# 字典按值取最小
scores = {'A': 90, 'B': 75, 'C': 88}
min_student = min(scores, key=scores.get)  # 'B'

# 配合 default 避免空列表报错
min([], default=0)          # 0

十一、总结

函数	核心作用	效率提升点
map	批量映射	C 级循环 + 迭代器节省内存
filter	条件筛选	惰性求值 + C 实现过滤
zip	并行迭代	避免索引访问，一次性打包
enumerate	索引+值	比 range(len()) 更简洁轻量
sorted	通用排序	Timsort + C 实现，比手写快几十倍
all	全真判断	短路逻辑，C 循环
any	任一真判断	短路逻辑，C 循环
sum	数值求和	C 累加，比 Python 循环快数倍
max`/`min	最值提取	单次遍历 + key 函数高效计算