Sắp xếp danh sách dựa trên các giá trị từ danh sách khác?

Tôi có một danh sách các chuỗi như thế này:

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

Cách sắp xếp X ngắn nhất bằng cách sử dụng các giá trị từ Y để có được đầu ra sau đây là gì?

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

Thứ tự của các phần tử có cùng "khóa" không quan trọng. Tôi có thể sử dụng các forcông trình xây dựng nhưng tôi tò mò liệu có cách nào ngắn hơn không. Bất kỳ đề xuất?

Mã ngắn nhất

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

Thí dụ:

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

Nói chung

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

Giải thích:

1. ziphai lists.
2. tạo một cái mới, được sắp xếp listdựa trên việc zipsử dụng sorted().
3. sử dụng một sự hiểu biết danh sách trích xuất các yếu tố đầu tiên của mỗi cặp từ được sắp xếp, nén list.

Để biết thêm thông tin về cách đặt \ sử dụng keytham số cũng như sortedchức năng nói chung, hãy xem cái này .

Nén hai danh sách lại với nhau, sắp xếp nó, sau đó lấy các phần bạn muốn:

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

Kết hợp những thứ này lại với nhau để có được:

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

Ngoài ra, nếu bạn không phiền khi sử dụng mảng numpy (hoặc trên thực tế đã xử lý các mảng numpy ...), đây là một giải pháp hay khác:

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]

Tôi tìm thấy nó ở đây: http://scienceoss.com/sort-one-list-by-another-list/

Giải pháp rõ ràng nhất với tôi là sử dụng keytừ khóa 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']

Lưu ý rằng bạn có thể rút ngắn phần này thành một lớp lót nếu bạn quan tâm đến:

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

Tôi thực sự đã đến đây để tìm cách sắp xếp một danh sách theo một danh sách nơi các giá trị khớp với nhau.

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 có một công cụ để sắp xếp các iterables song song:

Được

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]

Bản giới thiệu

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

Tôi thích có một danh sách các chỉ số được sắp xếp. Bằng cách đó, tôi có thể sắp xếp bất kỳ danh sách theo thứ tự như danh sách nguồn. Khi bạn có một danh sách các chỉ số được sắp xếp, việc hiểu danh sách đơn giản sẽ thực hiện thủ thuật:

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

Lưu ý rằng danh sách chỉ mục được sắp xếp cũng có thể được sử dụng numpy.argsort().

Một cách khác, kết hợp một số câu trả lời.

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

Để làm việc cho python3:

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

zip, sắp xếp theo cột thứ hai, trả về cột đầu tiên.

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

Một lót nhanh chóng.

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

Nói rằng bạn muốn liệt kê một danh sách phù hợp b.

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

Điều này hữu ích khi cần đặt một danh sách nhỏ hơn cho các giá trị lớn hơn. Giả sử rằng danh sách lớn hơn chứa tất cả các giá trị trong danh sách nhỏ hơn, nó có thể được thực hiện.

Bạn có thể tạo một pandas Series, sử dụng danh sách chính như datavà danh sách khác dưới dạng index, sau đó chỉ cần sắp xếp theo chỉ mục:

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

đầu ra:

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

Dưới đây là câu trả lời của Whatangs nếu bạn muốn có cả hai danh sách được sắp xếp (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']

Chỉ cần nhớ Zx và Zy là tuples. Tôi cũng đang lang thang nếu có một cách tốt hơn để làm điều đó.

Cảnh báo: Nếu bạn chạy nó với danh sách trống, nó gặp sự cố.

Tôi đã tạo ra một hàm tổng quát hơn, sắp xếp nhiều hơn hai danh sách dựa trên một danh sách khác, lấy cảm hứng từ câu trả lời của @ 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 = []

Để có được các giá trị duy nhất hiện diện trong list2

list_set = set(list2)

Để tìm vị trí của chỉ mục trong list2

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

Vị trí của chỉ mục list2được theo dõi bằng cách sử dụngcur_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)

Đây là một câu hỏi cũ nhưng một số câu trả lời tôi thấy được đăng không thực sự hoạt động vì zipkhông có kịch bản. Những câu trả lời khác không làm phiềnimport operator và cung cấp thêm thông tin về mô-đun này và lợi ích của nó ở đây.

Có ít nhất hai thành ngữ tốt cho vấn đề này. Bắt đầu với ví dụ đầu vào bạn cung cấp:

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

Sử dụng " Trang trí-Sắp xếp-Không trang trí thành ngữ "

Điều này còn được gọi là Schwartzian_transform sau R. Schwartz , người đã phổ biến mô hình này ở Perl vào những năm 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')

Lưu ý rằng trong trường hợp này Yvà Xđược sắp xếp và so sánh theo từ vựng. Đó là, các mục đầu tiên (từ Y) được so sánh; và nếu chúng giống nhau thì các mục thứ hai (từ X) được so sánh, v.v. Điều này có thể tạo ra không ổn định đầu ra trừ khi bạn bao gồm các chỉ mục danh sách ban đầu cho thứ tự từ điển để giữ các bản sao theo thứ tự ban đầu.

Sử dụng operatormô-đun

Điều này cho phép bạn kiểm soát trực tiếp hơn về cách sắp xếp đầu vào, do đó bạn có thể sắp xếp sự ổn định bằng cách chỉ cần nêu khóa cụ thể để sắp xếp theo. Xem thêm ví dụ ở đây .

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