Python 检查列表列表中的重复项并对其进行排序

我有一张桌子，里面有：

table = [[5, 7],[4, 3],[3, 3],[2, 3],[1, 3]]

每个列表中表示的第一个值（5,4,3,2,1）可以说是一个人的ID。表示的第二个值（7,3,3,3）为分数。我要做的是检测第二列中的重复值，在本例中是列表中的3。因为这4个列表的第二个值是3，所以我现在想根据第一个值对它们进行排序

在表中，请注意[1,3]的第一个值为1，因此，它应该替换表中的[4,3]位置。[2,3]应取代[3,3]作为交换

Expected output: [[5,7],[1,3],[2,3],[3,3],[4,3]]

我试图：

def checkDuplicate(arr):
    i = 0
    while (i<len(arr)-1):
        if arr[i][1] == arr[i+1][1] and arr[i][0] > arr[i+1][0]:
             arr[i],arr[i+1] = arr[i+1],arr[i]
        i+=1
    return arr

checkDuplicate(table)

def检查重复（arr）：
i=0
而（i arr[i+1][0]：
arr[i]，arr[i+1]=arr[i+1]，arr[i]
i+=1
返回arr
检查副本（表格）

---

代码没有达到我想要的输出，我希望在这方面能得到一些帮助。

您可以使用带有键的

排序的

table = [[5, 7], [4, 3], [3, 3], [2, 3], [1, 3]]

# Sorts by second index in decreasing order and then by first index in increasing order
sorted_table = sorted(table, key=lambda x: (-x[1], x[0]))

# sorted_table: [[5, 7], [1, 3], [2, 3], [3, 3], [4, 3]]

---

您应该按照第二列对整个列表进行排序，使用第一列来打破联系。这样做的好处是，即使在三列之间使用了七列，也可以正确地对三列进行分组，例如

table = [[4, 3],[3, 3],[5, 7],[2, 3],[1, 3]]

在Python中，您可以使用一行程序：

result = sorted(table, key=lambda x: (-x[1], x[0]))

如果您想要就地排序，请执行以下操作

table.sort(key=lambda x: (-x[1], x[0]))

在这种情况下，您可以做的另一件巧妙的事情是依赖Python排序算法的稳定性。实际上，建议在类似这样的复杂情况下按键的相反顺序进行多次排序。使用中的函数也可以加快代码的速度：

from opetator import itemgetter

result = sorted(table, key=itemgetter(0))
result.sort(key=itemgetter(1), reversed=True)

---

第一种排序将按正确的顺序排列ID。第二种排序将按分数降序排序，因为排序是稳定的，所以对于相同的分数，ID不会受到干扰。

如果您希望保留不重复的第二个元素的列表项，并且能够处理多个第二个项目可能被删除的情况重复，我想您需要的不仅仅是内置的

排序

我的职能是： 假设您的列表是：

table=[[5,7]、[6,1]、[8,9]、[3,1]、[4,3]、[3,3]、[2,3]、[1,3]

它不会触及项目

[5,7]

和

[8,9]

，但会根据第二个元素交换剩余项目，从而对其进行排序。结果将是：

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

代码如下：

def secondItemSort(table):
    # First get your second values
    secondVals = [e[1] for e in table]
    # The second values that are duplicate
    dups = [k for k,v in Counter(secondVals).items() if v>1]
    # The indices of those duplicate second values
    indices = dict()
    for d in dups:
        for i, e in enumerate(table):
            if e[1]==d:
                indices.setdefault(d, []).append(i)
    # Now do the sort by swapping the items intelligently
    for dupVal, indexList in indices.items():
        sortedItems = sorted([table[i] for i in indexList])
        c = 0
        for i in range(len(table)):
            if table[i][1] == dupVal:
                table[i] = sortedItems[c]
                c += 1
    # And return the intelligently sorted list
    return table

试验 让我们在稍微复杂一点的

表上进行测试

：

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

应该留在原位的项目：

[5,7]

和

[2,2]

应交换的项目：

• [6,1]

  和

  [3,1]

• [8,9]

  和

  [3,9]

• [4,3]、[3,3]、[2,3]、[1,3]

Drumroll…

In [127]: secondItemSort(table)
Out[127]: 
[[5, 7],
 [3, 1],
 [3, 9],
 [6, 1],
 [1, 3],
 [8, 9],
 [2, 3],
 [2, 2],
 [3, 3],
 [4, 3]]

---

您需要在其中有第二个嵌套循环。这是冒泡排序的开始。如果您想要更有效的排序，请按第二列然后按第一列对整个列表进行排序。您对

5,7

条目的移动是否满意？为什么

5,7

放在所有人前面…是

5

的bcz还是

7

的bcz？好的catch在第一列中按升序排列，-x[1]有什么用？它是按第二个索引排序的，OP称之为分数，按降序排列。他希望前面有

5,7

。@OlivierMelançon。谢谢你指出这一点。这就是我没有仔细阅读文档得到的结果。修复了