Python – Product of Selective Tuple Keys
Sometimes, while using a list of tuples, we come across a problem in which we have a certain list of keys and we just need the product of values of those keys from the list of tuples. This has a utility in rating or product of specific entities. Let’s discuss certain ways in which this can be done.
Method #1: Using dict() + loop + get() + list comprehension
We can perform this particular task by first, converting the list into the dictionary and then employing list comprehension to get the value of specific keys using the get function. The product of values is performed using a loop.
Python3
# Python3 code to demonstrate # Product of Selective Tuple Keys # using dict() + get() + list comprehension + loop # getting Product def prod(val): res = 1 for ele in val: res * = ele return res # Initializing list of tuples test_list = [( 'Nikhil' , 1 ), ( 'Akash' , 2 ), ( 'Akshat' , 3 ), ( 'Manjeet' , 4 )] # Initializing selection list select_list = [ 'Nikhil' , 'Akshat' ] # Printing original list print ( "The original list is: " + str (test_list)) # Printing selection list print ( "The selection list is : " + str (select_list)) # Product of Selective Tuple Keys # using dict() + get() + list comprehension + loop temp = dict (test_list) res = prod([temp.get(i, 0 ) for i in select_list]) # Printing the result print ( "The selective values product of keys : " + str (res)) |
The original list is: [('Nikhil', 1), ('Akash', 2), ('Akshat', 3), ('Manjeet', 4)] The selection list is : ['Nikhil', 'Akshat'] The selective values product of keys : 3
Time complexity: O(n)
Auxiliary space: O(n)
Method #2: Using next() + loop + list comprehension
This particular problem can be solved using the next function which performs the iteration using the iterators and hence more efficient way to achieve a possible solution. The product of values is performed using loop.
Python3
# Python3 code to demonstrate # Product of Selective Tuple Keys # using next() + list comprehension + loop # Function to get the product def prod(val): res = 1 for ele in val: res * = ele return res # Initializing list of tuples test_list = [( 'Nikhil' , 1 ), ( 'Akash' , 2 ), ( 'Akshat' , 3 ), ( 'Manjeet' , 4 )] # Initializing selection list select_list = [ 'Nikhil' , 'Akshat' ] # Printing original list print ( "The original list is : " + str (test_list)) # Printing selection list print ( "The selection list is : " + str (select_list)) # Product of Selective Tuple Keys # using next() + list comprehension + loop res = prod([ next ((sub[ 1 ] for sub in test_list if sub[ 0 ] = = i), 0 ) for i in select_list]) # Printing the result print ( "The selective values product of keys : " + str (res)) |
The original list is : [('Nikhil', 1), ('Akash', 2), ('Akshat', 3), ('Manjeet', 4)] The selection list is : ['Nikhil', 'Akshat'] The selective values product of keys : 3
Time Complexity: O(N * M), where n is the length of the test_list and m is the length of the select_list.
Auxiliary Space: O(M), where m is the length of the select_list.
Method #3: Using for loop and in operator
Python3
# Python3 code to demonstrate # Product of Selective Tuple Keys # Initializing list of tuples test_list = [( 'Nikhil' , 1 ), ( 'Akash' , 2 ), ( 'Akshat' , 3 ), ( 'Manjeet' , 4 )] # Initializing selection list select_list = [ 'Nikhil' , 'Akshat' ] # Printing original list print ( "The original list is : " + str (test_list)) # Printing selection list print ( "The selection list is : " + str (select_list)) # Product of Selective Tuple Keys res = 1 for i in test_list: if i[ 0 ] in select_list: res * = i[ 1 ] # Printing result print ( "The selective values product of keys : " + str (res)) |
The original list is : [('Nikhil', 1), ('Akash', 2), ('Akshat', 3), ('Manjeet', 4)] The selection list is : ['Nikhil', 'Akshat'] The selective values product of keys : 3
Time Complexity: O(n), where n is the number of elements in the list “test_list”.
Auxiliary Space: O(n), where n is the number of elements in the list “test_list”.
Method #4 : Using map() and lambda() functions
Python3
def prod(val): # Initialize a variable to store the product of values res = 1 # Loop through each value in the input list for ele in val: # Multiply the current product by the current value res * = ele # Return the final product return res # Initialize a list of tuples test_list = [( 'Nikhil' , 1 ), ( 'Akash' , 2 ), ( 'Akshat' , 3 ), ( 'Manjeet' , 4 )] # Initialize a list of selected keys select_list = [ 'Nikhil' , 'Akshat' ] # Create a dictionary from the list of tuples temp = dict (test_list) # Calculate the product of values of selected keys # using a map and lambda function # Printing original list print ( "The original list is : " + str (test_list)) # Printing selection list print ( "The selection list is : " + str (select_list)) result = prod( map ( lambda x: temp.get(x, 0 ), select_list)) # Print the result print ( "The selective values product of keys : " + str (result)) #This code is contributed by Jyothi pinjala |
The original list is : [('Nikhil', 1), ('Akash', 2), ('Akshat', 3), ('Manjeet', 4)] The selection list is : ['Nikhil', 'Akshat'] The selective values product of keys : 3
Time complexity: O(n)
Auxiliary Space: O(n)
Method #5: Using functools.reduce()+operator.mul+for loop
Python3
# Python3 code to demonstrate # Product of Selective Tuple Keys # initializing list of tuples test_list = [( 'Nikhil' , 1 ), ( 'Akash' , 2 ), ( 'Akshat' , 3 ), ( 'Manjeet' , 4 )] # initializing selection list select_list = [ 'Nikhil' , 'Akshat' ] # printing original list print ( "The original list is : " + str (test_list)) # printing selection list print ( "The selection list is : " + str (select_list)) # Product of Selective Tuple Keys res = [] for i in test_list: if i[ 0 ] in select_list: res.append(i[ 1 ]) from functools import reduce import operator res1 = reduce (operator.mul,res, 1 ) # printing result print ( "The selective values product of keys : " + str (res1)) |
The original list is : [('Nikhil', 1), ('Akash', 2), ('Akshat', 3), ('Manjeet', 4)] The selection list is : ['Nikhil', 'Akshat'] The selective values product of keys : 3
Time complexity: O(n)
Auxiliary Space: O(n)
Method #6:Using Recursion
This code defines a function selective_product(tuples, selection) that takes a list of tuples and a list of strings selection as input and returns the product of values in the tuples that have keys that appear in the selection list. The function recursively traverses the input list of tuples, checks if the key of the current tuple is in the selection list, and if so, multiplies its value with the product of the remaining tuples. If the key is not in the selection list, the function recurses on the remaining tuples.
The code then defines an example input list of tuples test_list and a selection list select_list, calls the selective_product function on them, and prints the resulting product.
Python3
def selective_product(tuples, selection): if len (tuples) = = 0 : return 1 elif tuples[ 0 ][ 0 ] in selection: return tuples[ 0 ][ 1 ] * selective_product(tuples[ 1 :], selection) else : return selective_product(tuples[ 1 :], selection) # Example usage test_list = [( 'Nikhil' , 1 ), ( 'Akash' , 2 ), ( 'Akshat' , 3 ), ( 'Manjeet' , 4 )] select_list = [ 'Nikhil' , 'Akshat' ] # printing original list print ( "The original list is : " + str (test_list)) # printing selection list print ( "The selection list is : " + str (select_list)) res = selective_product(test_list, select_list) print ( "The selective values product of keys : " + str (res)) #This code is contributed Vinay pinjala. |
The original list is : [('Nikhil', 1), ('Akash', 2), ('Akshat', 3), ('Manjeet', 4)] The selection list is : ['Nikhil', 'Akshat'] The selective values product of keys : 3
Time complexity: O(n)
Auxiliary Space: O(n)
Time complexity:
The function recurses over the input list of tuples. In the worst case, it needs to check each tuple once, so the worst-case time complexity is O(n), where n is the length of the input list.
Multiplying the values of selected tuples takes constant time, and the in operator used to check if the key is in the selection list also takes constant time.
Therefore, the overall time complexity of this function is O(n), where n is the length of the input list.
Auxiliary Space:
The function uses recursion to traverse the input list of tuples. In the worst case, the recursion depth is equal to the length of the input list, so the worst-case space complexity is O(n), where n is the length of the input list.
The function uses a constant amount of additional space for storing the selection list and temporary variables.
Therefore, the overall space complexity is O(n)
Method #5: Using list comprehension with conditional and reduce()
This method uses list comprehension to filter out the tuples whose first element is not in the select_list. Then it uses reduce() with the operator.mul function to multiply all the second elements of the filtered tuples.
Python3
from functools import reduce import operator test_list = [( 'Nikhil' , 1 ), ( 'Akash' , 2 ), ( 'Akshat' , 3 ), ( 'Manjeet' , 4 )] select_list = [ 'Nikhil' , 'Akshat' ] res = [tup[ 1 ] for tup in test_list if tup[ 0 ] in select_list] res1 = reduce (operator.mul, res, 1 ) print ( "The selective values product of keys : " + str (res1)) |
The selective values product of keys : 3
The time complexity of this code is O(n), where n is the length of the test_list.
The auxiliary space complexity is O(k), where k is the length of the filtered list obtained from the list comprehension.
Method 8 : Using filter() and reduce()
Use the filter() function to create a new list of tuples where the key of each tuple is in the selection list.
Use the reduce() function from the functools module to multiply the values of the tuples in the new list.
Return the result.
Python3
import functools def selective_product(tuples, selection): selected_tuples = filter ( lambda x: x[ 0 ] in selection, tuples) selected_values = [t[ 1 ] for t in selected_tuples] result = functools. reduce ( lambda x, y: x * y, selected_values, 1 ) return result # Example usage test_list = [( 'Nikhil' , 1 ), ( 'Akash' , 2 ), ( 'Akshat' , 3 ), ( 'Manjeet' , 4 )] select_list = [ 'Nikhil' , 'Akshat' ] # printing original list print ( "The original list is : " + str (test_list)) # printing selection list print ( "The selection list is : " + str (select_list)) res = selective_product(test_list, select_list) print ( "The selective values product of keys : " + str (res)) # Output: The selective values product of keys : 3 |
The original list is : [('Nikhil', 1), ('Akash', 2), ('Akshat', 3), ('Manjeet', 4)] The selection list is : ['Nikhil', 'Akshat'] The selective values product of keys : 3
Time complexity: O(n), where n is the length of the tuples list.
Auxiliary space: O(k), where k is the number of tuples whose keys are in the selection list.
Contact Us