เรียงลำดับรายการตามค่าจากรายการอื่นหรือไม่

ฉันมีรายการสตริงเช่นนี้

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

วิธีที่สั้นที่สุดในการเรียงลำดับ X โดยใช้ค่าจาก Y เพื่อรับเอาต์พุตต่อไปนี้คืออะไร

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

ลำดับขององค์ประกอบที่มี "คีย์" เหมือนกันไม่สำคัญ ฉันสามารถใช้forงานโครงสร้าง แต่ฉันอยากรู้ว่ามีวิธีที่สั้นกว่านี้หรือไม่ ข้อเสนอแนะใด ๆ

รหัสที่สั้นที่สุด

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

ตัวอย่าง:

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

พูด, พูดแบบทั่วไป, พูดทั่วๆไป

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

อธิบาย:

1. zip ทั้งสอง list s
2. สร้างใหม่เรียงlistตามการzipใช้sorted()การใช้
3. โดยใช้ความเข้าใจรายการแยกlistองค์ประกอบแรกของแต่ละคู่จากเรียงซิป

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับวิธีการตั้งค่า \ ใช้keyพารามิเตอร์เช่นเดียวกับsortedฟังก์ชั่นโดยทั่วไปจะดูที่นี้

ซิปรายการทั้งสองเข้าด้วยกันเรียงลำดับจากนั้นนำชิ้นส่วนที่คุณต้องการ:

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

รวมสิ่งเหล่านี้เข้าด้วยกันเพื่อรับ:

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

นอกจากนี้ถ้าคุณไม่สนใจการใช้อาร์เรย์ numpy (หรืออันที่จริงแล้วกำลังจัดการกับ numpy arrays ... ) นี่เป็นอีกวิธีที่ดี:

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]

ฉันพบมันที่นี่: http://scienceoss.com/sort-one-list-by-another-list/

ทางออกที่ชัดเจนที่สุดสำหรับฉันคือการใช้keyคำหลักหาเรื่อง

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

โปรดทราบว่าคุณสามารถย่อให้เหลือหนึ่งบรรทัดหากคุณต้องการ:

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

ที่จริงฉันมาที่นี่เพื่อค้นหารายการตามรายการที่ตรงกับค่า

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 มีเครื่องมือสำหรับการเรียงลำดับ iterables แบบขนาน:

ป.ร. ให้ไว้

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]

การสาธิต

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

ฉันชอบรายการดัชนีที่เรียงลำดับแล้ว ด้วยวิธีนี้ฉันสามารถเรียงลำดับรายการใด ๆ ในลำดับเดียวกันกับรายการแหล่งที่มา เมื่อคุณมีรายการดัชนีที่เรียงลำดับแล้วความเข้าใจในรายการแบบง่าย ๆ จะทำการหลอกลวง

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

โปรดทราบว่าสามารถใช้รายการดัชนีที่เรียงลำดับnumpy.argsort()ได้

อีกทางเลือกหนึ่งรวมหลายคำตอบ

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

ในการทำงานกับ python3:

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

zip, เรียงลำดับตามคอลัมน์ที่สองกลับคอลัมน์แรก

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

ซับหนึ่งที่รวดเร็ว

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

สมมติว่าคุณต้องการรายการ a เพื่อให้ตรงกับรายการ b.

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

สิ่งนี้มีประโยชน์เมื่อต้องการสั่งให้รายการเล็ก ๆ มีค่ามากขึ้น สมมติว่ารายการขนาดใหญ่มีค่าทั้งหมดในรายการขนาดเล็กก็สามารถทำได้

คุณสามารถสร้าง a pandas Seriesโดยใช้รายการหลักเป็นdataและรายการอื่นเป็นindexแล้วก็เรียงลำดับตามดัชนี:

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

เอาท์พุท:

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

นี่คือคำตอบอะไรถ้าคุณต้องการรับทั้งสองรายการเรียง (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']

เพิ่งจำได้ว่า Zx และ Zy เป็นสิ่งอันดับ ฉันกำลังหลงทางถ้ามีวิธีที่ดีกว่าในการทำเช่นนั้น

คำเตือน:หากคุณรันรายการที่ว่างเปล่ามันจะขัดข้อง

ฉันได้สร้างฟังก์ชั่นทั่วไปมากขึ้นซึ่งเรียงลำดับรายการมากกว่าสองรายการจากอีกรายการหนึ่งซึ่งได้แรงบันดาลใจจากคำตอบของ @ 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 = []

เพื่อรับค่าที่ไม่ซ้ำกันอยู่ใน list2

list_set = set(list2)

เพื่อหาตำแหน่งของดัชนีใน list2

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

ตำแหน่งของดัชนีใน list2มีการติดตาม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)

นี่เป็นคำถามเก่า แต่คำตอบบางอย่างที่ฉันเห็นโพสต์ไม่ได้ผลจริงเพราะzipไม่สามารถเขียนสคริปต์ได้ คำตอบอื่น ๆ ไม่ได้ใส่ใจimport operatorและให้ข้อมูลเพิ่มเติมเกี่ยวกับโมดูลนี้และประโยชน์ที่ได้รับที่นี่

มีสำนวนที่ดีอย่างน้อยสองประการสำหรับปัญหานี้ เริ่มต้นด้วยอินพุตตัวอย่างที่คุณให้ไว้:

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

ใช้สำนวน" Decorate-Sort-Undecorate "

สิ่งนี้เป็นที่รู้จักกันในชื่อSchwartzian_transformหลังจากR. Schwartzซึ่งเป็นที่นิยมในรูปแบบนี้ใน Perl ใน 90s:

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

โปรดทราบว่าในกรณีนี้YและXมีการจัดเรียงและเปรียบเทียบพจนานุกรม นั่นคือรายการแรก (จากY) มีการเปรียบเทียบ; และหากเป็นเหมือนกันรายการที่สอง (จากX) จะถูกเปรียบเทียบและอื่น ๆ สิ่งนี้สามารถสร้างความไม่แน่นอนเอาท์พุทที่เว้นแต่ว่าคุณได้รวมดัชนีรายการดั้งเดิมสำหรับการเรียงลำดับพจนานุกรมเพื่อให้ซ้ำกันในลำดับเดิม

การใช้งานoperatorโมดูล

สิ่งนี้ช่วยให้คุณควบคุมวิธีเรียงลำดับอินพุตได้โดยตรงมากขึ้นเพื่อให้คุณสามารถรับความเสถียรในการเรียงลำดับโดยเพียงระบุคีย์เฉพาะเพื่อเรียงลำดับ ดูตัวอย่างเพิ่มเติมที่นี่

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