我试图编写一个函数来读取包含列表的列表,并返回相同的列表结构但没有元素。
def remove_from_list(l):
for e in l:
if isinstance(e, list):
remove_from_list(e)
else:
l.remove(e)
return l
所以对于这样的输入:
[1, 2, [], [3,[4]], 5]
我应该得到这样的东西:
[[], [[]]]
我尝试了这些输入:
[1, 2, [], [3,[4]], 5]
[1, 2, [], [2,[3]], 2]
得到这些输出:
[2, [], [[4]]]
[[], [[3]], 2]
这是非常令人困惑的,因为两个列表的结构是相同的;只有元素不同。因此,我不仅会犯错误,而且会得到另一个错误。帮助我的错误的功能和解释将非常感激。
这里的关键问题是for
循环有一定数量的迭代,但是当你删除循环中的列表时,你正在缩小它们。因此,当列表变小时,循环指针保持固定。有一次,循环没有机会完成迭代。
选项1 作为一个简单的修复,您可以在函数内创建一个新列表。这应该更简单,并且不会改变您的原始列表。
def remove_from_list(l):
r = []
for e in l:
if isinstance(e, list):
r.append(remove_from_list(e))
return r
>>> remove_from_list([1, 2, [], [3,[4]], 5])
[[], [[]]]
此外,由于您只是附加空结构,因此这应该比创建数据副本和后续删除调用更快。
选项2
在wim's idea的基础上,反向迭代并使用del
,如果你想改变列表到位。
def remove_from_list(l):
r = []
for i in range(len(l) - 1, -1, -1):
if isinstance(l[i], list):
remove_from_list(l[i])
else:
del l[i]
>>> l = [1, 2, [], [3,[4]], 5]
>>> remove_from_list(l)
>>> l
[[], [[]]]
从良好实践的角度来看,我建议要么返回副本,要么在没有返回的情况下进行修改,但不能同时修改。
您可以执行时间比较,以确定哪种方法可以更快地处理数据。
一,设置 -
def remove_from_list(l):
r = []
for e in l:
if isinstance(e, list):
r.append(remove_from_list(e))
return r
def remove_from_list_reverse_del(l):
r = []
for i in range(len(l) - 1, -1, -1):
if isinstance(l[i], list):
remove_from_list(l[i])
else:
del l[i]
def remove_from_list_copy(l):
for e in l[:]: # make a copy by slicing
if isinstance(e, list):
remove_from_list_copy(e)
else:
l.remove(e)
return l
y = [1, 2, [], [3,[4]], 5]
z = copy.deepcopy(y * 10000)
接下来,时间 -
%timeit remove_from_list(z)
19.3 ms ± 334 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%%timeit
z2 = copy.deepcopy(z) # copying because this function mutates the original
remove_from_list_reverse_del(z2)
78.6 ms ± 157 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
虽然创造z2
浪费了很大一部分时间。
好老式的递归怎么了? (顺便说一下,这个答案还处理包含对自己的引用的列表。)
def f(l, i, ids):
if i >= len(l):
return l
if isinstance(l[i], list):
if not id(l[i]) in ids:
ids.add(id(l[i]))
f(l[i], 0, ids)
return f(l, i + 1, ids)
else:
del l[i]
return f(l, i, ids)
a = [1, 2, [], [3,[4]], 5]
a.append(a)
a[3].append(a[3])
print a # [1, 2, [], [3, [4], [...]], 5, [...]]
print f(a, 0, set([id(a)])) # [[], [[], [...]], [...]]
(至于你的误解 - 正如cᴏʟᴅsᴘᴇᴇᴅ所提到的,在for
循环中删除列表的部分可能会导致意外的结果,因为迭代的范围在它开始之前设置,但列表在中途被修改。)
简单的递归
def remove_from_list(l):
if l == []:
return []
elif not isinstance(l[0], list):
return remove_from_list(l[1:])
else:
return [remove_from_list(l[0])] + remove_from_list(l[1:])
有点复杂
def remove_from_list(l):
def remove_inner(l_in,l_out):
if l_in == []:
return l_out
elif not isinstance(l_in[0], list) or l[0] == []:
return remove_inner(l_in[1:],l_out)
else:
return remove_inner(l_in[1:], l_out + [remove_from_list(l_in[0])])
return remove_inner(l,[])
print(remove_from_list([1, 2, [], [3,[4]], 5]))
这是使用递归的另一种方法
def remove_from_list (l):
if not l:
return []
elif isinstance (l[0], list):
return [remove_from_list (l[0])] + remove_from_list (l[1:])
else:
return remove_from_list (l[1:])
print (remove_from_list ([1, 2, [], [3, [4]], 5]))
# [[], [[]]]
如果您觉得以这种方式思考问题很好,您会发现一些通用函数可以使事情变得更好
def is_empty (l):
return not l
def is_list (l):
return isinstance (l, list)
def head (l):
return l[0]
def tail (l):
return l[1:]
def remove_from_list (l):
if is_empty (l):
return []
elif is_list (head (l)):
return [remove_from_list (head (l))] + remove_from_list (tail (l))
else:
return remove_from_list (tail (l))
print (remove_from_list ([1, 2, [], [3, [4]], 5]))
# [[], [[]]]
它不会改变输入
data = [1, 2, [], [3, [4]], 5]
print (remove_from_list (data))
# [[], [[]]]
print (data)
# [1, 2, [], [3, [4]], 5]
还有一个尾递归版本,可以制作stack-safe(粗体变化)
def identity (x):
return x
def remove_from_list (l, k = identity):
if is_empty (l):
return k ([])
elif is_list (head (l)):
return remove_from_list (head (l), lambda x:
remove_from_list (tail (l), lambda y:
k ([x] + y)))
else:
return remove_from_list (tail (l), k)
print (remove_from_list (data))
# [[], [[]]]
问题是您在迭代同一列表时从列表中删除元素。一种解决方案是制作副本并对其进行迭代,如下所示:
def remove_from_list(l):
for e in l[:]: # make a copy by slicing
if isinstance(e, list):
remove_from_list(e)
else:
l.remove(e)
return l
结果:
>>> remove_from_list([1, 2, [], [3,[4]], 5])
[[], [[]]]
Python documentation对此行为的解释:
当循环修饰序列时有一个微妙之处(这只能发生在可变序列,即列表中)。内部计数器用于跟踪下一个使用的项目,并在每次迭代时递增。当该计数器达到序列的长度时,循环终止。这意味着如果套件从序列中删除当前(或前一个)项目,则将跳过下一个项目(因为它获取已经处理的当前项目的索引)。同样,如果套件在当前项目之前的序列中插入项目,则下次循环时将再次处理当前项目。