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}')

参考

• https://medium.com/@etirismagazine/advanced-python-functions-841d4ce0a91a