python 内置高級函數盤點

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, 6]

even_numbers = list(filter(lambda x: x % 2 == 0, numbers))

print(even_numbers) # 输出: [2, 4, 6]

区别总结

• 功能不同：map() 函数用于对可迭代对象的每个元素应用一个函数，并返回结果；而 filter() 函数用于过滤掉不符合条件的元素，返回符合条件的元素组成的新迭代器。
• 返回值：两者都返回迭代器对象（在 Python 3.x 中），但 map() 返回的是应用函数后的结果迭代器，filter() 返回的是过滤后的元素迭代器。
• 应用场景：map() 适用于需要对序列中每个元素进行转换的场景；filter() 适用于需要从序列中筛选出满足特定条件的元素的场景

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
注意： all([]) 为True  因为没有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
any([]) 为False  因为没有False元素

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.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.reversed(seq)

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

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

16. 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]

17.eval(expression, globals=None, locals=None)

eval()函数用于执行一个字符串表达式，并返回表达式的结果。可选参数globals和locals用于指定全局和局部命名空间，如果未提供，则使用当前命名空间。
ast.literal_eval是eval的一个安全替代方案。ast.literal_eval函数来自Python的ast模块，该模块用于处理Python的抽象语法树（AST）。ast.literal_eval只会对字符串中的字面量表达式进行求值
，并且这些表达式必须产生Python的基本数据类型（如数字、字符串、列表、元组、字典等）。这意味着它不会执行任意的Python代码，从而大大降低了安全风险。

# 执行字符串表达式
result = eval("3 + 5")
print(result)  # 输出 8

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

18.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()函数，以避免安全风险