Open In App
Related Articles

Python – Find minimum k records from tuple list

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report

Sometimes, while working with data, we can have a problem in which we have records and we require to find the lowest K scores from it. This kind of application is popular in web development domain. Let’s discuss certain ways in which this problem can be solved. 

Method #1 : Using sorted() + lambda The combination of above functionality can be used to perform this particular task. In this, we just employ sorted function, and print the lowest K elements using list slicing. 

Python3

# Python3 code to demonstrate working of
# Minimum K records
# Using sorted() + lambda
 
# Initializing list
test_list = [('Manjeet', 10), ('Akshat', 4), ('Akash', 2), ('Nikhil', 8)]
 
# Initializing K
K = 2
 
# printing original list
print("The original list is : " + str(test_list))
 
# Minimum K records
# Using sorted() + lambda
res = sorted(test_list, key = lambda x: x[1])[:K]
 
# printing result
print("The lowest K records are : " + str(res))

                    

Output
The original list is : [('Manjeet', 10), ('Akshat', 4), ('Akash', 2), ('Nikhil', 8)]
The lowest K records are : [('Akash', 2), ('Akshat', 4)]

Time complexity: O(n log n), where n is the length of the input list.
Auxiliary space: O(1). The space used by the algorithm is constant because the input list and K are the only variables that are being stored, and the result list is being constructed in place.

Method #2 : Using sorted() + itemgetter() The combination of above functions can also be used to perform this particular task. In this, the task performed by lambda function is performed by itemgetter() is used to get the index in tuple which has to be included in calculations. 

Python3

# Python3 code to demonstrate working of
# Minimum K records
# Using sorted() + itemgetter()
from operator import itemgetter
 
# Initializing list
test_list = [('Manjeet', 10), ('Akshat', 4), ('Akash', 2), ('Nikhil', 8)]
 
# Initializing K
K = 2
 
# printing original list
print("The original list is : " + str(test_list))
 
# Minimum K records
# Using sorted() + itemgetter()
res = sorted(test_list, key = itemgetter(1))[:K]
 
# printing result
print("The lowest K records are : " + str(res))

                    

Output
The original list is : [('Manjeet', 10), ('Akshat', 4), ('Akash', 2), ('Nikhil', 8)]
The lowest K records are : [('Akash', 2), ('Akshat', 4)]

Time complexity: O(n log n), where n is the length of the test_list.
Auxiliary space: O(k), where k is the value of K, since we are creating a new list of length K to store the minimum K records.

Method #3 : Using heapq.nsmallest()
This method uses the nsmallest() function from the heapq module which returns the k smallest elements from an iterable. This method is more efficient than sorting the entire list and slicing the first k elements as it only considers the k smallest elements and doesn’t sort the entire list.

Python3

# Python3 code to demonstrate working of
# Minimum K records
# Using heapq.nsmallest()
import heapq
 
# Initializing list
test_list = [('Manjeet', 10), ('Akshat', 4), ('Akash', 2), ('Nikhil', 8)]
   
# Initializing K
K = 2
   
# printing original list
print("The original list is : " + str(test_list))
   
# Minimum K records
# Using heapq.nsmallest()
res = heapq.nsmallest(K, test_list, key = lambda x: x[1])
   
# printing result
print("The lowest K records are : " + str(res))
#This code is contributed by Edula Vinay Kumar Reddy

                    

Output
The original list is : [('Manjeet', 10), ('Akshat', 4), ('Akash', 2), ('Nikhil', 8)]
The lowest K records are : [('Akash', 2), ('Akshat', 4)]

Time complexity of using heapq.nsmallest() is O(nlogk) and the Auxiliary space is O(k).

Method #4 : Using a for loop and conditional statements

This approach uses two nested for loops to find the minimum value in the list, and removes it from the list after it has been added to the result list. The outer for loop runs K times to find K minimum values. This approach may not be as efficient as the other methods for large lists.

Python3

# Python3 code to demonstrate working of
# Minimum K records
# Using a for loop and conditional statements
 
# Initializing list
test_list = [('Manjeet', 10), ('Akshat', 4), ('Akash', 2), ('Nikhil', 8)]
 
# Initializing K
K = 2
 
# printing original list
print("The original list is : " + str(test_list))
 
# Minimum K records
res = []
for i in range(K):
    min_val = test_list[0]
    for val in test_list:
        if val[1] < min_val[1]:
            min_val = val
    res.append(min_val)
    test_list.remove(min_val)
 
# printing result
print("The lowest K records are : " + str(res))

                    

Output
The original list is : [('Manjeet', 10), ('Akshat', 4), ('Akash', 2), ('Nikhil', 8)]
The lowest K records are : [('Akash', 2), ('Akshat', 4)]

The time complexity of the given code is O(K*N^2), where N is the length of the input list.

The space complexity is O(K), as we are storing the minimum K values in the res list.

Method #5: Using heapq.nlargest()


This method can be used to find the largest K elements in the list. We can negate the second element in the tuple and use heapq.nlargest() to find the K largest tuples. Finally, we can negate the second element back to obtain the K smallest tuples.

step-by-step approach:

  1. Negate the second element in each tuple using a lambda function.
  2. Use heapq.nlargest() to find the K largest tuples.
  3. Negate the second element in each tuple back to obtain the K smallest tuples.

Python3

import heapq
 
# Initializing list
test_list = [('Manjeet', 10), ('Akshat', 4), ('Akash', 2), ('Nikhil', 8)]
 
# Initializing K
K = 2
 
# printing original list
print("The original list is : " + str(test_list))
 
# Minimum K records using heapq.nlargest()
res = heapq.nlargest(K, test_list, key=lambda x: -x[1])
res = [(name, -score) for name, score in res]
 
# printing result
print("The lowest K records are : " + str(res))

                    

Output
The original list is : [('Manjeet', 10), ('Akshat', 4), ('Akash', 2), ('Nikhil', 8)]
The lowest K records are : [('Akash', -2), ('Akshat', -4)]

Time complexity: O(n log K), where n is the length of the list.
Auxiliary space: O(K), since we are storing K elements in the heap.



Last Updated : 06 Apr, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads