Python高级函数1：使用 map、reduce、filter、zip和 enumerate 简化代码
Python 是一种通用且广泛使用的编程语言，提供一系列内置函数和库来帮助完成各种任务。
这篇博客将介绍一些Python中可以简化代码并提高效率的高级函数。包括map()、reduce()、filter()、zip()和 enumerate()函数，这些函数可以帮助编写更高效、更简洁的代码。
1. 原理
1.1 map() 函数
将指定的函数应用于可迭代对象（例如列表、元组或字符串）的每个元素，并返回具有修改后元素的新可迭代对象。也可应用于多个可迭代对象，将每一个迭代对象对应的元素进行相应的操作；
1.2 reduce() 函数
Python中 functools 模块的一部分，允许将函数应用于一系列元素，以便将它们减少到单个值。 例如可以使用 reduce（） 将列表的所有元素相乘；
reduce()函数 还可以指定一个初始值作为其第三个参数。在这种情况下，初始值将用作函数的第一个参数，迭代对象的第一个元素将用作第二个参数。 例如，您可以使用 reduce()来计算数字列表的总和
1.3 filter() 函数
通过删除不满足指定条件的元素来过滤可迭代对象。它返回一个新的可迭代对象，其中仅包含满足条件的元素。 例如使用 filter()从列表中删除所有偶数；
filter() 也可以传递lambda 函数作为第一个参数
1.4 zip() 函数
将多个可迭代对象组合成一个元组的可迭代对象。zip()函数在最短的可迭代对象用尽时停止。 例如使用 zip() 将两个列表合并为元组列表；
也可以使用zip() 连接多个可迭代对象；
可以通过在函数调用或列表推导中使用 * 运算符来解压缩 zip()对象中的元组，如在函数调用中解包tuple/list表达式中解包tuple
1.5 enumerate() 函数
它向可迭代对象添加一个计数器并返回一个可迭代的元组，这些函数可以编写更干净、更简洁的代码；
也可以传递第2个参数指定计数器的起始值
2. 源码
# python高级函数1：map()、reduce()、filter()、zip()和 enumerate()
# python python_high1.py
# map() 函数，将指定的函数应用于可迭代对象（例如列表、元组或字符串）的每个元素，并返回具有修改后元素的新可迭代对象。
def get_lengths(words):
return map(len, words)
words = ['cat', 'window', 'defenestrate']
lengths = get_lengths(words)
print(list(lengths)) # [3, 6, 12]
from functools import reduce
def multiply(x, y):
return x * y
a = [1, 2, 3]
b = [10, 20, 30]
# map()函数也可应用于多个可迭代对象，将每一个迭代对象对应的元素进行相应的操作
result = map(multiply, a, b)
print(list(result)) # [10, 40, 90]
def multiply(x, y):
return x * y
a = [1, 2, 3, 4]
# reduce()函数是 Python中functools模块的一部分，允许将函数应用于一系列元素，以便将它们减少到单个值。例如可以使用reduce()将列表的所有元素相乘
result = reduce(multiply, a)
print(result) # 24
from functools import reduce
def add(x, y):
return x + y
a = [1, 2, 3, 4]
# reduce()函数 还可以指定一个初始值作为其第三个参数。在这种情况下，初始值将用作函数的第一个参数，迭代对象的第一个元素将用作第二个参数。 例如，您可以使用 reduce()来计算数字列表的总和
result = reduce(add, a, 0)
print(result) # 10
def is_odd(x):
return x % 2 == 1
a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# filter()函数通过删除不满足指定条件的元素来过滤可迭代对象。它返回一个新的可迭代对象，其中仅包含满足条件的元素。 例如使用 filter()从列表中删除所有偶数
odd_numbers = filter(is_odd, a)
print(list(odd_numbers)) # [1, 3, 5, 7, 9]
a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# filter()以 lambda 函数作为第一个参数
odd_numbers = filter(lambda x: x % 2 == 1, a)
print(list(odd_numbers)) # [1, 3, 5, 7, 9]
# zip()函数将多个可迭代对象组合成一个元组的可迭代对象。zip()函数在最短的可迭代对象用尽时停止。 例如可以使用 zip()将两个列表合并为元组列表：
a = [1, 2, 3]
b = ['a', 'b', 'c']
zipped = zip(a, b)
print(list(zipped)) # [(1, 'a'), (2, 'b'), (3, 'c')]
a = [1, 2, 3]
b = ['a', 'b', 'c']
c = [True, False, True]
# 使用zip()连接多个可迭代对象
zipped = zip(a, b, c)
print(list(zipped)) # [(1, 'a', True), (2, 'b', False), (3, 'c', True)]
# 可以通过在函数调用或列表推导中使用 * 运算符来解压缩 zip()对象中的元组
def print_tuples(a, b, c):
print(f'a: {
a}, b: {
b}, c: {
c}')
a = [1, 2, 3]
b = ['a', 'b', 'c']
c = [True, False, True]
zipped = zip(a, b, c)
# 在函数调用中解包tuple
for t in zipped:
print_tuples(*t)
print('------------------------------------------')
zipped = zip(a, b, c)
# list表达式中解包tuple
unzipped = [print_tuples(*t) for t in zipped]
print(unzipped)
# enumerate()函数向可迭代对象添加一个计数器，并返回一个元组的可迭代对象，其中每个元组由计数器和原始元素组成。 例如可以使用 enumerate()循环访问列表并打印每个元素的索引和值
a = ['a', 'b', 'c']
for i, element in enumerate(a):
print(f'{
i}: {
element}')
a = ['a', 'b', 'c']
# 也可以传递第2个参数指定计数器的起始值
for i, element in enumerate(a, 1):
print(f'{
i}: {
element}')