# 5 Best Ways to Find the Intersection of Multiple Lists in Python

Rate this post

π‘ Problem Formulation: Finding the intersection of multiple lists in Python involves determining the common elements among them. For instance, if the input lists are `[1, 2, 3]`, `[2, 3, 4]`, and `[3, 4, 5]`, the desired output is `[3]`, which is the element common to all lists.

## Method 1: Using Set Intersection

This method utilizes the built-in set data structure in Python to perform an intersection operation. Set intersections can efficiently compute common elements in lists by first converting the lists to sets and then using the `set.intersection()` method. It’s optimized for such operations and is ideal for accomplishing our goal.

Here’s an example:

```list1 = [1, 2, 3]
list2 = [2, 3, 4]
list3 = [3, 4, 5]

common_elements = set(list1).intersection(list2, list3)
print(common_elements)
```

Output: `{3}`

In the code snippet above, we first convert list1 to a set and then call the `.intersection()` method on it, passing the other two lists, list2 and list3, as arguments. The method returns a new set containing only the elements found in all the lists, which is then printed.

## Method 2: Using the reduce() Function

The `reduce()` function from the `functools` module can be applied to cumulatively perform intersections across a collection of lists. It’s useful when the number of lists is not known in advance or when pursuing a more functional programming approach.

Here’s an example:

```from functools import reduce

list1 = [1, 2, 3]
list2 = [2, 3, 4]
list3 = [3, 4, 5]
lists = [list1, list2, list3]

common_elements = reduce(lambda x, y: set(x) & set(y), lists)
print(common_elements)
```

Output: `{3}`

In this example, the `reduce()` function takes a lambda function that performs set intersection and an iterable of lists. It successively applies the lambda to the elements of the list, storing the current intersection result and carrying it on to the next comparison.

## Method 3: Using List Comprehensions

List comprehensions provide a succinct and readable way to create lists in Python. By combining list comprehensions with sets, we can create an intersection of multiple lists. This method is more verbose but can be more readable to those who prefer comprehension syntax.

Here’s an example:

```list1 = [1, 2, 3]
list2 = [2, 3, 4]
list3 = [3, 4, 5]

common_elements = [e for e in list1 if e in list2 and e in list3]
print(common_elements)
```

Output: `[3]`

The above code uses list comprehension to iterate through elements of list1 and checks if each element exists in list2 and list3. The resulting list contains only elements that are present in all the lists.

## Method 4: Using a Custom Function

Creating a custom function to find the intersection of multiple lists allows for greater control over the process, enabling custom logic handling and the potential for optimization specific to the application’s context.

Here’s an example:

```def intersection_of_lists(*lists):
sets = map(set, lists)
common = set.intersection(*sets)
return list(common)

list1 = [1, 2, 3]
list2 = [2, 3, 4]
list3 = [3, 4, 5]
result = intersection_of_lists(list1, list2, list3)

print(result)
```

Output: `[3]`

This custom function, `intersection_of_lists()`, accepts any number of lists, maps them to sets, and then computes the intersection of all these sets. The result is converted back to a list before being returned.

## Bonus One-Liner Method 5: Using Python’s Intersection Operator

For those who prefer concise code, Python’s intersection operator `&` can be used as a one-liner to find common elements among multiple lists, albeit readability might be slightly compromised for those not familiar with set operations.

Here’s an example:

```result = list(set(list1) & set(list2) & set(list3))
print(result)
```

Output: `[3]`

The above one-liner converts the lists into sets and then applies the intersection operator `&` successively to find the common elements. The resulting set is then converted back into a list.

## Summary/Discussion

• Method 1: Set Intersection. Efficient and Pythonic. Doesn’t maintain list order.
• Method 2: Using the reduce() Function. Good for unknown number of lists. Can be less intuitive to read.
• Method 3: List Comprehensions. Easy to read and understand. Not as efficient for large lists.
• Method 4: Custom Function. Allows for flexibility and customization. Requires writing additional code.
• Method 5: Python’s Intersection Operator. Compact one-liner. May not be clear to all readers.