Python：根据列表副本上的结果顺序对列表进行排序

：在最后一部分中，我正在寻找一种比嵌套for循环更快的方法

假设我们有一个列表

a=[a\u 0，a\u 1，…，a\u n]

。我们创建了一个名为

b=[b_0，b_1，…，b_n]

的

a

的深度副本，其中

b_i

和

a_i

是相同的对象，但分别存储。现在我们对

b

执行某种排序算法

some\u sort

，以获得排序

order\u b=[b''u 0，b''u 1，…，b''n]

，其中那些

b''u i

是

b

中的相同对象（由于

some\u sort

算法是破坏性的，因此

order\u b

中的元素不再与

b

中的元素相同，但引用被保留）。现在，我希望

a

按照

order\u b

中的相同顺序进行排序，即，获得排序

order\u a=[a''u 0，a''u 1，…，a''n]

这是从

a

的一种排列，其排列方式与从

b

的排列方式相同，但我不能对

a

执行排序算法

某些排序，因为该算法具有破坏性。有什么快速方法可以做到这一点吗

例如：
a=[a_0，a_1，a_2，a_3]
，
a
的深度副本是
b=[b_0，b_1，b_2，b_3]
。
b
的结果顺序是
顺序b=[b_3，b_2，b_0，b_1]
，然后我想要的是获得
顺序a=[a_3，a_2，a_1]
根据您提到的
顺序，您在
b''u i
中保留原始
b''u i
引用，因此您可以创建
{b''u i:idx}
的反向查找，例如（伪）：

import copy   
a = [2,4,3,1]
Out[94]: [2, 4, 3, 1]
#create a deep copy of a
b = copy.deepcopy(a)
Out[96]: [2, 4, 3, 1]
#add index of b and its value to a tuple
b1 = [(v,k) for k, v in enumerate(b)]
Out[98]: [(2, 0), (4, 1), (3, 2), (1, 3)]
#sort b1 (can using whatever criteria for sorting)
b1 = sorted(b1)
Out[100]: [(1, 3), (2, 0), (3, 2), (4, 1)]
#extract elements from a using the order of b1.
[a[e] for e in [e[-1] for e in b1]]
Out[101]: [1, 2, 3, 4]

演示，获取数字和字母的列表，将字母随机化，并以与随机化字母相同的顺序返回数字：

In [1]:
import random
a = list(range(10))
b = list('abcdefghij')
b_ = random.sample(b, k=len(b))
''.join(b_)

Out[1]:
'idfehbgacj'

In [2]:
mapping = {k: idx for idx, k in enumerate(b_)}
[m for m, n in sorted(zip(a,b), key=lambda x: mapping[x[1]])]

Out[2]:
[8, 3, 5, 4, 7, 1, 6, 0, 2, 9]

您提到您在
b''u i
中保留了原始的
b'u i
引用，因此您可以创建
{b'u i:idx}
的反向查找，例如（pseudo）：

演示，获取数字和字母的列表，将字母随机化，并以与随机化字母相同的顺序返回数字：

In [1]:
import random
a = list(range(10))
b = list('abcdefghij')
b_ = random.sample(b, k=len(b))
''.join(b_)

Out[1]:
'idfehbgacj'

In [2]:
mapping = {k: idx for idx, k in enumerate(b_)}
[m for m, n in sorted(zip(a,b), key=lambda x: mapping[x[1]])]

Out[2]:
[8, 3, 5, 4, 7, 1, 6, 0, 2, 9]

我有一个简单的解决方案：

a_u=[a[i]表示i in（b.索引（j）表示j in b_u）]

b_perm=[b中j的b.索引（j）]

a_u=[a[i]表示b_perm中的i]

import random
a = list(range(10))
b = list('abcdefghij')
b_ = random.sample(b, k=len(b))

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

a_ = [a[i] for i in (b.index(j) for j in b_)]

a_ = [2, 1, 5, 8, 4, 0, 7, 6, 9, 3]

我有一个简单的解决方案：

a_u=[a[i]表示i in（b.索引（j）表示j in b_u）]

b_perm=[b中j的b.索引（j）]

a_u=[a[i]表示b_perm中的i]

import random
a = list(range(10))
b = list('abcdefghij')
b_ = random.sample(b, k=len(b))

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

a_ = [a[i] for i in (b.index(j) for j in b_)]

a_ = [2, 1, 5, 8, 4, 0, 7, 6, 9, 3]

鉴于
order\u b
只是一个副本，你就不能
deepcopy
并分配给
order\u a
。没有更多细节，很难知道你想做什么。@AChampion我很抱歉它们与
b
不完全相同。请看我的编辑。@AChampion准确地说，
a
是
节点
实例的列表（我创建了一个
节点
类，该类具有属性
名称
和
父节点
（父节点））形成一个图形。当
some\u sort
作用于
b
时，它会改变它的一些成员的
parents
属性。因此
order\u b
中的成员实际上是那些
b
中的成员，首先被修改，然后被排序。既然
order\u b
只是一个副本，你就不能
deepcopy
并分配给
order>吗_a
。如果没有更多的细节，很难说出你想做什么。@AChampion我很抱歉它们与
b
不完全相同。请参阅我的编辑。@AChampion准确地说，
a
是
节点
实例的列表（我创建了一个
节点
类，具有属性
名称
和
父类
（父节点））形成一个图形。当
some\u sort
作用于
b
时，它将改变其某些成员的
parents
属性。因此
order\u b
中的成员实际上是那些
b
中的成员，首先被改变，然后被排序。谢谢。
idx
是什么？
idx
是
枚举（）给出的索引
。谢谢。什么是
idx
？
idx
是
enumerate（）
给出的索引。