Elenco di ordinamento basato sui valori di un altro elenco?

Ho un elenco di stringhe come questa:

X = ["a", "b", "c", "d", "e", "f", "g", "h", "i"]
Y = [ 0,   1,   1,   0,   1,   2,   2,   0,   1 ]

Qual è il modo più breve per ordinare X usando i valori da Y per ottenere il seguente output?

["a", "d", "h", "b", "c", "e", "i", "f", "g"]

L'ordine degli elementi che hanno la stessa "chiave" non ha importanza. Posso ricorrere all'uso di forcostrutti ma sono curioso di sapere se esiste un modo più breve. Eventuali suggerimenti?

Codice più breve

[x for _,x in sorted(zip(Y,X))]

Esempio:

X = ["a", "b", "c", "d", "e", "f", "g", "h", "i"]
Y = [ 0,   1,   1,    0,   1,   2,   2,   0,   1]

Z = [x for _,x in sorted(zip(Y,X))]
print(Z)  # ["a", "d", "h", "b", "c", "e", "i", "f", "g"]

Parlando in generale

[x for _, x in sorted(zip(Y,X), key=lambda pair: pair[0])]

Ha spiegato:

1. ziple due lists.
2. creare un nuovo, ordinato in listbase zipall'uso sorted().
3. usando una comprensione dell'elenco estrarre i primi elementi di ciascuna coppia dall'ordinato, compresso list.

Per ulteriori informazioni su come impostare \ utilizzare il keyparametro e la sortedfunzione in generale, dai un'occhiata a questo .

Comprimi le due liste insieme, ordinale, quindi prendi le parti che desideri:

>>> yx = zip(Y, X)
>>> yx
[(0, 'a'), (1, 'b'), (1, 'c'), (0, 'd'), (1, 'e'), (2, 'f'), (2, 'g'), (0, 'h'), (1, 'i')]
>>> yx.sort()
>>> yx
[(0, 'a'), (0, 'd'), (0, 'h'), (1, 'b'), (1, 'c'), (1, 'e'), (1, 'i'), (2, 'f'), (2, 'g')]
>>> x_sorted = [x for y, x in yx]
>>> x_sorted
['a', 'd', 'h', 'b', 'c', 'e', 'i', 'f', 'g']

Combina questi insieme per ottenere:

[x for y, x in sorted(zip(Y, X))]

Inoltre, se non ti dispiace usare array numpy (o in realtà hai già a che fare con array numpy ...), ecco un'altra bella soluzione:

people = ['Jim', 'Pam', 'Micheal', 'Dwight']
ages = [27, 25, 4, 9]

import numpy
people = numpy.array(people)
ages = numpy.array(ages)
inds = ages.argsort()
sortedPeople = people[inds]

L'ho trovato qui: http://scienceoss.com/sort-one-list-by-another-list/

La soluzione più ovvia per me è usare la keyparola chiave arg.

>>> X = ["a", "b", "c", "d", "e", "f", "g", "h", "i"]
>>> Y = [ 0,   1,   1,    0,   1,   2,   2,   0,   1]
>>> keydict = dict(zip(X, Y))
>>> X.sort(key=keydict.get)
>>> X
['a', 'd', 'h', 'b', 'c', 'e', 'i', 'f', 'g']

Tieni presente che puoi accorciarlo a una linea se ti interessa:

>>> X.sort(key=dict(zip(X, Y)).get)

In realtà sono venuto qui cercando di ordinare un elenco in base a un elenco in cui i valori corrispondevano.

list_a = ['foo', 'bar', 'baz']
list_b = ['baz', 'bar', 'foo']
sorted(list_b, key=lambda x: list_a.index(x))
# ['foo', 'bar', 'baz']

more_itertools ha uno strumento per ordinare in parallelo gli iterabili:

Dato

from more_itertools import sort_together


X = ["a", "b", "c", "d", "e", "f", "g", "h", "i"]
Y = [ 0,   1,   1,    0,   1,   2,   2,   0,   1]

dimostrazione

sort_together([Y, X])[1]
# ('a', 'd', 'h', 'b', 'c', 'e', 'i', 'f', 'g')

Mi piace avere un elenco di indici ordinati. In questo modo, posso ordinare qualsiasi elenco nello stesso ordine dell'elenco delle fonti. Una volta che hai un elenco di indici ordinati, una semplice comprensione dell'elenco farà il trucco:

X = ["a", "b", "c", "d", "e", "f", "g", "h", "i"]
Y = [ 0,   1,   1,    0,   1,   2,   2,   0,   1]

sorted_y_idx_list = sorted(range(len(Y)),key=lambda x:Y[x])
Xs = [X[i] for i in sorted_y_idx_list ]

print( "Xs:", Xs )
# prints: Xs: ["a", "d", "h", "b", "c", "e", "i", "f", "g"]

Si noti che l'elenco di indici ordinati può anche essere ottenuto utilizzando numpy.argsort().

Un'altra alternativa, che combina diverse risposte.

zip(*sorted(zip(Y,X)))[1]

Per lavorare con python3:

list(zip(*sorted(zip(B,A))))[1]

zip, ordina per seconda colonna, restituisce la prima colonna.

zip(*sorted(zip(X,Y), key=operator.itemgetter(1)))[0]

Una veloce fodera.

list_a = [5,4,3,2,1]
list_b = [1,1.5,1.75,2,3,3.5,3.75,4,5]

Dire che si desidera che l'elenco a corrisponda all'elenco b.

orderedList =  sorted(list_a, key=lambda x: list_b.index(x))

Ciò è utile quando è necessario ordinare un elenco più piccolo con valori più grandi. Supponendo che l'elenco più grande contenga tutti i valori nell'elenco più piccolo, è possibile farlo.

È possibile creare un pandas Series, utilizzando l'elenco primario come datae l'altro elenco come index, quindi ordinare semplicemente per indice:

import pandas as pd
pd.Series(data=X,index=Y).sort_index().tolist()

produzione:

['a', 'd', 'h', 'b', 'c', 'e', 'i', 'f', 'g']

Ecco la risposta di Whatangs se vuoi ottenere entrambi gli elenchi ordinati (python3).

X = ["a", "b", "c", "d", "e", "f", "g", "h", "i"]
Y = [ 0,   1,   1,    0,   1,   2,   2,   0,   1]

Zx, Zy = zip(*[(x, y) for x, y in sorted(zip(Y, X))])

print(list(Zx))  # [0, 0, 0, 1, 1, 1, 1, 2, 2]
print(list(Zy))  # ['a', 'd', 'h', 'b', 'c', 'e', 'i', 'f', 'g']

Ricorda solo che Zx e Zy sono tuple. Sto anche vagando se c'è un modo migliore per farlo.

Avvertenza: se lo esegui con elenchi vuoti si arresta in modo anomalo.

Ho creato una funzione più generale, che ordina più di due elenchi in base a un altro, ispirato dalla risposta di @ Whatang.

def parallel_sort(*lists):
    """
    Sorts the given lists, based on the first one.
    :param lists: lists to be sorted

    :return: a tuple containing the sorted lists
    """

    # Create the initially empty lists to later store the sorted items
    sorted_lists = tuple([] for _ in range(len(lists)))

    # Unpack the lists, sort them, zip them and iterate over them
    for t in sorted(zip(*lists)):
        # list items are now sorted based on the first list
        for i, item in enumerate(t):    # for each item...
            sorted_lists[i].append(item)  # ...store it in the appropriate list

    return sorted_lists

list1 = ['a','b','c','d','e','f','g','h','i']
list2 = [0,1,1,0,1,2,2,0,1]

output=[]
cur_loclist = []

Per ottenere valori univoci presenti in list2

list_set = set(list2)

Per trovare la loc dell'indice in list2

list_str = ''.join(str(s) for s in list2)

La posizione dell'indice in list2viene tracciata utilizzandocur_loclist

[0, 3, 7, 1, 2, 4, 8, 5, 6]

for i in list_set:
cur_loc = list_str.find(str(i))

while cur_loc >= 0:
    cur_loclist.append(cur_loc)
    cur_loc = list_str.find(str(i),cur_loc+1)

print(cur_loclist)

for i in range(0,len(cur_loclist)):
output.append(list1[cur_loclist[i]])
print(output)

Questa è una vecchia domanda, ma alcune delle risposte che vedo pubblicate in realtà non funzionano perché zipnon sono programmabili. Altre risposte non si sono preoccupate di import operatorfornire ulteriori informazioni su questo modulo e sui suoi vantaggi qui.

Ci sono almeno due buoni modi di dire per questo problema. A partire dall'input di esempio fornito:

X = ["a", "b", "c", "d", "e", "f", "g", "h", "i"]
Y = [ 0,   1,   1,   0,   1,   2,   2,   0,   1 ]

Usando il linguaggio " Decorate-Sort-Undecorate "

Questo è anche noto come Schwartzian_transform dopo R. Schwartz che ha reso popolare questo modello in Perl negli anni '90:

# Zip (decorate), sort and unzip (undecorate).
# Converting to list to script the output and extract X
list(zip(*(sorted(zip(Y,X)))))[1]                                                                                                                       
# Results in: ('a', 'd', 'h', 'b', 'c', 'e', 'i', 'f', 'g')

Si noti che in questo caso Ye Xsono ordinati e confrontati lessicograficamente. Cioè, i primi elementi (da Y) vengono confrontati; e se sono uguali, Xvengono confrontati i secondi elementi (da ) e così via. Ciò può creare output instabili a meno che non si includano gli indici dell'elenco originale per l'ordine lessicografico per mantenere i duplicati nel loro ordine originale.

Utilizzando il operatormodulo

Questo ti dà un controllo più diretto su come ordinare l'input, in modo da poter ottenere la stabilità dell'ordinamento semplicemente dichiarando la chiave specifica per ordinare. Vedi altri esempi qui .

import operator    

# Sort by Y (1) and extract X [0]
list(zip(*sorted(zip(X,Y), key=operator.itemgetter(1))))[0]                                                                                                 
# Results in: ('a', 'd', 'h', 'b', 'c', 'e', 'i', 'f', 'g')