The Required Argument:iterable

Accepting any Python iterable as its first argument makessum() generic, reusable, andpolymorphic. Because of this feature, you can usesum() with lists, tuples,sets,range objects, anddictionaries:

>>># 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 tosum() 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 usesum() with alist comprehension as an argument. Here’s an example that computes the sum of the squares of a range of values:

>>>sum([x**2forxinrange(1,6)])55

Python 2.4 addedgenerator expressions to the language. Again,sum() 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.

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 argument115>>>sum([1,2,3,4,5],start=100)# Keyword argument115

Here, you provide an initial value of100 tostart. The net effect is thatsum() adds this value to the cumulative sum of the values in the input iterable. Note that you can providestart as apositional argument or as akeyword argument. The latter option is way more explicit and readable.

If you don’t provide a value tostart, then it defaults to0. A default value of0 ensures the expected behavior of returning the total sum of the input values.

Computing Cumulative Sums

The first example you’ll code has to do with how to take advantage of thestart 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 usesum():

>>>cumulative_sales=0>>>monday=[50,27,42]>>>cumulative_sales=sum(monday,start=cumulative_sales)>>>cumulative_sales119>>>tuesday=[12,32,15]>>>cumulative_sales=sum(tuesday,start=cumulative_sales)>>>cumulative_sales178>>>wednesday=[20,24,42]>>>cumulative_sales=sum(wednesday,start=cumulative_sales)>>>cumulative_sales264    ...

By usingstart, 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 ofsum() is to use it as an intermediate calculation before doing further calculations. For example, say you need to calculate thearithmetic mean of a sample of numeric values. The arithmetic mean, also known as theaverage, is the total sum of the values divided by the number of values, ordata 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 forsum(). The next part of the operation, where you are dividing by 8, uses the count of numbers in your sample. To calculate yourdivisor, you can uselen():

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

Here, the call tosum() computes the total sum of the data points in your sample. Next, you uselen() 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>>>defaverage(data_points):...if(num_points:=len(data_points))==0:...raiseValueError("average requires at least one data point")...returnsum(data_points)/num_points...>>>average([2,3,4,2,3,6,4,2])3.25>>>average([])Traceback (most recent call last):  File"<stdin>", line1, in<module>  File"<stdin>", line3, inaverageValueError:average requires at least one data point

Insideaverage(), you first check if the input sample has any data points. If not, then you raise aValueError with a descriptive message. In this example, you use thewalrus operator to store the number of data points in the variablenum_points so that you won’t need to calllen() again. Thereturn statement computes the sample’s arithmetic mean and sends it back to the calling code.

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

Note that when you callaverage() with a proper sample, you’ll get the desired mean. If you callaverage() with an empty sample, then you get aValueError as expected.

Finding the Dot Product of Two Sequences

Another problem you can solve usingsum() is finding thedot product of two equal-length sequences of numeric values. The dot product is the algebraic sum ofproducts 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 usezip(). 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*yforx,yinzip(x_vector,y_vector))32

Withzip(), 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 byzip(). The final step is to add the products together usingsum().

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 tosum() in a custom function and provide a proper check for the length of the input sequences:

>>>defdot_product(x_vector,y_vector):...iflen(x_vector)!=len(y_vector):...raiseValueError("Vectors must have equal sizes")...returnsum(x*yforx,yinzip(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>", line1, in<module>  File"<stdin>", line3, indot_productValueError: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 aValueError.

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 have options when deciding how toflatten lists in Python. For example, you can use afor loop, as in the following code:

>>>defflatten_list(a_list):...flat=[]...forsublistina_list:...flat+=sublist...returnflat...>>>matrix=[...[1,2,3],...[4,5,6],...[7,8,9],...]>>>flatten_list(matrix)[1, 2, 3, 4, 5, 6, 7, 8, 9]

Insideflatten_list(), the loop iterates over all the nested lists contained ina_list. Then it concatenates them inflat 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 usesum() 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 andmatrix is now a flat list. However, usingsum() doesn’t seem to be the fastest solution.

Using a list comprehension is another common way to flatten a list of list in Python:

>>>defflatten_list(a_list):...return[itemforsublistina_listforiteminsublist]...>>>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 offlatten_list() uses a comprehension instead of a regularfor loop. However, thenested comprehensions can be challenging to read and understand.

Using.append() is another way to flatten a list of lists:

>>>defflatten_list(a_list):...flat=[]...forsublistina_list:...foriteminsublist:...flat.append(item)...returnflat...>>>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 offlatten_list(), someone reading your code can see that the function iterates over everysublist ina_list. In the secondfor loop, the function iterates over eachitem insublist to finally populate the newflat list with.append(). Arguably, readability can be an advantage of this solution.

Summing Floating-Point Numbers:math.fsum()

If your code is constantly summing floating-point numbers withsum(), then you should consider usingmath.fsum() instead. This function performs floating-point computations more carefully thansum(), which improves the precision of your computation.

According to itsdocumentation,fsum() “avoids loss of precision by tracking multiple intermediate partial sums.” The documentation provides the following example:

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

Withfsum(), you get a more precise result. However, you should note thatfsum() doesn’t solve therepresentation error in floating-point arithmetic. The following example uncovers this limitation:

>>>frommathimportfsum>>>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 values0.1 and0.2 in binary floating-point:

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

Unlikesum(), however,fsum() can help you reduce floating-point error propagation when you add very large and very small numbers together:

>>>frommathimportfsum>>>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 defeatssum(). Withsum(), you get0.0 as a result. This is quite far away from the correct result of20000.0, as you get withfsum().

Concatenating Iterables Withitertools.chain()

If you’re looking for a handy tool for concatenating or chaining a series of iterables, then consider usingchain() fromitertools. This function can take multiple iterables and build aniterator that yields items from the first one, from the second one, and so on until it exhausts all the input iterables:

>>>fromitertoolsimportchain>>>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 callchain(), you get an iterator of the items from the input iterables. In this example, you access successive items fromnumbers usingnext(). If you want to work with a list instead, then you can uselist() to consume the iterator and return a regular Python list.

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

>>>fromitertoolsimportchain>>>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 withchain(), you need to use theiterable unpacking operator (*). This operator unpacks all the input iterables so thatchain() can work with them and generate the corresponding iterator. The final step is to calllist() to build the desired flat list.

Concatenating Strings Withstr.join()

As you’ve already seen,sum() doesn’tconcatenate or join strings. If you need to do so, then the preferred and fastest tool available in Python isstr.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 fromgreeting are separated by spaces in your final string.