numpy.lexsort#

numpy.lexsort(ключи, ось=-1)#

Выполнить косвенную устойчивую сортировку с использованием последовательности ключей.

При наличии нескольких ключей сортировки lexsort возвращает массив целочисленных индексов, который описывает порядок сортировки по нескольким ключам. Последний ключ в последовательности используется для первичного порядка сортировки, совпадения разрешаются предпоследним ключом и так далее.

Параметры:

ключи(k, m, n, …) array-like: The k ключи для сортировки. The last ключ (например, последняя строка, если ключи является 2D массивом) является основным ключом сортировки. Каждый элемент ключи вдоль нулевой оси должен быть объектом, подобным массиву, той же формы.
осьint, необязательный: Ось для косвенной сортировки. По умолчанию сортировка выполняется по последней оси каждой последовательности. Отдельные срезы вдоль ось сортируется независимо; см. последний пример.

Возвращает:

индексы(m, n, …) ndarray из целых чисел: Массив индексов, сортирующих ключи вдоль указанной оси.

Смотрите также

argsort: Косвенная сортировка.
ndarray.sort: Сортировка на месте.
sort: Возвращает отсортированную копию массива.

Примеры

Сортировать имена: сначала по фамилии, затем по имени.

>>> import numpy as np
>>> surnames =    ('Hertz',    'Galilei', 'Hertz')
>>> first_names = ('Heinrich', 'Galileo', 'Gustav')
>>> ind = np.lexsort((first_names, surnames))
>>> ind
array([1, 2, 0])

>>> [surnames[i] + ", " + first_names[i] for i in ind]
['Galilei, Galileo', 'Hertz, Gustav', 'Hertz, Heinrich']

Сортировка по двум числовым ключам, сначала по элементам из a, затем разрешение ничьих в соответствии с элементами b:

>>> a = [1, 5, 1, 4, 3, 4, 4]  # First sequence
>>> b = [9, 4, 0, 4, 0, 2, 1]  # Second sequence
>>> ind = np.lexsort((b, a))  # Sort by `a`, then by `b`
>>> ind
array([2, 0, 4, 6, 5, 3, 1])
>>> [(a[i], b[i]) for i in ind]
[(1, 0), (1, 9), (3, 0), (4, 1), (4, 2), (4, 4), (5, 4)]

Сравнить с argsort, который бы сортировал каждый ключ независимо.

>>> np.argsort((b, a), kind='stable')
array([[2, 4, 6, 5, 1, 3, 0],
       [0, 2, 4, 3, 5, 6, 1]])

Для лексикографической сортировки с argsort, нам потребуется предоставить структурированный массив.

>>> x = np.array([(ai, bi) for ai, bi in zip(a, b)],
...              dtype = np.dtype([('x', int), ('y', int)]))
>>> np.argsort(x)  # or np.argsort(x, order=('x', 'y'))
array([2, 0, 4, 6, 5, 3, 1])

Нулевая ось ключи всегда соответствует последовательности ключей, поэтому 2D массивы обрабатываются так же, как и другие последовательности ключей.

>>> arr = np.asarray([b, a])
>>> ind2 = np.lexsort(arr)
>>> np.testing.assert_equal(ind2, ind)

Соответственно, ось параметр относится к оси каждый ключ, а не ключи сам аргумент. Например, массив arr рассматривается как последовательность двух одномерных ключей, поэтому указание axis=0 эквивалентно использованию оси по умолчанию, axis=-1.

>>> np.testing.assert_equal(np.lexsort(arr, axis=0),
...                         np.lexsort(arr, axis=-1))

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

>>> x = [[1, 2, 3, 4],
...      [4, 3, 2, 1],
...      [2, 1, 4, 3]]
>>> y = [[2, 2, 1, 1],
...      [1, 2, 1, 2],
...      [1, 1, 2, 1]]
>>> np.lexsort((x, y), axis=1)
array([[2, 3, 0, 1],
       [2, 0, 3, 1],
       [1, 0, 3, 2]])

Каждая строка результата — это то, что мы ожидали бы, если бы выполняли lexsort в соответствующей строке ключей:

>>> for i in range(3):
...     print(np.lexsort((x[i], y[i])))
[2 3 0 1]
[2 0 3 1]
[1 0 3 2]