关于python:Python-的-sumPythonic-的求和方法

摘要：Python 的内置函数 sum()是一种对数值列表求和的无效且 Pythonic 的办法。将多个数字相加是许多计算中常见的两头步骤，因而 sum()对于 Python 程序员来说是一个十分不便的工具。

本文分享自华为云社区《Python 的 sum()：Pythonic 的求和办法》，作者：Yuchuan。

Python 的内置函数 sum()是一种对数值列表求和的无效且 Pythonic 的办法。将多个数字相加是许多计算中常见的两头步骤，因而 sum()对于 Python 程序员来说是一个十分不便的工具。

作为一个额定的和乏味的应用状况，您能够连贯列表和元组应用 sum()，当你须要拼合列表的列表，能够很不便。

在本教程中，您将学习如何：

• 应用通用技术和工具手工对数值求和
• 应用 Pythonsum() 高效地增加多个数值
• 拼接列表和元组与 sum()
• 应用 sum() 靠近一般求和问题
• 应用适当的值的参数中 sum()
• 之间做出抉择 sum() 和代替工具来总结和串连对象

这些常识将帮忙您应用 sum()或其余代替和专用工具无效地解决和解决代码中的求和问题。

了解求和问题

将数值相加是编程中一个相当广泛的问题。例如，假如您有一个数字列表 [1, 2, 3, 4, 5] 并且想要将它们加在一起以计算它们的总和。应用规范算术，您将执行以下操作：

1 + 2 + 3 + 4 + 5 = 15

就数学而言，这个表达式非常简单。它会疏导您实现一系列简短的加法，直到您找到所有数字的总和。

能够手动进行这个特定的计算，但设想一下其余一些不太可能的状况。如果您有一个特地长的数字列表，手动增加可能效率低下且容易出错。如果您甚至不晓得列表中有多少项会产生什么？最初，设想一个场景，您须要增加的我的项目数量动静或不可预测地发生变化。

在这种状况下，无论您的数字列表是长列表还是短列表，Python 在解决 求和问题方面 都十分有用。

如果您想通过从头开始创立本人的解决方案来对数字求和，那么您能够尝试应用 for 循环：

>>>
>>> numbers = [1, 2, 3, 4, 5]
>>> total = 0

>>> for number in numbers:
...     total += number
...

>>> total
15

在这里，您首先创立 total 并将其初始化为 0. 此变量用作累加器，您能够在其中存储两头后果，直到取得最终后果。循环通过应用增广赋值累加每个间断值来迭代 numbers 和更新。total

您还能够将 for 循环包装在函数中。这样，您能够为不同的列表重用代码：

>>>
>>> def sum_numbers(numbers):
...     total = 0
...     for number in numbers:
...         total += number
...     return total
...

>>> sum_numbers([1, 2, 3, 4, 5])
15

>>> sum_numbers([])
0

在 中 sum_numbers()，您将一个可迭代对象——特地是一个数值列表——作为参数，并返回输出列表中值的总和。如果输出列表为空，则函数返回 0。该 for 循环与您之前看到的雷同。

您还能够应用递归代替迭代。递归是一种函数式编程技术，其中函数在其本人的定义中被调用。换句话说，递归函数在循环中调用本身：

>>>
>>> def sum_numbers(numbers):
...     if len(numbers) == 0:
...         return 0
...     return numbers[0] + sum_numbers(numbers[1:])
...

>>> sum_numbers([1, 2, 3, 4, 5])
15

当你定义一个递归函数时，你冒着陷入有限循环的危险。为了避免这种状况，您须要定义进行递归的 根本状况 和调用函数并启动隐式循环的 递归状况。

在下面的例子中，根本状况意味着零长度列表的总和是 0。递归状况意味着总和是第一个值 numbers[0]，加上其余值的总和 numbers[1:]。因为递归状况在每次迭代中应用较短的序列，因而您心愿在 numbers 是零长度列表时遇到根本状况。作为最终后果，您将取得输出列表中所有我的项目的总和 numbers。

留神：在此示例中，如果您不查看空输出列表（您的根本状况），则 sum_numbers()永远不会遇到有限递归循环。当您的 numbers 列表长度达到 时 0，代码会尝试拜访空列表中的我的项目，这会引发 IndexError 并中断循环。

应用这种实现，你永远不会从这个函数中失去一个总和。你 IndexError 每次都会失去一个。

在 Python 中对数字列表求和的另一种抉择是应用 reduce()from functools。要获取数字列表的总和，您能够将任一 operator.add 或适当的 lambda 函数作为第一个参数传递给 reduce()：

>>>
>>> from functools import reduce
>>> from operator import add

>>> reduce(add, [1, 2, 3, 4, 5])
15

>>> reduce(add, [])
Traceback (most recent call last):
    ...
TypeError: reduce() of empty sequence with no initial value

>>> reduce(lambda x, y: x + y, [1, 2, 3, 4, 5])
15

您能够致电 reduce()与缩小或折叠，function 与一起 iterable 作为参数。而后 reduce()应用输出函数解决 iterable 并返回单个累积值。

在第一个示例中，归约函数是 add()，它将两个数字相加。最终后果是 input 中数字的总和 iterable。作为一个毛病，reduce()提出了一个 TypeError 当你与一个空的调用它 iterable。

在第二个示例中，约简函数是一个 lambda 返回两个数字相加的函数。

因为像这样的求和在编程中很常见，因而每次须要对一些数字求和时编写一个新函数是大量重复性工作。此外，usingreduce()不是您可用的最易读的解决方案。

Python 提供了专门的内置函数来解决这个问题。该函数被不便地调用 sum()。因为它是一个内置函数，因而您能够间接在代码中应用它，而无需导入任何内容。

Python 入门 sum()

可读性是 Python 哲学背地最重要的准则之一。在对值列表求和时，可视化您要求循环执行的操作。您心愿它遍历一些数字，将它们累加到一个两头变量中，而后返回最终和。然而，您可能能够设想一个不须要循环的更易读的求和版本。您心愿 Python 取一些数字并将它们相加。

当初想想如何 reduce()求和。应用 reduce()能够说比基于循环的解决方案更不可读，更不间接。

这就是为什么将 Python 2.3 增加 sum()为内置函数来为求和问题提供 Pythonic 解决方案的起因。Alex Martelli 奉献了这个函数，它当初是对值列表求和的首选语法：

>>>
>>> sum([1, 2, 3, 4, 5])
15

>>> sum([])
0

哇！这很整洁，不是吗？它读起来像简略的英语，并分明地传播您在输出列表上执行的操作。应用 sum()比 for 循环或 reduce()调用更具可读性。与 reduce(), 当您提供空的可迭代对象时 sum()不会引发 a TypeError。相同，它能够了解地返回 0.

您能够 sum()应用以下两个参数进行调用：

1. iterable是一个必须的参数，能够保留任何 Python 可迭代对象。可迭代对象通常蕴含数值，但也能够蕴含列表或元组。
2. start是一个可选参数，能够保留一个初始值。而后将该值增加到最终后果中。它默认为 0.

在外部，从左到右 sum()增加 startplus 中的值 iterable。输出 iterable 中的值通常是数字，但您也能够应用列表和元组。可选参数 start 能够承受数字、列表或元组，具体取决于传递给 的内容 iterable。它不能带一个 string。

在以下两节中，您将理解 sum()在代码中应用的基础知识。

必须的参数：iterable

承受任何 Python iterable 作为它的第一个参数使得 sum()泛型、可重用和多态。因为此性能，您能够应用 sum()列表、元组、汇合、range 对象和字典：

>>>
>>> # Use a list
>>> sum([1, 2, 3, 4, 5])
15

>>> # Use a tuple
>>> sum((1, 2, 3, 4, 5))
15

>>> # Use a set
>>> sum({1, 2, 3, 4, 5})
15

>>> # Use a range
>>> sum(range(1, 6))
15

>>> # Use a dictionary
>>> sum({1: "one", 2: "two", 3: "three"})
6
>>> sum({1: "one", 2: "two", 3: "three"}.keys())
6

在所有这些示例中，sum()计算输出迭代中所有值的算术和，而不论它们的类型。在两个字典示例中，都调用 sum()返回输出字典键的总和。第一个示例默认对键求和，第二个示例因为.keys()调用输出字典而对键求和。

如果您的字典在其值中存储数字，并且您想对这些值而不是键进行求和，那么您能够.values()像.keys()示例中那样应用。

您还能够 sum()将列表推导式用作参数。这是一个计算一系列值的平方和的示例：

>>>
>>> sum([x ** 2 for x in range(1, 6)])
55

Python 2.4 向该语言增加了生成器表达式。同样，sum()当您应用生成器表达式作为参数时，按预期工作：

>>>
>>> sum(x ** 2 for x in range(1, 6))
55

这个例子展现了解决求和问题的最 Pythonic 技术之一。它在一行代码中提供了一个优雅、可读且高效的解决方案。

可选参数：start

第二个可选参数 start 容许您提供一个值来初始化求和过程。当您须要按程序解决累积值时，此参数很不便：

>>>
>>> sum([1, 2, 3, 4, 5], 100)  # Positional argument
115

>>> sum([1, 2, 3, 4, 5], start=100)  # Keyword argument
115

在这里，您提供初始值 100to start。净成果是 sum()将此值增加到输出可迭代中的值的累积总和中。请留神，您能够 start 作为地位参数或关键字参数提供。后一个选项更加明确和可读。

如果您没有为 提供值 start，则默认为 0。默认值 0 确保返回输出值总和的预期行为。

对数值求和

的次要目标 sum()是提供一种 Pythonic 形式来将数值相加。到目前为止，您曾经理解了如何应用该函数对整数求和。此外，能够应用 sum()任何其余数字 Python 类型，比方 float，complex，decimal.Decimal，和 fractions.Fraction。

以下是应用 sum()不同数字类型的值的几个示例：

>>>
>>> from decimal import Decimal
>>> from fractions import Fraction

>>> # Sum floating-point numbers
>>> sum([10.2, 12.5, 11.8])
34.5
>>> sum([10.2, 12.5, 11.8, float("inf")])
inf
>>> sum([10.2, 12.5, 11.8, float("nan")])
nan

>>> # Sum complex numbers
>>> sum([3 + 2j, 5 + 6j])
(8+8j)

>>> # Sum Decimal numbers
>>> sum([Decimal("10.2"), Decimal("12.5"), Decimal("11.8")])
Decimal('34.5')

>>> # Sum Fraction numbers
>>> sum([Fraction(51, 5), Fraction(25, 2), Fraction(59, 5)])
Fraction(69, 2)

在这里，您第一次应用 sum()与浮点数字。值得注意的是，当您应用特殊符号 inf 并 nan 在调用 float(“inf”)和 中时函数的行为 float(“nan”)。第一个符号代表一个有限值，因而 sum()返回 inf。第二个符号代表 NaN（不是数字）值。因为您无奈将数字与非数字相加，因而您会失去 nan 后果。

其余的例子总和 iterables 的 complex，Decimal 和 Fraction 数字。在所有状况下，sum()应用适当的数字类型返回后果累积总和。

连贯序列

只管 sum()次要用于对数值进行操作，但您也能够应用该函数来连贯列表和元组等序列。为此，您须要为 提供适当的值 start：

>>>
>>> num_lists = [[1, 2, 3], [4, 5, 6]]
>>> sum(num_lists, start=[])
[1, 2, 3, 4, 5, 6]

>>> # Equivalent concatenation
>>> [1, 2, 3] + [4, 5, 6]
[1, 2, 3, 4, 5, 6]

>>> num_tuples = ((1, 2, 3), (4, 5, 6))
>>> sum(num_tuples, start=())
(1, 2, 3, 4, 5, 6)

>>> # Equivalent concatenation
>>> (1, 2, 3) + (4, 5, 6)
(1, 2, 3, 4, 5, 6)

在这些示例中，您应用 sum()连贯列表和元组。这是一个乏味的性能，您能够应用它来展平列表列表或元组元组。这些示例工作的要害要求是为 抉择适当的值 start。例如，如果要连贯列表，则 start 须要持有一个列表。

在下面的示例中，sum()在外部执行连贯操作，因而它仅实用于反对连贯的序列类型，字符串除外：

>>>
>>> num_strs = ["123", "456"]
>>> sum(num_strs, "0")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: sum() can't sum strings [use''.join(seq) instead]

当您尝试应用 sum()来连贯字符串时，您会失去一个 TypeError. 正如异样音讯所暗示的那样，您应该应用 str.join()来连贯 Python 中的字符串。稍后，当您进入应用代替 sum()办法局部时，您将看到应用此办法的示例。

应用 Python 进行练习 sum()

到目前为止，您曾经学习了应用 sum(). 您曾经学习了如何应用此函数将数值相加，以及如何连贯列表和元组等序列。

在本节中，您将查看更多无关何时以及如何 sum()在代码中应用的示例。通过这些理论示例，您将理解到当您执行须要查找一系列数字之和作为两头步骤的计算时，此内置函数十分不便。

您还将理解到这 sum()在您应用列表和元组时会很有帮忙。您将看到的一个非凡示例是当您须要展平列表列表时。

计算累积和

您将编写的第一个示例与如何利用 start 参数对数值的累积列表求和无关。

假如您正在开发一个零碎来治理给定产品在多个不同销售点的销售。每天，您都会收到来自每个销售点的销售单位报告。您须要系统地计算累计总和，以理解整个公司在一周内销售了多少件商品。要解决此问题，您能够应用 sum()：

>>>
>>> cumulative_sales = 0

>>> monday = [50, 27, 42]
>>> cumulative_sales = sum(monday, start=cumulative_sales)
>>> cumulative_sales
119

>>> tuesday = [12, 32, 15]
>>> cumulative_sales = sum(tuesday, start=cumulative_sales)
>>> cumulative_sales
178

>>> wednesday = [20, 24, 42]
>>> cumulative_sales = sum(wednesday, start=cumulative_sales)
>>> cumulative_sales
264
    ...

通过应用 start，您能够设置一个初始值来初始化总和，这容许您将间断单位增加到先前计算的小计中。在本周末，您将取得公司的销售单位总数。

计算样本的平均值

的另一个理论用例 sum()是在进行进一步计算之前将其用作两头计算。例如，假如您须要计算数值样本的算术平均值。算术平均值，也称为平均值，是样本中值的总和除以值或数据点的数量。

如果你有样本 [2, 3, 4, 2, 3, 6, 4, 2] 并且你想手工计算算术平均值，那么你能够解决这个操作：

(2 + 3 + 4 + 2 + 3 + 6 + 4 + 2) / 8 = 3.25

如果您想通过应用 Python 加快速度，您能够将其分为两局部。此计算的第一局部，即您将数字相加，是 的工作 sum()。运算的下一部分，即除以 8，应用样本中的数字计数。要计算您的除数，您能够应用 len()：

>>>
>>> data_points = [2, 3, 4, 2, 3, 6, 4, 2]

>>> sum(data_points) / len(data_points)
3.25

在这里，调用 sum()计算样本中数据点的总和。接下来，您应用 len()来获取数据点的数量。最初，您执行所需的除法以计算样本的算术平均值。

在实践中，您可能心愿将此代码转换为具备一些附加性能的函数，例如描述性名称和查看空样本：

>>>
>>> # Python >= 3.8

>>> def average(data_points):
...     if (num_points := len(data_points)) == 0:
...         raise ValueError("average requires at least one data point")
...     return sum(data_points) / num_points
...

>>> average([2, 3, 4, 2, 3, 6, 4, 2])
3.25

>>> average([])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in average
ValueError: average requires at least one data point

在外部 average()，您首先查看输出样本是否有任何数据点。如果没有，那么你 ValueError 用一个描述性的音讯来引发。在此示例中，您应用 walrus 运算符将数据点的数量存储在变量中，num_points 以便您无需 len()再次调用。该 return 语句计算样本的算术平均值，并将其发送回调用代码。

留神：计算数据样本的平均值是统计和数据分析中的常见操作。Python 规范库提供了一个不便的模块，称为 statistics 解决这些类型的计算。

在 statistics 模块中，您将找到一个名为 的函数 mean()：

>>>
>>> from statistics import mean

>>> mean([2, 3, 4, 2, 3, 6, 4, 2])
3.25

>>> mean([])
Traceback (most recent call last):
    ...
statistics.StatisticsError: mean requires at least one data point

该 statistics.mean()函数的行为与 average()您之前编码的函数十分类似。当您 mean()应用数值样本进行调用时，您将取得输出数据的算术平均值。当您将空列表传递给 时 mean()，您将取得一个 statistics.StatisticsError.

请留神，当您 average()应用适当的样本调用时，您将取得所需的平均值。如果您 average()应用空样本调用，那么您会失去 ValueError 预期的后果。

求两个序列的点积

您能够应用的另一个问题 sum()是找到两个等长数值序列的点积。点积的代数和的产品在输出序列的每对值中的。例如，如果您有序列 (1, 2, 3) 和 (4, 5, 6)，那么您能够应用加法和乘法手动计算它们的点积：

1 × 4 + 2 × 5 + 3 × 6 = 32

要从输出序列中提取间断的值对，您能够应用 zip(). 而后您能够应用生成器表达式将每对值相乘。最初，sum()能够总结产品：

>>>
>>> x_vector = (1, 2, 3)
>>> y_vector = (4, 5, 6)

>>> sum(x * y for x, y in zip(x_vector, y_vector))
32

应用 zip()，您能够应用来自每个输出序列的值生成一个元组列表。生成器表达式循环遍历每个元组，同时将先前排列的间断值对乘以 zip()。最初一步是应用 将产品增加在一起 sum()。

下面示例中的代码无效。然而，点积是为等长的序列定义的，所以如果你提供不同长度的序列会产生什么？在这种状况下，zip()疏忽最长序列中的额定值，这会导致不正确的后果。

为了解决这种可能性，您能够将调用包装 sum()在自定义函数中，并为输出序列的长度提供适当的查看：

>>>
>>> def dot_product(x_vector, y_vector):
...     if len(x_vector) != len(y_vector):
...         raise ValueError("Vectors must have equal sizes")
...     return sum(x * y for x, y in zip(x_vector, y_vector))
...

>>> dot_product((1, 2, 3), (4, 5, 6))
32

>>> dot_product((1, 2, 3, 4), (5, 6, 3))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in dot_product
ValueError: Vectors must have equal sizes

这里，dot_product()将两个序列作为参数并返回它们对应的点积。如果输出序列的长度不同，则该函数会引发 a ValueError。

在自定义函数中嵌入性能容许您重用代码。它还使您有机会对函数进行描述性命名，以便用户仅通过浏览函数名称就晓得该函数的作用。

展平列表列表

展平列表列表是 Python 中的一项常见工作。假如您有一个列表列表，须要将其展平为一个蕴含原始嵌套列表中所有我的项目的列表。您能够应用多种办法中的任何一种在 Python 中展平列表。例如，您能够应用 for 循环，如以下代码所示：

>>>
>>> def flatten_list(a_list):
...     flat = []
...     for sublist in a_list:
...         flat += sublist
...     return flat
...

>>> matrix = [...     [1, 2, 3],
...     [4, 5, 6],
...     [7, 8, 9],
... ]

>>> flatten_list(matrix)
[1, 2, 3, 4, 5, 6, 7, 8, 9]

在 中 flatten_list()，循环遍历 中蕴含的所有嵌套列表 a_list。而后它 flat 应用加强赋值操作 ( +=)将它们连接起来。后果，您会失去一个立体列表，其中蕴含原始嵌套列表中的所有我的项目。

然而保持住！您曾经 sum()在本教程中学习了如何应用来连贯序列。您能够应用该性能来像下面的示例中那样展平列表列表吗？是的！就是这样：

>>>
>>> matrix = [...     [1, 2, 3],
...     [4, 5, 6],
...     [7, 8, 9],
... ]

>>> sum(matrix, [])
[1, 2, 3, 4, 5, 6, 7, 8, 9]

那很快！一行代码，matrix 当初是一个立体列表。然而，应用 sum()仿佛不是最快的解决方案。

任何暗示串联的解决方案的一个重要毛病是，在幕后，每个两头步骤都会创立一个新列表。这在内存应用方面可能十分节约。最终返回的列表只是在每一轮连贯中创立的所有列表中最近创立的列表。应用列表推导式可确保您只创立和返回一个列表：

>>>
>>> def flatten_list(a_list):
...     return [item for sublist in a_list for item in sublist]
...

>>> matrix = [...     [1, 2, 3],
...     [4, 5, 6],
...     [7, 8, 9],
... ]

>>> flatten_list(matrix)
[1, 2, 3, 4, 5, 6, 7, 8, 9]

这个新版本 flatten_list()在内存应用方面效率更高，节约更少。然而，嵌套的了解可能难以浏览和了解。

应用.append()可能是扁平化列表列表最易读和 Pythonic 的形式：

>>>
>>> def flatten_list(a_list):
...     flat = []
...     for sublist in a_list:
...         for item in sublist:
...             flat.append(item)
...     return flat
...

>>> matrix = [...     [1, 2, 3],
...     [4, 5, 6],
...     [7, 8, 9],
... ]

>>> flatten_list(matrix)
[1, 2, 3, 4, 5, 6, 7, 8, 9]

在这个版本中 flatten_list()，一个人浏览你的代码能够看出，性能遍历每个 sublist 在 a_list。在第一个 for 循环中，它遍历每个 iteminsublist 以最终 flat 应用.append(). 就像后面的推导一样，这个解决方案在这个过程中只创立了一个列表。这种解决方案的一个长处是它的可读性很强。

应用替代品 sum()

正如您曾经理解到的，sum()一般来说，对于解决数值很有帮忙。然而，在解决浮点数时，Python 提供了一种代替工具。在 中 math，您会找到一个名为的函数 fsum()，它能够帮忙您进步浮点计算的总体精度。

您可能有一项工作，您心愿连贯或链接多个可迭代对象，以便您能够将它们作为一个整体解决。对于这种状况，您能够查看 itertools 模块的 function chain()。

您可能还有一个要连贯字符串列表的工作。您在本教程中理解到，无奈 sum()用于连贯字符串。这个函数不是为字符串连贯而构建的。最 Pythonic 的代替办法是应用 str.join().

对浮点数求和：math.fsum()

如果您的代码一直应用 对浮点数求和 sum()，那么您应该思考 math.fsum()改用。此函数比 更认真地执行浮点计算 sum()，从而进步计算精度。

依据其文档，fsum()“通过跟踪多个两头局部和来防止精度损失。”该文档提供了以下示例：

>>>
>>> from math import fsum

>>> sum([.1, .1, .1, .1, .1, .1, .1, .1, .1, .1])
0.9999999999999999

>>> fsum([.1, .1, .1, .1, .1, .1, .1, .1, .1, .1])
1.0

应用 fsum()，您能够取得更准确的后果。然而，您应该留神这 fsum()并不能解决浮点运算中的示意谬误。以下示例揭示了此限度：

>>>
>>> from math import fsum

>>> sum([0.1, 0.2])
0.30000000000000004

>>> fsum([0.1, 0.2])
0.30000000000000004

在这些示例中，两个函数返回雷同的后果。这是因为不可能精确地示意这两个值 0.1 和 0.2 二进制浮点数：

>>>
>>> f"{0.1:.28f}"
'0.1000000000000000055511151231'

>>> f"{0.2:.28f}"
'0.2000000000000000111022302463'

sum()然而，与 不同的是，fsum()当您将十分大和十分小的数字相加时，能够帮忙您缩小浮点谬误流传：

>>>
>>> from math import fsum

>>> sum([1e-16, 1, 1e16])
1e+16
>>> fsum([1e-16, 1, 1e16])
1.0000000000000002e+16

>>> sum([1, 1, 1e100, -1e100] * 10_000)
0.0
>>> fsum([1, 1, 1e100, -1e100] * 10_000)
20000.0

哇！第二个例子十分令人诧异并且齐全失败 sum()。应用 sum()，您将失去 0.0 后果。这与 的正确后果相去甚远 20000.0，正如您所失去的 fsum()。

连贯可迭代对象 itertools.chain()

如果您正在寻找一个不便的工具来连贯或链接一系列可迭代对象，请思考应用 chain()from itertools。此函数能够采纳多个迭代器并构建一个迭代器，该迭代器从第一个、第二个中产生我的项目，依此类推，直到耗尽所有输出迭代：

>>>
>>> from itertools import chain

>>> numbers = chain([1, 2, 3], [4, 5, 6], [7, 8, 9])
>>> numbers
<itertools.chain object at 0x7f0d0f160a30>
>>> next(numbers)
1
>>> next(numbers)
2

>>> list(chain([1, 2, 3], [4, 5, 6], [7, 8, 9]))
[1, 2, 3, 4, 5, 6, 7, 8, 9]

当您调用 时 chain()，您会从输出可迭代对象中取得我的项目的迭代器。在本例中，您能够 numbers 应用拜访间断的我的项目 next()。如果你想应用一个列表，那么你能够应用它 list()来应用迭代器并返回一个惯例的 Python 列表。

chain() 在 Python 中展平列表列表也是一个不错的抉择：

>>>
>>> from itertools import chain

>>> matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

>>> list(chain(*matrix))
[1, 2, 3, 4, 5, 6, 7, 8, 9]

要应用 扁平化列表列表 chain()，您须要应用可迭代解包运算符 ( *)。此运算符解包所有输出可迭代对象，以便 chain() 能够应用它们并生成相应的迭代器。最初一步是调用 list()以构建所需的立体列表。

连贯字符串 str.join()

正如您曾经看到的，sum()不连贯或连贯字符串。如果您须要这样做，那么 Python 中可用的首选和最快的工具是 str.join(). 此办法将一系列字符串作为参数并返回一个新的连贯字符串：

>>>
>>> greeting = ["Hello,", "welcome to", "Real Python!"]

>>> "".join(greeting)'Hello, welcome to Real Python!'

应用.join()是连贯字符串的最无效和 Pythonic 的形式。在这里，您应用字符串列表作为参数并从输出构建单个字符串。请留神，.join()在连贯期间应用您调用办法的字符串作为分隔符。在此示例中，您调用.join()由单个空格字符 ( ” “)组成的字符串，因而原始字符串 fromgreeting 在最终字符串中由空格分隔。

论断

您当初能够应用 Python 的内置函数 sum()将多个数值相加。此函数提供了一种高效、可读且 Pythonic 的办法来解决代码中的求和问题。如果您正在解决须要对数值求和的数学计算，那么它 sum()能够成为您的救星。

在本教程中，您学习了如何：

• 应用通用技术和工具对数值求和
• 应用 Python 无效地增加多个数值 sum()
• 应用连贯序列 sum()
• 应用 sum() 靠近一般求和问题
• 应用适当的值的 iterable 和 start 争执中 sum()
• 之间做出抉择 sum() 和代替工具来总结和串连对象

有了这些常识，您当初能够以 Pythonic、可读且高效的形式将多个数值相加。

点击关注，第一工夫理解华为云陈腐技术~