5 Best Ways to Sort a List According to the Second Element in Sublists

by

💡 Problem Formulation: When working with lists of lists in Python, it’s common to encounter the challenge of sorting the parent list based on a specific element in the sublists. The typical scenario involves having a list where each element is a sublist, and the goal is to sort the entire list according to the second element (index 1) in each sublist. For example, given a list [['bread', 2], ['apple', 1], ['orange', 3]], the desired output after sorting by the second element is [['apple', 1], ['bread', 2], ['orange', 3]].

Method 1: Using the sorted() Function with a Custom Key Function

This method leverages Python’s built-in sorted() function, which is capable of sorting any iterable. It becomes particularly useful when we provide it with a custom key function to sort complex structures, like our list of sublists. Sorting according to the second element of each sublist can be done by specifying a lambda function as the key, which returns the second element for each sublist during the sorting process.

Here’s an example:

my_list = [['bread', 2], ['apple', 1], ['orange', 3]]
sorted_list = sorted(my_list, key=lambda x: x[1])
print(sorted_list)

The output of this code will be:

[['apple', 1], ['bread', 2], ['orange', 3]]

This code snippet creates a list of sublists and uses the sorted() function to produce a new list which is sorted by the second element in each sublist. The lambda function inside the key parameter extracts the second element of every sublist to be used for sorting.

Method 2: Sorting In-Place Using the list.sort() Method

The list.sort() method can sort the list in place, meaning the original list is modified. In-place sorting can be more memory efficient than using sorted(), which returns a new sorted list. Similar to sorted(), the key parameter with a lambda function is used to sort the list according to the second element in each sublist.

Here’s an example:

my_list = [['bread', 2], ['apple', 1], ['orange', 3]]
my_list.sort(key=lambda x: x[1])
print(my_list)

The output of this code will be:

[['apple', 1], ['bread', 2], ['orange', 3]]

This code manipulates the original list and sorts it based on the second element of each sublist. Using the sort() method is efficient for large lists where creating a copy is not preferable.

Method 3: Using the operator.itemgetter() Function

The operator module provides a set of efficient functions, which includes itemgetter(). This function allows you to construct a callable that assumes an iterable as input and extracts the item at a given index. Here, we use it to sort the list based on the second element of the sublists which is more efficient than using a lambda function.

Here’s an example:

from operator import itemgetter

my_list = [['bread', 2], ['apple', 1], ['orange', 3]]
sorted_list = sorted(my_list, key=itemgetter(1))
print(sorted_list)

The output of this code will be:

[['apple', 1], ['bread', 2], ['orange', 3]]

This snippet sorts the list by using the itemgetter() function from the operator module, which is more performance-optimized than the lambda approach.

Method 4: Custom Sort Function

If you require more complex sorting logic or simply prefer to define your own function for readability or reuse, you can create a custom sorting function. This function will take a sublist as its argument and return the element you want to sort by—in this case, the second element of the sublist.

Here’s an example:

def get_second_element(sublist):
    return sublist[1]

my_list = [['bread', 2], ['apple', 1], ['orange', 3]]
my_list.sort(key=get_second_element)
print(my_list)

The output of this code seems like this:

[['apple', 1], ['bread', 2], ['orange', 3]]

A custom sort function like get_second_element() can be more clear than a lambda function, especially for complex sorting, although it may be less concise for simple cases.

Bonus One-Liner Method 5: Using List Comprehension with Sorting

A more Pythonic and concise way could be to use list comprehension together with sorting. Though functionally similar to the other methods, list comprehensions can be faster and often more readable, particularly to those familiar with Python’s syntactic sugar.

Here’s an example:

my_list = [['bread', 2], ['apple', 1], ['orange', 3]]
my_list = [sublist for sublist in sorted(my_list, key=lambda x: x[1])]
print(my_list)

The output will be:

[['apple', 1], ['bread', 2], ['orange', 3]]

This one-liner uses a list comprehension to iterate over a sorted iterator created by the sorted() function. It is essentially a more Pythonic and condensed way of expressing the same behavior as Method 1.

Summary/Discussion

  • Method 1: Using sorted() Function with a Custom Key Function. Highly versatile. Creates a new sorted list. Can be less memory efficient for very large lists.
  • Method 2: Sorting In-Place Using list.sort(). It modifies the original list. More memory efficient, as it does not create a new list.
  • Method 3: Using operator.itemgetter(). Performance-friendly for large datasets. Slightly less readable for those not familiar with the operator module.
  • Method 4: Custom Sort Function. Allows more complex sorting logic. Enhances readability for complex conditions. Not as concise for simple tasks.
  • Method 5: One-Liner Using List Comprehension. Pythonic and concise. Ideal for Python enthusiasts and for writing less verbose code.