numpy.sort

numpy.sort(a, ось=-1, kind=None, порядок=None, *, стабильный=None)

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

Параметры:

aarray_like

Массив для сортировки.

осьint или None, опционально

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

kind{‘quicksort’, ‘mergesort’, ‘heapsort’, ‘stable’}, опционально

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

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

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

стабильныйbool, необязательно

Стабильность сортировки. Если 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 сортируются в конец. Расширенный порядок сортировки:

• Real: [R, nan]

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

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

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

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

Timsort добавлен для лучшей производительности на уже или почти отсортированных данных. На случайных данных timsort почти идентичен mergesort. Теперь он используется для стабильной сортировки, в то время как quicksort по-прежнему является сортировкой по умолчанию, если ничего не выбрано. Подробности о timsort см. в CPython listsort.txt 'mergesort' и 'stable' сопоставляются с поразрядной сортировкой для целочисленных типов данных. Поразрядная сортировка имеет сложность O(n) вместо O(n log n).

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

Примеры

Попробуйте в вашем браузере!

>>> import numpy as np
>>> 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]])

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

>>> 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', '

Сортировка по возрасту, затем по росту, если возрасты равны:

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

НазадОткрыть во вкладке