Python – Find minimum k records from tuple list

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.

Previous
Next