Can we use sum function in tuple in Python?

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 >>> from functools import reduce >>> from operator import add >>> 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(lambda x, y: x + y, [1, 2, 3, 4, 5]) 15 8 loop:

>>>>>> numbers = [1, 2, 3, 4, 5] >>> total = 0 >>> for number in numbers: ... total += number ... >>> total 15

Here, you first create >>> from functools import reduce >>> from operator import add >>> 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(lambda x, y: x + y, [1, 2, 3, 4, 5]) 15 9 and initialize it to >>> sum([1, 2, 3, 4, 5]) 15 >>> sum([]) 0 0. This variable works as an accumulator in which you store intermediate results until you get the final one. The loop iterates through >>> sum([1, 2, 3, 4, 5]) 15 >>> sum([]) 0 1 and updates >>> from functools import reduce >>> from operator import add >>> 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(lambda x, y: x + y, [1, 2, 3, 4, 5]) 15 9 by accumulating each successive value using an .

You can also wrap the >>> from functools import reduce >>> from operator import add >>> 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(lambda x, y: x + y, [1, 2, 3, 4, 5]) 15 8 loop in a function. This way, you can reuse the code for different lists:

>>>>>> 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

In >>> sum([1, 2, 3, 4, 5]) 15 >>> sum([]) 0 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 >>> from functools import reduce >>> from operator import add >>> 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(lambda x, 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:

>>>>>> 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

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 ** 2 for x in range(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:

>>>>>> from functools import reduce >>> from operator import add >>> 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(lambda x, 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 ** 2 for x in range(1, 6)]) 55 3 along with an >>> sum([x ** 2 for x in range(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 ** 2 for x in range(1, 6)]) 55 4 and returns a single cumulative value.

In the first example, the reduction function is >>> sum([x ** 2 for x in range(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 ** 2 for x in range(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 ** 2 for x in range(1, 6)]) 55 4.

In the second example, the reduction function is a >>> sum([x ** 2 for x in range(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.

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.

This is why Python 2.3 added >>> 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 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 >>> 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 is way more readable than a >>> from functools import reduce >>> from operator import add >>> 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(lambda x, 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 7, >>> 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 doesn’t raise a >>> sum(x ** 2 for x in range(1, 6)) 55 0 when you provide an empty iterable. Instead, it understandably returns >>> sum([1, 2, 3, 4, 5]) 15 >>> sum([]) 0 0.

You can call >>> 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 with the following two arguments:

1. >>> sum([x ** 2 for x in range(1, 6)]) 55 4 is a required argument that can hold any Python iterable. The iterable typically contains numeric values but can also contain lists or tuples.
2. >>> sum([1, 2, 3, 4, 5], 100) # Positional argument 115 >>> sum([1, 2, 3, 4, 5], start=100) # Keyword argument 115 8 is an optional argument that can hold an initial value. This value is then added to the final result. It defaults to >>> sum([1, 2, 3, 4, 5]) 15 >>> sum([]) 0 0.

Internally, >>> 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 adds >>> sum([1, 2, 3, 4, 5], 100) # Positional argument 115 >>> sum([1, 2, 3, 4, 5], start=100) # Keyword argument 115 8 plus the values in >>> sum([x ** 2 for x in range(1, 6)]) 55 4 from left to right. The values in the input >>> sum([x ** 2 for x in range(1, 6)]) 55 4 are normally numbers, but you can also use lists and tuples. The optional argument >>> sum([1, 2, 3, 4, 5], 100) # Positional argument 115 >>> sum([1, 2, 3, 4, 5], start=100) # Keyword argument 115 8 can accept a number, list, or tuple, depending on what is passed to >>> sum([x ** 2 for x in range(1, 6)]) 55 4. It can’t take a string.

In the following two sections, you’ll learn the basics of using >>> 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 in your code.

Summing Numeric Values

The primary purpose of >>> 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 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 >>> 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 with any other numeric Python types, such as , >>> 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 20, , and .

Here are a few examples of using >>> 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 with values of different numeric types:

>>>>>> from decimal import Decimal >>> from fractions import Fraction >>> # Sum floating-point numbers >>> sum([10.2, 12.5, 11.8]) 34.5 >>> sum([10.2, 12.5, 11.8, float("inf")]) inf >>> sum([10.2, 12.5, 11.8, float("nan")]) nan >>> # Sum complex numbers >>> sum([3 + 2j, 5 + 6j]) (8+8j) >>> # Sum Decimal numbers >>> sum([Decimal("10.2"), Decimal("12.5"), Decimal("11.8")]) Decimal('34.5') >>> # Sum Fraction numbers >>> sum([Fraction(51, 5), Fraction(25, 2), Fraction(59, 5)]) Fraction(69, 2)

Here, you first use >>> 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 with floating-point numbers. It’s worth noting the function’s behavior when you use the special symbols >>> 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 25 and >>> 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 26 in the calls >>> 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 27 and >>> 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 28. The first symbol represents an infinite value, so >>> 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 returns >>> 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 25. The second symbol represents NaN (not a number) values. Since you can’t add numbers with non-numbers, you get >>> 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 26 as a result.

The other examples sum iterables of >>> 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 20, >>> 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 33, and >>> 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 34 numbers. In all cases, >>> 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 returns the resulting cumulative sum using the appropriate numeric type.

Concatenating Sequences

Even though >>> 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 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 >>> sum([1, 2, 3, 4, 5], 100) # Positional argument 115 >>> sum([1, 2, 3, 4, 5], start=100) # Keyword argument 115 8:

>>>>>> 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 0

In these examples, you use >>> 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 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 >>> sum([1, 2, 3, 4, 5], 100) # Positional argument 115 >>> sum([1, 2, 3, 4, 5], start=100) # Keyword argument 115 8. For example, if you want to concatenate lists, then >>> sum([1, 2, 3, 4, 5], 100) # Positional argument 115 >>> sum([1, 2, 3, 4, 5], start=100) # Keyword argument 115 8 needs to hold a list.

In the examples above, >>> 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 is internally performing a concatenation operation, so it works only with those sequence types that support concatenation, with the exception of strings:

>>>>>> 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 1

When you try to use >>> 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 to concatenate strings, you get a >>> sum(x ** 2 for x in range(1, 6)) 55 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 .

Practicing 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

So far, you’ve learned the basics of working with >>> 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. You’ve learned how to use this function to add numeric values together and also to concatenate sequences such as lists and tuples.

In this section, you’ll look at some more examples of when and how to use >>> 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 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.

You’ll also learn that >>> 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 can be helpful when you’re working with lists and tuples. A special example you’ll look at is when you need to flatten a list of lists.

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