Python | Check if element is present in tuple
Last Updated :
02 May, 2023
Sometimes, while working with data, we can have a problem in which we need to check if the data we are working with has a particular element. Let’s discuss certain ways in which this task can be performed.
Method #1: Using loop
This is a brute force method to perform this task. In this, we iterate through the tuple and check each element if it’s our, if found we return True.
Python3
test_tup = (10, 4, 5, 6, 8)
print("The original tuple : " + str(test_tup))
N = 6
res = False
for ele in test_tup:
if N == ele:
res = True
break
print("Does tuple contain required value ? : " + str(res))
|
Output
The original tuple : (10, 4, 5, 6, 8)
Does tuple contain required value ? : True
Time complexity: O(n)
Auxiliary space: O(n), where n is the length of the tuple.
Method #2: Using in operator
It is used to perform this task. It is a one-liner and recommended to perform this task.
Python3
test_tup = (10, 4, 5, 6, 8)
print("The original tuple : " + str(test_tup))
N = 6
res = N in test_tup
print("Does tuple contain required value ? : " + str(res))
|
Output
The original tuple : (10, 4, 5, 6, 8)
Does tuple contain required value ? : True
Method 3: Using list comprehension method
Python3
t = (10, 4, 5, 6, 8)
n = 6
x = [i for i in t if i == n]
print(["yes" if x else "no"])
|
Method 4: Using lambda function
Python3
t = (10, 4, 5, 6, 8)
n = 6
x = tuple(filter(lambda i: (i == n), t))
print(["yes" if x else "no"])
|
Method 5: Using the enumerate function
Python3
t = ('10', '4', '5', '6', '8')
n = 6
x = [int(i) for i in t if int(i) == n]
print(["yes" if x else "no"])
|
Method 6: Using count() method
Python3
test_tup = (10, 4, 5, 6, 8)
print("The original tuple : " + str(test_tup))
N = 6
res = False
if(test_tup.count(N) >= 1):
res = True
print("Does tuple contain required value ? : " + str(res))
|
Output
The original tuple : (10, 4, 5, 6, 8)
Does tuple contain required value ? : True
Method 7: Using try/except and index:
Python3
test_tup = (10, 4, 5, 6, 8)
print("The original tuple : " + str(test_tup))
N = 6
res = False
try:
test_tup.index(N)
res = True
except ValueError:
pass
print("Does tuple contain required value ? : " + str(res))
|
Output
The original tuple : (10, 4, 5, 6, 8)
Does tuple contain required value ? : True
Time complexity: O(n)
Auxiliary Space : O(1)
Method 8: Using recursion
Python3
def value_present(start, lst, value):
if start == len(lst):
return False
if lst[start] == value:
return True
return value_present(start+1, lst, value)
test_tup = (10, 4, 5, 6, 8)
print("The original tuple : " + str(test_tup))
N = 6
res = value_present(0, test_tup, N)
print("Does tuple contain required value ? : " + str(res))
|
Output
The original tuple : (10, 4, 5, 6, 8)
Does tuple contain required value ? : True
Time complexity: O(n)
Auxiliary Space : O(n)
Method 9: reduce function from functools module:
- Import the reduce function from functools module.
- Define the tuple of strings named ‘t’ and an integer named ‘n’.
- Define a lambda function that takes an accumulator and an element and checks if the element is equal to n.
- If the element is equal to n, then append the integer version of the element to the accumulator, otherwise return the accumulator as it is.
- Pass this lambda function as the function argument to the reduce() function, along with the iterable ‘t’ and an empty list as the initial value of the accumulator.
- The reduce() function returns a list of integers that contain all the elements of ‘t’ that are equal to ‘n’.
- Check if this list is empty or not.
- If the list is not empty, print ‘yes’, otherwise print ‘no’.
Python3
from functools import reduce
t = ('10', '4', '5', '6', '8')
n = 6
print("The original tuple : " + str(t))
x = reduce(lambda acc, i: acc + [int(i)] if int(i) == n else acc, t, [])
if x:
print("True")
else:
print("false")
|
Time complexity: O(n), where n is the length of the tuple t. This is because the reduce() function iterates through the entire tuple once.
Auxiliary Space: O(k), where k is the number of integers in the tuple t that are equal to n. This is because the reduce() function creates a new list with only the integers that are equal to n.
has a context menu.
Method 10: Using numpy:
1. Initialize the tuple of tuples.
2. Convert the tuple of tuples to a NumPy array using np.array().
3. Check if “geeksforgeeks” is in the NumPy array.
4. If “geeksforgeeks” is present, print “geeksforgeeks is present”. Otherwise, print “geeksforgeeks is not present”.
Python3
import numpy as np
test_tuple = (("geeksforgeeks", "gfg"), ("CS_Portal", "best"))
test_array = np.array(test_tuple)
if "geeksforgeeks" in test_array:
print("geeksforgeeks is present")
else:
print("geeksforgeeks is not present")
|
Output:
geeksforgeeks is present
Time Complexity:
Converting the tuple of tuples to a NumPy array has a time complexity of O(n), where n is the total number of elements in the tuple of tuples.
Checking if a string is present in a 1D array has a time complexity of O(n), where n is the length of the 1D array.
Therefore, the overall time complexity of the NumPy implementation is O(n).
Auxiliary Space:
Converting the tuple of tuples to a NumPy array has a space complexity of O(n), where n is the total number of elements in the tuple of tuples.
Therefore, the overall space complexity of the NumPy implementation is also O(n).
Method 11: Using while loop and in operator:
Approach:
- Initialize the test_list.
- Initialize the boolean variable that contains True.
- While loop checks the condition for the boolean variable and the presence of the element in the list.
- If the element is present in the list negate the value boolean value.
- Print the result.
Python
test_tup = (10, 4, 5, 6, 8)
print("The original tuple : " + str(test_tup))
N = 6
temp = True
while temp and N in test_tup:
temp = False
print("Does tuple contain required value ? : " + str(not temp))
|
Output
The original tuple : (10, 4, 5, 6, 8)
Does tuple contain required value ? : True
Time Complexity: O(n), where n is the length of the list
Auxiliary Space: O(n)
Please Login to comment...