 # how to check if two lists of tuples are identical

• Last Update :
• Techknowledgy :

The tuples are checked for being identical using the '==' operator.,Two list of tuples are defined, and are displayed on the console.,When it is required to check if two list of tuples are identical, the '==' operator is used.,A list can be used to store heterogeneous values (i.e data of any data type like integer, floating point, strings, and so on).

```my_list_1 = [(11, 14), (54, 58)]
my_list_2 = [(98, 0), (10, 13)]

print("The first list of tuple is : ")
print(my_list_1)
print("The second list of tuple is : ")
print(my_list_2)

my_result = my_list_1 == my_list_2

print("Are the list of tuples identical?")
print(my_result)```

## Output

```The first list of tuple is: [(11, 14), (54, 58)]
The second list of tuple is: [(98, 0), (10, 13)]
Are the list of tuples identical ?
False```

Suggestion : 2

Last Updated : 11 Nov, 2019

```The original list 1: [(10, 4), (2, 5)]
The original list 2: [(10, 4), (2, 5)]
Are tuple lists identical ? : True```

Suggestion : 3

Instead, we can iterate through both lists with an index. This will allow us to perform operations on each element of the two lists simultaneously. Here's an example:

```def compare_lists(list1, list2):
# Let 's initialize our index to the first element
# in any list: element #0.
i = 0

# And now we walk through the lists.We have to be
# careful that we do not walk outside the lists,
# though...
while i < len(list1) and i < len(list2):
if list1[i] != list2[i]:
# If any two elements are not equal, say so.
return False

# We made it all the way through at least one list.
# However, they may have been different lengths.We
# should check that the index is at the end of both
# lists.
if i != (len(list1) - 1) or i != (len(list2) - 2):
# The index is not at the end of one of the lists.
return False

# At this point we know two things:
# 1. Each element we compared was equal.
# 2. The index is at the end of both lists.
# Therefore, we compared every element of both lists
# and they were equal.So we can safely say the lists
# are in fact equal.
return True```

That said, this is such a common thing to check for that Python has this functionality built in through the quality operator, `==`. So it's much easier to simply write:

`list1 == list2`

If you want to check if a list is sorted or not a very simple solution comes to mind:

```last_elem, is_sorted = None, True
for elem in mylist:
if last_elem is not None:
if elem < last_elem:
is_sorted = False
break
last_elem = elem```

If you still want to do it that way, here's another method:

```list1 = [(1, 2), (4, 6), (3, 10)]
sortedlist1 = sorted(list1, reverse = True)
all_equal = all(i == j
for i, j in zip(list1, sortedlist1))```

In `python 3.x`, you can check if two lists of tuples `a` and `b` are equal using the `eq` operator

```import operator

a = [(1, 2), (3, 4)]
b = [(3, 4), (1, 2)]
# convert both lists to sets before calling the eq
function
print(operator.eq(set(a), set(b))) #True```

Use this:

`sorted(list1) == sorted(list2)`

Suggestion : 4

In this problem, we are given two lists of tuples consisting of integer values. Our task is to create a Python program to check if the two lists of tuples are identical or not. Submitted by Shivang Yadav, on January 13, 2022 ,Python program to check if the element is present in tuple,Using this result we can check if both tuple lists are identical or not.,Python program to check if the given tuple is a true record or not

Example:

`tuple = ("python", "includehelp", 43, 54.23)`

We are given two tuple lists consisting of integer elements. We need to create a Python program to check whether the given tuple lists are identical i.e. consist of the same set of elements and the same position or not. And return true or false accordingly.

```Input:
tupList1 = [(2, 9), (5, 6)];
tupList2 = [(2, 9), (5, 6)]
Output:
true

Input:
tupList1 = [(2, 9), (5, 6)];
tupList2 = [(1, 5), (5, 6)]
Output:
false```

One method that can accomplish that task is using the equality operator '=='. It returns a boolean value based on the equality of the two collections in python.

```# Python program to check
if two lists of
# tuples are identical or not

# Initializing and printing list of tuples
tupList1 = [(10, 4), (2, 5)]
tupList2 = [(10, 4), (2, 5)]
print("The elements of tuple list 1 : " + str(tupList1))
print("The elements of tuple list 2 : " + str(tupList2))

# Checking
for identical tuple
isIdentical = tupList1 == tupList2

if (isIdentical):
print("Both Tuple Lists are identical.")
else:
print("Both Tuple Lists are not identical.")```

Note: The cmp() method is supported in Python 2.

```# Python program to check
if two lists of
# tuples are identical or not

# Initializing and printing list of tuples
tupList1 = [(10, 4), (2, 5)]
tupList2 = [(10, 4), (2, 5)]
print("The elements of tuple list 1 : " + str(tupList1))
print("The elements of tuple list 2 : " + str(tupList2))

# Checking
for identical tuple
isNotIdentical = cmp(tupList1, tupList2)

if (not isNotIdentical):
print("Both Tuple Lists are identical.")
else:
print("Both Tuple Lists are not identical.")```

Suggestion : 5

We can create two sorted numpy arrays from our lists and then we can compare them using numpy.array_equal() to check if both contains same elements. For example, ,In this article we will discuss 8 different ways to check if two lists are equal or not.,Suppose we have two lists and we want to check if both the lists are equal or not. There can be two meanings of 2 equality here,,map() function applies the given lambda function to each element of both the lists and stores the result to a new array. Which in our case will be a bool array because inside the lambda function we are checking if both the elements are equal or not.

Suppose we have two lists,

```first_list = [10, 10, 11, 12, 12, 13, 14, 16, 15, 16, 12]
sec_list = [16, 12, 13, 14, 15, 16, 10, 11, 12, 10, 12]```

We can create sorted versions of both the lists. If original lists contain the same elements but in different order, then the order of elements must be similar in sorted versions of the lists. So, by comparing sorting versions of lists we can find out if lists are equal or not. For example,

```def check_if_equal(list_1, list_2):
""
" Check if both the lists are of same length and if yes then compare
sorted versions of both the list to check
if both of them are equal
i.e.contain similar elements with same frequency.
""
"
if len(list_1) != len(list_2):
return False
return sorted(list_1) == sorted(list_2)```

```first_list = [10, 10, 11, 12, 12, 13, 14, 16, 15, 16, 12]
sec_list = [16, 12, 13, 14, 15, 16, 10, 11, 12, 10, 12]

if check_if_equal(first_list, sec_list):
print('Lists are equal i.e. contain similar elements with same frequency')
else:
print('Lists are not equal')```

For example,

```import collections

def check_if_equal_2(list_1, list_2):
""
" Check if both the lists are of same length and then get the frequency of each element in list using collections.Counter.Then Compare
if both the Counter
objects are equal or not to confirm
if lists contain similar elements with same frequency ""
"
if len(list_1) != len(list_2):
return False
return collections.Counter(list_1) == collections.Counter(list_2)

first_list = [10, 10, 11, 12, 12, 13, 14, 16, 15, 16, 12]
sec_list = [16, 12, 13, 14, 15, 16, 10, 11, 12, 10, 12]

if check_if_equal_2(first_list, sec_list):
print('Lists are equal i.e. contain similar elements with same frequency')
else:
print('Lists are not equal')```

We can create two sorted numpy arrays from our lists and then we can compare them using numpy.array_equal() to check if both contains same elements. For example,

```import numpy as np

first_list = [10, 10, 11, 12, 12, 13, 14, 16, 15, 16, 12]
sec_list = [16, 12, 13, 14, 15, 16, 10, 11, 12, 10, 12]

# Convert both lists to sorted numpy arrays, then compare
# them to check
if both are equal or not
result = np.array_equal(np.array(first_list).sort(), np.array(sec_list).sort())

if result:
print('Lists are equal i.e. contain similar elements with same frequency')
else:
print('Lists are not equal')```

Suggestion : 6

Short answer: The most Pythonic way to check if two ordered lists l1 and l2 are identical, is to use the l1 == l2 operator for element-wise comparison. If all elements are equal and the length of the lists are the same, the return value is True. ,Short answer: The most Pythonic way to compute the difference between two lists l1 and l2 is the list comprehension statement [x for x in l1 if x not in set(l2)]. This works even if you have duplicate list entries, it maintains the original list ordering, and it’s efficient due to the constant runtime complexity of the set membership operation.,You can use list comprehension to go over all elements in the first list but ignore them if they are in the second list:,Let’s discuss the most Pythonic ways of accomplishing these problems. We start with five ways to perform the Boolean comparison and look at five ways to perform the simple difference, next.

```l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]

# 1. Boolean Comparison
result = False

# 2. Difference
result = [4, 5]```

Examples:

```l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
# compare(l1, l2) -- > False

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3, 5, 4]
# compare(l1, l2) -- > False

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3, 4, 5]
# compare(l1, l2) -- > True```

Not always is the simplest method the best one. But for this particular problem, it is! The equality operator `==` compares a list element-wise—many Python coders don’t know this!

```# 1. Simple Comparison
def method_1(l1, l2):
return l1 == l2

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print(method_1(l1, l2))
# False```

Let’s see how you can use the function to make the previous code more concise:

```# 3. Zip + For Loop
def method_3(l1, l2):
for x, y in zip(l1, l2):
if x != y:
return False
return len(l1) == len(l2)

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print(method_3(l1, l2))
# False```
• You first create an iterable of Boolean values using the generator expression `x == y for x, y in zip(l1, l2)`.
• Then, you sum up over the Boolean values (another trick of pro coders) to find the number of elements that are the same and store it in variable `num_equal`.
• Finally, you compare this with the length of both lists. If all three values are the same, both lists have the same elements and their length is the same, too. They are equal!
```# 4. Sum + Zip + Len
def method_4(l1, l2):
num_equal = sum(x == y
for x, y in zip(l1, l2))
return num_equal == len(l1) == len(l2)

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print(method_4(l1, l2))
# False

print(method_4([1, 2], [1, 2]))
# True```

Suggestion : 7

The comparison operators can be used with tuples and other sequences. Python starts by comparing the first element from each sequence. If they are equal, it compares the next element of each, and so on, until it finds elements that differ. Subsequent elements are not considered (even if they’re really big).,Incorrect! Remember, the comparison operator starts by comparing just the first element of the two tuples, and only moves on if they're equal. Try again.,Decorate a sequence by building a list of tuples with one or more sort metrics preceding the elements from the sequence.,A sequence by building a list of tuples with one or more sort metrics preceding the elements from the sequence.

```(0, 1, 2) < (0, 3, 4) >>>
True
(0, 1, 2000000) < (0, 3, 4) >>>
True```
`(5, 7, 3) < (7, 4, 2)`
`['yonder', 'window', 'breaks', 'light', 'what', 'soft', 'but', 'in']`
```        word_list = ['pen', 'skyscraper', 'post', 'computer', 'apple', 'Hollywood']
tup_list = []
sorted_word_list = []
-- -
for word in word_list:
-- -
tup = len(word), word
-- -
tup_list.append(tup)
-- -
tup_list.sort(reverse = True)
-- -
tup_list.sort() #paired
-- -
for length, word in tup_list:
-- -
sorted_word_list.append(word)```

Suggestion : 8

sometimes we might want to get the difference between two lists,maybe we need to compare two lists and return the elements that intersect both,In the example below, we have two multidimensional lists that we want to compare. When passed to DeepDiff, it returns the exact location in which the elements differ.,The result is an empty dict, which means the lists are equal. If we try comparing a list with a float number that differs in more than 3 significant digits, the library will return that diff.

An example of a simple case would be a list of `int` or `str` objects.

```>>> numbers = [1, 2, 3] >>>
target = [1, 2, 3] >>>
numbers == target
True
>>>
[1, 2, 3] == [1, 3, 2]
False
>>>
['name', 'lastname'] == ['name', 'lastname']
True
>>>
['name', 'lastname'] == ['name', 'last name']
False```

Suppose you have a list of floating points that is built dynamically. You can add single elements, or elements derived from a mathematical operation such as `0.1 + 0.1`.

```>>> numbers = [] >>>
numbers.append(0.1 + 0.1 + 0.1) # derive the element based on a summation >>>
numbers.append(0.2) # add a single element >>>
target = [0.3, 0.2] >>>
numbers == target # compares the lists
False
>>>
numbers # Ooopppssss....
[0.30000000000000004, 0.2] >>>
target[0.3, 0.2]```

Things can get more complicated if the lists have custom objects or objects from other libraries, such as `numpy`.

```In : import numpy as np

In : numbers = [np.ones(3), np.zeros(2)]

In : numbers
Out: [array([1., 1., 1.]), array([0., 0.])]

In : target = [np.ones(3), np.zeros(2)]

In : numbers == target
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()```

For reproducibility, in this article I used the latest version of `deepdiff` which is `5.6.0`.

```In: from deepdiff
import DeepDiff

In: numbers = []

In: numbers.append(0.1 + 0.1 + 0.1) # derive the element based on a summation

In: numbers.append(0.2) # add a single element

In: target = [0.3, 0.2]

#
if we don 't specify the number of significant digits, the comparison will use ==
In: DeepDiff(numbers, target)
Out: {
'values_changed': {
'root': {
'new_value': 0.3,
'old_value': 0.30000000000000004
}
}
}

# 0.30000000000000004 and 0.3 are equal
if we only look at the first 3 significant digits
In: DeepDiff(numbers, target, significant_digits = 3)
Out: {}

In: numbers
Out: [0.30000000000000004, 0.2]

In: target = [0.341, 0.2]

# 0.341 differs in more than 3 significant digits
In: DeepDiff(numbers, target, significant_digits = 3)
Out: {
'values_changed': {
'root': {
'new_value': 0.341,
'old_value': 0.30000000000000004
}
}
}```

Let's see how it works.

```In: numbers = [10, 30, 20]

In: target = [10, 20, 30]

In: numbers == target
Out: False

In: sorted(numbers) == sorted(target)
Out: True

In: sorted(numbers)
Out: [10, 20, 30]

In: sorted(target)
Out: [10, 20, 30]```