5 Best Ways to Extract Unique Tuples From a Python List

In Python, a common scenario involves handling a list of tuples, where each tuple might contain several elements. Sometimes, it’s necessary to obtain a list of unique tuples, eliminating any duplicates. For example, given a list [('apple', 2), ('banana', 3), ('apple', 2)], the desired output is [('apple', 2), ('banana', 3)]. Here are five effective methods to achieve that.

Method 1: Using a Set

This method involves converting the list of tuples into a set. Since sets cannot have duplicate items, converting the list to a set automatically removes duplicates. Note that this method works only if the elements of the tuples are hashable.

Here’s an example:

input_list = [('apple', 2), ('banana', 3), ('apple', 2)]
unique_tuples = list(set(input_list))
print(unique_tuples)

Output: [('banana', 3), ('apple', 2)]

This simple approach converts the list of tuples input_list into a set, effectively filtering out the duplicates, and then converts it back to a list to obtain unique_tuples.

Method 2: Using Dict.fromkeys()

This method creates a dictionary using Dict.fromkeys() where the tuples are the keys. Since dictionary keys must be unique, any duplicates will be removed. Later, the keys are converted back to a list of tuples.

Here’s an example:

input_list = [('apple', 2), ('banana', 3), ('apple', 2)]
unique_tuples = list(dict.fromkeys(input_list))
print(unique_tuples)

Output: [('apple', 2), ('banana', 3)]

The dictionary dict.fromkeys(input_list) is created with list items as keys; as a result, duplicates are removed. The keys are collected back into a list with list(), ensuring the uniqueness of the tuples.

Method 3: Using Collections.OrderedDict

For preserving the order of elements, we can use collections.OrderedDict. Similar to method 2, it removes duplicates while keeping the initial order intact.

Here’s an example:

from collections import OrderedDict
input_list = [('apple', 2), ('banana', 3), ('apple', 2)]
unique_tuples = list(OrderedDict.fromkeys(input_list))
print(unique_tuples)

Output: [('apple', 2), ('banana', 3)]

By using OrderedDict.fromkeys(input_list), the original order is preserved, and the elements are de-duplicated. The result unique_tuples is a list of the unique tuples in their original order.

Method 4: Loop With Condition

Those looking for a more traditional approach might prefer iterating over the list and appending tuples that are not already in the new list.

Here’s an example:

input_list = [('apple', 2), ('banana', 3), ('apple', 2)]
unique_tuples = []
for t in input_list:
    if t not in unique_tuples:
        unique_tuples.append(t)
print(unique_tuples)

Output: [('apple', 2), ('banana', 3)]

This code iterates through input_list and checks if each tuple t is not already in the list unique_tuples. If it’s not, it gets appended, ensuring all tuples are unique.

Bonus One-Liner Method 5: List Comprehension and a Set

This one-liner combines a list comprehension with a set to keep track of added items, providing a compact and Pythonic solution.

Here’s an example:

input_list = [('apple', 2), ('banana', 3), ('apple', 2)]
unique_tuples = []
{unique_tuples.append(t) for t in input_list if t not in unique_tuples}
print(unique_tuples)

Output: [('apple', 2), ('banana', 3)]

This one-liner uses a set comprehension to iterate over input_list and conditionally append items to unique_tuples only if they haven’t been added before.

Summary/Discussion

• Method 1: Converting to a set. Strengths: Simple and quick for hashable tuple elements. Weaknesses: Does not preserve order of elements.
• Method 2: Using dict.fromkeys(). Strengths: Quick and maintains the order since Python 3.7+. Weaknesses: Can be less readable to those unfamiliar with dictionaries.
• Method 3: Using OrderedDict.fromkeys(). Strengths: Preserves order and is explicit about it. Weaknesses: Slightly more verbose and slower than using a standard dict in Python 3.7+.
• Method 4: Loop with condition. Strengths: Very explicit, easy to understand. Weaknesses: Least efficient, particularly for large lists.
• Method 5: One-Liner with list comprehension and a set. Strengths: Compact and Pythonic. Weaknesses: Could be confusing to beginners and considered less readable by some.