phpdecimal乞降技巧_Python 的 sumPythonic 的乞降方法

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

Python 的内置函数sum()是一种对数值列表求和的有效且Pythonic 的方法。
将多个数字相加是许多打算中常见的中间步骤，因此sum()对付 Python 程序员来说是一个非常方便的工具。

作为一个额外的和有趣的利用情形，您可以连接列表和元组利用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...>>> total15

在这里，您首先创建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哲学背后最主要的原则之一。
在对值列表求和时，可视化您哀求循环实行的操作。
您希望它遍历一些数字，将它们累加到一个中间变量中，然后返回终极和。
但是，您可能可以想象一个不须要循环的更易读的求和版本。
您希望 Python 取一些数字并将它们相加。

现在想想如何reduce()求和。
利用reduce()可以说比基于循环的办理方案更不可读，更不直接。

这便是为什么将Python2.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 argument115>>> sum([1, 2, 3, 4, 5], start=100) # Keyword argument115

在这里，您供应初始值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()方法部分时，您将看到利用此方法的示例。

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

在本节中，您将查看更多有关何时以及如何sum()在代码中利用的示例。
通过这些实际示例，您将理解到当您实行须要查找一系列数字之和作为中间步骤的打算时，此内置函数非常方便。

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

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

假设您正在开拓一个别系来管理给定产品在多个不同发卖点的发卖。
每天，您都会收到来自每个发卖点的发卖单位报告。
您须要系统地皮算累计总和，以理解全体公司在一周内发卖了多少件商品。
要办理此问题，您可以利用sum()：

>>>

>>> cumulative_sales = 0>>> monday = [50, 27, 42]>>> cumulative_sales = sum(monday, start=cumulative_sales)>>> cumulative_sales119>>> tuesday = [12, 32, 15]>>> cumulative_sales = sum(tuesday, start=cumulative_sales)>>> cumulative_sales178>>> wednesday = [20, 24, 42]>>> cumulative_sales = sum(wednesday, start=cumulative_sales)>>> cumulative_sales264 ...

通过利用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 averageValueError: 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_productValueError: 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()一样平常来说，对付处理数值很有帮助。
但是，在处理浮点数时，Python供应了一种替代工具。
在math中，您会找到一个名为的函数fsum()，它可以帮助您提高浮点打算的总体精度。

您可能有一项任务，您希望连接或链接多个可迭代工具，以便您可以将它们作为一个整体处理。
对付这种情形，您可以查看itertools模块的 function chain()。

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

如果您的代码不断利用 对浮点数求和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()。

如果您正在探求一个方便的工具来连接或链接一系列可迭代工具，请考虑利用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()以构建所需的平面列表。

正如您已经看到的，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()可以成为您的救星。

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

有了这些知识，您现在可以以 Pythonic、可读且高效的办法将多个数值相加。

点击关注，第一韶光理解华为云新鲜技能~华为云博客_大数据博客_AI博客_云打算博客_开拓者中央-华为云