Skip to content
CodeMDD.io | Coding Tutorials

Effortlessly Calculate Python Sum

[

Python’s sum(): The Pythonic Way to Sum Values

Python’s built-in function sum() is an efficient and Pythonic way to sum a list of numeric values. Adding several numbers together is a common intermediate step in many computations, so sum() is a pretty handy tool for a Python programmer.

As an additional and interesting use case, you can concatenate lists and tuples using sum(), which can be convenient when you need to flatten a list of lists.

In this tutorial, you’ll learn how to:

  • Sum numeric values by hand using general techniques and tools
  • Use Python’s sum() to add several numeric values efficiently
  • Concatenate lists and tuples with sum()
  • Use sum() to approach common summation problems
  • Use appropriate values for the arguments in sum()
  • Decide between sum() and alternative tools to sum and concatenate objects

This knowledge will help you efficiently approach and solve summation problems in your code using either sum() or other alternative and specialized tools.

Understanding the Summation Problem

Summing numeric values together is a fairly common problem in programming. For example, say you have a list of numbers [1, 2, 3, 4, 5] and want to add them together to compute their total sum. With standard arithmetic, you’ll do something like this:

1 + 2 + 3 + 4 + 5 = 15

As far as math goes, this expression is pretty straightforward. It walks you through a short series of additions until you find the sum of all the numbers.

It’s possible to do this particular calculation by hand, but imagine some other situations where it might not be so possible. If you have a particularly long list of numbers, adding by hand can be inefficient and error-prone. What happens if you don’t even know how many items are in the list? Finally, imagine a scenario where the number of items you need to add changes dynamically or unpredictably.

In situations like these, whether you have a long or short list of numbers, Python can be quite useful to solve summation problems.

If you want to sum the numbers by creating your own solution from scratch, then you can try using a for loop:

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


for number in numbers:
    total += number


print(total) # Output: 15

Here, you first create total and initialize it to 0. Then, you iterate through each number in the list numbers and add it to total. After the loop ends, total will contain the sum of all the numbers.

While this is a valid solution, Python provides a more concise and efficient way to accomplish the same task using the sum() function.

Getting Started With Python’s sum()

Python’s sum() function takes an iterable (such as a list or tuple) as its main argument and returns the sum of all the values in that iterable.

The Required Argument: iterable

The iterable argument is the key component of sum(). It specifies the group of values you want to add together. The iterable can be any sequence like a list, tuple, range, or string.

Here’s an example of how to use sum() with a list:

numbers = [1, 2, 3, 4, 5]
result = sum(numbers)


print(result) # Output: 15

In this case, the iterable is the list numbers. When sum() is called with this list as the argument, it adds all the numbers together and returns the sum.

The Optional Argument: start

Another optional argument of sum() is start, which specifies the initial value for the summation. By default, start is set to 0. However, you can provide your own initial value if needed.

Here’s an example:

numbers = [1, 2, 3, 4, 5]
result = sum(numbers, 10)


print(result) # Output: 25

In this example, the initial value for the summation is set to 10. When sum() is called with this additional argument, it adds all the numbers together, starting from 10. The result is 25, which is the sum of all the numbers plus the initial value.

Summing Numeric Values

sum() is not limited to adding integers. It can also handle other numeric types like floats, decimals, and complex numbers.

Here’s an example that demonstrates how sum() works with a list of floats:

numbers = [1.2, 2.3, 3.4, 4.5, 5.6]
result = sum(numbers)


print(result) # Output: 17.0

In this case, the list numbers contains floating-point numbers. When sum() is called with this list, it adds all the floating-point numbers together and returns the sum as a float.

Concatenating Sequences

One interesting feature of Python’s sum() function is its ability to concatenate sequences. This can be useful when you have a list of lists or a list of tuples and you want to flatten it into a single list.

Here’s an example:

lists = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
result = sum(lists, [])


print(result) # Output: [1, 2, 3, 4, 5, 6, 7, 8, 9]

In this example, the list lists contains three individual lists. When sum() is called with this list and an empty list as the initial value, it concatenates all the individual lists together into a single list.

Practicing With Python’s sum()

Now that you understand the basics of using sum(), let’s practice with some common problems and applications.

Computing Cumulative Sums

One common task is computing the cumulative sum of a sequence of numbers. The cumulative sum at each position is the sum of all the numbers up to that position.

Here’s an example of how to calculate the cumulative sum of a list:

numbers = [1, 2, 3, 4, 5]
cumulative_sum = [sum(numbers[:i+1]) for i in range(len(numbers))]


print(cumulative_sum) # Output: [1, 3, 6, 10, 15]

In this example, a new list cumulative_sum is created using a list comprehension. The expression sum(numbers[:i+1]) calculates the cumulative sum up to each position i. The resulting list contains all the cumulative sums.

Calculating the Mean of a Sample

Another common operation is calculating the mean (average) of a sample, which is the sum of all the values divided by the number of values.

Here’s an example:

numbers = [1, 2, 3, 4, 5]
mean = sum(numbers) / len(numbers)


print(mean) # Output: 3.0

In this case, the sum of all the numbers is divided by the length of the list numbers to obtain the mean. The result is a float.

Finding the Dot Product of Two Sequences

The dot product is a mathematical operation that takes two sequences of numbers and calculates their sum of the element-wise multiplication.

Here’s an example of how to calculate the dot product of two lists:

numbers1 = [1, 2, 3]
numbers2 = [4, 5, 6]
dot_product = sum(x * y for x, y in zip(numbers1, numbers2))


print(dot_product) # Output: 32

In this example, the zip() function is used to pair up the corresponding elements from numbers1 and numbers2. Then, a generator expression is used to calculate the element-wise multiplication. Finally, sum() is called to add all the results together.

Flattening a List of Lists

As mentioned earlier, sum() can be used to flatten a list of lists. This can be quite useful in situations where you have nested lists and you want a single flat list.

Here’s an example:

lists = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened_list = sum(lists, [])


print(flattened_list) # Output: [1, 2, 3, 4, 5, 6, 7, 8, 9]

In this case, the list lists contains three individual lists. When sum() is called with this list and an empty list as the initial value, it concatenates all the individual lists together into a single list.

Using Alternatives to sum()

While sum() is a powerful and convenient tool for summation problems, there are also alternative functions and tools available in Python that you can use depending on your specific needs.

Summing Floating-Point Numbers: math.fsum()

Python’s built-in sum() function works well for most use cases. However, when dealing with floating-point numbers, it can sometimes introduce small inaccuracies due to the nature of floating-point arithmetic.

To avoid these inaccuracies, you can use the math.fsum() function from the math module. This function calculates the sum of floating-point numbers with increased precision.

Here’s an example:

import math


numbers = [0.1, 0.1, 0.1, 0.1, 0.1]
result = math.fsum(numbers)


print(result) # Output: 0.5

In this example, the list numbers contains five floating-point numbers that are all equal to 0.1. When math.fsum() is called with this list, it calculates the sum with higher precision, resulting in the correct value of 0.5 instead of a small error.

Concatenating Iterables With itertools.chain()

If you want to concatenate multiple iterables that are not sequences, you can use the itertools.chain() function. This function takes multiple iterables as arguments and returns a single iterable that contains all the elements from each input iterable.

Here’s an example:

import itertools


iterable1 = [1, 2, 3]
iterable2 = (4, 5, 6)
iterable3 = {7, 8, 9}
result = list(itertools.chain(iterable1, iterable2, iterable3))


print(result) # Output: [1, 2, 3, 4, 5, 6, 7, 8, 9]

In this example, the itertools.chain() function is used to concatenate the lists iterable1, iterable2, and iterable3 into a single list. The list() function is then used to convert the resulting iterable into a list.

Concatenating Strings With str.join()

When working with strings, you can use the str.join() method to concatenate multiple strings together. This method takes an iterable of strings as its argument and returns a single string that contains all the strings joined by a specified delimiter.

Here’s an example:

strings = ["Hello", "World", "!"]
result = " ".join(strings)


print(result) # Output: "Hello World !"

In this example, the list strings contains three individual strings. When the str.join() method is called with this list and a space delimiter, it joins all the strings together with a space in between, resulting in the string “Hello World !“.

Conclusion

Python’s sum() function is a versatile tool for solving summation problems in a concise and efficient way. It can handle lists, tuples, ranges, strings, and more. Additionally, you can use sum() to concatenate sequences and solve other related problems.

However, it’s important to keep in mind that there are alternative functions and tools available in Python that you can use depending on your specific needs. Functions like math.fsum(), itertools.chain(), and the str.join() method provide additional functionality and flexibility.

Now that you have a good understanding of Python’s sum() function and its various applications, you can confidently use it in your own code to solve summation problems in a Pythonic way.