Exploring Pure Sorting in Python – KDnuggets

What Is Pure Sorting, And Why Do We Want It?

When working with Python iterables equivalent to lists, sorting is a standard operation you’ll carry out. To type lists you should use the checklist methodology type() to type an inventory in place or the sorted() perform that returns a sorted checklist.

The sorted() perform works nice when you’ve got an inventory of numbers or strings containing letters. However what about strings containing alphanumeric characters, equivalent to filenames, listing names, model numbers, and extra? The sorted() perform performs lexicographic sorting.

Have a look at this easy instance:

# Listing of filenames
filenames = ["file10.txt", "file2.txt", "file1.txt"]

sorted_filenames = sorted(filenames)
print(sorted_filenames)

You may get the next output:

Output >>> ['file1.txt', 'file10.txt', 'file2.txt']

Nicely, ‘file10.txt’ comes earlier than ‘file2.txt’ within the output. Not the intuitive sorting order we’re hoping for. It’s because the sorted() perform makes use of the ASCII values of the characters to type and never the numeric values. Enter pure sorting.

Pure sorting is a sorting method that arranges parts in a means that displays their pure order, significantly for alphanumeric knowledge. Not like lexicographic sorting, pure sorting interprets the numerical worth of digits inside strings and arranges them accordingly, leading to a extra significant and anticipated sequence.

On this tutorial, we’ll discover pure sorting with the Python library natsort.

Getting Began

To get began, you may set up the natsort library utilizing pip:

As a greatest apply, set up the required package deal in a digital surroundings for the venture. As a result of natsort requires Python 3.7 or later, be sure to’re utilizing a current Python model, ideally Python 3.11 or later. To learn to handle totally different Python variations, learn Too Many Python Variations to Handle? Pyenv to the Rescue.

Pure Sorting Fundamental Examples

 
We’ll begin with easy use circumstances the place pure sorting is helpful:

• Sorting file names: When working with file names containing digits, pure sorting ensures that recordsdata are ordered within the pure intuitive order.
• Model sorting: Pure sorting can be useful for ordering strings of model numbers, making certain that variations are sorted primarily based on their numerical values slightly than their ASCII values. Which could not replicate the specified versioning sequence.

Now let’s proceed to code these examples.

Sorting Filenames

 
Now that we’ve put in the natsort library, we will import it into our Python script and use the totally different features that the library provides.

Let’s revisit the primary instance of sorting file names (the one we noticed at first of the tutorial) the place the lexicographic sorting with the perform was not what we needed.

Now let’s type the identical checklist utilizing the natsorted() perform like so:

import natsort

# Listing of filenames
filenames = ["file10.txt", "file2.txt", "file1.txt"]

# Kind filenames naturally
sorted_filenames = natsort.natsorted(filenames)
print(sorted_filenames)

On this instance, natsorted() perform from the natsort library is used to type the checklist of file names naturally. In consequence, the file names are organized within the anticipated numerical order:

Output >>> ['file1.txt', 'file2.txt', 'file10.txt']

Sorting Model Numbers

 
Let’s take one other comparable instance the place now we have strings denoting variations:

import natsort

# Listing of model numbers
variations = ["v-1.10", "v-1.2", "v-1.5"]

# Kind variations naturally
sorted_versions = natsort.natsorted(variations)

print(sorted_versions)

Right here, the natsorted() perform is utilized to type the checklist of model numbers naturally. The ensuing sorted checklist maintains the right numerical order of the variations:

Output >>> ['v-1.2', 'v-1.5', 'v-1.10']

Customizing Sorting with a Key

When utilizing the built-in sorted() perform, you may need used the key parameter to customise. Equally, the sorted() perform additionally takes the non-compulsory key parameter which you should use to type primarily based on particular standards.

Let’s take an instance: now we have file_data which is the checklist of tuples. The primary aspect within the tuple (at index 0) is the file title and the second merchandise (at index 1) is the scale of the file.

Say we need to type primarily based on the file measurement in ascending order. So we set the key parameter to lambda x: x[1] in order that the file measurement at index 1 is used because the sorting key:

import natsort

# Listing of tuples containing filename and measurement
file_data = [
("data_20230101_080000.csv", 100),
("data_20221231_235959.csv", 150),
("data_20230201_120000.csv", 120),
("data_20230115_093000.csv", 80)
]

# Kind file knowledge primarily based on file measurement
sorted_file_data = natsort.natsorted(file_data, key=lambda x:x[1])

# Print sorted file knowledge
for filename, measurement in sorted_file_data:
    print(filename, measurement)

Right here’s the output:

data_20230115_093000.csv 80
data_20230101_080000.csv 100
data_20230201_120000.csv 120
data_20221231_235959.csv 150

Case-Insensitive Sorting of Strings

One other use case the place pure sorting is useful is while you want case-insensitive sorting of strings. Once more the lexicographic sorting primarily based on ASCII values won’t give the specified outcomes.

To carry out case-insensitive sorting, we will set alg to natsort.ns.IGNORECASE which can ignore the case when sorting. The alg key controls the algorithm that natsorted() makes use of:

import natsort

# Listing of strings with blended case
phrases = ["apple", "Banana", "cat", "Dog", "Elephant"]

# Kind phrases naturally with case-insensitivity
sorted_words = natsort.natsorted(phrases, alg=natsort.ns.IGNORECASE)

print(sorted_words)

Right here, the checklist of phrases with blended case is sorted naturally with case-insensitivity:

Output >>> ['apple', 'Banana', 'cat', 'Dog', 'Elephant']

Wrapping Up

And that is a wrap! On this tutorial, we reviewed the constraints of lexicographic sorting and the way pure sorting is usually a good different when working with alphanumeric strings. You will discover all of the code on GitHub.

We began with easy examples and in addition checked out sorting primarily based on customized keys and dealing with case-insensitive sorting in Python. Subsequent, you might discover different capabilities of the natsort library. I’ll see you all quickly in one other Python tutorial. Till then, hold coding!

Bala Priya C is a developer and technical author from India. She likes working on the intersection of math, programming, knowledge science, and content material creation. Her areas of curiosity and experience embody DevOps, knowledge science, and pure language processing. She enjoys studying, writing, coding, and occasional! At present, she’s engaged on studying and sharing her data with the developer group by authoring tutorials, how-to guides, opinion items, and extra. Bala additionally creates participating useful resource overviews and coding tutorials.