如何通过调用Python中的sort（）方法来调用和处理__lt__方法？

Question

Executing this code:

class Person(object):

    def __init__(self, name):
        self.name = name
        try:
            lastBlank = name.rindex(' ')
            self.lastName = name[lastBlank+1:]
        except:
            self.lastName = name

    def __lt__(self, other):
        if self.lastName == other.lastName:
            return self.name < other.name
        return self.lastName < other.lastName

    def __str__(self):
        return self.name

me = Person('Michael Guttag')
him = Person('Barack Hussein Obama')
her = Person('Madonna')
pList = [me, him, her]
pList.sort() #invoke __lt__()
for p in pList:
    print p

and it outputs:

Michael Guttag
Madonna
Barack Hussein Obama

In the book where it exemplifies class and operator overloading (or polymorphism) it says: In addition to providing the syntactic convenience of writing infix expressions that use < , this overloading provides automatic access to any polymorphic method defined using __lt__ . The built-in method sort is one such method. So, for example, if pList is a list composed of elements of type Person , the call pList.sort() will sort that list using the __lt__ method defined in class Person .

I don't understand how sort() is a polymorphic method (actually the concept of polymorphism is still unclear to me after lots of researching), and how the method __lt__ does the sorting to give such an output. I need a step-by-step guide. Thank you!

Answer 1

The rich comparison methods - __lt__ , __le__ , __gt__ , __ge__ and __eq__ implement the various comparison operations. All of them compares two objects (one of them being self ). Together, they let you answer questions like "out of these two objects, which, if either, is bigger "? There are quite a few sorting algorithms that let you take a list of objects, and provided you can answer questions like that one on every pair of them, will let you put the whole list in the right order. For example, one of the easier to understand ones is called selection sort - it works like this:

1. Compare the first two items. Take the smallest (if they're equal, pick the first one), call it s
2. Compare s to the next item that you haven't checked yet, and if that item is smaller, it is now s (otherwise, s is still the old s )
3. Do Step 2 repeatedly until you have no more items you haven't checked. This means s is now the smallest item in your list.
4. Move s to the start the list, shifting all the others up to fill the 'gap' where s was.
5. Consider the rest of the list (ie, excluding the first item), and run this whole process on that.
6. Keep going - excluding the first two, then the first three, and so on - until the remaining list only has one item. The whole list is now sorted.

Python's list.sort method runs a more complex, but faster, algorithm called Timsort . It achieves the same thing: given that you can know how any two elements are ordered relative to each other, it will sort the whole list for you.

The details of how Timsort works aren't important - the point of using an existing method instead of writing your own is so you can just believe that it does work. One thing that does matter is that nowhere in the documentation does it guarantee that it will use exactly < to compare each pair of elements - it is a good idea to implement at least __eq__ as well so that sort can know if two Person s happen to be equal. You could write it like this:

def __eq__(self, other):
    return self.name == other.name

Once you've done that, there is a bit of builtin magic called functools.total_ordering that can fill in all the rest of the comparison methods for you. You can use it like this:

import functools

@functools.total_ordering
class Person:
    ....