numpy.lexsort

numpy.lexsort(keys, axis=-1)

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

给定多个排序键,lexsort 返回一个整数索引数组,该数组描述了按多个键的排序顺序.序列中的最后一个键用于主排序顺序,关系由倒数第二个键打破,依此类推.

参数:

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

要排序的 k 个键.最后一个键(例如,如果 keys 是一个 2D 数组,则为最后一行)是主排序键. keys 中沿第零轴的每个元素必须是形状相同的类数组对象.

axis整数,可选

要间接排序的轴.默认情况下,对每个序列的最后一个轴进行排序.沿 axis 分隔的切片独立排序;请参见最后一个示例.

返回:

indices(m, n, …) 整数的ndarray

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

参见

argsort

间接排序.

ndarray.sort

原地排序.

sort

返回数组的排序副本.

示例

Try it in your browser!

对名称进行排序:首先按姓氏,然后按名字.

>>> 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 的第零轴始终与键的序列对应,因此 2D 数组的处理方式与其他键的序列相同.

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

因此, axis 参数引用每个键的轴,而不是 keys 参数本身的轴.例如,数组 arr 被视为两个 1-D 键的序列,因此指定 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]

Go BackOpen In Tab