# How to Get the Cartesian Product of Multiple Lists

## Introduction

The Cartesian product of multiple lists refers to obtaining every possible combination of values from those lists. For example, if we have three lists A, B, and C, the Cartesian product would consist of every possible triplet formed by taking one element from each list.

## Problem Description

Let's consider an example where we have multiple lists:

` ````
somelists = [
[1, 2, 3],
['a', 'b'],
[4, 5]
]
```

We need to find all the possible combinations of values from these lists.

## Approach using Itertools

To solve this problem, we can make use of the itertools module in Python. The itertools.product() function allows us to find the Cartesian product of any number of iterables.

` ````
import itertools
somelists = [
[1, 2, 3],
['a', 'b'],
[4, 5]
]
cartesian_product = list(itertools.product(*somelists))
print(cartesian_product)
```

The output of the above code will be:

` ``[(1, 'a', 4), (1, 'a', 5), (1, 'b', 4), (1, 'b', 5), (2, 'a', 4), (2, 'a', 5), ...]`

## Explanation

Let's break down the solution step-by-step:

- We import the itertools module, which provides various functions for efficient iteration.
- We define the list somelists, containing all the input lists.
- We use the * operator to unpack the list somelists as separate arguments for the itertools.product() function. This allows us to pass each list as an individual argument.
- We call the itertools.product() function, passing in the unpacked lists, to obtain an iterator of the Cartesian product.
- We convert the iterator to a list using the list() function.
- We print the Cartesian product.

## Alternative Approaches

While the above approach using itertools is the most efficient and concise way to obtain the Cartesian product, there are alternative approaches as well.

### Using Nested Loops

We can also solve this problem by using nested loops. This approach is simpler to understand but may not be as efficient as the itertools approach, especially for larger lists.

` ````
somelists = [
[1, 2, 3],
['a', 'b'],
[4, 5]
]
cartesian_product = []
for item1 in somelists[0]:
for item2 in somelists[1]:
for item3 in somelists[2]:
cartesian_product.append((item1, item2, item3))
print(cartesian_product)
```

## Conclusion

Obtaining the Cartesian product of multiple lists is a common task in programming, especially in scenarios where we need to generate all possible combinations of values. By using the itertools module in Python, we can efficiently solve this problem and avoid complex nested loops.

Remember to import the itertools module and use the itertools.product() function to obtain the Cartesian product. Alternatively, you can also use nested loops, although this approach may be less efficient for larger lists.