Trier la liste en fonction des valeurs d'une autre liste?

J'ai une liste de chaînes comme celle-ci:

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

Quel est le moyen le plus court de trier X en utilisant les valeurs de Y pour obtenir la sortie suivante?

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

L'ordre des éléments ayant la même "clé" n'a pas d'importance. Je peux recourir à l'utilisation de forconstructions mais je suis curieux de savoir s'il existe un chemin plus court. Aucune suggestion?

Code le plus court

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

Exemple:

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

En général

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

Expliqué:

1. ziples deux listart.
2. créer un nouveau, trié en listfonction de l' ziputilisation sorted().
3. en utilisant une compréhension de liste, extrayez les premiers éléments de chaque paire des fichiers triés et zippés list.

Pour plus d'informations sur la façon de définir \ utiliser le keyparamètre ainsi que la sortedfonction en général, jetez un œil à ceci .

Compressez les deux listes, triez-les, puis prenez les parties que vous souhaitez:

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

Combinez-les ensemble pour obtenir:

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

De plus, si cela ne vous dérange pas d'utiliser des tableaux numpy (ou si vous avez déjà affaire à des tableaux numpy ...), voici une autre bonne solution:

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]

Je l'ai trouvé ici: http://scienceoss.com/sort-one-list-by-another-list/

La solution la plus évidente pour moi est d'utiliser le keymot - clé 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']

Notez que vous pouvez le raccourcir en une ligne si vous souhaitez:

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

En fait, je suis venu ici pour trier une liste par liste où les valeurs correspondaient.

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 dispose d'un outil pour trier les itérables en parallèle:

Donné

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]

Démo

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

J'aime avoir une liste d'indices triés. De cette façon, je peux trier n'importe quelle liste dans le même ordre que la liste source. Une fois que vous avez une liste d'indices triés, une simple compréhension de liste fera l'affaire:

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

Notez que la liste d'index triée peut également être obtenue en utilisant numpy.argsort().

Une autre alternative, combinant plusieurs des réponses.

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

Afin de travailler pour python3:

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

zip, trier par la deuxième colonne, retourner la première colonne.

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

Une doublure rapide.

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

Dites que vous voulez que la liste a corresponde à la liste b.

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

Cela est utile lorsque vous devez commander une liste plus petite avec des valeurs plus grandes. En supposant que la liste plus grande contient toutes les valeurs de la liste plus petite, cela peut être fait.

Vous pouvez créer un pandas Series, en utilisant la liste principale as dataet l'autre liste as index, puis trier simplement par l'index:

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

production:

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

Voici la réponse de Whatangs si vous souhaitez obtenir les deux listes triées (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']

N'oubliez pas que Zx et Zy sont des tuples. Je me demande également s'il existe une meilleure façon de le faire.

Avertissement: si vous l'exécutez avec des listes vides, il se bloque.

J'ai créé une fonction plus générale, qui trie plus de deux listes en fonction d'une autre, inspirée de la réponse 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 = []

Pour obtenir des valeurs uniques présentes dans list2

list_set = set(list2)

Pour trouver l'emplacement de l'index dans list2

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

L'emplacement de l'index dans list2est suivi à l'aide decur_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)

Il s'agit d'une vieille question, mais certaines des réponses que je vois publiées ne fonctionnent pas car elles zipne sont pas scriptables. Les autres réponses n'ont pas pris la peine de import operatorfournir plus d'informations sur ce module et ses avantages ici.

Il existe au moins deux bons idiomes pour ce problème. En commençant par l'exemple d'entrée que vous avez fourni:

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

Utilisation de l' idiome " Décorer-Trier-Décorer "

Ceci est également connu sous le nom de Schwartzian_transform après R. Schwartz qui a popularisé ce modèle en Perl dans les années 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')

Notez que dans ce cas Yet Xsont triés et comparés lexicographiquement. Autrement dit, les premiers éléments (de Y) sont comparés; et s'ils sont identiques, les deuxièmes éléments (de X) sont comparés, etc. Cela peut créer des sorties instables sauf si vous incluez les index de liste d'origine pour l'ordre lexicographique afin de conserver les doublons dans leur ordre d'origine.

Utilisation du operatormodule

Cela vous donne un contrôle plus direct sur la façon de trier l'entrée, de sorte que vous pouvez obtenir une stabilité de tri en indiquant simplement la clé spécifique à trier. Voir plus d'exemples ici .

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