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 builtin 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
... return total
...
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 builtin 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 thesum()
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 builtin 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, howto guides, and more…. read more