numpy.sort

numpy.sort(a, axis=-1, kind='quicksort', order=None)

Функция sort() возвращает отсортированную копию массива.

Параметры:
a - массив NumPy или подобный массиву объект.
Исходный массив.
axis - целое число (необязательный параметр).
Определяет ось вдоль которой выполняется сортировка элементов. Если равен None, то сортировка выполняется по сжатому до одной оси представлению исходного массива. По умолчанию axis = -1, что соответствует сортировке по последней оси массива.
kind - строка (необязательный параметр).
Одна строка из множества {'quicksort', 'mergesort', 'heapsort', 'stable'}, которая указывает на алгоритм сортировки. Значение 'stable' приводит к автоматическому выбору устойчивого, лучшего алгоритма для типа данных сортируемого массива. По умолчанию kind = 'quicksort'.
order - строка или список строк (необязательный параметр).
В случае, когда массив a является структурированным, и его полям присвоено имя, то данный параметр позволяет указать порядок в котором они должны учавствовать в сортировке Если указаны не все поля, то неуказанные будут использоваться в том порядке в котором они перечислены в dtype структурированного массива.
Возвращает:
ndarray - массив NumPy
отсортированную копию исходного массива a с той же формой и типом данных.
Смотрите так же:
argsort, lexsort, searchsorted, partition

Замечание

Данная функция обладает эквивалентным методом класса ndarray, т.е. np.sort(a) равносильно вызову метода a.sort(), но в отличие от функции данный метод не возвращает копию, а меняет исходный массив:

>>> import numpy as np
>>> 
>>> 
>>> a = np.random.randint(0, 100, 10)
>>> a
array([64, 88,  2, 17, 89,  2, 77, 10, 70, 83])
>>> 
>>> np.sort(a)    #  возвращает копию
array([ 2,  2, 10, 17, 64, 70, 77, 83, 88, 89])
>>> 
>>> a.sort()      #  меняет исходный массив
>>> a
array([ 2,  2, 10, 17, 64, 70, 77, 83, 88, 89])

Параметр kind позволяет выбрать один из трех алгоритмов сортировки: 'quicksort', 'mergesort' или 'heapsort'. Каждый из алгоритмов делает временную копию данных при выполнении сортировки по всем осям кроме последней, так что сортировка только по последней оси выполняется быстрее всего и занимает меньше всего места.

Сортировка в массивах содержащих действительные числа и nan всегда сначала выполняется над действительными числами, а уже затем над nan.

Сортировка комплексных чисел выполняется лексикографически: если действительная и мнимая часть не равна nan то сортировка выполняется по действительной части, но если действительные части равны, то порядок определяется их мнимыми частями. Расширенный порядок сортировки: [R + Rj, R + nan, nan + Rj, nan + nan], где R - действительное число.

В NumPy, начиная с версии 1.12.0. алгоритм quicksort был заменен на алгоритм introsort.



Примеры

Сортировка одномерных массивов приводит к вполне ожидаемому результату:

>>> import numpy as np
>>> 
>>> a = np.random.randint(0, 100, 10)
>>> a
array([79,  6, 96,  4,  8, 70,  2, 94, 90, 83])
>>> 
>>> np.sort(a)
array([ 2,  4,  6,  8, 70, 79, 83, 90, 94, 96])

А вот многомерные массивы могут быть отсортированы по разным осям (направлениям). Например, двумерные массивы могут быть отсортированы как по столбцам так и по строкам:

>>> b = np.random.randint(0, 100, size = (6, 6))
>>> b
array([[79, 41, 17,  6, 12, 72],
       [34,  0, 13, 14,  3, 37],
       [70, 81, 28,  6, 33, 48],
       [85, 57, 18,  3, 47, 69],
       [43, 46,  5, 85,  6, 97],
       [93, 30, 98,  3,  2, 87]])
>>> 
>>> 
>>> np.sort(b, axis = 0)    #  сортировка по столбцам
array([[34,  0,  5,  3,  2, 37],
       [43, 30, 13,  3,  3, 48],
       [70, 41, 17,  6,  6, 69],
       [79, 46, 18,  6, 12, 72],
       [85, 57, 28, 14, 33, 87],
       [93, 81, 98, 85, 47, 97]])
>>> 
>>> np.sort(b, axis = 1)    #  сортировка по строкам (по умолчанию)
array([[ 6, 12, 17, 41, 72, 79],
       [ 0,  3, 13, 14, 34, 37],
       [ 6, 28, 33, 48, 70, 81],
       [ 3, 18, 47, 57, 69, 85],
       [ 5,  6, 43, 46, 85, 97],
       [ 2,  3, 30, 87, 93, 98]])

Трехмерные массивы, грубо говоря, могут быть отсортированы по "длине", "ширине" и "высоте":

>>> c = np.random.randint(0, 100, size = (2, 3, 4))
>>> c
array([[[66, 37, 91, 72],
        [68, 55, 76, 60],
        [98, 11, 99, 38]],

       [[22, 71,  0, 78],
        [21,  0, 60, 36],
        [46, 17, 88, 29]]])
>>> 
>>> np.sort(c, axis = 2)    #  сортировка по "ширине"
array([[[37, 66, 72, 91],
        [55, 60, 68, 76],
        [11, 38, 98, 99]],

       [[ 0, 22, 71, 78],
        [ 0, 21, 36, 60],
        [17, 29, 46, 88]]])
>>> 
>>> np.sort(c, axis = 1)    #  сортировка по "длине"
array([[[66, 11, 76, 38],
        [68, 37, 91, 60],
        [98, 55, 99, 72]],

       [[21,  0,  0, 29],
        [22, 17, 60, 36],
        [46, 71, 88, 78]]])
>>> 
>>> np.sort(c, axis = 0)    #  сортировка по "высоте"
array([[[22, 37,  0, 72],
        [21,  0, 60, 36],
        [46, 11, 88, 29]],

       [[66, 71, 91, 78],
        [68, 55, 76, 60],
        [98, 17, 99, 38]]])

Если выполняется сортировка структурированного массива, то параметр order позволяет указать по какому полю выполнять сортировку:

>>> data_type = [('recruit_name', 'U10'), ('age', int),
...              ('weight', float), ('height', float)]
>>> 
>>> recruit = [('Вася', 18, 57.1, 1.96),
...            ('Петька', 25, 94.9, 1.51),
...            ('Сёмка', 30, 72.5, 1.83),
...            ('Антоха', 30, 146.8, 1.76)]
>>> 
>>> vdv = np.array(recruit, dtype = data_type)
>>> vdv
array([('Вася', 18,  57.1, 1.96), ('Петька', 25,  94.9, 1.51),
       ('Сёмка', 30,  72.5, 1.83), ('Антоха', 30, 146.8, 1.76)],
      dtype=[('recruit_name', '<U10'), ('age', '<i4'), ('weight', '<f8'), ('height', '<f8')])
>>> 
>>> np.sort(vdv, order = 'weight')    #  сортировка по весу
array([('Вася', 18,  57.1, 1.96), ('Сёмка', 30,  72.5, 1.83),
       ('Петька', 25,  94.9, 1.51), ('Антоха', 30, 146.8, 1.76)],
      dtype=[('recruit_name', '<U10'), ('age', '<i4'), ('weight', '<f8'), ('height', '<f8')])
>>> 
>>> np.sort(vdv, order = 'height')    #  сортировка по росту
array([('Петька', 25,  94.9, 1.51), ('Антоха', 30, 146.8, 1.76),
       ('Сёмка', 30,  72.5, 1.83), ('Вася', 18,  57.1, 1.96)],
      dtype=[('recruit_name', '<U10'), ('age', '<i4'), ('weight', '<f8'), ('height', '<f8')])

Можно указывать несколько полей, заключив их в список, но так как в нашем списке нет людей с одинаковым ростом, то результат будет такой же как и для np.sort(vdv, order = 'height'):

>>> np.sort(vdv, order = ['height', 'weight'])    #  сортировка по росту и весу
array([('Петька', 25,  94.9, 1.51), ('Антоха', 30, 146.8, 1.76),
       ('Сёмка', 30,  72.5, 1.83), ('Вася', 18,  57.1, 1.96)],
      dtype=[('recruit_name', '<U10'), ('age', '<i4'), ('weight', '<f8'), ('height', '<f8')])