9 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
Free Bonus: Click here to get a Python Cheat Sheet and learn the basics of Python 3, like working with data types, dictionaries, lists, and Python functions.
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
>>> fromfunctoolsimportreduce>>> fromoperatorimportadd>>> reduce(add,[1,2,3,4,5])15>>> reduce(add,[])Traceback (most recent call last):...TypeError: reduce() of empty sequence with no initial value>>> reduce(lambdax,y:x+y,[1,2,3,4,5])15
4, you take an —specifically, a list of numeric values—as an argument and return the total sum of the values in the input list. If the input list is empty, then the function returns
>>> sum([1,2,3,4,5])15>>> sum([])0
0. The
>>> fromfunctoolsimportreduce>>> fromoperatorimportadd>>> reduce(add,[1,2,3,4,5])15>>> reduce(add,[])Traceback (most recent call last):...TypeError: reduce() of empty sequence with no initial value>>> reduce(lambdax,y:x+y,[1,2,3,4,5])15
8 loop is the same one that you saw before.
You can also use recursion instead of iteration. Recursion is a functional programming technique where a function is called within its own definition. In other words, a recursive function calls itself in a loop:
When you define a recursive function, you take the risk of running into an infinite loop. To prevent this, you need to define both a base case that stops the recursion and a recursive case to call the function and start the implicit loop.
In the above example, the base case implies that the sum of a zero-length list is
>>> sum([1,2,3,4,5])15>>> sum([])0
0. The recursive case implies that the total sum is the first value,
>>> sum([1,2,3,4,5])15>>> sum([])0
8, plus the sum of the rest of the values,
>>> sum([1,2,3,4,5])15>>> sum([])0
9. Because the recursive case uses a shorter sequence on each iteration, you expect to run into the base case when
>>> sum([1,2,3,4,5])15>>> sum([])0
1 is a zero-length list. As a final result, you get the sum of all the items in your input list,
>>> sum([1,2,3,4,5])15>>> sum([])0
1.
Note: In this example, if you don’t check for an empty input list (your base case), then
>>> sum([1,2,3,4,5])15>>> sum([])0
4 will never run into an infinite recursive loop. When your
>>> sum([1,2,3,4,5])15>>> sum([])0
1 list reaches a length of
>>> sum([1,2,3,4,5])15>>> sum([])0
0, the code tries to access an item from the empty list, which raises an
>>> # Use a list>>> sum([1,2,3,4,5])15>>> # Use a tuple>>> sum((1,2,3,4,5))15>>> # Use a set>>> sum({1,2,3,4,5})15>>> # Use a range>>> sum(range(1,6))15>>> # Use a dictionary>>> sum({1:"one",2:"two",3:"three"})6>>> sum({1:"one",2:"two",3:"three"}.keys())6
5 and breaks the loop.
With this kind of implementation, you’ll never get a sum from this function. You’ll get an
>>> # Use a list>>> sum([1,2,3,4,5])15>>> # Use a tuple>>> sum((1,2,3,4,5))15>>> # Use a set>>> sum({1,2,3,4,5})15>>> # Use a range>>> sum(range(1,6))15>>> # Use a dictionary>>> sum({1:"one",2:"two",3:"three"})6>>> sum({1:"one",2:"two",3:"three"}.keys())6
5 every time.
Another option to sum a list of numbers in Python is to use
>>> # Use a list>>> sum([1,2,3,4,5])15>>> # Use a tuple>>> sum((1,2,3,4,5))15>>> # Use a set>>> sum({1,2,3,4,5})15>>> # Use a range>>> sum(range(1,6))15>>> # Use a dictionary>>> sum({1:"one",2:"two",3:"three"})6>>> sum({1:"one",2:"two",3:"three"}.keys())6
7 from . To get the sum of a list of numbers, you can pass either or an appropriate
>>> sum([x**2forxinrange(1,6)])55
0 function as the first argument to
>>> # Use a list>>> sum([1,2,3,4,5])15>>> # Use a tuple>>> sum((1,2,3,4,5))15>>> # Use a set>>> sum({1,2,3,4,5})15>>> # Use a range>>> sum(range(1,6))15>>> # Use a dictionary>>> sum({1:"one",2:"two",3:"three"})6>>> sum({1:"one",2:"two",3:"three"}.keys())6
7:
>>>
>>> fromfunctoolsimportreduce>>> fromoperatorimportadd>>> reduce(add,[1,2,3,4,5])15>>> reduce(add,[])Traceback (most recent call last):...TypeError: reduce() of empty sequence with no initial value>>> reduce(lambdax,y:x+y,[1,2,3,4,5])15
You can call
>>> # Use a list>>> sum([1,2,3,4,5])15>>> # Use a tuple>>> sum((1,2,3,4,5))15>>> # Use a set>>> sum({1,2,3,4,5})15>>> # Use a range>>> sum(range(1,6))15>>> # Use a dictionary>>> sum({1:"one",2:"two",3:"three"})6>>> sum({1:"one",2:"two",3:"three"}.keys())6
7 with a reduction, or folding,
>>> sum([x**2forxinrange(1,6)])55
3 along with an
>>> sum([x**2forxinrange(1,6)])55
4 as arguments. Then
>>> # Use a list>>> sum([1,2,3,4,5])15>>> # Use a tuple>>> sum((1,2,3,4,5))15>>> # Use a set>>> sum({1,2,3,4,5})15>>> # Use a range>>> sum(range(1,6))15>>> # Use a dictionary>>> sum({1:"one",2:"two",3:"three"})6>>> sum({1:"one",2:"two",3:"three"}.keys())6
7 uses the input function to process
>>> sum([x**2forxinrange(1,6)])55
4 and returns a single cumulative value.
In the first example, the reduction function is
>>> sum([x**2forxinrange(1,6)])55
7, which takes two numbers and adds them together. The final result is the sum of the numbers in the input
>>> sum([x**2forxinrange(1,6)])55
4. As a drawback,
>>> # Use a list>>> sum([1,2,3,4,5])15>>> # Use a tuple>>> sum((1,2,3,4,5))15>>> # Use a set>>> sum({1,2,3,4,5})15>>> # Use a range>>> sum(range(1,6))15>>> # Use a dictionary>>> sum({1:"one",2:"two",3:"three"})6>>> sum({1:"one",2:"two",3:"three"}.keys())6
7 raises a when you call it with an empty
>>> sum([x**2forxinrange(1,6)])55
4.
In the second example, the reduction function is a
>>> sum([x**2forxinrange(1,6)])55
0 function that returns the addition of two numbers.
Since summations like these are commonplace in programming, coding a new function every time you need to sum some numbers is a lot of repetitive work. Additionally, using
>>> # Use a list>>> sum([1,2,3,4,5])15>>> # Use a tuple>>> sum((1,2,3,4,5))15>>> # Use a set>>> sum({1,2,3,4,5})15>>> # Use a range>>> sum(range(1,6))15>>> # Use a dictionary>>> sum({1:"one",2:"two",3:"three"})6>>> sum({1:"one",2:"two",3:"three"}.keys())6
7 isn’t the most readable solution available to you.
Python provides a dedicated built-in function to solve this problem. The function is conveniently called . Since it’s a built-in function, you can use it directly in your code without importing anything.
Remove ads
Getting Started With Python’s >>> def sum_numbers(numbers):
... if len(numbers) == 0:
... return 0
... return numbers[0] + sum_numbers(numbers[1:])
...
>>> sum_numbers([1, 2, 3, 4, 5])
15
9
Readability is one of the most important principles behind . Visualize what you are asking a loop to do when summing a list of values. You want it to loop over some numbers, accumulate them in an intermediate variable, and return the final sum. However, you can probably imagine a more readable version of summation that doesn’t need a loop. You want Python to take some numbers and sum them together.
Now think about how
>>> # Use a list>>> sum([1,2,3,4,5])15>>> # Use a tuple>>> sum((1,2,3,4,5))15>>> # Use a set>>> sum({1,2,3,4,5})15>>> # Use a range>>> sum(range(1,6))15>>> # Use a dictionary>>> sum({1:"one",2:"two",3:"three"})6>>> sum({1:"one",2:"two",3:"three"}.keys())6
7 does summation. Using
>>> # Use a list>>> sum([1,2,3,4,5])15>>> # Use a tuple>>> sum((1,2,3,4,5))15>>> # Use a set>>> sum({1,2,3,4,5})15>>> # Use a range>>> sum(range(1,6))15>>> # Use a dictionary>>> sum({1:"one",2:"two",3:"three"})6>>> sum({1:"one",2:"two",3:"three"}.keys())6
7 is arguably less readable and less straightforward than even the loop-based solution.
9 as a built-in function to provide a Pythonic solution to the summation problem. Alex Martelli contributed the function, which nowadays is the preferred syntax for summing a list of values:
>>>
>>> sum([1,2,3,4,5])15>>> sum([])0
Wow! That’s neat, isn’t it? It reads like plain English and clearly communicates the action you’re performing on the input list. Using
>>> fromfunctoolsimportreduce>>> fromoperatorimportadd>>> reduce(add,[1,2,3,4,5])15>>> reduce(add,[])Traceback (most recent call last):...TypeError: reduce() of empty sequence with no initial value>>> reduce(lambdax,y:x+y,[1,2,3,4,5])15
8 loop or a
>>> # Use a list>>> sum([1,2,3,4,5])15>>> # Use a tuple>>> sum((1,2,3,4,5))15>>> # Use a set>>> sum({1,2,3,4,5})15>>> # Use a range>>> sum(range(1,6))15>>> # Use a dictionary>>> sum({1:"one",2:"two",3:"three"})6>>> sum({1:"one",2:"two",3:"three"}.keys())6
7 call. Unlike
>>> # Use a list>>> sum([1,2,3,4,5])15>>> # Use a tuple>>> sum((1,2,3,4,5))15>>> # Use a set>>> sum({1,2,3,4,5})15>>> # Use a range>>> sum(range(1,6))15>>> # Use a dictionary>>> sum({1:"one",2:"two",3:"three"})6>>> sum({1:"one",2:"two",3:"three"}.keys())6
>>> # Use a list>>> sum([1,2,3,4,5])15>>> # Use a tuple>>> sum((1,2,3,4,5))15>>> # Use a set>>> sum({1,2,3,4,5})15>>> # Use a range>>> sum(range(1,6))15>>> # Use a dictionary>>> sum({1:"one",2:"two",3:"three"})6>>> sum({1:"one",2:"two",3:"three"}.keys())6
9 return the sum of the keys of the input dictionary. The first example sums the keys by default and the second example sums the keys because of the call on the input dictionary.
If your dictionary stores numbers in its values and you would like to sum these values instead of the keys, then you can do this by using just like in the
9 works as expected when you use a generator expression as an argument:
>>>
>>> sum(x**2forxinrange(1,6))55
This example shows one of the most Pythonic techniques to approach the summation problem. It provides an elegant, readable, and efficient solution in a single line of code.
9 is to provide a Pythonic way to add numeric values together. Up to this point, you’ve seen how to use the function to sum integer numbers. Additionally, you can use
9 is mostly intended to operate on numeric values, you can also use the function to concatenate sequences such as lists and tuples. To do that, you need to provide an appropriate value to
9 to concatenate lists and tuples. This is an interesting feature that you can use to flatten a list of lists or a tuple of tuples. The key requirement for these examples to work is to select an appropriate value for
9 is internally performing a concatenation operation, so it works only with those sequence types that support concatenation, with the exception of strings:
0. As the exception message suggests, you should use to concatenate strings in Python. You’ll see examples of using this method later on when you get to the section on .
9 in your code. With these practical examples, you’ll learn that this built-in function is quite handy when you’re performing computations that require finding the sum of a series of numbers as an intermediate step.
8 argument for summing cumulative lists of numeric values.
Say you’re developing a system to manage the sales of a given product at several different points of sale. Every day, you get a sold units report from each point of sale. You need to systematically compute the cumulative sum to know how many units the whole company sold over the week. To solve this problem, you can use
8, you set an initial value to initialize the sum, which allows you to add successive units to the previously computed subtotal. At the end of the week, you’ll have the company’s total count of sold units.
9 is to use it as an intermediate calculation before doing further calculations. For example, say you need to calculate the arithmetic mean of a sample of numeric values. The arithmetic mean, also known as the average, is the total sum of the values divided by the number of values, or , in the sample.
If you have the sample [2, 3, 4, 2, 3, 6, 4, 2] and you want to calculate the arithmetic mean by hand, then you can solve this operation:
(2 + 3 + 4 + 2 + 3 + 6 + 4 + 2) / 8 = 3.25
If you want to speed this up by using Python, you can break it up into two parts. The first part of this computation, where you are adding together the numbers, is a task for
55 again. The return statement computes the sample’s arithmetic mean and sends it back to the calling code.
Note: Computing the mean of a sample of data is a common operation in statistics and data analysis. The Python standard library provides a convenient module called to approach these kinds of calculations.
9 is finding the dot product of two equal-length sequences of numeric values. The dot product is the algebraic sum of products of every pair of values in the input sequences. For example, if you have the sequences (1, 2, 3) and (4, 5, 6), then you can calculate their dot product by hand using addition and multiplication:
1 × 4 + 2 × 5 + 3 × 6 = 32
To extract successive pairs of values from the input sequences, you can use
74, you generate a list of tuples with the values from each of the input sequences. The generator expression loops over each tuple while multiplying the successive pairs of values previously arranged by
The code in the above example works. However, the dot product is defined for sequences of equal length, so what happens if you provide sequences with different lengths? In that case,
81 takes two sequences as arguments and returns their corresponding dot product. If the input sequences have different lengths, then the function raises a
Embedding the functionality in a custom function allows you to reuse the code. It also gives you the opportunity to name the function descriptively so that the user knows what the function does just by reading its name.
Remove ads
Flattening a List of Lists
Flattening a list of lists is a common task in Python. Say you have a list of lists and need to flatten it into a single list containing all the items from the original nested lists. You can use any of several approaches to flattening lists in Python. For example, you can use a
>>> fromfunctoolsimportreduce>>> fromoperatorimportadd>>> reduce(add,[1,2,3,4,5])15>>> reduce(add,[])Traceback (most recent call last):...TypeError: reduce() of empty sequence with no initial value>>> reduce(lambdax,y:x+y,[1,2,3,4,5])15
An important drawback of any solution that implies concatenation is that behind the scenes, every intermediate step creates a new list. This can be pretty wasteful in terms of memory usage. The list that is eventually returned is just the most recently created list out of all the lists that were created at each round of concatenation. Using a list comprehension instead ensures that you create and return only one list:
92. Just like the comprehension from earlier, this solution creates only one list in the process. An advantage of this solution is that it is very readable.
Using Alternatives to >>> def sum_numbers(numbers):
... if len(numbers) == 0:
... return 0
... return numbers[0] + sum_numbers(numbers[1:])
...
>>> sum_numbers([1, 2, 3, 4, 5])
15
9
9 is helpful for working with numeric values in general. However, when it comes to working with floating-point numbers, Python provides an alternative tool. In
03, you’ll find a function called that can help you improve the general precision of your floating-point computations.
You might have a task where you want to concatenate or chain several iterables so that you can work with them as one. For this scenario, you can look to the
05. This function can take multiple iterables and build an that yields items from the first one, from the second one, and so on until it exhausts all the input iterables:
Concatenating Strings With >>> def sum_numbers(numbers):
... total = 0
... for number in numbers:
... total += number
... return total
...
>>> sum_numbers([1, 2, 3, 4, 5])
15
>>> sum_numbers([])
0
44
40 is the most efficient and Pythonic way to concatenate strings. Here, you use a list of strings as an argument and build a single string from the input. Note that
You can now use Python’s built-in function to add multiple numeric values together. This function provides an efficient, readable, and Pythonic way to solve summation problems in your code. If you’re dealing with math computations that require summing numeric values, then
9 and alternative tools to sum and concatenate objects
With this knowledge, you’re now able to add multiple numeric values together in a Pythonic, readable, and efficient way.
Mark as Completed
🐍 Python Tricks 💌
Get a short & sweet Python Trick delivered to your inbox every couple of days. No spam ever. Unsubscribe any time. Curated by the Real Python team.
Send Me Python Tricks »
About Leodanis Pozo Ramos
Leodanis is an industrial engineer who loves Python and software development. He's a self-taught Python developer with 6+ years of experience. He's an avid technical writer with a growing number of articles published on Real Python and other sites.
» More about Leodanis
Each tutorial at Real Python is created by a team of developers so that it meets our high quality standards. The team members who worked on this tutorial are:
Aldren
Bartosz
Joanna
Jacob
Sadie
Master Real-World Python Skills With Unlimited Access to Real Python
Join us and get access to thousands of tutorials, hands-on video courses, and a community of expert Pythonistas:
Level Up Your Python Skills »
Master Real-World Python Skills With Unlimited Access to Real Python
Join us and get access to thousands of tutorials, hands-on video courses, and a community of expert Pythonistas:
Level Up Your Python Skills »
What Do You Think?
Rate this article:
Tweet Share Share Email
What’s your #1 takeaway or favorite thing you learned? How are you going to put your newfound skills to use? Leave a comment below and let us know.
Commenting Tips: The most useful comments are those written with the goal of learning from or helping out other students. and get answers to common questions in our support portal.
When the sum of all items is divided by their number is known as?
MEAN-the sum of a set of numbers divided by the number of items in the set, also referred to as the average. MEDIAN- with a list of numbers that are arranged in numerical order, the median is the middle number. If there are two middle numbers, the median is the average of the two middle numbers.
Is defined as the sum of the values of the variables divided by the number of observations?
The mean is the sum of the value of each observation in a dataset divided by the number of observations. This is also known as the arithmetic average.
Is the sum of the values of all observations in a series divided by the number of observations constituting the series?
In statistics, the Arithmetic Mean (AM) or called average is the ratio of the sum of all observations to the total number of observations.
Is defined as the sum of all items divided by their number a median B mode D Arithmetice mean D correlation?
Mean is defined as the average value of a dataset. It is the sum of all values of a series divided by the number of valuesa in that series.