Summary: The most pythonic approach to add two lists element-wise is to use zip() to pair the elements at the same positions in both lists and then add the two elements. Here’s a quick look at the solution: [x + y for x, y in zip(li_1, li_2)]. An alternate proposition to this without using zip: [li_1[i]+li_2[i] for i in range(len(li_smaller))]

---

Problem Formulation

Problem Statement: Given two lists, how will you add the two lists element-wise?

Example: Consider that you have the following lists:

Input:
li_1 = [2,4,6]
li_2 = [1,3,5] Expected Output:
[3,7,11]

Challenge: How will you perform an element-wise addition of the two lists as shown below:

Solution 1: The Naive Approach

Approach:

• The basic solution to this problem is to find out the length of the smaller list.
• Then use a for loop to iterate across all the items of each list. Note that the range of iteration will be determined by the length of the smaller list.
• In every iteration, select an element from each list with the help of its index and then add them up.
• You can store the output generated in each iteration within another list and finally display the resultant list as an output.

Code:

# Given Lists

li_1 = [2, 4, 6]

li_2 = [1, 3, 5, 15]

res = [] # resultant list to store the output # Find the smaller list

li_smaller = li_1 if len(li_2) > len(li_1) else li_2 for i in range(len(li_smaller)): # add each item from each list one by one res.append(li_1[i] + li_2[i])

print(res)

Output:

[3, 7, 11]

The above solution can further be compressed with the help of a list comprehension, as shown below:

# Given Lists

li_1 = [2, 4, 6]

li_2 = [1, 3, 5, 15] # Find the smaller list

li_smaller = li_1 if len(li_2) > len(li_1) else li_2 res = [li_1[i]+li_2[i] for i in range(len(li_smaller))]

print(res)

Let’s try to understand the working principle behind the list comprehension used in the above snippet.

The first part is the expression. In the above snippet, li_1[i]+li_2[i] is the expression that denotes the element-wise addition of the two lists. The second part represents the context which represents the counter variable i that ranges from 0 until the length of the smaller list. It is basically keeping track of the index of each element in the lists.

Solution 2: Using zip and List Comprehension

Approach: A more pythonic solution to the given problem is to pass both the lists into the zip() method. This returns a tuple consisting of elements in pairs that are at the same position in each list. Once you get the pair of elements, you can simply add them up. All of this can be performed within a list comprehension.

Code:

li_1 = [2, 4, 6]

li_2 = [1, 3, 5, 15]

res = [x + y for x, y in zip(li_1, li_2)]

print(res) # OUTPUT: [3, 7, 11]

An advantage of using this approach over the previous solution is not only is it a more pythonic way of adding the two lists, but it also eliminates the necessity to explicitly find out the length of the smaller list in case the two lists have different lengths.

A Quick Recap to Zip():

The zip() function takes an arbitrary number of iterables and aggregates them to a single iterable, a zip object. It combines the i-th values of each iterable argument into a tuple. Hence, if you pass two iterables, each tuple will contain two values. If you pass three iterables, each tuple will contain three values. For example, zip together lists [1, 2, 3] and [4, 5, 6] to [(1,4), (2,5), (3,6)].
Read More: Python Zip — A Helpful Illustrated Guide

Finding Sum of Two Lists Element-wise for list of lists

li = [[1, 2, 3], [4, 5, 6]]

res = [a + b for a, b in zip(*li)]

print(res) # [5, 7, 9]

Solution 3: Using map() and add()

Prerequisites:

Python facilitates us with many predefined functions for numerous mathematical, logical, relational, bitwise etc operations. These functions are contained within the operator module. One such function is add(a,b), which returns the result of the addition of the two arguments, i.e., a+b.

The map() function transforms one or more iterables into a new one by applying a “transformator function” to the i-th elements of each iterable. The arguments are the transformator function object and one or more iterables. If you pass n iterables as arguments, the transformator function must be an n-ary function taking n input arguments. The return value is an iterable map object of transformed, and possibly aggregated, elements.

Approach: Pass the input lists and the add() function within the built-in method map(). The add() method will simply add the elements of the two lists and then return an iterable. This iterable can then be converted to a list using the list constructor.

Code:

from operator import add

li_1 = [2, 4, 6]

li_2 = [1, 3, 5, 15]

res = list(map(add, li_1, li_2))

print(res)

Output:

[3, 7, 11]

Finding Sum of Two Lists Element-wise for Unknown Number of Lists of Same Length

def sum_li(*args): return list(map(sum, zip(*args))) res = sum_li([1, 2, 3], [4, 5, 6], [7, 8, 9])

print(res) # [12, 15, 18]

Method 4: Using zip_longest from Itertools Module

Until now, all the solutions considered the length of the smaller list. What if you want to add the elements considering the length of the larger list. In other words, consider the following scenario:

Given:

li_1 = [2, 4, 6]
li_2 = [1, 3, 5, 15]

Expected Output:

[3, 7, 11, 15]

Approach: To deal with this scenario, you can use the zip_longest method of the itertools module. Not only will this method group the elements at the same position in each list, but it also allows you to take the remaining elements of the longer list into consideration.

• Pass the two lists within the zip_longest() function and assign 0 the fillvalue parameter.
• If all the items from the smaller list get exhausted, then the remaining values will be filled by the value that has been assigned to the fillvalue parameter.
• Finally, perform the addition of elements at the same position that have been paired by the zip_longest method using the sum() function.

Code:

from itertools import zip_longest

li_1 = [2, 4, 6]

li_2 = [1, 3, 5, 15]

res = [sum(x) for x in zip_longest(li_1, li_2, fillvalue=0)]

print(res)

Output:

[3, 7, 11, 15]

Method 5: Using Numpy

If you have two lists that have the same length, then using Numpy can be your best bet. There are two ways of implementing the solution that you need. Let’s have a look at them one by one:

The + Operator

You can simply create two numpy arrays from the two lists and then find their sum using the + operator. Easy peasy!

import numpy as np

li_1 = [2, 4, 6]

li_2 = [1, 3, 5]

a = np.array(li_1)

b = np.array(li_2)

print(a+b) # [ 3 7 11]

numpy.add

The alternate formulation to the above solution is to use the numpy.add() method instead of directly using the + operator.

import numpy as np

li_1 = [2, 4, 6]

li_2 = [1, 3, 5]

res = np.add(li_1, li_2)

print(res) # [ 3 7 11]

Conclusion

Phew! We unearthed a wealth of solutions to the given problem. Please feel free to use any solution that suits you. Here’s a general recommendation to use the above approaches:

• Using zip is probably the most pythonic approach when you have simple lists at your disposal.
• In case you do not wish to use zip, you can simply use a list comprehension as discussed in the first solution.
• For lists with different lengths, you may use the zip_longest method to solve your problem.

Happy learning!

Question: Given a list of lists such as [[1, 2], [3, 4]]. How to convert it to a tuple of tuples such as ((1, 2), (3, 4))?

If you’re in a hurry, here’s the most Pythonic way to convert a nested list to a nested tuple:

Use a generator expression with the built-in tuple() function to convert a list of lists to a tuple of tuples like so: tuple(tuple(x) for x in my_list).

Here’s a graphic on how to convert back and forth between nested list and nested tuples:

But there’s more to it! Studying the different methods to achieve the same goal will make you a better coder.

So keep reading!

Method 1: Tuple Comprehension + tuple()

The recommended way to convert a list of lists to a tuple of tuples is using generator expression in combination with the built-in tuple() function like so: tuple(tuple(x) for x in my_list).

Here’s a concrete example:

lists = [[1, 2], [3, 4], [5, 6]]

tuples = tuple(tuple(x) for x in lists) print(tuples)

# ((1, 2), (3, 4), (5, 6))

Try It Yourself:

This approach is simple and effective. The generator expression defines how to convert each inner list (x in the example) to a new tuple element.

You use the constructor tuple(x) to create a new tuple from the list x.

Example Three Elements per Tuple

If you have three elements per list, you can use the same approach with the conversion:

lists = [[1, 2, 1], [3, 4, 3], [5, 6, 5]]

tuples = tuple(tuple(x) for x in lists) print(tuples)

# ((1, 2, 1), (3, 4, 3), (5, 6, 5))

You can see the execution flow in the following interactive visualization (just click the “Next” button to see what’s happening in the code):

Example Varying Number of List Elements

And if you have a varying number of elements per list, this approach still works beautifully:

lists = [[1], [2, 4, 3], [6, 5]]

tuples = tuple(tuple(x) for x in lists) print(tuples)

# ((1,), (2, 4, 3), (6, 5))

You see that an approach with generator expression is the best way to convert a list of lists to a tuple of tuples.

But are there any alternatives? Let’s have a look at a completely different approach to solve this problem:

Method 2: Map Function + list()

Use the map function that applies a specified function on each element of an iterable.

Side Note: Guido van Rossum, the creator of Python, didn’t like the map() function as it’s less readable and less efficient than the generator expression version (Method 1 in this tutorial). You can read about a detailed discussion on how exactly he argued on my blog article.

So, without further ado, here’s how you can convert a list of lists into a tuple of tuples using the map() function:

lists = [[1], [2, 4, 3], [6, 5]]

tuples = tuple(map(tuple, lists)) print(tuples)

# ((1,), (2, 4, 3), (6, 5))

Try it yourself:

Video tutorial on the map() function:

The first argument of the map() function is the tuple function name.

This tuple() function converts each element on the given iterable lists (the second argument) into a tuple.

The result of the map() function is an iterable too, so you need to convert it to a tuple before printing it to the shell because the default string representation of an iterable is not human-readable.

Method 3: Simple For Loop with append() and tuple()

To convert a list of lists to a tuple of tuples, first initialize an empty “outer” list and store it in a variable.

Then iterate over all lists using a simple for loop and convert each separately to a tuple.

Next, append each result to the outer list variable using the list.append() builtin method in the loop body.

Finally, convert the list of tuples to a list tuple of tuples using the tuple() function.

The following example does exactly that:

lists = [[1], [2, 4, 3], [6, 5]] tmp = []

for t in lists: tmp.append(tuple(t))

tuples = tuple(tmp) print(tuples)

# ((1,), (2, 4, 3), (6, 5))

Related Video Tutorial

Related Conversion Articles

• How to Convert a List of Lists to a List of Tuples
• How to Convert a List of Lists to a Pandas Dataframe
• How to Convert a List of Lists to a NumPy Array
• How to Convert a List of Lists to a Dictionary in Python
• How to Convert a Tuple of Tuples to a List of Lists in Python

Where to Go From Here?

Enough theory. Let’s get some practice!

Coders get paid six figures and more because they can solve problems more effectively using machine intelligence and automation.

To become more successful in coding, solve more real problems for real people. That’s how you polish the skills you really need in practice. After all, what’s the use of learning theory that nobody ever needs?

You build high-value coding skills by working on practical coding projects!

Do you want to stop learning with toy projects and focus on practical code projects that earn you money and solve real problems for people?

If your answer is YES!, consider becoming a Python freelance developer! It’s the best way of approaching the task of improving your Python skills—even if you are a complete beginner.

If you just want to learn about the freelancing opportunity, feel free to watch my free webinar “How to Build Your High-Income Skill Python” and learn how I grew my coding business online and how you can, too—from the comfort of your own home.

Join the free webinar now!