Classificando a lista com base nos valores de outra lista?

Eu tenho uma lista de seqüências de caracteres como esta:

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

Qual é a maneira mais curta de classificar X usando valores de Y para obter a seguinte saída?

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

A ordem dos elementos com a mesma "chave" não importa. Posso recorrer ao uso de forconstruções, mas estou curioso para saber se há uma maneira mais curta. Alguma sugestão?

Código mais curto

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

Exemplo:

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"]

De um modo geral

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

Explicado:

1. zipos dois lists.
2. crie um novo, classificado com listbase no zipuso sorted().
3. usando uma compreensão de lista, extraia os primeiros elementos de cada par dos classificados, zipados list.

Para obter mais informações sobre como definir \ use o keyparâmetro, bem como a sortedfunção em geral, dê uma olhada nisso .

Feche as duas listas, classifique-as e pegue as partes que deseja:

>>> 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']

Combine-os para obter:

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

Além disso, se você não se importa em usar matrizes numpy (ou na verdade já está lidando com matrizes numpy ...), aqui está outra solução interessante:

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]

Encontrei-o aqui: http://scienceoss.com/sort-one-list-by-another-list/

A solução mais óbvia para mim é usar a keypalavra - chave 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']

Observe que você pode reduzi-lo para uma linha, se desejar:

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

Na verdade, eu vim aqui procurando classificar uma lista por uma lista em que os valores correspondiam.

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 possui uma ferramenta para classificar iterables em paralelo:

Dado

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]

Demo

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

Eu gosto de ter uma lista de índices classificados. Dessa forma, eu posso classificar qualquer lista na mesma ordem que a lista de fontes. Depois de ter uma lista de índices classificados, uma simples compreensão da lista fará o truque:

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"]

Observe que a lista de índice classificada também pode ser obtida usando numpy.argsort().

Outra alternativa, combinando várias das respostas.

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

Para trabalhar com python3:

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

zip, classifique pela segunda coluna, retorne a primeira coluna.

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

Uma linha rápida.

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

Digamos que você queira que a lista a corresponda à lista b.

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

Isso é útil quando é necessário solicitar uma lista menor com valores maiores. Supondo que a lista maior contenha todos os valores da lista menor, isso pode ser feito.

Você pode criar um pandas Series, usando a lista principal como datae a outra lista como indexe, em seguida, basta classificar pelo índice:

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

resultado:

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

Aqui está a resposta do Whatangs se você deseja obter as duas listas classificadas (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']

Lembre-se de que Zx e Zy são tuplas. Também estou vagando se há uma maneira melhor de fazer isso.

Aviso: Se você executá-lo com listas vazias, ele trava.

Criei uma função mais geral, que classifica mais de duas listas com base em outra, inspirada na resposta de @ 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 = []

Para obter valores exclusivos presentes em list2

list_set = set(list2)

Para encontrar o local do índice em list2

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

A localização do índice list2é rastreada usandocur_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)

Esta é uma pergunta antiga, mas algumas das respostas que vejo postadas não funcionam de fato porque zipnão são programáveis. Outras respostas não se deram ao trabalho de import operatorfornecer mais informações sobre este módulo e seus benefícios aqui.

Existem pelo menos duas boas expressões para esse problema. Começando com a entrada de exemplo que você forneceu:

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

Usando o idioma " Decorar-Classificar-Undecorate "

Isso também é conhecido como Schwartzian_transform após R. Schwartz, que popularizou esse padrão em Perl nos anos 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')

Note-se que, neste caso, Ye Xsão ordenados e comparados lexicographically. Ou seja, os primeiros itens (de Y) são comparados; e se forem iguais, os segundos itens (de X) serão comparados e assim por diante. Isso pode criar instabilidade resultados menos que você inclua os índices da lista original da ordem lexicográfica para manter as duplicatas na ordem original.

Usando o operatormódulo

Isso fornece um controle mais direto sobre como classificar a entrada, para que você possa obter estabilidade na classificação simplesmente indicando a chave específica a ser classificada. Veja mais exemplos aqui .

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