Sometimes, while working with Python tuples, we can have a problem in which we need to perform ordering of all the tuples keys using external list. This problem can have application in data domains such as Data Science. Let’s discuss certain ways in which this task can be performed.
Input : test_list = [(‘Gfg’, 10), (‘best’, 3), (‘CS’, 8), (‘Geeks’, 7)], ord_list = [‘Geeks’, ‘best’, ‘CS’, ‘Gfg’]
Output : [(‘Geeks’, 7), (‘best’, 3), (‘CS’, 8), (‘Gfg’, 10)]Input : test_list = [(‘best’, 3), (‘CS’, 8), (‘Geeks’, 7)], ord_list = [‘Geeks’, ‘best’, ‘CS’]
Output : [(‘Geeks’, 7), (‘best’, 3), (‘CS’, 8)]
Method #1 : Using dict() + list comprehension The combination of above functions can be used to solve this problem. In this, we perform this task by converting tuple list to dictionaries, and as a second step use list comprehension to iterate through list and map the dictionary keys with values.
Python3
# Python3 code to demonstrate working of # Order Tuples by List# Using dict() + list comprehension# initializing listtest_list = [('Gfg', 3), ('best', 9), ('CS', 10), ('Geeks', 2)]# printing original listprint("The original list is : " + str(test_list))# initializing order list ord_list = ['Geeks', 'best', 'CS', 'Gfg']# Order Tuples by List# Using dict() + list comprehensiontemp = dict(test_list)res = [(key, temp[key]) for key in ord_list]# printing result print("The ordered tuple list : " + str(res)) |
The original list is : [('Gfg', 3), ('best', 9), ('CS', 10), ('Geeks', 2)]
The ordered tuple list : [('Geeks', 2), ('best', 9), ('CS', 10), ('Gfg', 3)]
Time complexity: O(n)
Auxiliary space: O(n)
Method #2 : Using setdefault() + sorted() + lambda The combination of above functions can be used to solve this problem. In this, we perform task of mapping elements to indices and creating a lookup using setdefault. And, as a second step, using sorted to sort list using lookup dictionary value list.
Python3
# Python3 code to demonstrate working of # Order Tuples by List# Using setdefault() + sorted() + lambda# initializing listtest_list = [('Gfg', 3), ('best', 9), ('CS', 10), ('Geeks', 2)]# printing original listprint("The original list is : " + str(test_list))# initializing order list ord_list = ['Geeks', 'best', 'CS', 'Gfg']# Order Tuples by List# Using setdefault() + sorted() + lambdatemp = dict()for key, ele in enumerate(ord_list): temp.setdefault(ele, []).append(key) res = sorted(test_list, key = lambda ele: temp[ele[0]].pop()) # printing result print("The ordered tuple list : " + str(res)) |
The original list is : [('Gfg', 3), ('best', 9), ('CS', 10), ('Geeks', 2)]
The ordered tuple list : [('Geeks', 2), ('best', 9), ('CS', 10), ('Gfg', 3)]
Time complexity: O(n log n), where n is the length of the input list.
Auxiliary space: O(n), where n is the length of the input list.
Method #3: Using lists and index() method
Python3
# Python3 code to demonstrate working of# Order Tuples by List# initializing listtest_list = [('Gfg', 3), ('best', 9), ('CS', 10), ('Geeks', 2)]# printing original listprint("The original list is : " + str(test_list))# initializing order listord_list = ['Geeks', 'best', 'CS', 'Gfg']res=[]x=[]for i in test_list: x.append(i[0])for i in ord_list: if i in x: res.append(test_list[x.index(i)])# printing resultprint("The ordered tuple list : " + str(res)) |
The original list is : [('Gfg', 3), ('best', 9), ('CS', 10), ('Geeks', 2)]
The ordered tuple list : [('Geeks', 2), ('best', 9), ('CS', 10), ('Gfg', 3)]
Time complexity: O(n^2), where n is the length of the input list.
Auxiliary space: O(n), where n is the length of the input list .
Method #4 : Using lambda
Approach
Using the sorted function and a lambda function to sort the tuples based on the index of the first element in ord_list.
Algorithm
1. Sort the test_list using the sorted() function with a lambda function that takes a tuple as an argument and returns the index of its first element in ord_list.
2. Return the sorted list of tuples.
Python3
def order_tuples_by_list(test_list, ord_list): return sorted(test_list, key=lambda x: ord_list.index(x[0]))test_list = [('Gfg', 10), ('best', 3), ('CS', 8), ('Geeks', 7)]ord_list = ['Geeks', 'best', 'CS', 'Gfg']print(order_tuples_by_list(test_list, ord_list)) |
[('Geeks', 7), ('best', 3), ('CS', 8), ('Gfg', 10)]
Time complexity: O(nlogn) because we sort the list of tuples.
Auxiliary Space: O(n) because we create a dictionary with n elements.
METHOD 4:Using sorted() function with itemgetter() function
APPROACH:
This program orders a list of tuples based on the second element of each tuple
ALGORITHM:
1.Import the itemgetter function from the operator module.
2.Define the original list of tuples.
3.Sort the list using the sorted() function with itemgetter(1) as the key parameter.
4.Store the sorted list in a new variable.
5.Print the new ordered list.
Python3
from operator import itemgetter# inputoriginal_list = [('Gfg', 3), ('best', 9), ('CS', 10), ('Geeks', 2)]# sort the list using the sorted() function with itemgetter() function as its key parameterordered_list = sorted(original_list, key=itemgetter(1))# outputprint(ordered_list) |
[('Geeks', 2), ('Gfg', 3), ('best', 9), ('CS', 10)]
Time Complexity: O(nlogn): Sorting the list takes O(nlogn) time complexity.
Space Complexity: O(n): A new list is created to store the sorted tuples, which takes O(n) space complexity.
METHOD 5:Using reduce():
Algorithm:
- Initialize the original list with tuples and the order list.
- Create an empty list res to hold the ordered tuples.
- Iterate over the tuples in the original list, extract the first element of each tuple and append it to a list x.
- Iterate over the elements of the order list.
- If the current element is in the list x, then append the corresponding tuple to the list res.
- Return the list res.
Python3
from functools import reduce# initializing listtest_list = [('Gfg', 3), ('best', 9), ('CS', 10), ('Geeks', 2)]# printing original listprint("The original list is : " + str(test_list))# initializing order listord_list = ['Geeks', 'best', 'CS', 'Gfg']# using reduce() to sort the list based on order listres = reduce(lambda acc, key: acc + [ele for ele in test_list if ele[0] == key], ord_list, [])# printing resultprint("The ordered tuple list : " + str(res))#This is code is contributed by Vinay Pinjala. |
The original list is : [('Gfg', 3), ('best', 9), ('CS', 10), ('Geeks', 2)]
The ordered tuple list : [('Geeks', 2), ('best', 9), ('CS', 10), ('Gfg', 3)]
Time Complexity:
Creating the original list and order list takes constant time O(1).
Iterating over the tuples in the original list takes O(n) time, where n is the number of tuples in the original list.
Extracting the first element of each tuple and appending it to the list x takes O(n) time.
Iterating over the elements of the order list takes O(m) time, where m is the number of elements in the order list.
If the current element is in the list x, then finding its index in the list x takes O(1) time, and appending the corresponding tuple to the list res takes O(1) time. This step is executed at most m times.
Therefore, the total time complexity of the code is O(n + m).
Space Complexity:
The space required to store the original list and order list is O(1).
The space required to store the list res is at most O(m).
The space required to store the list x is at most O(n).
Therefore, the total space complexity of the code is O(n + m).
