Python sum() Function

Python sum() function is used to get the sum of numbers of an iterable.

Python sum() function syntax is:

sum(iterable[, start])

start is an optional number with default value of 0. If start is provided, then the sum of start and all the numbers in the iterable is returned.

Python sum() List of Numbers

s = sum([1, 2, 3])
print(s)

s = sum([1, 2, 3], 10)
print(s)

Output:

6
16

Note that sum() method doesn’t take keyword arguments, so if we write sum([1, 2, 3], start=10) then it will throw exception as TypeError: sum() takes no keyword arguments.

Python Sum of a Sequence of Integers

Since sum accepts iterable as argument, we can pass tuple, bytes of numbers too.

s = sum(bytes([1, 2]))
print(s)

s = sum(bytearray([1, 2]), 10)
print(s)

# sum of integers in different formats, tuple of numbers
s = sum((1, 0b11, 0o17, 0xFF))
print(s)

s = sum((1, 0b11, 0o17, 0xFF), 0xF)
print(s)

Output:

3
13
274
289

Python Sum of Floats

s = sum([1.5, 2.5, 3])
print(s)

Output: 7.0 If you want to add floating point values with extended precision, you can use math.fsum() function.

Python Sum of Complex Numbers

sum() function works with complex numbers too.

s = sum([1 + 2j, 3 + 4j])
print(s)

s = sum([1 + 2j, 3 + 4j], 2 + 2j)
print(s)

s = sum([1 + 2j, 2, 1.5 - 2j])
print(s)

Output:

(4+6j)
(6+8j)
(4.5+0j)

Performance and Limitations of sum()

The sum() function is optimized for performance and can handle large datasets effectively. However, its performance can vary depending on the type of iterable being processed and the total size of the data. Here are some insights and practical tips to understand the performance and limitations of sum():

Performance Insights

1. Processing Large Ranges: The sum() function is highly efficient with iterables like range() because they are generated lazily and don’t occupy memory for all elements at once.

# Example: Summing a large range

s = sum(range(1_000_000))

print(s) # Output: 499999500000

Note: This is memory-efficient since range() doesn’t store all the numbers in memory.

2. Memory Usage with Lists: When passing a list, sum() requires all elements to be stored in memory, which can lead to memory constraints for extremely large datasets.

large_list = list(range(1_000_000))

s = sum(large_list)

print(s) # Output: 499999500000

Tip: If possible, use range() or a generator expression for better memory efficiency.

3. Generators for Efficiency: Generators allow for on-the-fly computation without preloading all elements into memory, making them ideal for summing very large datasets.

s = sum(x for x in range(1_000_000) if x % 2 == 0)

print(s) # Output: 249999500000

Limitations

1. Single Type of Elements: All elements in the iterable must be of a type that supports addition (+). If mixed types (e.g., strings and numbers) are present, a TypeError will occur.

s = sum([1, ‘2’, 3]) # TypeError: unsupported operand type(s) for +: ‘int’ and ‘str’

2. Handling Float Precision: While sum() can handle floats, it may suffer from precision errors when dealing with very large or very small floating-point numbers. In such cases, consider using math.fsum() for higher precision.

from math import fsum

floats = [1e-16, 1, 1e-16]

print(sum(floats)) # Output: 1.0 (loss of precision)

print(fsum(floats)) # Output: 1.0000000000000002 (better precision)

Practical Tips

• Use range() or generator expressions for better memory management when summing large datasets.
• For floating-point numbers, prefer math.fsum() to avoid precision errors.
• Ensure the elements in the iterable are of compatible types for addition to prevent errors.

By understanding these performance characteristics and limitations, you can maximize the efficiency of the sum() function in your Python programs.