Sortujesz listę na podstawie wartości z innej listy?


369

Mam listę takich ciągów:

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

Jaki jest najkrótszy sposób sortowania X przy użyciu wartości z Y, aby uzyskać następujące dane wyjściowe?

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

Kolejność elementów mających ten sam „klucz” nie ma znaczenia. Mogę skorzystać z forkonstruktów, ale jestem ciekawy, czy istnieje krótsza droga. Jakieś sugestie?


Odpowiedź riza może być przydatna podczas drukowania danych, ponieważ zip (* posortowane (zip (X, Y), klucz = para lambda: para [0])) zwraca zarówno posortowane X, jak i Y posortowane z wartościami X.
jojo

Odpowiedzi:


479

Najkrótszy kod

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

Przykład:

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

Mówiąc ogólnie

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

Wyjaśnione:

  1. zipdwa lists.
  2. utwórz nowy, posortowany listwedług zipużycia sorted().
  3. korzystając ze zrozumienia listy, wyodrębnij pierwsze elementy każdej pary z posortowanego pliku zip list.

Aby uzyskać więcej informacji na temat ustawiania \ używania keyparametru oraz sortedogólnie funkcji, spójrz na to .



117
Jest to poprawne, ale dodam notatkę, że jeśli próbujesz posortować wiele tablic według tej samej tablicy, to niekoniecznie będzie działać zgodnie z oczekiwaniami, ponieważ kluczem używanym do sortowania jest (y, x) , nie tylko y. Zamiast tego powinieneś użyć [x dla (y, x) w posortowanym (zip (Y, X), klucz = para lambda: para [0])]
gms7777 17.01.2014

1
dobre rozwiązanie! Ale tak powinno być: lista jest uporządkowana w odniesieniu do pierwszego elementu par, a zrozumienie wyodrębnia „drugi” element par.
MasterControlProgram

To rozwiązanie jest kiepskie, jeśli chodzi o przechowywanie. W miarę możliwości preferowane jest sortowanie na miejscu.
Hatefiend

107

Zbierz razem dwie listy, posortuj je, a następnie weź potrzebne części:

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

Połącz je razem, aby uzyskać:

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

1
Jest to w porządku, jeśli Xjest to lista str, ale bądź ostrożny, jeśli istnieje możliwość, która <nie jest zdefiniowana dla niektórych par przedmiotów X, np. - jeśli niektóre z nich byłyNone
John La Rooy

1
Kiedy próbujemy użyć sortowania na obiekcie zip, AttributeError: 'zip' object has no attribute 'sort'to właśnie otrzymuję.
Ash Upadhyay

2
Używasz Python 3. W Pythonie 2 zip utworzył listę. Teraz tworzy iterowalny obiekt. sorted(zip(...))powinien nadal działać, lub: them = list(zip(...)); them.sort()
Ned Batchelder

77

Ponadto, jeśli nie masz nic przeciwko korzystaniu z tablic numpy (lub w rzeczywistości już masz do czynienia z tablicami numpy ...), oto inne fajne rozwiązanie:

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]

Znalazłem to tutaj: http://scienceoss.com/sort-one-list-by-another-list/


1
W przypadku większych tablic / wektorów to rozwiązanie z numpy jest korzystne!
MasterControlProgram,

1
Jeśli są już tablicami numerycznymi, to po prostu sortedArray1= array1[array2.argsort()]. Ułatwia to także sortowanie wielu list według określonej kolumny tablicy 2D: np. sortedArray1= array1[array2[:,2].argsort()]Sortowanie tablicy1 (która może mieć wiele kolumn) według wartości w trzeciej kolumnie tablicy2.
Aaron Bramson,

40

Najbardziej oczywistym rozwiązaniem jest użycie keysłowa kluczowego 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']

Pamiętaj, że możesz skrócić to do jednej linijki, jeśli zależy Ci na:

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

2
Czy to wymaga, aby wartości w X były niepotrzebne?
Jack Peng

15

Przybyłem tutaj, aby posortować listę według listy, w której wartości są zgodne.

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

1
Czy to jest wydajne?
AFP_555

Nie wiem. Zgłoś, co znajdziesz.
nackjicholson

1
To jest zły pomysł. indexwykona wyszukiwanie O (N) w list_awyniku O(N² log N)sortowania.
Richard

Dzięki, nie rób tego, gdy liczy się wydajność!
nackjicholson

15

more_itertools ma narzędzie do sortowania iteracyjnych równolegle:

Dany

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]

Próbny

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

13

Lubię mieć listę posortowanych indeksów. W ten sposób mogę posortować dowolną listę w tej samej kolejności co lista źródłowa. Po utworzeniu listy posortowanych indeksów wystarczy proste zrozumienie listy:

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

Zauważ, że można również uzyskać posortowaną listę indeksów numpy.argsort().


12

Kolejna alternatywa, łącząca kilka odpowiedzi.

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

Aby pracować dla Python3:

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

7

zip, sortuj według drugiej kolumny, zwróć pierwszą kolumnę.

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

Uwaga: key = operator.itemgetter (1) rozwiązuje problem duplikatu
Keith

zip nie jest indeksowalny ... musisz go użyćlist(zip(*sorted(zip(X,Y), key=operator.itemgetter(1))))[0]
raphael

@Keith jaki duplikat?
Josh

Jeśli jest więcej niż jeden pasujący, dostaje pierwszy
Keith

3

Szybki jednowarstwowy.

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

Powiedz, że chcesz, aby lista a pasowała do listy b.

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

Jest to pomocne, gdy trzeba zamówić mniejszą listę z wartościami większymi. Zakładając, że większa lista zawiera wszystkie wartości na mniejszej liście, można to zrobić.


To nie rozwiązuje pytania PO. Czy próbowałeś tego z przykładowymi listami Xi Y?
Aryeh Leib Taurog

To jest zły pomysł. indexwykona wyszukiwanie O (N) w list_bwyniku O(N² log N)sortowania.
Richard

1

Możesz utworzyć pandas Series, używając podstawowej listy jako datai drugiej listy jako index, a następnie po prostu posortować według indeksu:

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

wynik:

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

1

Oto odpowiedź Whatangsa, jeśli chcesz uzyskać obie posortowane listy (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']

Pamiętaj tylko, że Zx i Zy to krotki. Wędruję również, jeśli istnieje lepszy sposób na zrobienie tego.

Ostrzeżenie: jeśli uruchomisz go z pustymi listami, ulega awarii.


1

Stworzyłem bardziej ogólną funkcję, która sortuje więcej niż dwie listy w oparciu o inną, inspirowaną odpowiedzią @ 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

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

output=[]
cur_loclist = []

Aby uzyskać unikalne wartości obecne w list2

list_set = set(list2)

Aby znaleźć lokalizację indeksu w list2

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

Lokalizacja indeksu list2jest śledzona za pomocącur_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)

0

To stare pytanie, ale niektóre odpowiedzi, które widzę, nie są w rzeczywistości skuteczne, ponieważ zipnie można ich skryptować. Inne odpowiedzi nie przeszkadzały import operatori podają więcej informacji o tym module i jego zaletach tutaj.

Istnieją co najmniej dwa dobre idiomy dotyczące tego problemu. Począwszy od podanego przykładowego wejścia:

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

Korzystanie z idiomu „ Dekorowanie-Sortowanie-Undecorowanie

Jest to również znane jako Schwartzian_transform po R. Schwartz, który spopularyzował ten wzór w Perlu w latach 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')

Zauważ, że w tym przypadku Yi Xsą klasyfikowane i porównano leksykograficznie. Oznacza to, że pierwsze pozycje (od Y) są porównywane; a jeśli są takie same, wówczas Xporównywane są drugie elementy (z ) i tak dalej. Może to tworzyć niestabilne dane wyjściowe, chyba że podasz oryginalne indeksy listy dla porządku leksykograficznego, aby zachować duplikaty w ich oryginalnej kolejności.

Korzystanie z operatormodułu

Zapewnia to większą bezpośrednią kontrolę nad sposobem sortowania danych wejściowych, dzięki czemu można uzyskać stabilność sortowania , po prostu określając konkretny klucz do sortowania. Zobacz więcej przykładów tutaj .

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')
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.