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 code to demonstrate working of # Check if element is present in tuple # using loop # initialize tuple test_tup = ( 10 , 4 , 5 , 6 , 8 )
# printing original tuple print ( "The original tuple : " + str (test_tup))
# initialize N N = 6
# Check if element is present in tuple # using loop res = False
for ele in test_tup:
if N = = ele:
res = True
break
# printing result print ( "Does tuple contain required value ? : " + str (res))
|
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 code to demonstrate working of # Check if element is present in tuple # Using in operator # initialize tuple test_tup = ( 10 , 4 , 5 , 6 , 8 )
# printing original tuple print ( "The original tuple : " + str (test_tup))
# initialize N N = 6
# Check if element is present in tuple # Using in operator res = N in test_tup
# printing result print ( "Does tuple contain required value ? : " + str (res))
|
The original tuple : (10, 4, 5, 6, 8) Does tuple contain required value ? : True
Method 3: Using list comprehension method
t = ( 10 , 4 , 5 , 6 , 8 )
n = 6
x = [i for i in t if i = = n]
print ([ "yes" if x else "no" ])
|
['yes']
Method 4: Using lambda function
t = ( 10 , 4 , 5 , 6 , 8 )
n = 6
x = tuple ( filter ( lambda i: (i = = n), t))
print ([ "yes" if x else "no" ])
|
['yes']
Method 5: Using the enumerate function
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" ])
|
['yes']
Method 6: Using count() method
# Python3 code to demonstrate working of # Check if element is present in tuple # using loop # initialize tuple test_tup = ( 10 , 4 , 5 , 6 , 8 )
# printing original tuple print ( "The original tuple : " + str (test_tup))
# initialize N N = 6
# Check if element is present in tuple # using loop res = False
if (test_tup.count(N) > = 1 ):
res = True
# printing result print ( "Does tuple contain required value ? : " + str (res))
|
The original tuple : (10, 4, 5, 6, 8) Does tuple contain required value ? : True
Method 7: Using try/except and index:
# Python3 code to demonstrate working of # Check if element is present in tuple # using loop # initialize tuple test_tup = ( 10 , 4 , 5 , 6 , 8 )
# printing original tuple print ( "The original tuple : " + str (test_tup))
# initialize N N = 6
# Check if element is present in tuple # using loop res = False
try :
test_tup.index(N)
res = True
except ValueError:
pass
# printing result print ( "Does tuple contain required value ? : " + str (res))
# this code is contributed by edula vinay kumar reddy |
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 code to demonstrate working of # Check if element is present in tuple # using recursion method # defining recursion function def value_present(start, lst, value):
if start = = len (lst): # base condition
return False
if lst[start] = = value: # checking lst[start] is value or not
return True
return value_present(start + 1 , lst, value) # recursive call
# initialize tuple test_tup = ( 10 , 4 , 5 , 6 , 8 )
# printing original tuple print ( "The original tuple : " + str (test_tup))
# initialize N N = 6
res = value_present( 0 , test_tup, N)
print ( "Does tuple contain required value ? : " + str (res))
# this code is contributed by tvsk |
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’.
from functools import reduce
t = ( '10' , '4' , '5' , '6' , '8' )
n = 6
# printing original tuple 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" )
#This code is contributed by Jyothi pinjala.
|
True
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”.
import numpy as np
# Initialize the tuple of tuples test_tuple = (( "geeksforgeeks" , "gfg" ), ( "CS_Portal" , "best" ))
# Convert the tuple of tuples to a 2D NumPy array test_array = np.array(test_tuple)
# Check if the element is present in any of the tuples if "geeksforgeeks" in test_array:
print ( "geeksforgeeks is present" )
else :
print ( "geeksforgeeks is not present" )
#This code is contributed by Rayudu. |
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.
# Python3 code to demonstrate working of # Check if element is present in tuple # using loop # initialize tuple test_tup = ( 10 , 4 , 5 , 6 , 8 )
# printing original tuple print ( "The original tuple : " + str (test_tup))
# initialize N N = 6
temp = True
# Check if element is present in tuple # using loop while temp and N in test_tup:
temp = False
# printing result print ( "Does tuple contain required value ? : " + str ( not temp))
|
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)