Comment obtenir les indices d'un tableau trié en Python

J'ai une liste numérique:

myList = [1, 2, 3, 100, 5]

Maintenant, si je trie cette liste pour l'obtenir [1, 2, 3, 5, 100]. Ce que je veux, ce sont les indices des éléments de la liste d'origine dans l'ordre trié, c'est-à-dire [0, 1, 2, 4, 3] --- la fonction de tri de MATLAB qui renvoie à la fois les valeurs et les indices.

Si vous utilisez numpy, vous disposez de la fonction argsort ():

>>> import numpy
>>> numpy.argsort(myList)
array([0, 1, 2, 4, 3])

http://docs.scipy.org/doc/numpy/reference/generated/numpy.argsort.html

Cela renvoie les arguments qui trieraient le tableau ou la liste.

Quelque chose comme la prochaine:

>>> myList = [1, 2, 3, 100, 5]
>>> [i[0] for i in sorted(enumerate(myList), key=lambda x:x[1])]
[0, 1, 2, 4, 3]

enumerate(myList) vous donne une liste contenant des tuples de (index, valeur):

[(0, 1), (1, 2), (2, 3), (3, 100), (4, 5)]

Vous triez la liste en la passant à sortedet en spécifiant une fonction pour extraire la clé de tri (le deuxième élément de chaque tuple; c'est la lambdaraison d'être. Enfin, l'index d'origine de chaque élément trié est extrait à l'aide de la [i[0] for i in ...]compréhension de la liste.

myList = [1, 2, 3, 100, 5]    
sorted(range(len(myList)),key=myList.__getitem__)

[0, 1, 2, 4, 3]

Les réponses enumeratesont agréables, mais personnellement, je n'aime pas le lambda utilisé pour trier par valeur. Ce qui suit inverse simplement l'index et la valeur et trie cela. Il va donc d'abord trier par valeur, puis par index.

sorted((e,i) for i,e in enumerate(myList))

Réponse mise à jour avec enumerateet itemgetter:

sorted(enumerate(a), key=lambda x: x[1])
# [(0, 1), (1, 2), (2, 3), (4, 5), (3, 100)]

Compressez les listes ensemble: le premier élément du tuple sera l'index, le second est la valeur (puis triez-le en utilisant la deuxième valeur du tuple x[1] , x est le tuple)

Ou en utilisant itemgetterdepuis le operatormodule`:

from operator import itemgetter
sorted(enumerate(a), key=itemgetter(1))

J'ai fait une vérification rapide des performances avec perfplot (un de mes projets) et j'ai trouvé qu'il était difficile de recommander autre chose que numpy (notez l'échelle logarithmique):

Code pour reproduire l'intrigue:

import perfplot
import numpy


def sorted_enumerate(seq):
    return [i for (v, i) in sorted((v, i) for (i, v) in enumerate(seq))]


def sorted_enumerate_key(seq):
    return [x for x, y in sorted(enumerate(seq), key=lambda x: x[1])]


def sorted_range(seq):
    return sorted(range(len(seq)), key=seq.__getitem__)


def numpy_argsort(x):
    return numpy.argsort(x)


perfplot.save(
    "argsort.png",
    setup=lambda n: numpy.random.rand(n),
    kernels=[sorted_enumerate, sorted_enumerate_key, sorted_range, numpy_argsort],
    n_range=[2 ** k for k in range(15)],
    xlabel="len(x)",
)

Si vous ne souhaitez pas utiliser numpy,

sorted(range(len(seq)), key=seq.__getitem__)

est le plus rapide, comme démontré ici .

Essentiellement, vous devez faire une argsort, quelle implémentation dont vous avez besoin dépend si vous voulez utiliser des bibliothèques externes (par exemple NumPy) ou si vous voulez rester pure-Python sans dépendances.

La question que vous devez vous poser est la suivante: voulez-vous

• indices qui trieraient le tableau / la liste
• indices que les éléments auraient dans le tableau / liste trié

Malheureusement, l'exemple de la question ne précise pas ce qui est souhaité car les deux donneront le même résultat:

>>> arr = np.array([1, 2, 3, 100, 5])

>>> np.argsort(np.argsort(arr))
array([0, 1, 2, 4, 3], dtype=int64)

>>> np.argsort(arr)
array([0, 1, 2, 4, 3], dtype=int64)

Choisir le argsort implémentation

Si vous avez NumPy à votre disposition, vous pouvez simplement utiliser la fonction numpy.argsortou la méthode numpy.ndarray.argsort.

Une implémentation sans NumPy a déjà été mentionnée dans certaines autres réponses, je vais donc récapituler la solution la plus rapide en fonction de la réponse de référence ici

def argsort(l):
    return sorted(range(len(l)), key=l.__getitem__)

Obtenir les indices qui trieraient le tableau / la liste

Pour obtenir les indices qui trieraient le tableau / la liste, vous pouvez simplement appeler argsortle tableau ou la liste. J'utilise les versions de NumPy ici mais l'implémentation Python devrait donner les mêmes résultats

>>> arr = np.array([3, 1, 2, 4])
>>> np.argsort(arr)
array([1, 2, 0, 3], dtype=int64)

Le résultat contient les indices nécessaires pour obtenir le tableau trié.

Puisque le tableau trié serait [1, 2, 3, 4]le tableau argsorted contient les indices de ces éléments dans l'original.

• La plus petite valeur est 1et elle est à l'index 1dans l'original, donc le premier élément du résultat est1 .
• Le 2est à l'index 2dans l'original donc le deuxième élément du résultat est 2.
• Le 3est à l'index 0dans l'original, donc le troisième élément du résultat est 0.
• La plus grande valeur 4et elle est à l'index 3dans l'original, donc le dernier élément du résultat est 3.

Obtention des indices que les éléments auraient dans le tableau / liste trié

Dans ce cas, vous devrez postuler argsort deux fois :

>>> arr = np.array([3, 1, 2, 4])
>>> np.argsort(np.argsort(arr))
array([2, 0, 1, 3], dtype=int64)

Dans ce cas :

• le premier élément de l'original est 3, qui est la troisième plus grande valeur de sorte qu'il aurait un index 2dans le tableau / liste trié de sorte que le premier élément est2 .
• le deuxième élément de l'original est 1, qui est la plus petite valeur pour qu'il ait un index 0dans le tableau / liste trié, de sorte que le deuxième élément l'est 0.
• le troisième élément de l'original est 2, qui est la deuxième plus petite valeur, de sorte qu'il aurait un index 1dans le tableau / liste trié, de sorte que le troisième élément l'est 1.
• le quatrième élément de l'original est 4la valeur la plus élevée, il aurait donc un index 3dans le tableau / la liste trié, de sorte que le dernier élément l'est 3.

Les autres réponses sont FAUX.

Courir argsortune fois n'est pas la solution. Par exemple, le code suivant:

import numpy as np
x = [3,1,2]
np.argsort(x)

des rendements array([1, 2, 0], dtype=int64)qui ne sont pas ce que nous voulons.

La réponse devrait être d'exécuter argsortdeux fois:

import numpy as np
x = [3,1,2]
np.argsort(np.argsort(x))

donne array([2, 0, 1], dtype=int64)comme prévu.

Importer numpy comme np

POUR INDEX

S=[11,2,44,55,66,0,10,3,33]

r=np.argsort(S)

[output]=array([5, 1, 7, 6, 0, 8, 2, 3, 4])

argsort Renvoie les indices de S dans l'ordre trié

POUR LA VALEUR

np.sort(S)

[output]=array([ 0,  2,  3, 10, 11, 33, 44, 55, 66])

Nous allons créer un autre tableau d'index de 0 à n-1 Puis compresser ceci dans le tableau d'origine, puis le trier sur la base des valeurs d'origine

ar = [1,2,3,4,5]
new_ar = list(zip(ar,[i for i in range(len(ar))]))
new_ar.sort()

"