numpy.lexsort#

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

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

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

参数:
keys(k, m, n, …) array-like

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

axisint, optional

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

返回:
indices(m, n, …) ndarray of ints

沿指定轴对键进行排序的索引数组。

另请参阅

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))

对于更高维度的数组，axis 参数开始起作用。结果数组的形状与每个键的形状相同，并且值是我们期望的，如果 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]
在此页面