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]:

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']]