Python 是一种多功能编程语言，以其可读性和表现力而闻名。虽然它鼓励编写干净且可维护的代码，但在某些情况下，简洁的单行代码可以节省时间和精力。

列表推导式：

Python 的列表推导式提供了一种简洁而强大的方法来创建列表。它允许将循环和条件语句组合到一行代码中。让我们仔细看看列表推导式是如何工作的。

让我们观察这段将偶数分成新列表的代码：

random_numbers = [1, 3, 2, 8, 11, 20, 10]
even_numbers = []

for number in random_numbers:
  if number % 2 == 0:
    even_numbers.append(number)

print(even_numbers)
# Output: [2, 8, 20, 10]

现在用列表推导式

random_numbers = [1, 3, 2, 8, 11, 20, 10]
even_numbers = [number for number in random_numbers if number % 2 == 0]

print(even_numbers)
# Output: [2, 8, 20, 10]

现在代码看起来更短，仍然可以理解。列表推导式也适用于字典和集合：

random_numbers = [1, 3, 2, 8, 11, 20, 10]

even_numbers = set(number for number in random_numbers if number % 2 == 0)
print(even_numbers)
# Output: {2, 8, 20, 10}

square_numbers = {number: number ** 2 for number in random_numbers}
print(square_numbers)
# Output: {1: 1, 3: 9, 2: 4, 8: 64, 11: 121, 20: 400, 10: 100}

map（） & filter（） 函数：

在某些情况下，需要对列表中的所有元素运行函数。

例如，如果对列表中的数字进行四舍五入，可以通过使用 List Comprehension 来实现：

float_numbers = [1.3, 3.2, 10.4, 9.432, 342.2]
rounded_numbers = [round(number) for number in float_numbers]

print(rounded_numbers)
# Output: [1, 3, 10, 9, 342]

也可以使用 map（） 函数来进一步缩短我们的代码。

map（） 是一个内置函数，它将给定函数应用于可迭代对象的每个项目（例如列表、元组或字符串）并返回包含结果的迭代器。map（） 函数的一般语法如下：

map(function, iterable)

所以现在的代码可以看起来像这样：

float_numbers = [1.3, 3.2, 10.4, 9.432, 342.2]
rounded_numbers = list(map(round, float_numbers))

print(rounded_numbers)
# Output: [1, 3, 10, 9, 342]

记得上面滤掉偶数吗？可以使用 filter（） 来实现同样的事情！

filter（） 是一个内置函数，允许您根据给定条件选择性地过滤可迭代对象的元素。它返回一个迭代器，其中包含原始可迭代对象中满足指定条件的元素。

filter（） 函数的一般语法如下：

filter(function, iterable)

所以现在代码可以看起来像这样：

def is_even(number):
  return number % 2 == 0

random_numbers = [1, 3, 2, 8, 11, 20, 10]
even_numbers = list(filter(is_even, random_numbers))

print(even_numbers)
# Output: [2, 8, 20, 10]

map（） 和 filter（） 也可以组合在一起。有时这种组合可以简化代码，有时则不会。如果它使代码难以理解，请不要强迫它。

下面是一个使用 map（） 和 filter（） 对数字进行四舍五入并只选择偶数的示例：

def is_even(number):
  return number % 2 == 0

float_numbers = [1.3, 3.2, 10.4, 9.432, 342.2]

rounded_numbers = list(filter(is_even, map(round, float_numbers)))

print(rounded_numbers)
# Output: [10, 342]

如果我使用 List Comprehension，这是相同的实现：

float_numbers = [1.3, 3.2, 10.4, 9.432, 342.2]

rounded_numbers = [round(number) for number in float_numbers if round(number) % 2 == 0]

print(rounded_numbers)
# Output: [10, 342]

map（） 和 filter（） 使行更短，但列表理解可能使其更容易理解。

Lambda 函数

还记得创建这个函数来传递给 filter（） 方法吗？

def is_even(number):
  return number % 2 == 0

filter（） 的使用让我们写了更多的行，的目标是把所有东西都写在一行中。来解决这个问题的 lambda 表达式来了。

Lambda 函数是可以在一行中定义的匿名函数。当需要小型的一次性函数时，它们非常有用。

lambda 的语法为：

lambda arguments: output expression

下面是一个示例：

is_even = lambda number: number % 2 == 0

print(is_even(3))
# Output: False

print(is_even(6))
# Output: True

因此，如果我们将其应用于从列表中过滤偶数的原始示例，我们的代码将如下所示：

random_numbers = [1, 3, 2, 8, 11, 20, 10]
even_numbers = list(filter(lambda number: number % 2 == 0, random_numbers))

print(even_numbers)
# Output: [2, 8, 20, 10]

zip（） 函数

zip（） 函数允许你同时迭代多个可迭代对象。它将每个可迭代对象中的相应元素组合成 Tuples。

下面是一个示例，演示了如何使用 zip（） 将两个列表合并为一个 Tuples 列表：

names = ['Alice', 'Bob', 'Charlie']
ages = [25, 30, 35]

zipped = list(zip(names, ages))

print(zipped)
# Output: [('Alice', 25), ('Bob', 30), ('Charlie', 35)]

any（） 和 all（） 函数

any（） 和 all（） 函数可用于检查多个值的条件。any（） 如果可迭代对象中的任何元素的计算结果为 True，则返回 True。all（） 仅当所有元素的计算结果都为 True 时才返回 True

考虑这个示例，它检查列表中是否有任何数字可以被 5 整除：

random_numbers = [7, 13, 20, 42, 8]
is_divisible_by_5 = any(x % 5 == 0 for x in random_numbers)

print(is_divisible_by_5)
# Output: True

functools.reduce（）

functools 模块中的 reduce（） 函数将两个参数的函数累积应用于可迭代对象的元素。它返回单个值作为结果。

下面是一个计算数字列表乘积的示例，而不是这样做：

random_numbers = [2, 3, 4, 5]
product = 1

for num in random_numbers:
  product *= num

print(product)
# Output: 120

您可以这样做（注意我们在这里是如何使用 lambda的）：

from functools import reduce

random_numbers= [2, 3, 4, 5]
product = reduce(lambda x, y: x * y, random_numbers)

print(product)
# Output: 120

itertools 模块

itertools 是 Standard Library 中的一个模块，它提供了用于创建和操作迭代器的函数集合。迭代器是用于一次遍历一个元素集合的对象，而无需将整个集合存储在内存中。

itertools 模块提供了几个函数，这些函数基于常见的组合模式生成迭代器。这些函数旨在高效地动态生成元素，使其内存高效，适合处理大型或无限序列。

repeat（） 函数

repeat（） 函数生成一个迭代器，该迭代器重复返回同一元素指定次数，如果未提供 times，则无限期返回。

语法：

repeat(element, times=None)

下面是一个简单的示例：

import itertools

repeated = list(itertools.repeat('Hello', 3))

print(repeated)
# Output: ['Hello', 'Hello', 'Hello']

combinations（） 函数

combinations（） 函数生成一个迭代器，该迭代器从可迭代对象的元素中生成长度 r 的所有可能组合。

语法：

combinations(iterable, r)

例如：

import itertools

letters = ['A', 'B', 'C']
combinations = list(itertools.combinations(letters, 2))

print(combinations)
# Output: [('A', 'B'), ('A', 'C'), ('B', 'C')]

permutations（） 函数

排列是按特定顺序排列的元素。

permutations（） 函数生成一个迭代器，该迭代器从可迭代对象的元素中产生长度为 r 的所有可能排列。如果未提供 r，则生成整个可迭代对象的所有可能排列。

语法：

permutations(iterable, r=None)

下面是一个示例代码：

import itertools

letters = ['A', 'B', 'C']
permutations = list(itertools.permutations(letters))

print(permutations)
# Output: [('A', 'B', 'C'),
#          ('A', 'C', 'B'),
#          ('B', 'A', 'C'),
#          ('B', 'C', 'A'),
#          ('C', 'A', 'B'),
#          ('C', 'B', 'A')]

chain（） 函数

chain（） 函数将多个可迭代对象合并到一个迭代器中，并按照其传递顺序从每个可迭代对象中依次生成元素。

语法：

chain(*iterables)

下面是一个扁平化列表的常见示例：

import itertools

lists = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flatten = list(itertools.chain(*lists))

print(flatten)
# Output: [1, 2, 3, 4, 5, 6, 7, 8, 9]