Question

我需要比较两个基本上是列表列表的列表，找出存在于一个列表中但没有其他列表的子列表。子列表的排列也没有考虑，即['a'，'b'] = ['b，'a']。这两个列表是

List_1 = [['T_1','T_2'],['T_2','T_3'],['T_1','T_3']]
List_2 = [['T_1','T_2'],['T_3','T_1']]

输出列表应为

out_list = [['T_2','T_3']]

Answer 1

对于两个元素子列表，这应该足够了：

[x for x in List_1 if x not in List_2 and x[::-1] not in List_2]

代码：

List_1 = [['T_1','T_2'],['T_2','T_3'],['T_1','T_3']]
List_2 = [['T_1','T_2'],['T_3','T_1']]

print([x for x in List_1 if x not in List_2 and x[::-1] not in List_2])

Answer 2

这是一个有点混乱的功能解决方案，在此过程中使用set和tuple（使用set s是因为您要计算的是{{3} }和tuple之所以使用，是因为与list不同，它们是可哈希的，可以用作set元素）：

List_1 = [['T_1','T_2'],['T_2','T_3'],['T_1','T_3']]
List_2 = [['T_1','T_2'],['T_3','T_1']]

f = lambda l : tuple(sorted(l))

out_list = list(map(list, set(map(f, List_1)).symmetric_difference(map(f, List_2))))

print(out_list)

输出：

[['T_2', 'T_3']]

Answer 3

我想说frozensets更适合这样的任务：

fs2 = set(map(frozenset,List_2))
out = set(map(frozenset,List_1)).symmetric_difference(fs2)

print(out)                                 
# {frozenset({'T_2', 'T_3'})}

在这里使用frozensets的优点是可以对其进行散列，因此您可以简单地映射两个列表并采用set.symmetric_difference。

如果要从输出中嵌套列表，则只需执行以下操作：

list(map(list, out))

请注意，尽管给出的任务应该没有问题，但某些子列表可能会以不同的顺序出现

Answer 4

您可以将列表转换为sets进行相等性比较，并使用any()仅将第二个列表中不存在的项目添加到列表中：

// index.d.ts
declare module 'react-load-script' {
  // imports here...

  export interface ScriptProps {
    url: string;
    onLoad: () => void;
    // etc...
  }

  export default class Script extends React.Component<ScriptProps> {}
}

为了更好地理解每个答案的资源消耗和效率，我做了一些tests。希望它能帮助您选择最佳。

有关问题数据的结果：

Olvin Roght's answer- 12.963876624000001 ;
yatu's answer- 8.218290244000002 ;
rusu_ro1's answer- 8.857162503000001 ;
MrGeek's answer- 11.631234766000002 ;
Austin's answer- 3.452045860999995 ;
GZ0's answer- 7.037438627 。

bigger data上的结果：

Olvin Roght's answer- 83.452110953 ;
yatu's answer- 0.1939603360000035 ;
rusu_ro1's answer- 0.24479892000000802 ;
MrGeek's answer- 0.32636319700000627 ;
Austin's answer- 5.052051797000004 ;
GZ0's answer- 0.20400504799999908 。

Answer 5

如果列表中没有重复项，则可以使用：

 set(frozenset(e) for e in List_1).symmetric_difference({frozenset(e) for e in List_2})

输出：

{frozenset({'T_2', 'T_3'}), frozenset({1, 2})}

如果需要列表列表作为输出，可以使用：

[list(o) for o in output]

输出：

[['T_2', 'T_3']]

Answer 6

这是@yatu和@rusu_ro1的frozenset解决方案的单线变体，适合那些希望使用更简洁语法的人：

out = [*map(list,{*map(frozenset,List_1)}^{*map(frozenset,List_2)})]

如果不需要将输出转换为嵌套列表，只需执行

out = {*map(frozenset,List_1)}^{*map(frozenset,List_2)}

同时，使用symmetric_difference函数而不是^运算符的一个优点是前者可以将任何可迭代的值用作其参数。这样可以避免将map(frozenset,List_2)转换为集合，从而获得一些性能。

out = [*map(list,{*map(frozenset,List_1)}.symmetric_difference(map(frozenset,List_2)))]

如何在python中找到一个列表而不是另一个列表的子列表？

6 个答案: