# Python: 2 Ways to Find Common Elements in 2 Lists

When working with Python, there might be cases where you want to find all mutual elements in 2 lists to identify shared values, determine overlapping elements, or measure the similarity between them.

This concise, example-based article will walk you through a couple of different ways to retrieve elements that are present in 2 given lists in Python. Weâ€™ll also discuss the performance (time complexity and space complexity) as well as the pros and cons of each approach so you can make an optimal choice for your use case.

## Using set intersection

The main idea of this solution is to convert the lists into sets and then use the `&` operator to find the intersection of the sets, which is the set of common elements.

Example:

``````# Define two lists
list1 = ['dog', 'turtle', 'elephant', 'slingacademy.com']
list2 = ['turtle', 'slingacademy.com', 'giraffe', 'lion']

# Convert the lists into sets
set1 = set(list1)
set2 = set(list2)

# Find the intersection of the sets
common_set = set1 & set2

# Convert the set back into a list if needed
common_list = list(common_set)

# Print the result
print(common_list)``````

Output:

``['turtle', 'slingacademy.com']``

Performance: This approach has a time complexity of `O(n + m)`, where n and m are the lengths of the lists. This is because converting a list into a set takes `O(n)` time, and finding the intersection of two sets takes `O(min(n, m))` time. The space complexity is `O(n + m)` as well, since we need to store two sets and one result set.

• Pros: This code is concise, easy to understand, and fast for large lists.
• Cons: Does not preserve the order of the elements. It also requires the elements to be hashable, which means they cannot be mutable objects like lists or dictionaries.

## Using list comprehension

This approach can be briefly explained in the 2 steps below:

1. Use a list comprehension to iterate over one list (e.g., `list1`) and check if each element is in the other list (e.g., `list2`) using the `in` operator.
2. The result is a new list that contains only the common elements.

Code example:

``````# Define two lists
list1 = ['dog', 'turtle', 'elephant', 'slingacademy.com', [1, 2, 3]]
list2 = ['turtle', 'slingacademy.com', 'giraffe', [1, 2, 3], 'lion']

# Use a list comprehension to find common elements
common_list = [x for x in list1 if x in list2]

# Print the result
print(common_list)``````

Output:

``['turtle', 'slingacademy.com', [1, 2, 3]]``

Performance: This technique has a time complexity of `O(n * m)`, where n and m are the lengths of the lists. This is because, for each element in `list1`, we need to scan through `list2` to check if it is in it. The space complexity is `O(n)`since we need to store a new list that may contain up to `n` elements (in the worst case).

• Cons: This solution is less efficient than using sets, especially for large lists, since the time complexity is `O(n * m)`.