How to sort a list of strings numerically

I approached the same problem yesterday and found a module called natsort, which solves your problem. Use:

from natsort import natsorted # pip install natsort

# Example list of strings
a = ['1', '10', '2', '3', '11']

[In]  sorted(a)
[Out] ['1', '10', '11', '2', '3']

[In]  natsorted(a)
[Out] ['1', '2', '3', '10', '11']

# Your array may contain strings
[In]  natsorted(['string11', 'string3', 'string1', 'string10', 'string100'])
[Out] ['string1', 'string3', 'string10', 'string11', 'string100']

It also works for dictionaries as an equivalent of sorted.

You could pass a function to the key parameter to the .sort method. With this, the system will sort by int(x) instead of x.

list1.sort(key=int)

BTW, to convert the list to integers permanently, use the map function

list1 = list(map(int, list1))   # you don't need to call list() in Python 2.x

or list comprehension

list1 = [int(x) for x in list1]

In case you want to use sorted() function: sorted(list1, key=int)

It returns a new sorted list.

You can also use:

import re

def sort_human(l):
    convert = lambda text: float(text) if text.isdigit() else text
    alphanum = lambda key: [convert(c) for c in re.split('([-+]?[0-9]*\.?[0-9]*)', key)]
    l.sort(key=alphanum)
    return l

This is very similar to other stuff that you can find on the internet but also works for alphanumericals like [abc0.1, abc0.2, ...].

Python's sort isn't weird. It's just that this code:

for item in list1:
   item=int(item)

isn't doing what you think it is - item is not replaced back into the list, it is simply thrown away.

Anyway, the correct solution is to use key=int as others have shown you.

Seamus Campbell's answer doesn't work on Python 2.x.

list1 = sorted(list1, key=lambda e: int(e)) using lambda function works well.

Try this. It’ll sort the list in-place in descending order (there isn’t any need to specify a key in this case):

Process

listB = [24, 13, -15, -36, 8, 22, 48, 25, 46, -9]
listC = sorted(listB, reverse=True) # listB remains untouched
print listC

output:

 [48, 46, 25, 24, 22, 13, 8, -9, -15, -36]

The real problem is that 'sort' sorts things alphanumerically.

So if you have a list, ['1', '2', '10', '19'], and run 'sort', you get ['1', '10'. '19', '2']. That is, 10 comes before 2, because it looks at the first character and sorts starting from that.

It seems most methods in Python return things in that order. For example, if you have a directory named 'abc' with the files labelled as 1.jpg, 2.jpg, etc., say, up to 15.jpg and you do file_list=os.listdir(abc), the file_list is not ordered as you expect, but rather as file_list=['1.jpg', '11.jpg'---'15.jpg', '2.jpg].

If the order in which files are processed is important (presumably that's why you named them numerically) the order is not what you think it will be. You can avoid this by using "zeros" padding. For example if you have a list, alist=['01', '03', '05', '10', '02','04', '06] and you run 'sort' on it, you get the order you wanted, alist=['01', '02', etc.], because the first character is 0 which comes before 1. The amount of zeros padding you need is determined by the largest value in the list.

For example, if the largest is, say, between 100 and 1000, you need to pad single digits as 001, 002 ---010, 011--100, 101, etc.

I've arrived here looking for a generic string, containing numbers at any position, which I think is not really solved in current answers (or, if covered, is way simpler).

I've come up with a simple solution covering that scenario:

def numeric_sort(input: Iterable[str]) -> List[str]:
    def repl(num):
        return f"{int(num[0]):010d}"

    return sorted(input, key=lambda i: re.sub(r'(\d+)', repl, i))


def test_numeric_sort():
    assert numeric_sort(["a2", "a11",  "a1"])   == ["a1", "a2", "a11"]
    assert numeric_sort(["a2", "a11",  "b1"])   == ["a2", "a11", "b1"]
    assert numeric_sort(["a2", "a2b3", "a2b1"]) == ["a2", "a2b1", "a2b3"]

You need to choose a limit for the maximum number (shouldn't be a problem). You can change int...:d for float...:f, once you adjust the regex.

It may be not the best Python code, but for string lists like ['1', '1.0', '2.0', '2', '1.1', '1.10', '1.11', '1.2', '7', '3', '5'], with the expected target ['1', '1.0', '1.1', '1.2', '1.10', '1.11', '2', '2.0', '3', '5', '7'] helped me...

unsortedList = ['1', '1.0', '2.0', '2', '1.1', '1.10', '1.11', '1.2', '7', '3', '5']
sortedList = []
sortDict = {}
sortVal = []
# Set zero correct (integer): example: 1.000 will be 1 and breaks the order
zero = "000"
for i in sorted(unsortedList):
  x = i.split(".")
  if x[0] in sortDict:
    if len(x) > 1:
        sortVal.append(x[1])
    else:
        sortVal.append(zero)
    sortDict[x[0]] = sorted(sortVal, key = int)
  else:
    sortVal = []
    if len(x) > 1:
        sortVal.append(x[1])
    else:
        sortVal.append(zero)
    sortDict[x[0]] = sortVal
for key in sortDict:
  for val in sortDict[key]:
    if val == zero:
       sortedList.append(str(key))
    else:
       sortedList.append(str(key) + "." + str(val))
print(sortedList)

The most recent solution is right. You are reading solutions as a string, in which case the order is 1, then 100, then 104 followed by 2 then 21, then 2001001010, 3 and so forth.

You have to cast your input as an int instead:

sorted strings:

stringList = (1, 10, 2, 21, 3)

sorted ints:

intList = (1, 2, 3, 10, 21)

To cast, just put the stringList inside int (blahblah).

Again:

stringList = (1, 10, 2, 21, 3)

newList = int (stringList)

print newList

=> returns (1, 2, 3, 10, 21)

A simple way to sort a numerical list:

numlists = ["5","50","7","51","87","97","53"]
results = list(map(int, numlists))
results.sort(reverse=False)
print(results)

If you want to use strings of the numbers, better take another list as shown in my code. It will work fine.

list1 = ["1", "10", "3", "22", "23", "4", "2", "200"]

k = []
for item in list1:
    k.append(int(item))

k.sort()
print(k)
# [1, 2, 3, 4, 10, 22, 23, 200]

Converting to int is nice but you can't always convert the whole string to int. So I just convert the \d+ substrings to int.

import re
from typing import List

def make_string_sortable_numerically(string:str) -> List[str|int]:
    def isolate_digits(x:str) -> List[str]:
        return re.split(r'(\d+)', x)
    def convert_digits_to_int(substrings:List[str]) -> List[str|int]:
        return [int(x) if str.isdigit(x) else x for x in substrings]
    return convert_digits_to_int(isolate_digits(string))

unsorted = ["abc100", "abc11"]
print(f"sored normally: {sorted(unsorted)}")
print(f"sorted numerically: {sorted(unsorted, key=make_string_sortable_numerically)}")

sored normally: ['abc100', 'abc11']
sorted numerically: ['abc11', 'abc100']

actually, the above answer has the same problem as https://stackoverflow.com/a/40039556/6307935. Here is something that I think should be robust:

def _make_string_sortable_numerically(string:str) -> List[Tuple[int, int]]:
    """
    each character becomes a tuple of two ints. The first int is either 0,1, or 2
    0 for characters that come before numbers, 1 for numbers, 2 for after numbers
    the second int is the unicode value of the character, or the integer value of the number
    that this character is a part of.
                $         7         8         9         a        ~
    "$789a~" -> [[0, 36], [1, 789], [1, 789], [1, 789], [2, 97], [2, 126]]
    """
    output = [[None, None] for _ in range(len(string))]
    skip_these_indexes = [False]*len(string)
    for i, char in enumerate(string):
        if skip_these_indexes[i]:
            continue
        char_int = ord(char)
        if char_int < ord("0"):
            output[i] = (0, char_int)
        elif str.isdigit(char):
            first_digit_index = i
            last_digit_index = i
            while (last_digit_index < len(string)-1 and str.isdigit(string[last_digit_index+1])):
                last_digit_index += 1
            this_number = int(string[first_digit_index:last_digit_index+1])
            for digit_index in range(first_digit_index, last_digit_index+1):
                skip_these_indexes[digit_index] = True
                output[digit_index] = (1, this_number)
        elif char_int > ord("9"):
            output[i] = (2, char_int)
    return output