Sorting a list or tuple is easy in Python! Since a tuple is basically like an array that is not modifiable, we’ll treat it almost the same as a list.
Sorting a Python List the Simple Way
Okay, so if you only want to sort a list of numbers, Python has a built-in function that does all the hard work for you.
Say we have a list of numbers:
>>> a = [3, 6, 8, 2, 78, 1, 23, 45, 9]
And we want to sort them in ascending order. All we do is call sort
on the list, for in-place sorting, or the built-in function sorted
for not modifying the original list and returning a new sorted list. Both functions take in the same arguments and can be treated as “the same” for our purposes here, except for the reason above.
Here we go:
>>> sorted(a) [1, 2, 3, 6, 8, 9, 23, 45, 78] >>> >>> a.sort() >>> a [1, 2, 3, 6, 8, 9, 23, 45, 78]
- Python Programming – Tuple Functions
- Python Programming – Python Native Data Types
- How to Slice Lists/Arrays and Tuples in Python
What about descending order?
Here you go:
>>> sorted(a, reverse=True) [78, 45, 23, 9, 8, 6, 3, 2, 1] >>> a.sort(reverse=True) >>> l [78, 45, 23, 9, 8, 6, 3, 2, 1]
What is Python doing behind the scenes? It’s calling a version of mergesort on the list. It calls the function __cmp__
on each object when comparing values, and decides which one to put in front of the other based on the value returned from __cmp__
. The return value is 0
for equal to, 1
for greater than, and -1
for less than the compared value. We’ll use this information later to make our own objects sortable.
What about tuples, you say? I’m getting to that.
Sorting a Python Tuple the Simple Way
Since tuples are arrays that you cannot modify, they don’t have an in-place sort
function that can be called directly on them. They must always use the sorted
function to return a sorted list. Keeping that in mind, here’s how to do it:
>>> tup = (3, 6, 8, 2, 78, 1, 23, 45, 9) >>> sorted(tup) [1, 2, 3, 6, 8, 9, 23, 45, 78]
Notice how sorted
returns an array.
Okay, now let’s see how to sort something a little more complicated.
Sorting a List of Lists or Tuples
This is a little more complicated, but still pretty easy, so don’t fret! Both the sorted
function and the sort
function take in a keyword argument called key
.
What key
does is it provides a way to specify a function that returns what you would like your items sorted by. The function gets an “invisible” argument passed to it that represents an item in the list, and returns a value that you would like to be the item’s “key” for sorting.
Let me illustrate, for your superb eyes only, the key
keyword argument!
So, taking a new list, let’s test it out by sorting by the first item in each sub-list:
>>> def getKey(item): ... return item[0] >>> l = [[2, 3], [6, 7], [3, 34], [24, 64], [1, 43]] >>> sorted(l, key=getKey) [[1, 43], [2, 3], [3, 34], [6, 7], [24, 64]]
Here we can see that the list is now sorted by the first item in the sub-list in ascending order. Note that you could have used the sort
function as well, but I personally like the sorted
function better, so I’ll be using that in further examples.
What happened? Remember that “invisible” argument I was talking about? That’s what gets passed into the getKey
function every time the sorted
needs a value. Tricky, tricky python ;).
Sorting by the second item in each sub-list would be as simple as changing the getKey
function to this:
def getKey(item): return item[1]
Alright. All good. Now, what about a list of tuples? Glad you asked!
It’s actually the exact same as our example above, but has the list defined as such:
>>> a = [(2, 3), (6, 7), (3, 34), (24, 64), (1, 43)] >>> sorted(l, key=getKey) [(1, 43), (2, 3), (3, 34), (6, 7), (24, 64)]
The only thing that has changed is that we now get a list of tuples instead of a list of lists returned to us.
The exact same solution can be applied to a tuple of tuples, so I’m not going to go there, as that would just be redundant. It would also waste more of those digital trees that make this beautiful digital paper.
Sorting a List (or Tuple) of Custom Python Objects
Here’s a custom object that I created:
def __init__(self, name, number): self.name = name self.number = number
Let’s make a list of them, for sorting purposes:
customlist = [ Custom('object', 99), Custom('michael', 1), Custom('theodore the great', 59), Custom('life', 42) ]
Okay, so we’ve got all of our fancy new custom objects in a list and we want to be able to sort them. How do we do that?
Well, we could define a function, like we did above, that takes in the item and returns a list. So let’s do that.
def getKey(custom): return custom.number
This one is a little different, because our object is not a list anymore. This allows us to sort by the number
property in the custom object.
So if we run the sorted
function on our list of fancy custom objects, we get this:
>>> sorted(customlist, key=getKey) [<__main__.Custom object at 0x7f64660cdfd0>, <__main__.Custom object at 0x7f64660d5050>, <__main__.Custom object at 0x7f64660d5090>, <__main__.Custom object at 0x7f64660d50d0>]
A big mess of ugliness that we don’t understand. Perfect. But don’t worry, dear viewer, there is a simple fix we can apply to our custom object to make it all better!
Let’s redefine our object class like this:
class Custom(object): def __init__(self, name, number): self.name = name self.number = number def __repr__(self): return '{}: {} {}'.format(self.__class__.__name__, self.name, self.number)
Ok, what the heck did we just do? First, the __repr__
function tells Python how we want the object to be represented as. In more complex terms, it tells the interpreter how to display the object when it is printed to the screen.
So, we tell Python to represent the object by it’s class name, name, and number.
Now lets try sorting it again:
>>> sorted(customlist, key=getKey) [Custom: michael 1, Custom: life 42, Custom: theodore the great 59, Custom: object 99]
That’s much better! Now we can actually tell that it sorted properly!
But there’s a little bit of a problem. It’s just nit-picking, but I don’t want to have to type that key
keyword every time I call sorted.
So, how do I do that? Well, remember that __cmp__
function I told you about? Let’s put it into action!
Let’s redefine our object one more time like this:
class Custom(object): def __init__(self, name, number): self.name = name self.number = number def __repr__(self): return '{}: {} {}'.format(self.__class__.__name__, self.name, self.number) def __cmp__(self, other): if hasattr(other, 'number'): return self.number.__cmp__(other.number)
Looking good. What this does is tell Python to compare the value of the current object to another object in the list to see how it compares. Like I said above, the sorted
function will call the __cmp__
function on the objects it is sorting in order to determine where they should be in relation to other objects.
Now we can just call sorted
without worrying about including the key
keyword, like so:
>>> sorted(customlist) [Custom: michael 1, Custom: life 42, Custom: theodore the great 59, Custom: object 99]
And voilà! It works nicely. Please note that all of the above also applies to tuples of the custom object. But I like to save my digital trees, as you know.
Sorting a Heterogeneous List of Custom Python Objects
Alright. Since Python is a dynamic language, it doesn’t so much care about what objects we throw into lists. They can all be the same type, or they can all be different.
So let’s define another different object to use with our Custom
object.
class AnotherObject(object): def __init__(self, tag, age, rate): self.tag = tag self.age = age self.rate = rate def __repr__(self): return '{}: {} {} {}'.format(self.__class__.__name__, self.tag, self.age, self.rate) def __cmp__(self, other): if hasattr(other, 'age'): return self.age.__cmp__(other.age)
It’s a similar object, but still different from our Custom
object.
Let’s make a list of these and our Custom
objects:
customlist = [ Custom('object', 99), Custom('michael', 1), Custom('theodore the great', 59), Custom('life', 42), AnotherObject('bananas', 37, 2.2), AnotherObject('pants', 73, 5.6), AnotherObject('lemur', 44, 9.2) ]
Now if we try to run sorted
on this list:
>>> sorted(customlist) Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: an integer is required
We get a lovely error. Why? Because Custom
doesn’t have an attribute called age
and AnotherObject
doesn’t have an attribute called number
.
What do we do? Panic!
Just kidding. We know what to do. Let’s redefine those objects again!
class Custom(object): def __init__(self,name,number): self.name = name self.number = number def __repr__(self): return '{}: {} {}'.format(self.__class__.__name__, self.name, self.number) def __cmp__(self, other): if hasattr(other, 'getKey'): return self.getKey().__cmp__(other.getKey()) def getKey(self): return self.number class AnotherObject(object): def __init__(self, tag, age, rate): self.tag = tag self.age = age self.rate = rate def __repr__(self): return '{}: {} {} {}'.format(self.__class__.__name__, self.tag, self.age, self.rate) def __cmp__(self, other): if hasattr(other, 'getKey'): return self.getKey().__cmp__(other.getKey()) def getKey(self): return self.age
Awesome! What did we just do? We defined a common getKey
function that both of the objects have so that we can compare them easily.
So now if we run the sorted
function again, we get:
>>> sorted(customlist) [Custom: michael 1, AnotherObject: bananas 37 2.2, Custom: life 42, AnotherObject: lemur 44 9.2, Custom: theodore the great 59, AnotherObject: pants 73 5.6, Custom: object 99]
Nice! Now our objects can be compared and sorted to their hearts content.
You still prefer the using the key
keyword, you say?
You can do that too. If you leave out the __cmp__
functions in each object, and define an outside function like so:
def getKey(customobj): return customobj.getKey()
And then call sorted like so:
>>> sorted(customlist, key=getKey) [Custom: michael 1, AnotherObject: bananas 37 2.2, Custom: life 42, AnotherObject: lemur 44 9.2, Custom: theodore the great 59, AnotherObject: pants 73 5.6, Custom: object 99]
And there you have it! Pretty straight forward, but not as straight forward as some might guess. Still, Python makes it pretty easy with its built in sorted
function.
For more sorting ideas, head over to How to Sort Python Dictionaries by Key or Value. You could also check out Lambda Function Syntax (Inline Functions) in Python for instructions on how to sort with lambda functions.
And there you are. One step closer to becoming the world’s Python master.
Sayonara, for now.