Python – Rear element extraction from list of tuples records

While working with tuples, we store different data as different tuple elements. Sometimes, there is a need to print specific information from the tuple like rear index. For instance, a piece of code would want just names to be printed on all the student data. Let’s discuss certain ways in which one can achieve solutions to this problem. 

Method #1: Using list comprehension 

List comprehension is the simplest way in which this problem can be solved. We can just iterate over only the rear index value in all the index and store it in a list and print it after that. 

The original list is : [(1, 'Rash', 21), (2, 'Varsha', 20), (3, 'Kil', 19)]
List with only rear tuple element : [21, 20, 19]

Time complexity: O(n), where n is the number of tuples in the list.
Auxiliary space: O(n), as we are creating a new list to store the extracted elements.

Method #2: Using map() + itemgetter()

map() coupled with itemgetter() can perform this task in simpler way. map() maps all the element we access using itemgetter() and returns the result. 

Follow the below steps to implement the above idea:

1. Importing the itemgetter module from the operator library.
2. Initializing a list of tuples test_list that contains three tuples, where each tuple represents a record containing three elements: an integer value, a string value, and another integer value.
3. Printing the original list using the print() function, which will display the list of tuples on the console.
4. Using the map() function with the itemgetter() function to extract the last element of each tuple in the test_list. The itemgetter(-1) function is used as a key function to extract the last element of each tuple.
5. Converting the output of the map() function to a list using the list() function.
6. Assigning the extracted last elements to a new list named res.
7. Printing the res list, which contains only the last element of each tuple in the test_list. This will display the extracted last elements of each tuple on the console.

Below is the implementation of the above approach: 

The original list is : [(1, 'Rash', 21), (2, 'Varsha', 20), (3, 'Kil', 19)]
List with only rear tuple element : [21, 20, 19]

Time complexity: O(n), where n is the length of the input list test_list.
Auxiliary space: O(n), where n is the length of the input list test_list. 

Method#3: Using the Recursive method.

The original list is : [(1, 'Rash', 21), (2, 'Varsha', 20), (3, 'Kil', 19)]
List with only rear tuple element : [21, 20, 19]

Time Complexity: O(n)
Auxiliary Space: O(n)

Method#4:Using enumerate

Approach:

1. Initialize a list of tuples test_list.
2. Print the original list test_list.
3. Use enumerate() to get the index and tuple of each record in test_list.
4. For each tuple in test_list, iterate over its elements using range() and select the last element using its index.
5. Append the selected element to a new list res.
6. Print the final list res.

Below is the implementation of the above approach:

The original list is : [(1, 'Rash', 21), (2, 'Varsha', 20), (3, 'Kil', 19)]
List with only rear tuple element : [21, 20, 19]

Time complexity: O(nm), where n is the number of tuples in test_list and m is the length of the longest tuple. The enumerate() function and two nested loops iterate over all the elements in each tuple, so their time complexity is proportional to m. Therefore, the overall time complexity is O(nm).

Auxiliary space: O(n), where n is the number of tuples in test_list. The res list stores only the last element of each tuple, so its size is proportional to n. Therefore, the space complexity is O(n).

Method#5:Using numpy(): 

Algorithm:

1. Import numpy module as np.
2. Initialize a list of tuples called test_list.
3. Print the original test_list.
4. Convert the test_list to a numpy array using np.array().
5. Extract the last column of the numpy array using numpy slicing with arr[:, -1].
6. Store the extracted elements in a new list called res.
7. Print the list with only the last element of each tuple.

Output: 

The original list is : [(1, 'Rash', 21), (2, 'Varsha', 20), (3, 'Kil', 19)]
List with only rear tuple element : ['21' '20' '19']

Time complexity:  O(n), where n is the number of tuples in the input list. The numpy array conversion takes O(n) time, and slicing takes constant time.
Space complexity:  O(n), where n is the number of tuples in the input list. This is because the input list is converted to a numpy array which takes O(n) space, and the resulting array containing only the last elements of each tuple also takes O(n) space.

Method #6: Using a for loop

Step-by-step approach:

1. Initialize a list of tuples called test_list
2. Print the original list using the print() function
3. Create an empty list called res to store the extracted elements
4. Use a for loop to iterate over each tuple in test_list
   • Extract the last element (which has index -1) and append it to res
5. Print the result using the print() function.

Below is the implementation of the above approach:

The original list is : [(1, 'Rash', 21), (2, 'Varsha', 20), (3, 'Kil', 19)]
List with only rear tuple element : [21, 20, 19]

Time complexity: O(n), where n is the length of test_list because we iterate over each element in the list once.
Auxiliary space: O(n), where n is the length of test_list because we create a new list called res with n elements.

Method 6: Using Loops 

The original list is: [(1, 'Rash', 21), (2, 'Varsha', 20), (3, 'Kil', 19)]
List with only rear tuple element: [21, 20, 19]

Time complexity: O(n) where n is the length of the input list
Auxiliary space: O(n) where n is the length of the input list, for the output list.

manjeet_04

Follow

Improve

Article Tags :

• Python
• Python Programs
• Python list-programs
• Python tuple-programs

Practice Tags :

• python