Sorting Numbers

You can usesorted() to sort a list in Python. In this example, a list of integers is defined, and thensorted() is called with thenumbersvariable as the argument:

>>>numbers=[6,9,3,1]>>>sorted(numbers)[1, 3, 6, 9]>>>numbers[6, 9, 3, 1]

The output from this code is a new, sorted list. When the original variable is printed, the initial values are unchanged.

This example shows four important characteristics ofsorted():

1. You don’t have to define thesorted() function. It’s a built-in function that’s available in any standard installation of Python.
2. You’re ordering the values innumbers from smallest to largest when you callsorted(numbers). When you pass no additional arguments or parameters,sorted() orders the values innumbers in ascending order.
3. You don’t change the originalnumbers variable becausesorted() provides sorted output and doesn’t update the original value in place.
4. You get an ordered list as a return value when you callsorted().

These points mean thatsorted() can be used on a list, and the output can immediately beassigned to a variable:

>>>numbers=[6,9,3,1]>>>numbers_sorted=sorted(numbers)>>>numbers_sorted[1, 3, 6, 9]>>>numbers[6, 9, 3, 1]

In this example, a new variable callednumbers_sorted now stores the output of thesorted() function.

You can confirm all of these observations by callinghelp() onsorted():

>>>help(sorted)Help on built-in function sorted in module builtins:sorted(iterable, /, *, key=None, reverse=False)    Return a new list containing all items from the iterable in ascending order.    A custom key function can be supplied to customize the sort order, and the    reverse flag can be set to request the result in descending order.

You’ll cover the optional argumentskey andreverse later in the tutorial.

The first parameter ofsorted() is aniterable. That means that you can usesorted() ontuples andsets very similarly:

>>>numbers_tuple=(6,9,3,1)>>>sorted(numbers_tuple)[1, 3, 6, 9]>>>numbers_set={5,10,1,0}>>>sorted(numbers_set)[0, 1, 5, 10]

Notice how even though the input was a set and a tuple, the output is a list becausesorted() returns a new list by definition. The returned object can be cast to a new type if it needs to match the input type. Be careful if attempting to cast the resulting list back to a set, as a set by definition is unordered:

>>>numbers_tuple=(6,9,3,1)>>>numbers_set={5,10,1,0}>>>numbers_tuple_sorted=sorted(numbers_tuple)>>>numbers_set_sorted=sorted(numbers_set)>>>numbers_tuple_sorted[1, 3, 6, 9]>>>numbers_set_sorted[0, 1, 5, 10]>>>tuple(numbers_tuple_sorted)(1, 3, 6, 9)>>>set(numbers_set_sorted){0, 1, 10, 5}

When you cast thenumbers_set_sorted value to aset, it’s unordered, as expected. If you’re curious about how sets work in Python, then you can check out the tutorialSets in Python.

Sorting Strings

Just like lists, tuples, and sets, strings are also iterables. This means you can sortstr types as well. The example below shows howsorted() iterates through each character in the value passed to it and orders them in the output:

>>>string_number_value="34521">>>sorted(string_number_value)['1', '2', '3', '4', '5']>>>string_value="I like to sort">>>sorted(string_value)[' ', ' ', ' ', 'I', 'e', 'i', 'k', 'l', 'o', 'o', 'r', 's', 't', 't']

Just like before, you can usesorted() to iterate through each element of the iterable you pass in. In a string, each element means each character, including spaces.

If you want to sort a sentence by words, then you can use Python’s.split() method:

>>>string_value="I like to sort">>>sorted_string=sorted(string_value.split())>>>sorted_string['I', 'like', 'sort', 'to']

In this example, you use.split() to convert the original sentence into a list of words. Afterward, you sort the list instead of individual characters.

Handling Lists With Non-Comparable Data Types

There are data types that can’t be compared to each other usingsorted() because they’re too different. Python will return an error if you attempt to usesorted() on a list containing non-comparable data. In the example below, you haveNone and the integer zero (0) in the same list. Python doesn’t know how to sort these two types because of their incompatibility:

>>>mixed_types=[None,0]>>>sorted(mixed_types)Traceback (most recent call last):...TypeError:'<' not supported between instances of 'int' and 'NoneType'

This error shows why Python can’t sort the values given to it. It’s trying to put the values in order by using theless than operator (<) to determine which value is lower in sorting order. You can replicate this error by manually comparing the two values:

>>>None<0Traceback (most recent call last):...TypeError:'<' not supported between instances of 'NoneType' and 'int'

The sameTypeError is thrown when you try to compare two non-comparable values without usingsorted().

If the values in the list can be compared without raising aTypeError, then the list can be sorted. This prevents sorting iterables with intrinsically unorderable values and producing output that may not make sense.

Python can implicitly convert a value to another type. Even though elements in a list look different, Python may able to interpret them asintegers and compare them to each other usingsorted():

>>>sorted([1,False,True,0])[False, 0, 1, True]

Python interprets theBooleanFalse as0 andTrue as1. You can verify that Python considers the integers0 and1 equal toFalse andTrue by comparing them manually:

>>>0==FalseTrue>>>1==TrueTrue

If you have a look at the ordered list from before, you can spot another important aspect of sorting calledsort stability. In Python, when you sort equal values, they’ll retain their original order in the output. Since the integer1 comes beforeTrue in the unsorted list,1 will appear beforeTrue in the sorted list.

Considering Length When Sorting Similar Strings

In the example above, you were sorting either single characters or different words. When dealing with a list that contains similar strings, Python sorts shorter strings first:

>>>sorted(["aaa","a"])['a', 'aaa']

Strings that contain identical values will end up being sorted shortest to longest because the shorter strings lack elements to compare against the longer ones.

This doesn’t mean that shorter strings always come first:

>>>sorted(["aaa","ab","a"])['a', 'aaa', 'ab']

If the first letter is the same, thensorted() will use the second character to determine order, and so on.

In the example above,ab is shorter thanaaa. But while traversing through the string to determine how to sortab compared toaaa, the second letter ofab is considered larger than the second letter ofaaa. That’s because the letterb has a largerUnicode than the lettera.

You can leverage Python’sord() function to investigate a character’s Unicode:

>>>ord("b")98>>>ord("a")97

To learn more about some of Python’s quirks when ordering strings, check out the tutorialHow to Sort Unicode Strings Alphabetically in Python.

Sorting Iterables in Reverse Order

As the name suggests, the keyword argumentreverse let’s you reverse the order of an iterable. Thereverse keyword accepts a Boolean value:

>>>numbers=[10,3,7]>>>sorted(numbers)[3, 7, 10]>>>sorted(numbers,reverse=True)[10, 7, 3]

The default value ofreverse isFalse, which results in the ascending order of items. If you setreverse toTrue, then the sorting will be in descending order.

Sorting Strings by Length

One of the most powerful components ofsorted() is the keyword argument calledkey. This argument expects a function to be passed to it, and that function will be used on each value in the list being sorted to determine the resulting order.

To demonstrate a basic example, let’s assume the requirement for ordering a specific list is the length of the strings in the list, from shortest to longest. You can use thelen() function to return the length of a string, along with thekey argument:

>>>word="paper">>>len(word)5>>>words=["banana","pie","Washington","book"]>>>sorted(words,key=len)['pie', 'book', 'banana', 'Washington']

The resulting order is a list with a string order of shortest to longest. The length of each element in the list is determined bylen() and then returned in ascending order.

Ignoring the Case When Sorting Strings

By default, sorting in Python iscase sensitive. This means that words starting with an uppercase Z will be sorted before those beginning with lowercase letters because of their Unicode values:

>>>sorted(["ape","Zebra","elephant"])['Zebra', 'ape', 'elephant']

You can pass instr.lower as the value ofkey to sort strings independently of a character’s case:

>>>sorted(["ape","Zebra","elephant"],key=str.lower)['ape', 'elephant', 'Zebra']

During sorting, the function passed tokey is called on each element to determine sort order, but the original values remain in the output.

Avoiding Pitfalls When Usingsorted() With akey Argument

There are two main limitations to look out for when you’re using functions with thekey argument.

First, the number of required arguments in the function passed tokey must be exactly one:

>>>defadd(x,y):...returnx+y...>>>sorted([1,2,3],key=add)Traceback (most recent call last):...TypeError:add() missing 1 required positional argument: 'y'

The example above shows the definition of an addition function that takes two arguments. When that function is used inkey on a list of numbers, it fails because it’s missing a second argument. Each timeadd() is called during the sort, it’s only receiving one element from the list at a time.

The second limitation ofkey is that the function used withkey must be able to handle all the values in the iterable.

Here, you have a list of numbers represented as strings to be used insorted(), andkey is going to attempt to convert them to numbers usingint:

>>>values_to_cast=["11","3","2"]>>>sorted(values_to_cast,key=int)['2', '3', '11']

However, if a value in the iterable can’t be cast to an integer, then usingint as the value forkey will fail:

>>>values_to_cast=["11","3","2","A"]>>>sorted(values_to_cast,key=int)Traceback (most recent call last):...ValueError:invalid literal for int() with base 10: 'A'

As long as a string contains a numeric value, Python can convert the string to an integer. SinceA isn’t a numeric value, you receive aValueError when callingsorted() withkey=int.

Combiningsorted() Withlambda Functions

Thekey functionality is extremely powerful because it allows you to manipulate the output order using almost any function, whether built-in or user-defined.

If the ordering requirement is to order an iterable by each string spelled backwards, then you could define a function that reverses a word.

In the example below, you define a function namedreverse_word() that reverses the string passed to it. Then, you usereverse_word as the value ofkey when callingsorted():

>>>defreverse_word(word):...returnword[::-1]...>>>words=["cookie","banana","donut","pizza"]>>>sorted(words,key=reverse_word)['banana', 'pizza', 'cookie', 'donut']

Theword[::-1] slice syntax reverses a string. Each element will havereverse_word() applied to it, and the sorting order will be based on the characters in the reversed version of each word. If two words have the same final letter, the next letter is compared, and so on.

As a result, the elements inwords are sorted based on their ending letters, which is why"pizza" comes before"cookie" but after"banana".

Instead of writing a standalone function, you can shorten the code and leverage thelambda keyword. Withlambda, you can create ananonymous function, commonly refered to as alambda function.

By usinglambda, you can define a function inline and use it directly as the value ofkey. Instead of defining and callingreverse_word(), you can accomplish the same result with fewer lines of code:

>>>words=["cookie","banana","donut","pizza"]>>>sorted(words,key=lambdaword:word[::-1])['banana', 'pizza', 'cookie', 'donut']

In the example above, thekey is defined as alambda. Thelambda function takes one argument namedword. Then,word[::-1] is called on each element and reverses the word. That reversed output is then used for sorting, but the original words are still returned.

Understanding the Differences Between.sort() andsorted()

The.sort() method accomplishes more or less the same thing as thesorted() function. But there are four critical differences between.sort() andsorted():

1. .sort() is a method of thelist class.
2. .sort() can only be used with lists.
3. .sort() returnsNone.
4. .sort() modifies the order of elements in place.

As a method,.sort() works with the list instance itself. In other words, you don’t explicitly pass in an iterable as an argument.

Have a look at the impacts of these differences in code:

>>>tuple_val=(5,1,3,5)>>>tuple_val.sort()Traceback (most recent call last):...AttributeError:'tuple' object has no attribute 'sort'>>>values_to_sort=list(tuple_val)>>>returned_from_sort=values_to_sort.sort()>>>print(returned_from_sort)None>>>print(values_to_sort)[1, 3, 5, 5]

When you try calling.sort() with a tuple, you get anAttributeError because.sort() only exists for lists.

Then, there are some other pretty dramatic differences in how.sort() operates compared tosorted() in this code example:

1. .sort() returnsNone, so the assignment toreturned_from_sort isNone and not an ordered list.
2. Calling.sort() changes thevalues_to_sort list in place, and the original order is not maintained in any way.

These differences in behavior make.sort() andsorted() absolutely not interchangeable in code, and they can produce wildly unexpected outcomes if one is used in the wrong way.

Using Keywords Arguments With.sort() andsorted()

The.sort() method has the samekey andreverse optional keyword arguments that produce the same robust functionality assorted().

Revisit some examples from before, this time using.sort() instead ofsorted():

>>>numbers=[10,3,7][3, 7, 10]>>>numbers.sort(reverse=True)>>>numbers[10, 7, 3]

Just like when you usedsorted(), if you setreverse toTrue when calling.sort() on a list, then the sorting will be in descending order.

When you pass instr.lower as the value ofkey, you can sort strings independently of a character’s case:

>>>animals=["ape","Zebra","elephant"]>>>animals.sort(key=str.lower)>>>animals['ape', 'elephant', 'Zebra']

During sorting, the function passed tokey is being called on each element to determine the sort order.

If you want to practice using.sort(), then try refactoring thesorted() examples from earlier sections with.sort(). When doing so, keep in mind that.sort() only works with lists.