Python 的十个常用高阶函数

map

将给定函数应用于可迭代对象的每个元素，并返回一个新的迭代器，通常用于对序列进行批量操作。

In [1]:
nums = list(range(6))
nums
Out[1]:
[0, 1, 2, 3, 4, 5]
In [2]:
squares = map(lambda x: x * x, nums)
In [3]:
list(squares)
Out[3]:
[0, 1, 4, 9, 16, 25]

filter

用于筛选序列，返回一个迭代器。根据提供的函数对序列中的每个元素进行判断，仅保留使该函数返回值为 True 的元素。

In [4]:
even_nums = filter(lambda x: x % 2 == 0, nums)
In [5]:
list(even_nums)
Out[5]:
[0, 2, 4]

sorted

将列表中的元素按照一定的顺序排序，可以接受一个 key 函数来自定义排序行为。

In [6]:
students = ["Alice", "bob", "Charlie", "dave"]
In [7]:
sorted(students)
Out[7]:
['Alice', 'Charlie', 'bob', 'dave']
In [8]:
sorted(students, key=str.lower)
Out[8]:
['Alice', 'bob', 'Charlie', 'dave']

all

用于判断可迭代对象中的所有元素是否都满足某个条件。如果所有元素都满足条件，则返回 True，反之返回 False。当可迭代对象为空时，返回 True。

In [9]:
all([])
Out[9]:
True
In [10]:
is_even = map(lambda x: x % 2 == 0, nums)
In [11]:
all(is_even)
Out[11]:
False

any

用于判断可迭代对象中是否至少有一个元素满足某个条件。如果至少有一个元素满足条件，则返回 True，反之返回 False。当可迭代对象为空时，返回 False。

In [12]:
any([])
Out[12]:
False
In [13]:
any(is_even)
Out[13]:
True

enumerate

用于将可迭代对象转换为一个索引序列，返回一个包含索引和元素的元组的迭代器。

In [14]:
fruits = ["apple", "banana", "cherry"]
for index, fruit in enumerate(fruits):
    print(index, fruit)

0 apple
1 banana
2 cherry

zip

用于将多个可迭代对象打包成一个元组的迭代器。

In [15]:
names = ["Alice", "Bob", "Charlie"]
scores = [85, 90, 95]
list(zip(names, scores))
Out[15]:
[('Alice', 85), ('Bob', 90), ('Charlie', 95)]

functools.reduce

用于对序列进行累积操作，它将序列的前两个元素传给函数，然后返回一个值，再将这个值与序列的下一个元素一起传给函数，直到序列中的所有元素都被处理完毕。

In [16]:
import functools
In [17]:
functools.reduce(lambda x, y: x + y, nums)
Out[17]:
15

functools.partial

用于固定函数的某些参数，并返回一个新的函数，这在创建函数变体时非常有用。

In [18]:
def greet(name, place):
    return f"Hello, {name} from {place}!"
In [19]:
greet_world = functools.partial(greet, place="world")
In [20]:
greet_world("Henry")
Out[20]:
'Hello, Henry from world!'

functools.lru_cache

这是一个装饰器，用于缓存函数的返回值，优化性能，避免重复计算，对计算密集型函数非常有用。

In [21]:
def fib1(n):
    if n < 2:
        return n
    return fib1(n - 1) + fib1(n - 2)
In [22]:
@functools.lru_cache(maxsize=32)
def fib2(n):
    if n < 2:
        return n
    return fib2(n - 1) + fib2(n - 2)
In [23]:
print(fib1(10))
print(fib2(10))

55
55
In [24]:
%timeit fib1(10)
%timeit fib2(10)

19.4 µs ± 932 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)
72.7 ns ± 3.44 ns per loop (mean ± std. dev. of 7 runs, 10,000,000 loops each)

itertools 模块

提供了许多用于操作迭代器的高阶函数，如 chain(), combinations(), permutations(), cycle(), repeat(), groupby() 等。

In [25]:
import itertools
In [26]:
items = ["A", "B", "C"]
In [27]:
list(itertools.combinations(items, 2))
Out[27]:
[('A', 'B'), ('A', 'C'), ('B', 'C')]
In [28]:
list(itertools.permutations(items, 2))
Out[28]:
[('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'C'), ('C', 'A'), ('C', 'B')]
In [29]:
list(itertools.repeat(items, 2))
Out[29]:
[['A', 'B', 'C'], ['A', 'B', 'C']]

相关推荐