numpy.lexsort#

numpy.lexsort(keys, axis=-1)#

使用一系列键执行间接稳定排序。

给定多个排序键，lexsort 返回一个整数索引数组，该数组描述了根据多个键的排序顺序。序列中的最后一个键用于主要排序顺序，使用倒数第二个键打破平局，依此类推。

参数:
keys(k, m, n, …) 类数组

要排序的 k 个键。最后一个键（例如，如果 keys 是一个二维数组，则为最后一行）是主要排序键。keys 沿第零轴的每个元素必须是相同形状的类数组对象。

axisint，可选

要间接排序的轴。默认情况下，对每个序列的最后一个轴进行排序。沿 axis 分割的切片独立排序；请参阅最后一个示例。

返回值:
indices(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])

keys 的第零轴始终对应于键序列，因此二维数组的处理方式与其他键序列相同。

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

因此，axis 参数指的是每个键的轴，而不是 keys 参数本身的轴。例如，数组 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]
本页内容