Geekflare is supported by our audience. We may earn affiliate commissions from buying links on this site.
In Development Last updated: June 12, 2023
Share on:
Invicti Web Application Security Scanner – the only solution that delivers automatic verification of vulnerabilities with Proof-Based Scanning™.

Learn all about the sum() function in Python: from the syntax to use it with various iterables—with helpful code examples.

When working with Python iterables, such as a list of numbers, a common operation is to find the sum of all elements in the list. We’ll run into such operations when working with other iterables, such as tuples and sets, too.

This can be done in a few different ways, but the recommended Pythonic way is using the built-in sum() function.

Here, we’ll start by looking at the other approaches, such as looping and defining a function. We’ll then proceed to learn the syntax of Python’s sum() function and code examples to understand it better.

## Summing Values in a Python Iterable

📋 You can code along in a Python REPL. Or you can use Geekflare’s Online Python editor.

Consider the following list of numbers:

``>>> nums = [2,8,5,3,11,7,9]``

Our goal is to find the sum of all numbers in the list. We’ll get to the Python `sum()` function soon, but we’ll start with some of the other approaches we can take. These include:

• Using a simple for loop
• Using the `reduce()` function from the functools module
• Defining a custom function

### Using Loops

To find the sum of all elements in a list, we can use a for loop like so:

• Initialize `total` variable to zero.
• Loop through the `nums` list and access each number.
• Add the number to the `total`.
``````>>> nums = [2,8,5,3,11,7,9]
>>> total = 0
>>> for num in nums:
...     total += num
...
>>> total
45``````

### Using the Reduce Function

Another approach to summing iterables is using the `reduce()` function. The reduce function, built into Python’s functools module, takes in a function and an iterable. And reduces the iterable by successively applying the function on the elements of the iterable.

Here, we use a lambda function to define the addition of two numbers and pass in `nums` list as the iterable.

``````>>> nums = [2,8,5,3,11,7,9]
>>> from functools import reduce
>>> total = reduce(lambda n1, n2: n1 + n2, nums)
>>> total
45``````

The `reduce()` function works by successively adding two numbers—from left to right—until it reduces to a single sum value:

### Using a Custom Function

We can also define a custom function to do this. Here, we define a function `sum_list` that:

• Takes in a list of numbers as the argument and
• Returns the sum of elements in a list.

The body of the function uses the looping construct we looked at earlier. But defining a function gives us reusability.

``````>>> def sum_list(some_list):
...     total = 0
...     for num in some_list:
...        total += num
...``````

Calling the `sum_list()` function with `nums` as the arguments returns the sum of 45:

``````>>> nums = [2,8,5,3,11,7,9]
>>> total = sum_list(nums)
>>> total
45``````

Next, let’s learn about the built-in `sum()` function. It’s not only concise but also robust in that it works well with several iterables and data types.

## Syntax of the Python Sum Function

The syntax to use the `sum()` function is as follows:

``sum(iterable, start)``

Here,

• `iterable` is a required argument. It can be any iterable for which the summing operation is valid such as a list or tuples of numbers. Calling the `sum()` function with Python strings raises a TypeError exception (more on this later).
• `start` is an optional argument. It is often a numeric value that is added to the computed sum. This can be helpful when you need to add a constant value to the result.

Now that we’ve learned the syntax of the Python `sum()` function, let’s use it to sum iterables.

## Summing Iterables with Sum Function

### #1. List

Let’s find the sum of numbers in the `nums` list using the `sum()` function:

``````>>> nums = [2,8,5,3,11,7,9]
>>> sum_1 = sum(nums)
>>> sum_1
45``````

#### Using the Optional Start Value

To add a constant value to the sum, we can use the `sum()` function with the optional `start` value. Here, we pass in a `start` value of 100 as a positional argument:

``````>>> sum_start = sum(nums,100)
>>> sum_start
145``````

The `start` value can also be specified as a keyword argument:

``````>>> sum_start = sum(nums,start=10)
>>> sum_start
55``````

### #2. Tuple

The `sum()` function also works with tuples. We create a tuple `nums_tuple` by casting the `nums` list to a tuple:

``````>>> nums_tuple = tuple(nums)
>>> nums_tuple
(2, 8, 5, 3, 11, 7, 9)``````
``````>>> sum_2 = sum(nums_tuple)
>>> sum_2
45``````

### #3. Set

We can also use the `sum()` function with a set of numbers:

``````>>> nums_set = set(nums)
>>> nums_set
{2, 3, 5, 7, 8, 9, 11}``````

Here, we cast the `nums` list to a Python set and compute the sum of elements in `nums_set`.

``````>>> sum_3 = sum(nums_set)
>>> sum_3
45``````

### #4. Dictionary

Consider the following `student_dict` with numeric keys. Notice what happens when you call the `sum()` function with this dictionary as the argument.

``````>>> students_dict = {1:106,2:112,3:127}
>>> sum_4 = sum(students_dict)
>>> sum_4
6``````

The `sum()` function, by default, returns the sum of the keys.

#### Summing the Keys

We know that the default behavior is to sum the keys of the dictionary.

However, you can make this more explicit by using the dictionary method `keys()` to access the keys. And then pass in the list of keys to the `sum()` function:

``````>>> sum_keys = sum(students_dict.keys())
>>> sum_keys
6``````

#### Summing the Values

If you’d like to sum the values of the dictionary instead, access the values by calling the `values()` method on the dictionary object:

``````>>> sum_vals = sum(students_dict.values())
>>> sum_vals
345``````

## Using Python’s Sum Function with Other Numeric Data Types

So far, we have seen how to use the `sum()` function with iterables of integers. Now let’s look at a couple of examples with other numeric data types.

### Complex Numbers

The `sum()` function can also be used to sum complex numbers. In this example, `nums_c` is a list of complex numbers:

``````>>> nums_c = [3 + 4j, 1 + 2j]
>>> sum_c = sum(nums_c)
>>> sum_c
(4+6j)``````

### Floating Point Numbers

Here, we use the `sum()` function to sum the list of floating point numbers `nums_f`:

``````>>> nums_f = [1.8,2.5,3.6,7.2]
>>> sum_f = sum(nums_f)
>>> sum_f
15.100000000000001``````

📑 For improved precision in the result of adding floating point numbers, you can use the fsum() function from the math module to sum iterables with floating point values.

## Flattening with the Sum Function

Now let’s see how the `sum()` function can be used to flatten and concatenate iterables.

### Flatten a List

Suppose we have a nested list:

``>>> lists = [[2,4,6],[3,5,7]]``

When we call the `sum()` function by passing in this nested list as the argument along with an empty list as the `start` value:

``````>>> sum(lists,[])
[2, 4, 6, 3, 5, 7]``````

We see that the nested list has now then flattened into a single list of numbers.

Equivalently, when we think of the list to be of the form `l3 = [l1,l2]`, the `sum()` function concatenates the two lists `l1` and `l2` nested within the list `l3`.

📝As a quick exercise, try using the `sum()` function on other nested iterables.

### Common Pitfall: Don’t Use Python’s sum() Function with Strings

Because we have seen that the `sum()` function can be used to flatten and concatenate lists (and other iterables like tuples); it’s tempting to think that we can use it to concatenate strings as well.

But if you try to do so, you’ll run into a `TypeError`:

``````>>> sum(['a','b','c'],'')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: sum() can't sum strings [use ''.join(seq) instead]``````

So the `sum()` function cannot be used to sum (or concatenate) strings.

However, as seen in the error message above, you can use the `join()` method to concatenate a list of strings into a single string.

``````>>> ''.join(['a','b','c'])
'abc'``````

### Conclusion

In this tutorial, we learned how to use the built-in `sum()` function to find the sum of all elements in an iterable. The general syntax to use the `sum()` function is: `sum(iterable, start)`, where `iterable` is a required argument and `start` is an optional argument.

We then coded several examples to understand the use of the `sum()` function with iterables like lists, tuples, sets, and dictionaries. Later, we looked at how the `sum()` function can be used for flattening and concatenating iterables—with the exception of Python strings.

I hope you found this tutorial helpful. Next, you may want to check out this tutorial on Python’s map function.

• Bala Priya is a developer and technical writer from India with over three years of experience in the technical content writing space. She shares her learning with the developer community by authoring tech tutorials, how-to guides, and more…. read more