Comparing 2 Lists in Python: Different Methods for Equality Checks

Introduction

When working with Python, comparing lists to check if they are equal is a common task. This involves verifying not only that both lists contain the same elements but also that they are arranged in the same order, unless order doesn’t matter for your specific use case. Lists of differing lengths are immediately considered unequal.

This article explores several Python methods to compare lists effectively, catering to different scenarios and preferences. We will cover techniques using:

• The sort() method or the sorted() function with the equality operator (==)
• The set() function with the equality operator (==)
• The collections.Counter() class with the equality operator (==)
• List comprehensions
• Combining reduce() and map() functions

By the end of this guide, you’ll understand the strengths and weaknesses of each method, enabling you to choose the most appropriate approach for your Python projects.

Using sort() or sorted() for Ordered List Comparison

One straightforward approach to compare lists for equality, especially when the order of elements doesn’t initially match, is to sort them first. Python provides two primary ways to sort lists: the sort() method and the sorted() function.

The sort() method operates in-place, meaning it modifies the original list directly. On the other hand, sorted() returns a new sorted list, leaving the original list unchanged. After sorting, if two lists are equal, they will contain identical elements in the same positions. The == operator then performs an element-wise comparison, checking for equality at each index.

This method is particularly useful when you need to compare lists where the element order might vary but the content should be the same.

Important Note: Both sort() and sorted() require that the lists being sorted contain elements of comparable data types. Mixing data types that cannot be ordered will result in a TypeError.

Example with sort() Method

The following code demonstrates how to use the sort() method to prepare lists for comparison:

l1 = [10, 20, 30, 40, 50]
l2 = [20, 30, 50, 40, 70]
l3 = [50, 10, 30, 20, 40]

l1.sort()
l2.sort()
l3.sort()

if l1 == l2:
    print("The lists l1 and l2 are the same")
else:
    print("The lists l1 and l2 are not the same")

if l1 == l3:
    print("The lists l1 and l3 are the same")
else:
    print("The lists l1 and l3 are not the same")

Output:

The lists l1 and l3 are the same
The lists l1 and l2 are not the same

In this example, l1 and l3 become equal after sorting because they contain the same elements, regardless of their initial order. l2, however, differs in content and thus remains unequal to l1 even after sorting.

Example with sorted() Function

Alternatively, you can use the sorted() function if you need to preserve the original lists. Here’s how:

l1 = [10, 20, 30, 40, 50]
l2 = [20, 30, 50, 40, 70]
l3 = [50, 10, 30, 20, 40]

l1_sorted = sorted(l1)
l2_sorted = sorted(l2)
l3_sorted = sorted(l3)

if l1_sorted == l2_sorted:
    print("The lists l1 and l2 are the same")
else:
    print("The lists l1 and l2 are not the same")

if l1_sorted == l3_sorted:
    print("The lists l1 and l3 are the same")
else:
    print("The lists l1 and l3 are not the same")

Output:

The lists l1 and l3 are the same
The lists l1 and l2 are not the same

The output is identical to the sort() method example, but the original lists l1, l2, and l3 remain unchanged. This is beneficial when you need to use the lists in their original order later in your program.

Comparing Lists Ignoring Order with set()

If the order of elements in the lists is not significant for your comparison, using Python sets provides an efficient and concise solution. Sets, by definition, are unordered collections of unique elements. Converting lists to sets and then comparing them using the == operator checks if they contain the same elements, irrespective of their original order and duplicates.

Important Note: Sets only store unique elements. If your lists contain duplicates and you need to consider them for equality, the set() method might not be suitable. Consider collections.Counter() for duplicate-aware unordered comparison.

l1 = [10, 20, 30, 40, 50]
l2 = [50, 10, 30, 20, 40]
l3 = [10, 20, 20, 30, 40] # List with duplicate

set_l1 = set(l1)
set_l2 = set(l2)
set_l3 = set(l3)

if set_l1 == set_l2:
    print("Lists l1 and l2 are equal (ignoring order)")
else:
    print("Lists l1 and l2 are not equal (ignoring order)")

if set_l1 == set_l3:
    print("Lists l1 and l3 are equal (ignoring order)")
else:
    print("Lists l1 and l3 are not equal (ignoring order)")

Output:

Lists l1 and l2 are equal (ignoring order)
Lists l1 and l3 are not equal (ignoring order)

As demonstrated, l1 and l2 are considered equal as sets because they have the same unique elements. However, l1 and l3 are not equal as sets because l3 after converting to set loses the duplicate 20, making its set representation different from l1.

Using collections.Counter() for Unordered Comparison with Duplicates

When you need to compare lists while disregarding order but considering the frequency of each element (including duplicates), the collections.Counter() class is the ideal tool. Counter() creates a dictionary-like object that counts the occurrences of each item in a list. Comparing Counter objects for equality effectively checks if the lists have the same elements with the same frequencies, regardless of their order.

import collections

l1 = [10, 20, 30, 40, 50]
l2 = [20, 30, 50, 40, 70]
l3 = [50, 20, 30, 40, 10]
l4 = [10, 20, 20, 30, 50] # List with duplicate

counter_l1 = collections.Counter(l1)
counter_l2 = collections.Counter(l2)
counter_l3 = collections.Counter(l3)
counter_l4 = collections.Counter(l4)

if counter_l1 == counter_l2:
    print("Lists l1 and l2 are the same (unordered, with counts)")
else:
    print("Lists l1 and l2 are not the same (unordered, with counts)")

if counter_l1 == counter_l3:
    print("Lists l1 and l3 are the same (unordered, with counts)")
else:
    print("Lists l1 and l3 are not the same (unordered, with counts)")

if counter_l1 == counter_l4:
    print("Lists l1 and l4 are the same (unordered, with counts)")
else:
    print("Lists l1 and l4 are not the same (unordered, with counts)")

Output:

Lists l1 and l2 are not the same (unordered, with counts)
Lists l1 and l3 are the same (unordered, with counts)
Lists l1 and l4 are not the same (unordered, with counts)

Here, l1 and l3 are deemed equal by Counter because they contain the same elements with the same counts. l2 is different due to different elements, and l4 is different from l1 because of the duplicate ’20’ in l4, which changes the element counts.

List Comprehension for Conditional Comparison

List comprehensions offer a more manual, element-wise comparison approach. You can use them to create a new list containing elements that are present in one list but not in the other. If the resulting list is empty, it implies the original lists are equal in terms of content, although this method is generally less efficient for direct equality checking than the == operator on sorted lists or sets.

l1 = [10, 20, 30, 40, 50]
l2 = [50, 75, 30, 20, 40]
l3 = [50, 20, 30, 40, 10]

res_l1_l2 = [x for x in l1 + l2 if x not in l1 or x not in l2]
if not res_l1_l2:
    print("Lists l1 and l2 are equal (list comprehension)")
else:
    print("Lists l1 and l2 are not equal (list comprehension)")

res_l1_l3 = [x for x in l1 + l3 if x not in l1 or x not in l3]
if not res_l1_l3:
    print("Lists l1 and l3 are equal (list comprehension)")
else:
    print("Lists l1 and l3 are not equal (list comprehension)")

Output:

Lists l1 and l2 are not equal (list comprehension)
Lists l1 and l3 are not equal (list comprehension)

Note: The provided list comprehension example in the original article is not correctly designed for checking list equality. It identifies elements that are unique to either list, not elements that are different between the lists. For accurate equality comparison using list comprehension, a more complex approach would be needed to compare elements at each index, which negates the simplicity list comprehensions are intended for in this context. For direct equality, simpler methods like == are preferred.

Corrected List Comprehension for Ordered Comparison (Less Efficient):

For ordered comparison using list comprehension (though less efficient than direct ==):

l1 = [10, 20, 30]
l2 = [10, 20, 30]
l3 = [10, 30, 20]

if all(l1[i] == l2[i] for i in range(len(l1))) and len(l1) == len(l2):
    print("l1 and l2 are equal (ordered, list comprehension)")
else:
    print("l1 and l2 are not equal (ordered, list comprehension)")

if all(l1[i] == l3[i] for i in range(len(l1))) and len(l1) == len(l3):
    print("l1 and l3 are equal (ordered, list comprehension)")
else:
    print("l1 and l3 are not equal (ordered, list comprehension)")

Output:

l1 and l2 are equal (ordered, list comprehension)
l1 and l3 are not equal (ordered, list comprehension)

This corrected example iterates through indices and checks element-wise equality, but it’s less readable and efficient than simply using l1 == l2.

Using reduce() and map() for Element-wise Comparison

The map() and functools.reduce() functions can be combined for a functional approach to list comparison. map() applies a comparison function element-wise across the lists, and reduce() then aggregates these boolean results to determine overall equality.

Important Note: This method, as implemented in the original article, relies on element order for comparison. Lists with the same elements in a different order will be considered unequal.

import functools

l1 = [10, 20, 30, 40, 50]
l2 = [20, 30, 50, 40, 70]
l3 = [10, 20, 30, 40, 50]

if functools.reduce(lambda x, y: x and y, map(lambda p, q: p == q, l1, l2), True):
    print("Lists l1 and l2 are the same (reduce & map)")
else:
    print("Lists l1 and l2 are not the same (reduce & map)")

if functools.reduce(lambda x, y: x and y, map(lambda p, q: p == q, l1, l3), True):
    print("Lists l1 and l3 are the same (reduce & map)")
else:
    print("Lists l1 and l3 are not the same (reduce & map)")

Output:

Lists l1 and l2 are not the same (reduce & map)
Lists l1 and l3 are the same (reduce & map)

map(lambda p, q: p == q, l1, l2) generates a sequence of boolean values indicating element-wise equality. functools.reduce(lambda x, y: x and y, ..., True) then effectively performs an “AND” operation on this sequence. If all element-wise comparisons are true, reduce returns True, indicating list equality. The True argument to reduce is the initializer, used when the iterable is empty (though lists being compared are unlikely to be empty in this context).

Conclusion

This article has detailed several methods for comparing two lists in Python, each suited for different scenarios:

• sort() or sorted() with ==: For ordered comparison after rearranging elements.
• set() with ==: For unordered comparison, ignoring duplicates and order.
• collections.Counter() with ==: For unordered comparison, considering element frequencies (duplicates).
• List Comprehension (Corrected): While possible, less efficient and readable for direct equality checks compared to simpler methods. Best used for more complex conditional list creation based on comparisons.
• reduce() and map(): Functional approach for ordered, element-wise comparison.

The most efficient and Pythonic way to check for ordered equality is usually the direct == comparison. For unordered equality, set() or collections.Counter() offer clear and efficient solutions depending on whether you need to account for element counts. Choose the method that best aligns with your specific comparison requirements and coding style.

Continue exploring Python’s list manipulation capabilities and other helpful features to enhance your programming skills.

For further learning, explore more Python tutorials.

Thanks for learning with compare.edu.vn!

About the authors:

Safa Mulani, Content Contributor

Andrea Anderson, Technical Reviewer