我有两个列表：
big_list = [2, 1, 2, 3, 1, 2, 4]
sub_list = [1, 2]
我要删除big_list中所有出现的sub_list。
结果应为[2, 3, 4]
对于字符串，您可以使用：
'2123124'.replace('12', '')
但是AFAIK不适用于列表。
这不是Removing a sublist from a list的重复项，因为我想从大列表中删除所有子列表。在另一个问题中，结果应为[5,6,7,1,2,3,4]。
更新：为简单起见，我在此示例中使用整数。但是列表项可以是任意对象。
Update2：
如果big_list = [1, 2, 1, 2, 1]和sub_list = [1, 2, 1]，
我希望结果为[2, 1]（如'12121'.replace('121', '')）
Update3：
我不喜欢将StackOverflow中的源代码复制+粘贴到我的代码中。因此，我在软件建议中提出了第二个问题：https://softwarerecs.stackexchange.com/questions/51273/library-to-remove-every-occurrence-of-sub-list-from-list-python
Update4：如果您知道可以进行此方法调用的库，请将其编写为答案，因为这是我的首选解决方案。
测试应通过此测试：
def test_remove_sub_list(self):
self.assertEqual([1, 2, 3], remove_sub_list([1, 2, 3], []))
self.assertEqual([1, 2, 3], remove_sub_list([1, 2, 3], [4]))
self.assertEqual([1, 3], remove_sub_list([1, 2, 3], [2]))
self.assertEqual([1, 2], remove_sub_list([1, 1, 2, 2], [1, 2]))
self.assertEquals([2, 1], remove_sub_list([1, 2, 1, 2, 1], [1, 2, 1]))
self.assertEqual([], remove_sub_list([1, 2, 1, 2, 1, 2], [1, 2]))
答案 0 :(得分：25)
您必须自己实施。这是基本概念：
def remove_sublist(lst, sub):
i = 0
out = []
while i < len(lst):
if lst[i:i+len(sub)] == sub:
i += len(sub)
else:
out.append(lst[i])
i += 1
return out
这将遍历原始列表的每个元素，并将其添加到输出列表（如果它不是子集的成员）。这个版本的效率不是很高，但是在创建不包含您的子集的新列表的意义上，它的工作方式类似于您提供的字符串示例。只要它们支持==，它也适用于任意元素类型。从[1,1,1]中删除[1,1,1,1]会正确生成[1]，就像字符串一样。
这是一个IDEOne link，展示了
的结果>>> remove_sublist([1, 'a', int, 3, float, 'a', int, 5], ['a', int])
[1, 3, <class 'float'>, 5]
答案 1 :(得分：14)
尝试del和slicing。最糟糕的时间复杂度是O(N^2)。
sub_list=['a', int]
big_list=[1, 'a', int, 3, float, 'a', int, 5]
i=0
while i < len(big_list):
if big_list[i:i+len(sub_list)]==sub_list:
del big_list[i:i+len(sub_list)]
else:
i+=1
print(big_list)
结果：
[1, 3, <class 'float'>, 5]
答案 2 :(得分：8)
一种递归方法：
reverseArrayToNum(my_list);
这将输出：
def remove(lst, sub):
if not lst:
return []
if lst[:len(sub)] == sub:
return remove(lst[len(sub):], sub)
return lst[:1] + remove(lst[1:], sub)
print(remove(big_list, sub_list))
答案 3 :(得分：6)
一种改进的版本，用于检查是否lst[i:i+len(sub)] < len(lst)
def remove_sublist(lst, sub):
i = 0
out = []
sub_len = len(sub)
lst_len = len(lst)
while i < lst_len:
if (i+sub_len) < lst_len:
if lst[i: i+sub_len] == sub:
i += sub_len
else:
out.append(lst[i])
i += 1
else:
out.append(lst[i])
i += 1
return out
答案 4 :(得分：6)
如何？
def remove_sublist(lst, sub):
max_ind_sub = len(sub) - 1
out = []
i = 0
tmp = []
for x in lst:
if x == sub[i]:
tmp.append(x)
if i < max_ind_sub: # partial match
i += 1
else: # found complete match
i = 0
tmp = []
else:
if tmp: # failed partial match
i = 0
out += tmp
if x == sub[0]: # partial match
i += 1
tmp = [x]
else:
out.append(x)
return out
性能：
lst = [2, 1, 2, 3, 1, 2, 4]
sub = [1, 2]
%timeit remove_sublist(lst, sub) # solution of Mad Physicist
%timeit remove_sublist_new(lst, sub)
>>> 2.63 µs ± 112 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
>>> 1.77 µs ± 13.7 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
更新
我的第一个解决方案有一个错误。能够修复它（上面更新了我的代码），但是该方法现在看起来更加复杂。在性能方面，它仍然比本地计算机上的 Mad Physicist 解决方案要好。
答案 5 :(得分：5)
使用itertools.zip_longest创建n个元素元组（其中n是sub_list的长度），然后在其中一个元素与sub_list匹配时过滤当前元素和接下来的n-1个元素
>>> from itertools import zip_longest, islice
>>> itr = zip_longest(*(big_list[i:] for i in range(len(sub_list))))
>>> [sl[0] for sl in itr if not (sl == tuple(sub_list) and next(islice(itr, len(sub_list)-2, len(sub_list)-1)))]
[2, 3, 4]
要提高效率，您可以在开始过滤之前先计算tuple(sub_list)和len(sub_list)
>>> l = len(sub_list)-1
>>> tup = tuple(sub_list)
>>> [sl[0] for sl in itr if not (sl == tup and next(islice(itr, l-1, l)))]
[2, 3, 4]
答案 6 :(得分：5)
更新：more_itertools库已发布more_itertool.replace，该工具可解决此特定问题（请参阅选项3）。
首先，这是适用于通用可迭代对象的其他一些选项（列表，字符串，迭代器等）：
代码
选项1-不带库：
def remove(iterable, subsequence):
"""Yield non-subsequence items; sans libraries."""
seq = tuple(iterable)
subsequence = tuple(subsequence)
n = len(subsequence)
skip = 0
for i, x in enumerate(seq):
slice_ = seq[i:i+n]
if not skip and (slice_ == subsequence):
skip = n
if skip:
skip -= 1
continue
yield x
选项2-带有more_itertools
import more_itertools as mit
def remove(iterable, subsequence):
"""Yield non-subsequence items."""
iterable = tuple(iterable)
subsequence = tuple(subsequence)
n = len(subsequence)
indices = set(mit.locate(mit.windowed(iterable, n), pred=lambda x: x == subsequence))
it_ = enumerate(iterable)
for i, x in it_:
if i in indices:
mit.consume(it_, n-1)
else:
yield x
演示
list(remove(big_list, sub_list))
# [2, 3, 4]
list(remove([1, 2, 1, 2], sub_list))
# []
list(remove([1, "a", int, 3, float, "a", int, 5], ["a", int]))
# [1, 3, float, 5]
list(remove("11111", "111"))
# ['1', '1']
list(remove(iter("11111"), iter("111")))
# ['1', '1']
选项3-带有more_itertools.replace ：
演示
pred = lambda *args: args == tuple(sub_list)
list(mit.replace(big_list, pred=pred, substitutes=[], window_size=2))
# [2, 3, 4]
pred=lambda *args: args == tuple(sub_list)
list(mit.replace([1, 2, 1, 2], pred=pred, substitutes=[], window_size=2))
# []
pred=lambda *args: args == tuple(["a", int])
list(mit.replace([1, "a", int, 3, float, "a", int, 5], pred=pred, substitutes=[], window_size=2))
# [1, 3, float, 5]
pred=lambda *args: args == tuple("111")
list(mit.replace("11111", pred=pred, substitutes=[], window_size=3))
# ['1', '1']
pred=lambda *args: args == tuple(iter("111"))
list(mit.replace(iter("11111"), pred=pred, substitutes=[], window_size=3))
# ['1', '1']
详细信息
在所有这些示例中，我们正在使用较小的窗口切片扫描主序列。我们产生切片中未找到的任何内容，并跳过切片中的任何内容。
选项1-不带库
迭代一个枚举序列，并评估大小为n（子序列的长度）的切片。如果即将到来的切片等于子序列，请重置skip并产生该项目。否则，迭代过去。 skip跟踪循环前进了多少次，例如sublist的大小为n=2，因此每场比赛跳过两次。
请注意，您可以通过删除前两个元组分配并将iterable参数替换为seq来将此选项转换为单独与sequences一起使用，例如def remove(seq, subsequence):。
选项2-带有more_itertools
为迭代中的每个匹配子序列定位索引。在迭代枚举的迭代器时，如果在indices中找到索引，则通过消耗迭代器中的下一个n-1元素来跳过剩余的子序列。否则，将产生一个项目。
通过> pip install more_itertools安装此库。
选项3-带有more_itertools.replace ：
此工具用替换值替换谓词中定义的项的子序列。要删除物品，我们用一个空容器代替，例如substitutes=[]。替换项目的长度由window_size参数指定（此值等于子序列的长度）。
答案 7 :(得分：4)
比以上任何内容更具可读性，并且没有额外的内存占用：
def remove_sublist(sublist, mainlist):
cursor = 0
for b in mainlist:
if cursor == len(sublist):
cursor = 0
if b == sublist[cursor]:
cursor += 1
else:
cursor = 0
yield b
for i in range(0, cursor):
yield sublist[i]
这是给在线用户的，如果您想从库中获取一个函数，就这样吧
[x for x in remove_sublist([1, 2], [2, 1, 2, 3, 1, 2, 4])]
答案 8 :(得分：3)
Python 2.x中的Kinda不同方法！
y yh x xw w Nxt
0 2987 3129 347 2092 1735.0 501
7 1663 2180 375 1092 600.0 1323
请注意，您需要以相反的顺序删除它们，以免丢失后续的索引。
在Python3中， locate（）的签名会有所不同。
答案 9 :(得分：1)
（有关最终方法，请参见最后一个代码段）
我曾经认为简单的字符串转换就足够了：
big_list = [2, 1, 2, 3, 1, 2, 4]
sub_list = [1, 2]
new_list = list(map(int, list((''.join(map(str, big_list))).replace((''.join(map(str, sub_list))), ''))))
我实质上是使用列表的等效字符串进行查找/替换。之后，我将它们映射为整数，以便保留变量的原始类型。这将适用于任何大小的大列表和子列表。
但是，如果您在没有文本表示形式的任意对象上调用它，则可能无法使用。此外，此方法仅保留对象的文本版本；如果需要保留原始数据类型，则会出现问题。
为此，我用不同的方法组成了一个解决方案：
new_list = []
i = 0
while new_list != big_list:
if big_list[i:i+len(sub_list)] == sub_list:
del big_list[i:i+len(sub_list)]
else:
new_list.append(big_list[i])
i += 1
从本质上讲，我会在找到sub_list的每个重复项时删除它们，并在找到不属于重复项的元素时追加到new_list中。当new_list和big_list相等时，所有重复项都已找到，这是我停止的时间。我没有使用try-except，因为我不认为应该有任何索引错误。
这与@MadPhysicist的答案相似，并且效率大致相同，但是我的占用更少的内存。
第二种方法适用于具有任意大小列表的任何类型的对象，因此比第一种方法灵活得多。但是，如果您的列表只是整数，则第一种方法会更快。
但是，我还没有完成！我构思了一种单线列表理解功能，它具有与第二种方法相同的功能！
import itertools
new_list = [big_list[j] for j in range(len(big_list)) if j not in list(itertools.chain.from_iterable([ list(range(i, i+len(sub_list))) for i in [i for i, x in enumerate(big_list) if x == sub_list[0]] if big_list[i:i+len(sub_list)] == sub_list ]))]
最初，这似乎令人生畏，但我向您保证，这很简单！首先，我创建一个索引列表，其中子列表的第一个元素已经出现。接下来，对于每个索引，我检查以下元素是否构成子列表。如果有，则将构成子列表重复项的索引范围添加到另一个列表中。之后，我使用itertools中的函数来平整列表的结果列表。展平列表中的每个元素都是一个索引，与子列表重复。最后，我创建一个new_list，它由big_list的每个元素组成，该元素的索引在扁平化列表中找不到。
我认为此方法没有其他任何答案。我最喜欢它，因为一旦意识到它的工作原理并且非常高效（由于列表理解的性质），它就非常整洁。
答案 10 :(得分：0)
您可以将递归与生成器一起使用：
def remove(d, sub_list):
if d[:len(sub_list)] == sub_list and len(sub_list) <= len(d[:len(sub_list)]):
yield from [[], remove(d[len(sub_list):], sub_list)][bool(d[len(sub_list):])]
else:
yield d[0]
yield from [[], remove(d[1:], sub_list)][bool(d[1:])]
tests = [[[2, 1, 2, 3, 1, 2, 4], [1, 2]], [[1, 2, 1, 2], [1, 2]], [[1, 'a', int, 3, float, 'a', int, 5], ['a', int]], [[1, 1, 1, 1, 1], [1,1,1]]]
for a, b in tests:
print(list(remove(a, b)))
输出：
[2, 3, 4]
[]
[1, 3, <class 'float'>, 5]
[1, 1]
答案 11 :(得分：0)
只是为了好玩，这是最接近单线的近似值：
from functools import reduce
big_list = [2, 1, 2, 3, 1, 2, 4]
sub_list = [1, 2]
result = reduce(lambda r, x: r[:1]+([1]+r[2:-r[1]],[min(len(r[0]),r[1]+1)]+r[2:])[r[-r[1]:]!=r[0]]+[x], big_list+[0], [sub_list, 1])[2:-1]
不相信它有用吗？选中on IDEone！
当然，它远非高效，而且令人反感，但它应该有助于说服OP接受@Mad Physicist's answer。
答案 12 :(得分：0)
您可以尝试通过将其转换为字符串列表，然后再次替换为整数类型来实现此目的。
您可以在一行中这样做
.bg-info{
background-color: #17a2b8 !important;
}
输入
map(int,list(("".join(map(str, big_list))).replace("".join(map(str, sub_list)),'').replace(''.join((map(str, sub_list))[::-1]),'')))
输出
[2，1]
输入
big_list = [1, 2, 1, 2, 1]
sub_list = [1, 2, 1]
输出
[2，3，4]