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 被视为两个 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]
On this page