5 Best Ways to Sort Lists of Strings by Numbers in Python

Python developers often need to sort lists where elements are strings containing numbers. It’s crucial to sort these lists in a way that numerical values within the strings determine the order. For instance, given the input list ["apple2", "apple12", "apple1"], the desired output after sorting would be ["apple1", "apple2", "apple12"]. This article explores five methods to achieve such sorting efficiently.

Method 1: Using the sort() Function with Custom Key

Python’s sort() method can be customized with a key function to sort strings based on embedded numerical values. This technique is both powerful and flexible, allowing for complex sorting logic within a single line of code.

♥️ Info: Are you AI curious but you still have to create real impactful projects? Join our official AI builder club on Skool (only $5): SHIP! - One Project Per Month

Here’s an example:

import re

def numerical_sort(value):
    numbers = re.compile(r'(\d+)')
    parts = numbers.split(value)
    parts[1::2] = map(int, parts[1::2])
    return parts

my_list = ["apple2", "apple12", "apple1"]
my_list.sort(key=numerical_sort)
print(my_list)

Output:

["apple1", "apple2", "apple12"]

This code snippet defines a key function numerical_sort that uses regular expressions to find all number sequences in each string and split the string into parts. Then it casts these numbers to integers, enabling proper numerical comparison. The sort() method uses this key function to arrange the strings in the desired order.

Method 2: Using the sorted() Function with Custom Key

Python’s built-in sorted() function returns a new list and is therefore non-destructive. Like sort(), it can also accept a key function that manipulates the sorting criteria, excellent for once-off sorting tasks.

Here’s an example:

import re

my_list = ["apple2", "apple12", "apple1"]
sorted_list = sorted(my_list, key=lambda x: [int(c) if c.isdigit() else c for c in re.split('([0-9]+)', x)])
print(sorted_list)

Output:

["apple1", "apple2", "apple12"]

In this example, a lambda function is used as the key. This anonymous function applies a regular expression to split the string into a list of strings and numbers. Numbers are converted to integers to ensure they are compared numerically. The list is then sorted using this transformed list as the criterion.

Method 3: Using natsort Library

The natsort library provides a natural sorting function, which can sort lists of strings that contain numbers in a human-friendly way. This specialized library is perfect when looking for an out-of-the-box solution that requires no custom code.

Here’s an example:

from natsort import natsorted

my_list = ["apple2", "apple12", "apple1"]
sorted_list = natsorted(my_list)
print(sorted_list)

Output:

["apple1", "apple2", "apple12"]

The natsort library’s natsorted() function directly sorts the list without any additional setup. It’s particularly useful for quick implementation and when dealing with complex string sorting scenarios.

Method 4: Using Manual Numeric Sorting

A more hands-on approach can involve manually parsing string numbers, extracting them, converting them to integers, and then sorting. This solution is useful when it’s preferable to control every aspect of the sorting process.

Here’s an example:

my_list = ["apple2", "apple12", "apple1"]

def extract_number(s):
    return int(''.join(filter(str.isdigit, s)))

sorted_list = sorted(my_list, key=extract_number)
print(sorted_list)

Output:

["apple1", "apple2", "apple12"]

The function extract_number filters out all digit characters and converts them to an integer, providing a numeric basis for sorting the strings. This approach is direct and clear, favoring explicitness.

Bonus One-Liner Method 5: List Comprehension with sorted()

For the fans of Python one-liners, list comprehensions offer a compact way to combine sorting logic into a concise expression using sorted().

Here’s an example:

import re

my_list = ["apple2", "apple12", "apple1"]
sorted_list = sorted(my_list, key=lambda x: [(int(y) if y.isdigit() else y) for y in re.split('(\d+)', x)])
print(sorted_list)

Output:

["apple1", "apple2", "apple12"]

This compact snippet extends the earlier lambda function to use list comprehension to process each string. It’s an elegant, albeit dense, solution that capitalizes on Python’s expressive power.

Summary/Discussion

• Method 1: Using the sort() function with a custom key. It’s efficient and Pythonic but requires defining an extra function.
• Method 2: Using the sorted() function with a custom key. It’s a versatile and non-invasive approach, suitable for single-time use or where immutability of the original list is important.
• Method 3: Using natsort library. Ideal for developers seeking a hassle-free, natural sorting method without custom logic.
• Method 4: Manual numeric sorting. Offers the utmost control, making it great for educational purposes or specialized sorting. May be overkill for simple scenarios.
• Bonus Method 5: List comprehension with sorted(). A Pythonic one-liner that shows off Python’s compact power, which might not be as readable to beginners.