Python内置的20个高阶函数的功能和示例详解

更多资料获取

📚 个人网站：ipengtao.com

Python是一门功能丰富的编程语言，提供了许多内置函数来处理各种数据操作。其中，高阶函数是一类特殊的函数，它们接受其他函数作为参数，或者返回函数作为结果。高阶函数是函数式编程的核心概念之一，可以大大提高代码的可读性和灵活性。本文将介绍Python内置的20个高阶函数，包括它们的功能和示例代码，帮助大家更好地理解和应用这些强大的函数。

1. `map(function, iterable, ...)`

map()函数接受一个函数和一个可迭代对象作为参数，将函数应用于可迭代对象的每个元素，并返回一个包含结果的迭代器。

# 将列表中的每个元素加1
numbers = [1, 2, 3, 4, 5]
result = map(lambda x: x + 1, numbers)
print(list(result))  # 输出 [2, 3, 4, 5, 6]

2. `filter(function, iterable)`

filter()函数接受一个函数和一个可迭代对象作为参数，将函数应用于可迭代对象的每个元素，并返回一个包含满足条件的元素的迭代器。

# 过滤出列表中的偶数
numbers = [1, 2, 3, 4, 5]
result = filter(lambda x: x % 2 == 0, numbers)
print(list(result))  # 输出 [2, 4]

3. `reduce(function, iterable[, initializer])`

reduce()函数接受一个函数和一个可迭代对象作为参数，递归地将函数应用于可迭代对象的元素，返回一个单一的结果值。

from functools import reduce# 计算列表中所有元素的乘积
numbers = [1, 2, 3, 4, 5]
result = reduce(lambda x, y: x * y, numbers)
print(result)  # 输出 120

4. `sorted(iterable, key=None, reverse=False)`

sorted()函数接受一个可迭代对象作为参数，返回一个新的排好序的列表。可选参数key用于指定排序关键字函数，reverse用于指定是否降序排序。

# 对列表进行排序
fruits = ["apple", "banana", "cherry", "date"]
result = sorted(fruits)
print(result)  # 输出 ['apple', 'banana', 'cherry', 'date']# 根据字符串长度进行排序
result = sorted(fruits, key=lambda x: len(x))
print(result)  # 输出 ['date', 'apple', 'banana', 'cherry']# 降序排序
result = sorted(fruits, reverse=True)
print(result)  # 输出 ['date', 'cherry', 'banana', 'apple']

5. `zip(*iterables)`

zip()函数接受多个可迭代对象作为参数，返回一个包含元组的迭代器，每个元组包含来自各个可迭代对象的元素。

# 合并两个列表
names = ["Alice", "Bob", "Charlie"]
scores = [85, 92, 78]
result = zip(names, scores)
print(list(result))  # 输出 [('Alice', 85), ('Bob', 92), ('Charlie', 78)]

6. `enumerate(iterable, start=0)`

enumerate()函数接受一个可迭代对象作为参数，返回一个包含元组的迭代器，每个元组包含元素的索引和值。

# 枚举列表中的元素
fruits = ["apple", "banana", "cherry"]
result = enumerate(fruits)
print(list(result))  # 输出 [(0, 'apple'), (1, 'banana'), (2, 'cherry')]

7. `all(iterable)`

all()函数接受一个可迭代对象作为参数，如果可迭代对象的所有元素都为真，则返回True，否则返回False。

# 检查列表中的元素是否都大于0
numbers = [1, 2, 3, 4, 5]
result = all(x > 0 for x in numbers)
print(result)  # 输出 True# 检查列表中的元素是否都为真
values = [True, True, False, True]
result = all(values)
print(result)  # 输出 False

8. `any(iterable)`

any()函数接受一个可迭代对象作为参数，如果可迭代对象的任何元素为真，则返回True，否则返回False。

# 检查列表中是否有元素大于10
numbers = [1, 2, 3, 4, 5]
result = any(x > 10 for x in numbers)
print(result)  # 输出 False# 检查列表中是否有元素为真
values = [True, False, False, False]
result = any(values)
print(result)  # 输出 True

9. `max(iterable, *args, key=None, default=None)`

max()函数接受一个可迭代对象作为参数，返回可迭代对象中的最大元素。可选参数key用于指定比较的关键字函数，default用于指定可迭代对象为空时的默认返回值。

# 获取列表中的最大值
numbers = [1, 3, 2, 4, 5]
result = max(numbers)
print(result)  # 输出 5# 根据字符串长度获取最长的字符串
fruits = ["apple", "banana", "cherry", "date"]
result = max(fruits, key=lambda x: len(x))
print(result)  # 输出 'banana'# 设置默认返回值
result = max([], default="No elements")
print(result)  # 输出 'No elements'

10. `min(iterable, *args, key=None, default=None)`

min()函数接受一个可迭代对象作为参数，返回可迭代对象中的最小元素。可选参数key用于指定比较的关键字函数，default用于指定可迭代对象为空时的默认返回值。

# 获取列表中的最小值
numbers = [1, 3, 2, 4, 5]
result = min(numbers)
print(result)  # 输出 1# 根据字符串长度获取最短的字符串
fruits = ["apple", "banana", "cherry", "date"]
result = min(fruits, key=lambda x: len(x))
print(result)  # 输出 'date'# 设置默认返回值
result = min([], default="No elements")
print(result)  # 输出 'No elements'

11. `sum(iterable, start=0)`

sum()函数接受一个可迭代对象作为参数，返回可迭代对象中所有元素的总和。可选参数start用于指定总和的初始值。

# 计算列表中所有元素的总和
numbers = [1, 2, 3, 4, 5]
result = sum(numbers)
print(result)  # 输出 15# 指定初始值并计算总和
result = sum(numbers, start=10)
print(result)  # 输出 25

12. `any(iterable)`

any()函数接受一个可迭代对象作为参数，如果可迭代对象的任何元素为真，则返回True，否则返回False。

# 检查列表中是否有元素大于10
numbers = [1, 2, 3, 4, 5]
result = any(x > 10 for x in numbers)
print(result)  # 输出 False# 检查列表中是否有元素为真
values = [True, False, False, False]
result = any(values)
print(result)  # 输出 True

13. `iter(obj, sentinel)`

iter()函数返回一个迭代器对象，该迭代器会不断调用可迭代对象的__next__()方法，直到达到指定的sentinel值为止。

# 使用 iter() 创建一个迭代器
iterator = iter(lambda: input("Enter 'stop' to quit: "), 'stop')
for item in iterator:print(item)

14. `next(iterator, default)`

next()函数接受一个迭代器对象和一个默认值作为参数，返回迭代器的下一个元素。如果迭代器耗尽，将返回默认值。

# 获取迭代器的下一个元素
numbers = [1, 2, 3]
iterator = iter(numbers)
result = next(iterator)
print(result)  # 输出 1# 迭代器耗尽时返回默认值
result = next(iterator, None)
print(result)  # 输出 None

15. `len(s)`

len()函数返回对象的长度，例如列表、字符串、元组等。

# 获取列表的长度
fruits = ["apple", "banana", "cherry"]
result = len(fruits)
print(result)  # 输出 3# 获取字符串的长度
text = "Hello, World!"
result = len(text)
print(result)  # 输出 13

16. `reversed(seq)`

reversed()函数接受一个序列作为参数，返回一个逆序的迭代器。

# 反转列表
fruits = ["apple", "banana", "cherry"]
result = list(reversed(fruits))
print(result)  # 输出 ['cherry', 'banana', 'apple']

17. `slice(start, stop, step)`

slice()函数返回一个切片对象，该对象可以用于切片操作。start表示起始位置，stop表示结束位置，step表示步长。

# 创建一个切片对象
my_slice = slice(1, 5, 2)# 使用切片对象进行切片操作
numbers = [0, 1, 2, 3, 4, 5, 6]
result = numbers[my_slice]
print(result)  # 输出 [1, 3]

18. `sorted(iterable, key=None, reverse=False)`

sorted()函数接受一个可迭代对象作为参数，返回一个新的排好序的列表。可选参数key用于指定排序关键字函数，reverse用于指定是否降序排序。

# 对列表进行排序
fruits = ["apple", "banana", "cherry", "date"]
result = sorted(fruits)
print(result)  # 输出 ['apple', 'banana', 'cherry', 'date']# 根据字符串长度进行排序
result = sorted(fruits, key=lambda x: len(x))
print(result)  # 输出 ['date', 'apple', 'banana', 'cherry']# 降序排序
result = sorted(fruits, reverse=True)
print(result)  # 输出 ['date', 'cherry', 'banana', 'apple']

19. `eval(expression, globals=None, locals=None)`

eval()函数用于执行一个字符串表达式，并返回表达式的结果。可选参数globals和locals用于指定全局和局部命名空间，如果未提供，则使用当前命名空间。

# 执行字符串表达式
result = eval("3 + 5")
print(result)  # 输出 8# 在自定义命名空间中执行表达式
x = 10
result = eval("x + 5", globals(), locals())
print(result)  # 输出 15

需要谨慎使用eval()函数，因为它可以执行任意的Python代码，可能存在安全风险。

20. `exec(object, globals=None, locals=None)`

exec()函数用于执行一个字符串或代码块，并返回None。它可以用于执行包含Python代码的字符串或文件内容。可选参数globals和locals用于指定全局和局部命名空间。

# 执行包含Python代码的字符串
code = """
x = 10
y = 20
result = x + y
print(result)
"""
exec(code)  # 输出 30# 在自定义命名空间中执行代码块
x = 5
exec("x = x * 2", globals(), locals())
print(x)  # 输出 10

与eval()函数类似，需要谨慎使用exec()函数，以避免安全风险。

总结

Python内置了许多强大的高阶函数，它们提供了丰富的功能来处理各种数据操作。本文介绍了20个常用的高阶函数，包括map、filter、reduce、sorted、zip、enumerate、all、any、max、min、sum、len、reversed、slice、sorted、eval、exec等。通过掌握这些高阶函数，可以更高效地处理数据、编写更简洁的代码，并更好地理解函数式编程的概念。