在 Python 2.3 中按最后 N 个字符对字符串列表进行排序

Question

In newer Python, I am able to use the sorted function and easily sort out a list of strings according to their last few chars as such:

lots_list = ['anything']

print sorted(lots_list, key=returnlastchar)

def returnlastchar(s):     
    return s[10:] 

How can I implement the above to lots_list.sort() in older Python (2.3)?

" Error: When I tried using sorted() , the global name sorted is not defined . "

Answer 1

The Schwartzian transform is usually more efficient than using the cmp argument (This is what newer versions of Python do when using the key argument)

lots_list=['anything']

def returnlastchar(s):     
    return s[10:] 

decorated = [(returnlastchar(s), s) for s in lots_list]
decorated.sort()
lots_list = [x[1] for x in decorated]

Answer 2

I don't have python 2.3 on hand, however, according to this post Sorting a list of lists by item frequency in Python 2.3 http://docs.python.org/release/2.3/lib/typesseq-mutable.html this method should also works for you.

def mycmp(a, b):
    return cmp(a[10:], b[10:])

lots_list.sort(mycmp)

Answer 3

It's not hard to write you're own version of sorted . Here is a drop-in replacement (excluding the cmp paramenter):

def _count():
    i = 0
    while 1:
        yield i
        i += 1

def sorted(iterable, key=None, reverse=False):
    'Drop-in replacement for the sorted() built-in function (excluding cmp())'
    seq = list(iterable)
    if reverse:
        seq.reverse()
    if key is not None:
        seq = zip(map(key, seq), _count(), seq)
    seq.sort()
    if key is not None:
        seq = map(lambda decorated: decorated[2], seq)
    if reverse:
        seq.reverse()
    return seq

Answer 4

You can write your own sorted() like so:

try:
    sorted
except NameError:
    def sorted(seq, key=None):
        lst = list(seq)  # get copy of list
        if key is not None:
            def my_cmp(a, b):
                return cmp(key(a), key(b))
        else:
            my_cmp = cmp
        lst.sort(my_cmp)
        return lst

This will only define your new sorted() if there is no built-in sorted() . First, we try to evaluate the name sorted and if we get a NameError we define our own. I'm using map(None, seq) as a fast way to make a new list out of the values of seq .

Or, if we want to use the Schwartzian Transform for maximum efficiency as suggested by @gnibbler:

try:
    sorted
except NameError:
    import operator as op
    def sorted(seq, key=None):
        if key is not None:
            lst = [(key(x), x) for x in seq]
            lst.sort()
            return map(lambda x: x[1], lst)
        else:
            lst = list(seq) # get list from sequence
            lst.sort()
            return lst