5 Best Ways to Sort a List of Strings by Numerical Value in Python

Sorting a list of strings by their embedded numerical value is a common problem in Python programming. For instance, given the list ["item12", "item3", "item25"], the desired output after sorting by numerical value is ["item3", "item12", "item25"]. This article explores the best methods to achieve this sorting using Python.

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

This method involves using the built-in sorted() function in Python with a custom key that extracts the numerical value within the string using a lambda function. The sorted() function is effective for all iterable types, which allows for sorting objects based on custom logic specified by a key function.

♥️ 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

# Sample list
items = ["item12", "item3", "item25"]

# Custom sorting key that extracts numbers from strings
sorted_items = sorted(items, key=lambda x: int(re.search(r'\d+', x).group()))

print(sorted_items)

Output:

['item3', 'item12', 'item25']

In this code snippet, the lambda function within the sorted() method uses a regular expression to find all digits in each string and converts them to an integer. The list is then sorted based on these integer values rather than the original strings, resulting in the desired numerical sort order.

Method 2: Using int() with Error Handling

Another approach to sort strings by their numerical values is to attempt to convert string segments to integers and handle any errors. This method ensures that non-numeric strings are placed correctly in the sorted order according to Python’s sorting algorithm.

Here’s an example:

# Sample list with a non-numeric entry for demonstration
items = ["item12", "item3", "text", "item25"]

# Custom sorting key that tries to convert string segments to int
sorted_items = sorted(items, key=lambda x: int(''.join(filter(str.isdigit, x))) if x.isdigit() else float('inf'))

print(sorted_items)

Output:

['item3', 'item12', 'item25', 'text']

This code ensures that numerals are extracted and converted to integers while strings that do not contain any numbers are placed at the end by assigning them a value of infinity. The filter() function is used to extract digits and isdigit() to check if the string can be converted to an integer.

Method 3: The natsort Library

The third method employs an external library called natsort to sort the list in a human-readable, or “natural”, order. This library is well-suited for the task at hand, as it can handle mixed types of data containing numbers and text seamlessly.

Here’s an example:

from natsort import natsorted

# Sample list
items = ["item12", "item3", "item25"]

# Using natsort to naturally sort the list
sorted_items = natsorted(items)

print(sorted_items)

Output:

['item3', 'item12', 'item25']

The natsorted() function from the natsort library takes in an iterable and automatically sorts its items as a human would expect them to be sorted, considering both numerical and non-numerical components of strings.

Method 4: Using Regular Expressions with the sort() Method

In this method, regular expressions are again employed, this time to extend the in-place sort() method of a list, which modifies the list directly. This approach is useful when you want to avoid creating a new sorted list and prefer to sort the existing one.

Here’s an example:

import re

# Sample list
items = ["item12", "item3", "item25"]

# In-place sorting with the sort() method
items.sort(key=lambda x: int(re.search(r'\d+', x).group()))

print(items)

Output:

['item3', 'item12', 'item25']

As with the sorted() method, a lambda function is used to extract numbers from strings. However, instead of returning a new list, the original list is sorted in place, which can be more memory-efficient when dealing with large lists.

Bonus One-Liner Method 5: List Comprehension and Sorting Tuples

For a succinct one-liner approach, you can create a list of tuples, each containing the numerical part of the string and the string itself, sort this list, and then extract the strings in sorted order.

Here’s an example:

# Sample list
items = ["item12", "item3", "item25"]

# One-liner to sort strings by their numerical values
sorted_items = [item for _, item in sorted((int(re.search(r'\d+', s).group()), s) for s in items)]

print(sorted_items)

Output:

['item3', 'item12', 'item25']

The code snippet creates tuples where the first element is the numerical value from the string, using a list comprehension combined with a generator expression. The list of tuples is sorted, and the strings are then picked from the tuples to form the sorted list. This method uses more advanced Python syntax but is highly succinct and readable for experienced Python developers.

Summary/Discussion

• Method 1: Using sorted() with a custom key. This method is flexible and maintains the original list. However, the use of regular expressions can make it less efficient for large lists.
• Method 2: Using int() with error handling. This technique handles non-numeric strings gracefully, but the use of error handling might lead to computationally expensive catches for large datasets.
• Method 3: Employing the natsort library. Highly efficient for a natural sort order and easy to use, but requires an external dependency.
• Method 4: Regular Expressions with sort(). In-place modification saves memory for large lists, but, like Method 1, regular expressions may slow down the process.
• Method 5: List comprehension and sorting tuples. Provides a concise one-liner, though it may be less straightforward to those new to Python.