5 Best Ways to Order a List of Lists by Length in Python

by

💡 Problem Formulation: Python developers often face the need to organize complex data structures. For instance, when dealing with a list containing other lists, it may be necessary to sort these nested lists by their length. Given an input like [['banana', 'apple', 'cherry'], ['dragonfruit'], ['fig', 'kiwi']], the desired output after sorting by length would be [['dragonfruit'], ['fig', 'kiwi'], ['banana', 'apple', 'cherry']]. This article outlines several methods to accomplish this task.

Method 1: Using the sorted() Function

The sorted() function in Python returns a new sorted list from the items in an iterable. We can pass a custom key function to sorted() that defines the sorting criteria, which, in this case, is the length of the nested lists.

Here’s an example:

list_of_lists = [['banana', 'apple', 'cherry'], ['dragonfruit'], ['fig', 'kiwi']]
sorted_list = sorted(list_of_lists, key=len)
print(sorted_list)

Output:

[['dragonfruit'], ['fig', 'kiwi'], ['banana', 'apple', 'cherry']]

This code snippet sorts the list of lists by each list’s length using the built-in Python function sorted(), specifying len as the key function to sort by the length of the sublists.

Method 2: Using the sort() Method

The sort() method modifies the list in place and sorts the list using a given key function. Similar to sorted(), it can use the length of nested lists as a criterion, which is useful when the original order does not need to be preserved.

Here’s an example:

list_of_lists = [['mango', 'peach'], ['apple'], ['grape', 'melon', 'berry']]
list_of_lists.sort(key=len)
print(list_of_lists)

Output:

[['apple'], ['mango', 'peach'], ['grape', 'melon', 'berry']]

This snippet directly sorts the original list_of_lists using the sort() method, organizing the sublists by increasing length.

Method 3: Sort by Length and Secondary Criteria

If multiple sublists have the same length and secondary sorting criteria are needed, a lambda function can be used as the key in sorted() or sort(), allowing for fine control over the sorting order.

Here’s an example:

list_of_lists = [['lime', 'melon'], ['berry', 'kiwi'], ['apple']]
sorted_list = sorted(list_of_lists, key=lambda x: (len(x), x))
print(sorted_list)

Output:

[['apple'], ['berry', 'kiwi'], ['lime', 'melon']]

This snippet sorts sublists primarily by length and secondarily by alphabetical order. The lambda function returns a tuple where the first element is the length, and the second is the list itself, influencing the sort order.

Method 4: Using a Custom Sort Function

For complex sort logic, a custom function can be defined and passed to sorted() or sort() as the key parameter. This method offers maximum flexibility in determining the sort behavior.

Here’s an example:

def custom_sort(sublist):
    return len(sublist), sum(ord(char) for item in sublist for char in item)

list_of_lists = [['cabbage'], ['bean', 'artichoke'], ['dates', 'apricot']]
sorted_list = sorted(list_of_lists, key=custom_sort)
print(sorted_list)

Output:

[['cabbage'], ['bean', 'artichoke'], ['dates', 'apricot']]

This custom sort function takes into account both the length of sublists and the sum of the ASCII values of all characters contained within. This can be a way to sort by length, then by lexical content.

Bonus One-Liner Method 5: Using List Comprehension

List comprehension can be used to generate a new list, ordered by applying a sort within the comprehension itself. This is a more Pythonic and often more readable way to sort lists for simple sorting operations.

Here’s an example:

list_of_lists = [['a', 'b'], ['c']]
sorted_list = sorted([sublist for sublist in list_of_lists], key=len)
print(sorted_list)

Output:

[['c'], ['a', 'b']]

This code uses a list comprehension to iterate over each sublist, then sorts the entire new list by length. It’s essentially a more concise way of applying Method 1.

Summary/Discussion

  • Method 1: Using sorted() function. Strengths: returns a new list, original remains unchanged. Weaknesses: not in-place, requires extra memory.
  • Method 2: Using sort() method. Strengths: in-place sorting, efficient memory usage. Weaknesses: modifies the original list.
  • Method 3: Sort by length and secondary criteria. Strengths: allows for complex sorting logic. Weaknesses: possibly slower for very large lists due to added sorting criteria.
  • Method 4: Using a custom sort function. Strengths: highly customizable, can incorporate any logic. Weaknesses: can be overkill for simple sorts, potentially less readable.
  • Method 5: Bonus One-Liner using List Comprehension. Strengths: concise and readable. Weaknesses: less versatile for complex sorts, creates a new list.