排序与字母混合的实数列表

Question

I have a list of data that I must sort, and sadly the naming scheme for these objects are not very consistent. The data is a list of strings that are most often real numbers, but sometimes have a letter on the end. Some examples of acceptable values in this list are like the following:

# this is how it should be sorted
['1', '1.1', '1.2', '2', '2.1A', '2.1B', '2.2A', '101.1', '101.2']

Since these are in a database, my first thought was to use the following django method to return the results sorted but it returns it as follows.

#took out unneeded code
choices = [l.number for l in Locker.objects.extra(
               select={'asnumber': 'CAST(number as BYTEA)'}).order_by('asnumber')]
print choices
==> ['1', '1.1', '101.1', '101.2', '2', '2.1A', '2.1B', '2.2A']

It sadly was unable to sort it as it should be. So my new plan is to write a method that would work with the python sorted method but I'm still not sure how to go about writing this. I need to find a way to sort by the real number portion of the string then as a secondary sort, sort by the letter appended to the end.

Any advice on where to go with this?

Answer 1

Let the DBMS do the sorting, that's what it is very good at. You can hardly rival the performance in your application.

If all you got is fractional numbers with A or B appended, you can simply:

SELECT *
FROM  (
   SELECT unnest(
    ARRAY['1', '1.1', '1.2', '2', '2.1A', '2.1B', '2.2A', '101.1', '101.2']) AS s
   ) x
ORDER  BY rtrim(s, 'AB')::numeric, s;

Orders exactly as requested, and fast, too. The subselect with ARRAY and unnest() is just for building a quick testcase. The ORDER BY clause is what matters - rtrim() in the manual .

If there are other characters involved, you might want to update your question to complete the picture.

Answer 2

x = ['1', '1.1', '1.2', '2', '2.1A', '2.1B', '2.2A', '101.1', '101.2']

#sort by the real number portion

import string

letters = tuple(string.ascii_letters)

def change(x):
    if x.endswith(letters):
        return float(x[:len(x) -1])
    else:
        return float(x)

my_list = sorted(x, key = lambda k: change(k))

Result:

>>> my_list
['1', '1.1', '1.2', '2', '2.1A', '2.1B', '2.2A', '101.1', '101.2']

Answer 3

I prematurely generalized to arbitrary amounts of letters on the end:

from itertools import takewhile

def sort_key(value):
    cut_point = len(value) - len(list(takewhile(str.isalpha, reversed(value))))
    return (float(value[:cut_point]), value[cut_point:])

sorted((
    l.number
    for l in Locker.objects.extra(select={'asnumber': 'CAST(number as BYTEA)'})
), key = sort_key)

Answer 4

Split the strings into tuples - a real number (convert it to float or decimal) and an often empty string of characters. If you sort the tuples, and use python's builtin sort (timesort), it should be really fast.

Be careful if scientific notation is allowed in your reals, eg 1e10.

If there's any chance at all that there'll be additional complexity in the comparisons later, use a class instead of a tuple. But the tuples will likely be faster. Then define one or more comparison functions (depending on if you're in python 2.x or 3.x).

Tuples compare element 0, then element 1, etc.

Your class alternative would need to have a cmp method or the 3.x equivalent.

Answer 5

Storing the string as a string and then parsing it to sort it seems like the wrong approach. If what you really have there is

• major number
• minor number
• optional revision

Then I would strongly suggest storing it as two integers and a text field. Sorting on major_number, minor_number, revision would work exactly as expected. You could either define the asnumber as a view at the database level or as a class based on the three base numbers with an associated __cmp__() .