So erhalten Sie Indizes eines sortierten Arrays in Python

Ich habe eine numerische Liste:

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

Nun, wenn ich diese Liste sortiere, um zu erhalten [1, 2, 3, 5, 100]. Was ich möchte, sind die Indizes der Elemente aus der ursprünglichen Liste in der sortierten Reihenfolge, dh [0, 1, 2, 4, 3] --- ala MATLABs Sortierfunktion, die sowohl Werte als auch Indizes zurückgibt.

Wenn Sie numpy verwenden, steht Ihnen die Funktion argsort () zur Verfügung:

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

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

Dies gibt die Argumente zurück, die das Array oder die Liste sortieren würden.

So etwas wie das nächste:

>>> 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) gibt Ihnen eine Liste mit Tupeln von (Index, Wert):

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

Sie sortieren die Liste, indem Sie sie an übergeben sortedund eine Funktion zum Extrahieren des Sortierschlüssels angeben (das zweite Element jedes Tupels; dafür lambdaist das vorgesehen. Schließlich wird der ursprüngliche Index jedes sortierten Elements mithilfe des [i[0] for i in ...]Listenverständnisses extrahiert .

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

[0, 1, 2, 4, 3]

Die Antworten mit enumeratesind nett, aber ich persönlich mag das Lambda nicht, das verwendet wird, um nach dem Wert zu sortieren. Im Folgenden werden nur der Index und der Wert umgekehrt und sortiert. Es wird also zuerst nach Wert und dann nach Index sortiert.

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

Aktualisierte Antwort mit enumerateund itemgetter:

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

Zippen Sie die Listen zusammen: Das erste Element im Tupel enthält den Index, das zweite den Wert (sortieren Sie ihn dann nach dem zweiten Wert des Tupels x[1] , x ist das Tupel).

Oder mit itemgetteraus dem operatorModul`:

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

Ich habe diese mit perfplot (einem meiner Projekte) schnell überprüft und festgestellt, dass es schwierig ist, etwas anderes als numpy zu empfehlen (beachten Sie die Protokollskala):

Code zur Reproduktion der Handlung:

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)",
    logx=True,
    logy=True,
)

Wenn Sie numpy nicht verwenden möchten,

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

ist am schnellsten, wie hier gezeigt .

Im Wesentlichen müssen Sie eine durchführen argsort. Welche Implementierung Sie benötigen, hängt davon ab, ob Sie externe Bibliotheken (z. B. NumPy) verwenden möchten oder ob Sie Pure-Python ohne Abhängigkeiten bleiben möchten.

Die Frage, die Sie sich stellen müssen, lautet: Wollen Sie die

• Indizes, die das Array / die Liste sortieren würden
• Indizes, die die Elemente im sortierten Array / in der sortierten Liste haben würden

Leider macht das Beispiel in der Frage nicht klar, was gewünscht wird, da beide das gleiche Ergebnis liefern:

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

Auswahl der argsortImplementierung

Wenn Sie NumPy zur Verfügung haben, können Sie einfach die Funktion numpy.argsortoder Methode verwendennumpy.ndarray.argsort .

Eine Implementierung ohne NumPy wurde bereits in einigen anderen Antworten erwähnt, daher werde ich hier nur die schnellste Lösung gemäß der Benchmark-Antwort zusammenfassen

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

Abrufen der Indizes, die das Array / die Liste sortieren würden

Um die Indizes zu erhalten, die das Array / die Liste sortieren würden, können Sie einfach argsortdas Array oder die Liste aufrufen . Ich verwende hier die NumPy-Versionen, aber die Python-Implementierung sollte die gleichen Ergebnisse liefern

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

Das Ergebnis enthält die Indizes, die zum Abrufen des sortierten Arrays erforderlich sind.

Da das sortierte Array [1, 2, 3, 4]das argsortierte Array wäre, enthält es die Indizes dieser Elemente im Original.

• Der kleinste Wert ist 1und befindet sich am Index 1im Original, sodass das erste Element des Ergebnisses ist1 .
• Das 2ist 2im Original im Index, also ist das zweite Element des Ergebnisses 2.
• Das 3ist 0im Original im Index, also ist das dritte Element des Ergebnisses 0.
• Der größte Wert 4und der Index 3im Original, also das letzte Element des Ergebnisses 3.

Abrufen der Indizes, die die Elemente im sortierten Array / in der sortierten Liste haben würden

In diesem Fall müssten Sie sich argsort zweimal bewerben :

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

In diesem Fall :

• Das erste Element des Originals ist 3der drittgrößte Wert, sodass es einen Index 2im sortierten Array / der sortierten Liste hat, also das erste Element 2.
• Das zweite Element des Originals ist 1der kleinste Wert, sodass es einen Index 0im sortierten Array / der sortierten Liste hat, also das zweite Element 0.
• Das dritte Element des Originals ist 2der zweitkleinste Wert, sodass es einen Index 1im sortierten Array / der sortierten Liste hat, also das dritte Element 1.
• Das vierte Element des Originals ist 4der größte Wert, sodass es einen Index 3im sortierten Array / der sortierten Liste hat, also das letzte Element 3.

Die anderen Antworten sind falsch.

argsortEinmal laufen ist nicht die Lösung. Zum Beispiel der folgende Code:

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

Renditen, array([1, 2, 0], dtype=int64)die wir nicht wollen.

Die Antwort sollte sein, argsortzweimal zu laufen :

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

gibt array([2, 0, 1], dtype=int64)wie erwartet.

Importiere numpy als np

FÜR 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 Gibt die Indizes von S in sortierter Reihenfolge zurück

FÜR WERT

np.sort(S)

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

Wir werden ein weiteres Array von Indizes von 0 bis n-1 erstellen. Dann komprimieren Sie dieses in das ursprüngliche Array und sortieren es dann anhand der ursprünglichen Werte

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

`