如何在列表列表中找到元素總是重復的公共位置，然后刪除這些重復項？

Question

我有一個列表列表，其中列表總是以相同的方式排序，並且在每個列表中有幾個元素是重復的。 因此，我想從列表中刪除重復項，但重要的是我保留每個列表的結構，即如果元素索引 0、1 和 2 都是給定列表的重復項，則其中兩個將從列表中刪除，但是那么相同的位置元素也必須從所有其他列表中刪除，以保留有序結構。

然而，至關重要的是，索引為 0、1 和 2 的元素在其他列表中可能不是重復的，因此我只想在確定整個列表中索引為 0、1 和 2 的元素時才這樣做2總是重復的。

例如，假設我有這個列表列表

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

應用我的方法后，我想留下

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

您會看到元素索引 1 和 2 以及元素 8 都被不斷刪除，因為它們在所有列表中始終重復，而元素索引 3 和 4 沒有，因為它們並不總是重復的。

到目前為止我的想法（盡管我認為這可能不是最好的方法以及我尋求幫助的原因）

def check_duplicates_in_same_position(arr_list):
    check_list = []
    for arr in arr_list:
        duplicate_positions_list = []
        positions = {}
        for i in range(len(arr)):
            item = arr[i]
            if item in positions:
                positions[item].append(i)
            else:
                positions[item] = [i]
        duplicate_positions = {k: v for k, v in positions.items() if len(v) > 1}
        for _, item in duplicate_positions.items():
            duplicate_positions_list.append(item)
        check_list.append(duplicate_positions_list)
    
    return check_list

這將返回列表列表的列表，其中每個元素都是一個列表，其中包含一堆列表，這些列表的元素是該列表的重復項的索引，因此

[[[0, 1, 2], [3, 4], [7, 8]],
 [[0, 1, 2, 4, 6], [7, 8]],
 [[0, 1, 2], [3, 4], [7, 8]]]

然后我想以某種方式比較這些列表，例如刪除元素索引 1 和 2 以及索引 8，因為這些是每個列表的常見匹配項。

Answer 1

假設所有子列表的長度都相同，這應該可行：

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

[list(x) for x in zip(*dict.fromkeys(zip(*l)))]

# Output: [[1, 3, 3, 2, 4, 6], [5, 4, 5, 6, 5, 7], [9, 2, 2, 7, 8, 10]]

---

解釋：

1. zip(*l) - 這將創建一個新的一維數組。 第 n 個元素將是一個元組，其中包含原始子列表中的所有第 n 個元素：

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

2. 從前面的列表中，我們只想保留那些不重復的。 有多種方法可以實現這一點。 如果您搜索如何在維護訂單的同時刪除重復項，則會彈出此答案。 它使用dict.fromkeys(<list>) 。 由於 python 字典鍵必須是唯一的，這將刪除重復項並生成以下 output：

{(1, 5, 9): None,
 (3, 4, 2): None,
 (3, 5, 2): None,
 (2, 6, 7): None,
 (4, 5, 8): None,
 (6, 7, 10): None}

3. 我們現在要將這些鍵解壓縮到原始的二維數組中。 為此，我們可以再次使用zip ：

zip(*dict.fromkeys(zip(*l)))

4. 由於 zip 返回元組，我們最終必須使用列表理解將元組轉換為列表：

[list(x) for x in zip(*dict.fromkeys(zip(*l)))]

Answer 2

我會用這樣的東西 go。 它不是太快，但取決於列表的大小，它可能就足夠了。

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

azip = zip(*L)
temp_L = []
for zz in azip:
    if not zz in temp_L:
        temp_L.append(zz)
new_L = [list(zip(*temp_L))[zz] for zz in range(len(L))]

首先，我們 zip L 中的三個（或更多）列表。然后，我們遍歷每個元素，檢查它是否已經存在。 如果不是，我們將它添加到我們的臨時列表 temp_L。 最后我們將 temp_L 重組為原始格式。 它返回

new_L
>> [(1, 3, 3, 2, 4, 6), (5, 4, 5, 6, 5, 7), (9, 2, 2, 7, 8, 10)]