sum()

Einleitung

sum() ist die kanonische Form, eine Sammlung von Werten zu addieren. Sie ist:

• Idiomatisch: Pythonisch und kürzer als ein for-Loop mit Akku.
• Stream-fähig: Funktioniert mit Generatoren ohne Materialisierung — wichtig für große Datenmengen.
• Typ-flexibel: Mit start-Parameter lassen sich auch Objekte addieren, die + als Operator unterstützen.

Eine wichtige Ausnahme: sum() lehnt Strings ab. Wer Strings konkatenieren will, nutzt "".join() — nicht sum(strings, ""). Der Grund ist Performance: sum() mit Strings wäre O(n²) wegen der Immutability.

Für Floating-Point-genaues Summieren ist math.fsum() die richtige Wahl — es vermeidet Akkumulations-Fehler.

Syntax

sum(iterable)
sum(iterable, start)

Rückgabewert

Die Summe der Elemente plus start. Bei leerer Iterable: start selbst (Default: 0).

Beispiele

Standard-Summierung

sum() arbeitet mit Listen, Tupeln, Generatoren — alles, was iterierbar ist:

print(sum([1, 2, 3, 4, 5]))
print(sum((10, 20, 30)))
print(sum(range(1, 101)))   # Gauß'sche Summe 1..100

15
60
5050

Mit start-Wert

Der start-Wert ist nicht nur ein Offset — er bestimmt auch den Typ des Akkumulators:

from decimal import Decimal
ints = [1, 2, 3]
print(sum(ints, 100))                    # 100 + 1 + 2 + 3
print(sum([Decimal("0.1")] * 3, Decimal("0")))   # exakte Decimal-Summe

106
0.3

Mit Generator-Expression

Wenn man Werte aus Daten berechnen will, ist eine Generator-Expression in sum() deutlich speicher-effizienter als eine Liste:

# Summe der Quadrate von 1 bis 10
print(sum(x * x for x in range(1, 11)))

385

Strings — NICHT mit sum()

Bei Strings verbietet sum() die Anwendung explizit, weil String-Konkatenation O(n²) wäre. Die richtige Lösung ist str.join():

try:
    sum(["a", "b", "c"], "")
except TypeError as e:
    print(e)

# Korrekt:
print("".join(["a", "b", "c"]))

sum() can't sum strings [use ''.join(seq) instead]
abc

Praktische Beispiele

Bedingte Aggregation: Anzahl der Elemente, die ein Prädikat erfüllen

sum() über einen Boolean-Generator zählt — kürzer als ein expliziter Counter:

nums = [3, 7, 1, 8, 4, 12, 5]
gt_5 = sum(1 for n in nums if n > 5)
print(f"{gt_5} Werte sind größer als 5")

3 Werte sind größer als 5

Listen flachklopfen mit start=[]

Mit start=[] lässt sich sum() als Flatten-Operation für eine flache Liste-of-Lists missbrauchen — funktioniert, ist aber langsam (O(n²)). Für Production: itertools.chain.from_iterable().

from itertools import chain
nested = [[1, 2], [3, 4], [5]]

# sum-Trick (langsam):
flat = sum(nested, [])
print(flat)

# Schnell und idiomatisch:
flat = list(chain.from_iterable(nested))
print(flat)

[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5]

Float-genauer Summieren mit math.fsum

Beim Summieren vieler Floats können sich Rundungsfehler ansammeln — math.fsum() summiert ohne Genauigkeitsverlust:

import math
values = [0.1] * 10
print(sum(values))         # zeigt Rundungsfehler
print(math.fsum(values))   # exakt

0.9999999999999999
1.0

Praktische Hinweise

• sum() ist O(n) — schneller als manuelle Summier-Schleife.
• Strings sind explizit verboten — "".join(seq) nutzen.
• math.fsum() für präzise Float-Summen (vermeidet Rundungsfehler).
• start setzt den Akkumulator-Typ — perfekt für Decimal, Fraction oder eigene Klassen.
• Verwandte Funktionen: len() (Anzahl), min()/max() (Extreme), statistics.mean() (Durchschnitt), functools.reduce() (allgemeine Aggregation).