如果同一索引处的两个条目相同，则从嵌套列表中删除一个条目[重复]

Question

我有一个嵌套列表，如下所示：

l = [['h', 'i', 'l'],
     ['m', 'b', 'x'],
     ['u', 'o', 'l'],
     ['f', 'j', 'x']]

如您所见，索引 2 处的条目对于子列表 1 和 3 以及子列表 0 和 2 是相同的。

如何删除在特定索引处具有相同条目的子列表？

预期结果：

nl = [['h', 'i', 'l'],
      ['m', 'b', 'x']]

我尝试使用set() 函数，但没有成功。

有人可以帮忙吗？

Answer 1

这里是单行解决方案：

[l[i] for i in sorted({e[2]: i for i, e in zip(range(len(l) - 1, -1, -1), l[::-1])}.values())]

输出：

[['h', 'i', 'l'], 
 ['m', 'b', 'x']]

这是一个 for 循环解决方案：

uniq_value = set()
final_list = []
for e in l:
    if e[2] not in uniq_value:
        uniq_value.add(e[2])
        final_list.append(e)

final_list

输出：

[['h', 'i', 'l'], 
 ['m', 'b', 'x']]

我一直在对@FilipMłynarski、@Exa 和我的解决方案进行基准测试：

from simple_benchmark import BenchmarkBuilder
from random import choice
from string import ascii_letters
import numpy as np

b = BenchmarkBuilder()

def _filip(x):
    stack = [set() for _ in x[0]]
    for row in x:
        if all(i not in seen for i, seen in zip(row, stack)):
            for idx, i in enumerate(row):
                stack[idx].add(i)
            yield row

@b.add_function()            
def filip(l):
    return list(_filip(l))

@b.add_function()
def exa(l):
    t = []
    for sl in l:
        for st in t:
            for (v, o) in zip(sl, st):
                if v == o:
                    break
            else:
                continue
            break
        else:
            t.append(sl)
    return t

@b.add_function()
def kederrac(l):
    uniq_value = set()
    final_list = []
    for e in l:
        if e[2] not in uniq_value:
            uniq_value.add(e[2])
            final_list.append(e)

    return final_list

@b.add_function()
def exa_fix_index(l):
    t = []
    for sl in l:
        for st in t:
            if sl[2] == st[2]:
                break
            else:
                continue
            break
        else:
            t.append(sl)
    return t

@b.add_function()
def mathfux(array, idx=2):
    array = np.array(array)
    ith_column = array[:, idx]
    u, good_indices = np.unique(ith_column, return_index=True)
    new_array = array[good_indices]
    new_array = new_array.tolist() #if you need to convert back to list
    return new_array

@b.add_arguments('Size of list of lists')
def argument_provider():
    for exp in range(2, 7):
        size = 10**exp
        list_of_lists = [[choice(ascii_letters) for _ in range(3)] for _ in range(size)]
        yield size,  list_of_lists

r = b.run()
r.plot()

输出：

Answer 2

仅仅使用set() 是行不通的，因为您要删除具有至少一个重复元素的条目，不是整个列表。我们可以创建一个函数来跟踪我们希望在未来避免的可见元素（这里是集合列表stack），同时迭代提供的列表，到具有所有值的yield元素独一无二。

l = [
    ['h', 'i', 'l'],
    ['m', 'b', 'x'],
    ['u', 'o', 'l'],
    ['f', 'j', 'x'],
]

def fix(x):
    stack = [set() for _ in x[0]]
    for row in x:
        if all(i not in seen for i, seen in zip(row, stack)):
            for idx, i in enumerate(row):
                stack[idx].add(i)
            yield row

print(list(fix(l)))  # -> [['h', 'i', 'l'], ['m', 'b', 'x']]

Answer 3

在我看来，numpy 是在您的情况下最简单的方法：

def delete_by_index(array, idx):
    array = np.array(array)
    ith_column = array[:, idx]
    u, good_indices = np.unique(ith_column, return_index=True)
    new_array = array[good_indices]
    new_array = new_array.tolist() #if you need to convert back to list
    return new_array

print(delete_by_index(l, 2)) #prints expected result

我在那里做了两件重要的事情：

• 提取ith_column，即['l', 'x', 'l', 'x']，用于i=2；
• 使用np.unique 方法返回（排序的）唯一项目['l', 'x'] 及其索引[0, 1] 根据these docs。

效率如何，numpy 的使用应该比使用 for 循环更快，因为它的所有操作都执行用 C 编写的循环。

Answer 4

虽然 Filip 的答案看起来很酷，但它有点太复杂了 - 正如我们所发现的那样 - 相当缓慢。只需跟踪所有唯一列表并在每次迭代时扫描它们以确定我们当前的列表是否有效（具有统一的唯一元素），就可以了。

def fix(l):
    t = []
    for sl in l:
        for st in t:
            for (v, o) in zip(sl, st):
                if v == o:
                    break
            else:
                continue
            break
        else:
            t.append(sl)
    return t

这在~2.2946 执行，而 Filip 根据timeit.timeit 命中~6.1039（终端中的复制粘贴解决方案）：

>>> timeit.timeit(lambda: fix(l)) # mine
2.3752248109999528
>>> timeit.timeit(lambda: list(fix(l))) # Filip
6.073348348000309

对于具体的指标，一些调整给了我们：

def fix(l, i):
    t = []
    for sl in l:
        for st in t:
            if sl[i] == st[i]:
                break
            else:
                continue
            break
        else:
            t.append(sl)
    return t

基准第三指数：

>>> timeit.timeit(lambda: fix(l, 2))
0.9275596050001695

正如预期的那样，当您知道要摆脱什么时，速度会快得多。

为避免在处理大量数据时出现不必要的内存开销，请在 t.append(sl) 上添加 yield sl 并删除 return 语句（在所有示例中）。