Python 的 sum() Pythonic 的求和方法詳細

前言：

我們現在可以使用 Python 的內置函數sum()將多個數值相加。此函數提供瞭一種高效、可讀且 Pythonic 的方法來解決代碼中的求和問題。如果您正在處理需要對數值求和的數學計算，那麼它sum()可以成為您的救星。

Python 的內置函數sum()是一種對數值列表求和的有效且Pythonic 的方法。將多個數字相加是許多計算中常見的中間步驟，因此sum()對於 Python 程序員來說是一個非常方便的工具。

作為一個額外的和有趣的使用情況，您可以連接列表和元組使用sum()，當你需要拼合列表的列表，可以很方便。

在本教程中，我們將學習如何：

• 使用通用技術和工具手工對數值求和
• 使用Pythonsum()高效地添加多個數值
• 拼接列表和元組與sum()
• 使用sum()接近普通求和問題
• 使用適當的值的參數中sum()
• 之間做出選擇sum()和替代工具來總結和串連對象

這些知識將幫助您使用sum()或其他替代和專用工具有效地處理和解決代碼中的求和問題。

1、理解求和問題

將數值相加是編程中一個相當普遍的問題。例如，假設您有一個數字列表 [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() 。由於它是一個內置函數，因此您可以直接在代碼中使用它，而無需導入任何內容。

2、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()使用以下兩個參數進行調用：

iterable是一個必需的參數，可以保存任何 Python 可迭代對象。可迭代對象通常包含數值，但也可以包含列表或元組。
start是一個可選參數，可以保存一個初始值。然後將該值添加到最終結果中。它默認為0.
在內部，從左到右sum()添加startplus 中的值iterable。輸入iterable中的值通常是數字，但您也可以使用列表和元組。可選參數start可以接受數字、列表或元組，具體取決於傳遞給 的內容iterable。它不能帶一個string。

在以下兩節中，您將瞭解sum()在代碼中使用的基礎知識。

2.1 必需的參數： 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 技術之一。它在一行代碼中提供瞭一個優雅、可讀且高效的解決方案。

2.2 可選參數： 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確保返回輸入值總和的預期行為。

3、對數值求和

的主要目的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()使用適當的數字類型返回結果累積總和。

4、連接序列

盡管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()方法部分時，您將看到使用此方法的示例。

5、使用 Python 進行練習 sum()

到目前為止，您已經學習瞭使用sum(). 您已經學習瞭如何使用此函數將數值相加，以及如何連接列表和元組等序列。

在本節中，您將查看更多有關何時以及如何sum()在代碼中使用的示例。通過這些實際示例，您將瞭解到當您執行需要查找一系列數字之和作為中間步驟的計算時，此內置函數非常方便。

您還將瞭解到這sum()在您使用列表和元組時會很有幫助。您將看到的一個特殊示例是當您需要展平列表列表時。

5.1 計算累積和

您將編寫的第一個示例與如何利用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，您可以設置一個初始值來初始化總和，這允許您將連續單位添加到先前計算的小計中。在本周末，您將獲得公司的銷售單位總數。

5.2 計算樣本的平均值

的另一個實際用例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預期的結果。

5.3 求兩個序列的點積

您可以使用的另一個問題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。

在自定義函數中嵌入功能允許您重用代碼。它還使您有機會對函數進行描述性命名，以便用戶僅通過閱讀函數名稱就知道該函數的作用。

5.4 展平列表列表

展平列表列表是 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(). 就像前面的推導一樣，這個解決方案在這個過程中隻創建瞭一個列表。這種解決方案的一個優點是它的可讀性很強。

6、使用替代品 sum()

正如您已經瞭解到的，sum()一般來說，對於處理數值很有幫助。但是，在處理浮點數時，Python 提供瞭一種替代工具。在 中math，您會找到一個名為的函數fsum() ，它可以幫助您提高浮點計算的總體精度。

您可能有一項任務，您希望連接或鏈接多個可迭代對象，以便您可以將它們作為一個整體處理。對於這種情況，您可以查看itertools模塊的 function chain() 。

您可能還有一個要連接字符串列表的任務。您在本教程中瞭解到，無法sum()用於連接字符串。這個函數不是為字符串連接而構建的。最 Pythonic 的替代方法是使用str.join().

6.1 對浮點數求和： 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() 。

6.2 連接可迭代對象 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()以構建所需的平面列表。

6.3 連接字符串 str.join()

正如您已經看到的，sum()不連接或連接字符串。如果您需要這樣做，那麼 Python 中可用的首選和最快的工具是str.join(). 此方法將一系列字符串作為參數並返回一個新的連接字符串：

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

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

使用.join()是連接字符串的最有效和 Pythonic 的方式。在這裡，您使用字符串列表作為參數並從輸入構建單個字符串。請註意，.join()在連接期間使用您調用方法的字符串作為分隔符。在此示例中，您調用.join()由單個空格字符 ( " ")組成的字符串，因此原始字符串 fromgreeting在最終字符串中由空格分隔。

7、結論

您現在可以使用 Python 的內置函數sum()將多個數值相加。此函數提供瞭一種高效、可讀且 Pythonic 的方法來解決代碼中的求和問題。如果您正在處理需要對數值求和的數學計算，那麼它sum()可以成為您的救星。

到此這篇關於Python 的 sum() Pythonic 的求和方法詳細的文章就介紹到這瞭,更多相關Python 的 sum() Pythonic 的求和方法內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！

推薦閱讀：

• 初識python的numpy模塊
• Python中號稱神仙的六個內置函數詳解
• Python 中的反轉字符串reversed(),切片
• Python 代碼實現列表的最小公倍數
• Python中itertools簡介使用介紹