numpy.sort

numpy.sort(a, axis=-1, kind=None, order=None, *, stable=None)[source]

Возвращает отсортированную копию массива.

Параметры:

aarray_like

Массив, который нужно отсортировать.

axisint или None, необязательно

Ось, по которой нужно отсортировать. Если None, массив сжимается перед сортировкой. По умолчанию -1, что сортирует по последней оси.

kind{‘quicksort’, ‘mergesort’, ‘heapsort’, ‘stable’}, optional

Алгоритм сортировки. По умолчанию ‘quicksort’. Обратите внимание, что как ‘stable’, так и ‘mergesort’ используют timsort или radix sort, и, как правило, фактическая реализация будет различаться в зависимости от типа данных. Вариант ‘mergesort’ сохранён для обратной совместимости.

Изменено в версии 1.15.0.: Добавлен параметр ‘stable’.

orderstr или список str, необязательно

Когда a — массив с определёнными полями, этот аргумент указывает, какие поля сравнивать в первую, вторую и т. д. очередь. Одно поле можно указать как строку, и не все поля нужно указывать, но не указанные поля всё равно будут использоваться в порядке их появления в dtype, чтобы разрушить ничьи.

stablebool, optional

Устойчивость сортировки. Если True, возвращаемый массив будет сохранять относительный порядок a значений, которые сравниваются как равные. Если False или None, это не гарантируется. Внутренне этот параметр выбирает kind='stable'. По умолчанию: None.

Новое в версии 2.0.0.

Возвращает:

sorted_arrayndarray

Массив того же типа и формы, что и a.

См. также

ndarray.sort

Метод сортировки массива на месте.

argsort

Косвенная сортировка.

lexsort

Косвенная устойчивая сортировка по нескольким ключам.

searchsorted

Поиск элементов в отсортированном массиве.

partition

Частичная сортировка.

Примечания

Различные алгоритмы сортировки характеризуются своей средней скоростью, производительностью в худшем случае, размером рабочей области и тем, являются ли они устойчивыми. Устойчивая сортировка сохраняет элементы с одинаковым ключом в том же относительном порядке. Четыре реализованных в NumPy алгоритма имеют следующие свойства:

kind	скорость	худший случай	рабочая область	устойчива
‘quicksort’	1	O(n^2)	0	нет
‘heapsort’	3	O(n*log(n))	0	нет
‘mergesort’	2	O(n*log(n))	~n/2	да
‘timsort’	2	O(n*log(n))	~n/2	да

Примечание

Тип данных определяет, какой из ‘mergesort’ или ‘timsort’ фактически используется, даже если указан ‘mergesort’. Пользовательский выбор на более мелком уровне в настоящее время недоступен.

Для повышения производительности sort создаёт временную копию при необходимости, чтобы данные были смежными в памяти вдоль оси сортировки. Для ещё лучшей производительности и уменьшения потребления памяти убедитесь, что массив уже смежен вдоль оси сортировки.

Порядок сортировки для комплексных чисел является лексикографическим. Если обе вещественные и мнимые части не являются NaN, то порядок определяется вещественными частями, за исключением случаев, когда они равны, в этом случае порядок определяется мнимыми частями.

До numpy 1.4.0 сортировка вещественных и комплексных массивов, содержащих значения NaN, приводила к неопределённому поведению. В версиях numpy ≥ 1.4.0 значения NaN сортируются в конец. Расширенный порядок сортировки:

• Вещественные: [R, nan]
• Комплексные: [R + Rj, R + nanj, nan + Rj, nan + nanj]

где R — вещественное значение, не равное NaN. Комплексные значения с одинаковым расположением nan сортируются в соответствии с не-nan частью, если она существует. Значения, не равные NaN, сортируются как и раньше.

Новое в версии 1.12.0.

quicksort был изменён на: introsort. Когда сортировка не делает достаточного прогресса, она переключается на heapsort. Эта реализация делает quicksort O(n*log(n)) в худшем случае.

‘stable’ автоматически выбирает лучший устойчивый алгоритм сортировки для сортируемого типа данных. Он, вместе с ‘mergesort’, в настоящее время отображается на timsort или radix sort в зависимости от типа данных. Совместимость с API в настоящее время ограничивает возможность выбора реализации, и она жёстко задана для различных типов данных.

Новое в версии 1.17.0.

Timsort добавлен для повышения производительности на уже или почти отсортированных данных. На случайных данных timsort почти идентичен mergesort. Он теперь используется для устойчивой сортировки, в то время как quicksort всё ещё является алгоритмом по умолчанию, если не выбран другой. Для подробностей о timsort см. CPython listsort.txt. ‘mergesort’ и ‘stable’ отображаются на radix sort для целочисленных типов данных. Radix sort — сортировка O(n) вместо O(n log n).

Изменено в версии 1.18.0.

NaT теперь сортируется в конец массивов для согласованности с NaN.

Примеры

>>> a = np.array([[1,4],[3,1]])
>>> np.sort(a)                # sort along the last axis
array([[1, 4],
       [1, 3]])
>>> np.sort(a, axis=None)     # sort the flattened array
array([1, 1, 3, 4])
>>> np.sort(a, axis=0)        # sort along the first axis
array([[1, 1],
       [3, 4]])

Используйте ключевое слово order для указания поля для использования при сортировке структурированного массива:

>>> dtype = [('name', 'S10'), ('height', float), ('age', int)]
>>> values = [('Arthur', 1.8, 41), ('Lancelot', 1.9, 38),
...           ('Galahad', 1.7, 38)]
>>> a = np.array(values, dtype=dtype)       # create a structured array
>>> np.sort(a, order='height')                        
array([('Galahad', 1.7, 38), ('Arthur', 1.8, 41),
       ('Lancelot', 1.8999999999999999, 38)],
      dtype=[('name', '|S10'), ('height', '<f8'), ('age', '<i4')])

Отсортировать по возрасту, затем по росту, если возраст одинаковый:

>>> np.sort(a, order=['age', 'height'])               
array([('Galahad', 1.7, 38), ('Lancelot', 1.8999999999999999, 38),
       ('Arthur', 1.8, 41)],
      dtype=[('name', '|S10'), ('height', '<f8'), ('age', '<i4')])