Python 根据按步骤排序的另一个列表对列表进行排序

我正在尝试根据列表

A

的排序对列表

B

进行排序。棘手的部分是列表

A

的排序是分步骤完成的。 我试过压缩列表，但就是没法让它工作

列表

A

的排序如下：

steps = [0, 1, 3, 5]
B = ['A', 'B', 'C', 'D', 'E', 'F', 'G']
A = [['X', 'Y'], ['X'], ['X', 'Y', 'Z'], ['X', 'Y', 'Z'], ['X'], ['X', 'Y', 'Z'], ['X', 'Y']

for i in range(len(steps)-1):
    A[steps[i]:steps[i + 1]] = sorted(A[steps[i]:steps[i + 1]], key = len, reverse=True)

发生了以下情况：

---

A

中的子列表0根据长度按相反顺序排序，然后子列表1,2，然后3,4，最后5,6。

您可以使用zip对列表进行排序，您只需要一个键函数来解释这些对。然后，一旦您对这些对进行了排序，就可以使用zip“解压”它们

B=['A'，'B'，'C'，'D'，'E'，'F'，'G']
A=['X'，'Y']，['X']，['X'，'Y'，'Z']，['X'，'Y'，'Z']，['X']，['X'，'Y'，'Z']，['X'，'Y']
右（对）：
返回透镜（对[1]）
C=已排序（zip（B，A），key=lenRight）
B_排序，A_排序=zip（*C）
打印（按B_排序）
打印（A_排序）

这将输出：

('B', 'E', 'A', 'G', 'C', 'D', 'F')
(['X'], ['X'], ['X', 'Y'], ['X', 'Y'], ['X', 'Y', 'Z'], ['X', 'Y', 'Z'], ['X', 'Y', 'Z'])

编辑：

我现在明白了

steps=[1,3,5]
B=['A'，'B'，'C'，'D'，'E'，'F'，'G']
A=['X'，'Y']，['X']，['X'，'Y'，'Z']，['X'，'Y'，'Z']，['X']，['X'，'Y'，'Z']，['X'，'Y']
最后一步=0
分类列表=[]
右（对）：
返回透镜（对[1]）
对于步骤中的步骤：
C=已排序（zip（B[lastStep:lastStep+step]，A[lastStep:lastStep+step]），key=lenRight，reverse=True）
B_排序，A_排序=zip（*C）
sortedList.append（（A_排序，B_排序））
最后一步
对于成对分类列表：
A_排序，B_排序=成对
打印（A_排序，B_排序）

产出：

(['X', 'Y'],) ('A',)
(['X', 'Y', 'Z'], ['X', 'Y', 'Z'], ['X']) ('C', 'D', 'B')
(['X', 'Y', 'Z'], ['X', 'Y', 'Z'], ['X', 'Y'], ['X']) ('D', 'F', 'G', 'E')

---

假设

A

中的所有对象都是可散列且唯一的：

将

A

和

B

一起压缩到列表

C

中，并将该列表置于一旁

使用神秘的基于步长的算法对

A

进行排序。不要担心

B

或

C

排序完成后，构建一个反向查找字典，将

a

项放到排序算法放置它们的位置

使用反向查找和压缩列表对

B

进行排序 最后构建

C

、构建查找字典和组织

B

的成本都是O（n）

免责声明：不喜欢写回

B

。希望写入一个大小合适的新列表

更新：上面的代码只有在A中没有重复项时才有效。下面的代码片段通过附加一个唯一性（原始索引）来处理重复项。虽然这是可行的，但这种方法太复杂了。您还可以将A和B的zip排序在一起，这在另一个答案中进行了描述

A = [29, 42, 29, 17]
B = ['bravo1', 'charlie', 'bravo2', 'alpha']
A2 = [(index, a) for index,a in enumerate(A)]
C = list(zip(A, B))
A2.sort(key=lambda t : t[1] ) # replace with your mystery sorter, which has to deal with tuples now
A = [a for (_, a) in A2]
lookup = {t:index for (index, t) in enumerate(A2)}

for  original_index, (a, b) in enumerate(C):
    new_index = lookup[original_index, a]
    B[new_index] = b

print(A)
print(B)

为了完整性，如果我必须处理A中的重复项，下面的代码就是我真正要做的。这基本上是发布的另一个答案

A = [29, 42, 29, 17]
B = ['bravo1', 'charlie', 'bravo2', 'alpha']
C = list(zip(A, B))
C.sort(key=lambda t : t[0] ) # replace with your mystery sorter, which has to deal with a zip of A and B together
[A, B] = zip(*C)

print(A)
print(B)

---

谢谢你的回复。它的工作原理与您描述的一样，但它忽略了一个事实，即列表需要分步排序。例如：前3个元素按其长度排列，然后第4个元素按其长度排列，然后第3个元素按其长度排列，依此类推。我现在明白你的意思了，并用一个对子列表排序的元素更新了答案再次感谢你，这似乎很好！不使用单独的“def lenRight”是否可以执行此操作？我尝试将密钥更改为“lambda:len（pair[1]），但无法理解。lambda几乎可以使用，但需要输入lambda，所以：

lambda pair:len（pair[1]）

Aha我明白了，太棒了。非常感谢。在您的示例代码中，我没有看到列表

a

，您的问题中没有提到代码中的列表

C

。请澄清。还有一个建议。如果您包含您期望的输出，那就太好了。循环和子列表使您很难理解您要做的事情。样本输出会有帮助。嗨，我真的不能让它工作很不幸。问题：如果列表中的项目不唯一，使用查找的方法是否有效？@Fred_Alb，要使此方法有效，列表中的项目需要唯一，或者通过附加一些数据使其唯一。我将编辑以澄清。

A = [29, 42, 29, 17]
B = ['bravo1', 'charlie', 'bravo2', 'alpha']
A2 = [(index, a) for index,a in enumerate(A)]
C = list(zip(A, B))
A2.sort(key=lambda t : t[1] ) # replace with your mystery sorter, which has to deal with tuples now
A = [a for (_, a) in A2]
lookup = {t:index for (index, t) in enumerate(A2)}

for  original_index, (a, b) in enumerate(C):
    new_index = lookup[original_index, a]
    B[new_index] = b

print(A)
print(B)

#output
[17, 29, 29, 42]
['alpha', 'bravo1', 'bravo2', 'charlie']

A = [29, 42, 29, 17]
B = ['bravo1', 'charlie', 'bravo2', 'alpha']
C = list(zip(A, B))
C.sort(key=lambda t : t[0] ) # replace with your mystery sorter, which has to deal with a zip of A and B together
[A, B] = zip(*C)

print(A)
print(B)