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**to add several numeric values efficiently`sum()`

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

**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 `for`

loop:

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

Here, you first create `total`

and initialize it to `0`

. This variable works as an accumulator in which you store intermediate results until you get the final one. The loop iterates through `numbers`

and updates `total`

by accumulating each successive value using an augmented assignment.

You can also wrap the `for`

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_numbers()`

, you take an iterable—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 `0`

. The `for`

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

. The recursive case implies that the total sum is the first value, `numbers[0]`

, plus the sum of the rest of the values, `numbers[1:]`

. Because the recursive case uses a shorter sequence on each iteration, you expect to run into the base case when `numbers`

is a zero-length list. As a final result, you get the sum of all the items in your input list, `numbers`

.

**Note:** In this example, if you don’t check for an empty input list (your base case), then `sum_numbers()`

will never run into an infinite recursive loop. When your `numbers`

list reaches a length of `0`

, the code tries to access an item from the empty list, which raises an `IndexError`

and breaks the loop.

With this kind of implementation, you’ll never get a sum from this function. You’ll get an `IndexError`

every time.

Another option to sum a list of numbers in Python is to use `reduce()`

from `functools`

. To get the sum of a list of numbers, you can pass either `operator.add`

or an appropriate `lambda`

function as the first argument to `reduce()`

:

```
>>> 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 `reduce()`

with a reduction, or folding, `function`

along with an `iterable`

as arguments. Then `reduce()`

uses the input function to process `iterable`

and returns a single cumulative value.

In the first example, the reduction function is `add()`

, which takes two numbers and adds them together. The final result is the sum of the numbers in the input `iterable`

. As a drawback, `reduce()`

raises a `TypeError`

when you call it with an empty `iterable`

.

In the second example, the reduction function is a `lambda`

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 `reduce()`

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 `sum()`

. Since it’s a built-in function, you can use it directly in your code without importing anything.

## Getting Started With Python’s `sum()`

Readability is one of the most important principles behind Python’s philosophy. 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 `reduce()`

does summation. Using `reduce()`

is arguably less readable and less straightforward than even the loop-based solution.

This is why Python 2.3 added `sum()`

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 `sum()`

is way more readable than a `for`

loop or a `reduce()`

call. Unlike `reduce()`

, `sum()`

doesn’t raise a `TypeError`

when you provide an empty iterable. Instead, it understandably returns `0`

.

You can call `sum()`

with the following two arguments:

is a required argument that can hold any Python iterable. The iterable typically contains numeric values but can also contain lists or tuples.`iterable`

is an optional argument that can hold an initial value. This value is then added to the final result. It defaults to`start`

`0`

.

Internally, `sum()`

adds `start`

plus the values in `iterable`

from left to right. The values in the input `iterable`

are normally numbers, but you can also use lists and tuples. The optional argument `start`

can accept a number, list, or tuple, depending on what is passed to `iterable`

. It can’t take a string.

In the following two sections, you’ll learn the basics of using `sum()`

in your code.

### The Required Argument: `iterable`

Accepting any Python iterable as its first argument makes `sum()`

generic, reusable, and polymorphic. Because of this feature, you can use `sum()`

with lists, tuples, sets, `range`

objects, and dictionaries:

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

In all these examples, `sum()`

computes the arithmetic sum of all the values in the input iterable regardless of their types. In the two dictionary examples, both calls to `sum()`

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 `.keys()`

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 `.values()`

just like in the `.keys()`

example.

You can also use `sum()`

with a list comprehension as an argument. Here’s an example that computes the sum of the squares of a range of values:

```
>>> sum([x ** 2 for x in range(1, 6)])
55
```

Python 2.4 added generator expressions to the language. Again, `sum()`

works as expected when you use a generator expression as an argument:

```
>>> sum(x ** 2 for x in range(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.

### The Optional Argument: `start`

The second and optional argument, `start`

, allows you to provide a value to initialize the summation process. This argument is handy when you need to process cumulative values sequentially:

```
>>> sum([1, 2, 3, 4, 5], 100) # Positional argument
115
>>> sum([1, 2, 3, 4, 5], start=100) # Keyword argument
115
```

Here, you provide an initial value of `100`

to `start`

. The net effect is that `sum()`

adds this value to the cumulative sum of the values in the input iterable. Note that you can provide `start`

as a positional argument or as a keyword argument. The latter option is way more explicit and readable.

If you don’t provide a value to `start`

, then it defaults to `0`

. A default value of `0`

ensures the expected behavior of returning the total sum of the input values.

## Summing Numeric Values

The primary purpose of `sum()`

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 `sum()`

with any other numeric Python types, such as `float`

, `complex`

, `decimal.Decimal`

, and `fractions.Fraction`

.

Here are a few examples of using `sum()`

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 `sum()`

with **floating-point** numbers. It’s worth noting the function’s behavior when you use the special symbols `inf`

and `nan`

in the calls `float("inf")`

and `float("nan")`

. The first symbol represents an **infinite** value, so `sum()`

returns `inf`

. The second symbol represents NaN (not a number) values. Since you can’t add numbers with non-numbers, you get `nan`

as a result.

The other examples sum iterables of `complex`

, `Decimal`

, and `Fraction`

numbers. In all cases, `sum()`

returns the resulting cumulative sum using the appropriate numeric type.

## Concatenating Sequences

Even though `sum()`

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

:

```
>>> num_lists = [[1, 2, 3], [4, 5, 6]]
>>> sum(num_lists, start=[])
[1, 2, 3, 4, 5, 6]
>>> # Equivalent concatenation
>>> [1, 2, 3] + [4, 5, 6]
[1, 2, 3, 4, 5, 6]
>>> num_tuples = ((1, 2, 3), (4, 5, 6))
>>> sum(num_tuples, start=())
(1, 2, 3, 4, 5, 6)
>>> # Equivalent concatenation
>>> (1, 2, 3) + (4, 5, 6)
(1, 2, 3, 4, 5, 6)
```

In these examples, you use `sum()`

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

. For example, if you want to concatenate lists, then `start`

needs to hold a list.

In the examples above, `sum()`

is internally performing a concatenation operation, so it works only with those sequence types that support concatenation, with the exception of strings:

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

When you try to use `sum()`

to concatenate strings, you get a `TypeError`

. As the exception message suggests, you should use `str.join()`

to concatenate strings in Python. You’ll see examples of using this method later on when you get to the section on Using Alternatives to `sum()`

.

## Practicing With Python’s `sum()`

So far, you’ve learned the basics of working with `sum()`

. 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 `sum()`

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 `sum()`

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.

### Computing Cumulative Sums

The first example you’ll code has to do with how to take advantage of the `start`

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 `sum()`

:

```
>>> cumulative_sales = 0
>>> monday = [50, 27, 42]
>>> cumulative_sales = sum(monday, start=cumulative_sales)
>>> cumulative_sales
119
>>> tuesday = [12, 32, 15]
>>> cumulative_sales = sum(tuesday, start=cumulative_sales)
>>> cumulative_sales
178
>>> wednesday = [20, 24, 42]
>>> cumulative_sales = sum(wednesday, start=cumulative_sales)
>>> cumulative_sales
264
...
```

By using `start`

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

### Calculating the Mean of a Sample

Another practical use case of `sum()`

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 data points, 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 `sum()`

. The next part of the operation, where you are dividing by 8, uses the count of numbers in your sample. To calculate your divisor, you can use `len()`

:

```
>>> data_points = [2, 3, 4, 2, 3, 6, 4, 2]
>>> sum(data_points) / len(data_points)
3.25
```

Here, the call to `sum()`

computes the total sum of the data points in your sample. Next, you use `len()`

to get the number of data points. Finally, you perform the required division to calculate the sample’s arithmetic mean.

In practice, you may want to turn this code into a function with some additional features, such as a descriptive name and a check for empty samples:

```
>>> # Python >= 3.8
>>> def average(data_points):
... if (num_points := len(data_points)) == 0:
... raise ValueError("average requires at least one data point")
... return sum(data_points) / num_points
...
>>> average([2, 3, 4, 2, 3, 6, 4, 2])
3.25
>>> average([])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 3, in average
ValueError: average requires at least one data point
```

Inside `average()`

, you first check if the input sample has any data points. If not, then you raise a `ValueError`

with a descriptive message. In this example, you use the walrus operator to store the number of data points in the variable `num_points`

so that you won’t need to call `len()`

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

to approach these kinds of calculations.

In the `statistics`

module, you’ll find a function called `mean()`

:

```
>>> from statistics import mean
>>> mean([2, 3, 4, 2, 3, 6, 4, 2])
3.25
>>> mean([])
Traceback (most recent call last):
...
statistics.StatisticsError: mean requires at least one data point
```

The `statistics.mean()`

function has very similar behavior to the `average()`

function you coded earlier. When you call `mean()`

with a sample of numeric values, you’ll get the arithmetic mean of the input data. When you pass an empty list to `mean()`

, you’ll get a `statistics.StatisticsError`

.

Note that when you call `average()`

with a proper sample, you’ll get the desired mean. If you call `average()`

with an empty sample, then you get a `ValueError`

as expected.

### Finding the Dot Product of Two Sequences

Another problem you can solve using `sum()`

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 `zip()`

. Then you can use a generator expression to multiply each pair of values. Finally, `sum()`

can sum the products:

```
>>> x_vector = (1, 2, 3)
>>> y_vector = (4, 5, 6)
>>> sum(x * y for x, y in zip(x_vector, y_vector))
32
```

With `zip()`

, 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 `zip()`

. The final step is to add the products together using `sum()`

.

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, `zip()`

ignores the extra values from the longest sequence, which leads to an incorrect result.

To deal with this possibility, you can wrap the call to `sum()`

in a custom function and provide a proper check for the length of the input sequences:

```
>>> def dot_product(x_vector, y_vector):
... if len(x_vector) != len(y_vector):
... raise ValueError("Vectors must have equal sizes")
... return sum(x * y for x, y in zip(x_vector, y_vector))
...
>>> dot_product((1, 2, 3), (4, 5, 6))
32
>>> dot_product((1, 2, 3, 4), (5, 6, 3))
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 3, in dot_product
ValueError: Vectors must have equal sizes
```

Here, `dot_product()`

takes two sequences as arguments and returns their corresponding dot product. If the input sequences have different lengths, then the function raises a `ValueError`

.

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.

### 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 `for`

loop, as in the following code:

```
>>> def flatten_list(a_list):
... flat = []
... for sublist in a_list:
... flat += sublist
... return flat
...
>>> matrix = [
... [1, 2, 3],
... [4, 5, 6],
... [7, 8, 9],
... ]
>>> flatten_list(matrix)
[1, 2, 3, 4, 5, 6, 7, 8, 9]
```

Inside `flatten_list()`

, the loop iterates over all the nested lists contained in `a_list`

. Then it concatenates them in `flat`

using an augmented assignment operation (`+=`

). As the result, you get a flat list with all the items from the original nested lists.

But hold on! You’ve already learned how to use `sum()`

to concatenate sequences in this tutorial. Can you use that feature to flatten a list of lists like you did in the example above? Yes! Here’s how:

```
>>> matrix = [
... [1, 2, 3],
... [4, 5, 6],
... [7, 8, 9],
... ]
>>> sum(matrix, [])
[1, 2, 3, 4, 5, 6, 7, 8, 9]
```

That was quick! A single line of code and `matrix`

is now a flat list. However, using `sum()`

doesn’t seem to be the fastest solution.

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:

```
>>> def flatten_list(a_list):
... return [item for sublist in a_list for item in sublist]
...
>>> matrix = [
... [1, 2, 3],
... [4, 5, 6],
... [7, 8, 9],
... ]
>>> flatten_list(matrix)
[1, 2, 3, 4, 5, 6, 7, 8, 9]
```

This new version of `flatten_list()`

is more efficient and less wasteful in terms of memory usage. However, the nested comprehensions can be challenging to read and understand.

Using `.append()`

is probably the most readable and Pythonic way to flatten a list of lists:

```
>>> def flatten_list(a_list):
... flat = []
... for sublist in a_list:
... for item in sublist:
... flat.append(item)
... return flat
...
>>> matrix = [
... [1, 2, 3],
... [4, 5, 6],
... [7, 8, 9],
... ]
>>> flatten_list(matrix)
[1, 2, 3, 4, 5, 6, 7, 8, 9]
```

In this version of `flatten_list()`

, someone reading your code can see that the function iterates over every `sublist`

in `a_list`

. Inside this first `for`

loop, it iterates over each `item`

in `sublist`

to finally populate the new `flat`

list with `.append()`

. 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 `sum()`

As you’ve already learned, `sum()`

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

, you’ll find a function called `fsum()`

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

module’s function `chain()`

.

You might also have a task where you want to concatenate a list of strings. You’ve learned in this tutorial that there’s no way to use `sum()`

for concatenating strings. This function just wasn’t built for string concatenation. The most Pythonic alternative is to use `str.join()`

.

### Summing Floating-Point Numbers: `math.fsum()`

If your code is constantly summing floating-point numbers with `sum()`

, then you should consider using `math.fsum()`

instead. This function performs floating-point computations more carefully than `sum()`

, which improves the precision of your computation.

According to its documentation, `fsum()`

“avoids loss of precision by tracking multiple intermediate partial sums.” The documentation provides the following example:

```
>>> from math import fsum
>>> sum([.1, .1, .1, .1, .1, .1, .1, .1, .1, .1])
0.9999999999999999
>>> fsum([.1, .1, .1, .1, .1, .1, .1, .1, .1, .1])
1.0
```

With `fsum()`

, you get a more precise result. However, you should note that `fsum()`

doesn’t solve the representation error in floating-point arithmetic. The following example uncovers this limitation:

```
>>> from math import fsum
>>> sum([0.1, 0.2])
0.30000000000000004
>>> fsum([0.1, 0.2])
0.30000000000000004
```

In these examples, both functions return the same result. This is due to the impossibility of accurately representing both values `0.1`

and `0.2`

in binary floating-point:

```
>>> f"{0.1:.28f}"
'0.1000000000000000055511151231'
>>> f"{0.2:.28f}"
'0.2000000000000000111022302463'
```

Unlike `sum()`

, however, `fsum()`

can help you reduce floating-point error propagation when you add very large and very small numbers together:

```
>>> from math import fsum
>>> sum([1e-16, 1, 1e16])
1e+16
>>> fsum([1e-16, 1, 1e16])
1.0000000000000002e+16
>>> sum([1, 1, 1e100, -1e100] * 10_000)
0.0
>>> fsum([1, 1, 1e100, -1e100] * 10_000)
20000.0
```

Wow! The second example is pretty surprising and totally defeats `sum()`

. With `sum()`

, you get `0.0`

as a result. This is quite far away from the correct result of `20000.0`

, as you get with `fsum()`

.

### Concatenating Iterables With `itertools.chain()`

If you’re looking for a handy tool for concatenating or chaining a series of iterables, then consider using `chain()`

from `itertools`

. This function can take multiple iterables and build an iterator that yields items from the first one, from the second one, and so on until it exhausts all the input iterables:

```
>>> from itertools import chain
>>> numbers = chain([1, 2, 3], [4, 5, 6], [7, 8, 9])
>>> numbers
<itertools.chain object at 0x7f0d0f160a30>
>>> next(numbers)
1
>>> next(numbers)
2
>>> list(chain([1, 2, 3], [4, 5, 6], [7, 8, 9]))
[1, 2, 3, 4, 5, 6, 7, 8, 9]
```

When you call `chain()`

, you get an iterator of the items from the input iterables. In this example, you access successive items from `numbers`

using `next()`

. If you want to work with a list instead, then you can use `list()`

to consume the iterator and return a regular Python list.

`chain()`

is also a good option for flattening a list of lists in Python:

```
>>> from itertools import chain
>>> matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> list(chain(*matrix))
[1, 2, 3, 4, 5, 6, 7, 8, 9]
```

To flatten a list of lists with `chain()`

, you need to use the **iterable unpacking operator** (`*`

). This operator unpacks all the input iterables so that `chain()`

can work with them and generate the corresponding iterator. The final step is to call `list()`

to build the desired flat list.

### Concatenating Strings With `str.join()`

As you’ve already seen, `sum()`

doesn’t concatenate or join strings. If you need to do so, then the preferred and fastest tool available in Python is `str.join()`

. This method takes a sequence of strings as an argument and returns a new, concatenated string:

```
>>> greeting = ["Hello,", "welcome to", "Real Python!"]
>>> " ".join(greeting)
'Hello, welcome to Real Python!'
```

Using `.join()`

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 `.join()`

uses the string on which you call the method as a separator during the concatenation. In this example, you call `.join()`

on a string that consists of a single space character (`" "`

), so the original strings from `greeting`

are separated by spaces in your final string.

## Conclusion

You can now use Python’s built-in function `sum()`

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 `sum()`

can be your lifesaver.

**In this tutorial, you learned how to:**

- Sum numeric values using
**general techniques and tools** - Add several numeric values efficiently using
**Python’s**`sum()`

**Concatenate sequences**using`sum()`

- Use
`sum()`

to approach common**summation problems** - Use appropriate values for the
in`iterable`

and`start`

arguments`sum()`

- Decide between
`sum()`

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.