删除列表中存在的任何空列表

Question

我有一个清单：

i = [[1,2,3,[]],[],[],[],[4,5,[],7]]

我想删除所有的空列表：

[[1,2,3],[4,5,7]]

我该怎么做？

这是我的代码：

res = [ele for ele in i if ele != []]

Answer 1

使用递归函数从列表中删除空列表。
使用递归，您可以将空列表删除到任何深度：

def remove_nested_list(listt):
    for index, value in enumerate(reversed(listt)):
        if isinstance(value, list) and value != []:
            remove_nested_list(value)
        elif isinstance(value, list) and len(value) == 0:
            listt.remove(value)


a = [[1, 2, 3, 0, []], [], [], [], [4, 5, [], 7]]
print(f"before-->{a}")
remove_nested_list(a)
print(f"after-->{a}")

输出：

before-->[[1, 2, 3, 0, []], [], [], [], [4, 5, [], 7]]
after-->[[1, 2, 3, 0], [4, 5, 7]]

Answer 2

你可以使用列表推导（实际上是嵌套推导）：

i = [[1, 2, 3, []], [], [], [], [4, 5, [], 7]]

res = [[sub_item for sub_item in item if sub_item != []] for item in i if item != []]
print(res)

我们检查空列表两次，一次检查i 中的容器列表和if item != []，另一次检查这些容器中的单个元素，使用if sub_item != []。

Answer 3

您还可以通过过滤“无值”来删除空列表。

尝试：

i = 过滤器（无，i）

Answer 4

我会使用一些不会改变原始列表的方法。

第一个简单地删除列表中的所有空列表，而不是嵌套：

def remove_empty_lists(lst):
    return [ e for e in lst if not (isinstance(e, list) and len(e)==0) ]

第二种方法只是以递归方式使用前者：

def deep_remove_empty_lists(lst):
    lst = remove_empty_lists(lst)
    return [ deep_remove_empty_lists(e) if isinstance(e, list) else e for e in lst ]

所以，在提交的案例中：

i = [[1,2,3,[]],[],[],[],[4,5,[],7]]
deep_remove_empty_lists(i)

#=> [[1, 2, 3], [4, 5, 7]]

或者在最深的嵌套情况下：

ii = [[1,2,3,[]],[],[],[],[4,5,[],7,[8, 9, [], [10, 11, []]]]]
deep_remove_empty_lists(ii)

#=> [[1, 2, 3], [4, 5, 7, [8, 9, [10, 11]]]]

Answer 5

如果嵌套总是两层深，即在你的问题中，一个干净的方法是：

>>> not_empty_list = lambda value: value != []

## Above is equivalent to:
#  not_empty_list = [].__ne__
#  not_empty_list = functools.partial(operator.ne, []))

>>> result = [
        list(filter(not_empty_list, inner_list))
        for inner_list in i 
        if not_empty_list(inner_list)
    ]
>>> result
[[1, 2, 3], [4, 5, 7]]

处理像[]这样的列表：

>>> i
[[1, 2, 3, []], [], [], [], [4, 5, [], 7], [[]]]

>>> result = [
        list(filter(not_empty_list, inner_list))
        for inner_list in i 
        if not_empty_list(inner_list)
    ]
>>> list(filter(not_empty_list, result))
[[1, 2, 3], [4, 5, 7]]

Answer 6

从任意嵌套列表中删除空列表。我们可以在这里使用递归。 这是一个简单的方法。我们需要遍历列表并检查元素是否为空列表。如果是，那么我们不会将其添加到最终列表中。如果不是空列表，我们重复上述过程。

def remove_empty(lst):
    return (
        [remove_empty(i) for i in lst if i!=[]]
        if isinstance(lst, list)
        else lst
    )

输出：

i = [[1, 2, 3, []], [], [], [], [4, 5, [], 7]]
print(remove_empty(i))
# [[1, 2, 3], [4, 5, 7]]

# Example taken from iGian's answer 
ii = [[1, 2, 3, []], [], [], [], [4, 5, [], 7, [8, 9, [], [10, 11, []]]]] 
print(remove_empty(ii))
# [[1, 2, 3], [4, 5, 7, [8, 9, [10, 11]]]]

要检查一个对象是否可迭代，我们使用collection.abc.iterable

from collections.abc import Iterable
all(
    isinstance(i, Iterable)
    for i in ([], tuple(), set(), dict(), range(10), (_ for _ in range(10)))
)
# True

现在，您可以将 isinstance(lst, list) 替换为 isinstance(lst, Iterable) 以从每个可迭代对象中过滤掉空列表，即 []。

编辑：

@Teepeemm 指出了一个绝妙的极端案例，所有答案都错过了。

为了解决这个问题，我们需要两个递归函数，一个用于检查它是否为空嵌套列表，第二个用于删除空嵌套列表

def empty(lst):
    if lst == []:
        return True
    elif isinstance(lst, list):
        return all(empty(i) for i in lst)
    else:
        return False

def remove_empty(lst):
    return (
        [remove_empty(i) for i in lst if not empty(i)]
        if isinstance(lst, list)
        else lst
    )

i = [[1, 2, 3, [[]]]] 
remove_empty(i)
# [[1, 2, 3]]
remove_nested_list(i) # Muhammad Safwan's answer
print(i) # [[1, 2, 3, []]]

ii = [[1, 2, 3, [[], [[[[], []]]]]]]
remove_empty(ii)
# [[1, 2, 3]]
remove_nested_list(ii) # Muhammad Safwan's answer
print(ii) # [[1, 2, 3, [[[[]]]]]]

Answer 7

如果您需要能够处理任意深度嵌套的列表，并且还想删除例如[[]] 或 [[], [[], []]] 或其他仅包含空列表的列表（列表仅包含）空列表，这是一个简单的递归解决方案：

def simplify(value):
  if isinstance(value, list):
    return [y for y in (simplify(x) for x in value) if y != []]
  else:
    return value

print(simplify([[1,2,3,[]],[],[],[],[4,5,[],7],[[],[[]]],[[],[8]]]))

^{Try it online!}

此解决方案与迄今为止发布的大多数（全部？）其他递归解决方案之间的主要区别在于它首先递归地简化它遇到的任何子列表，然后然后跳过任何简化后为空的子列表。这也是允许它跳过 [[]] 等子列表的原因。

(但是请注意，如果给定一个列表，此函数仍将始终返回一个列表，即使该列表可能为空。例如，simplify([[], [[]]]) 仍将返回[]，而不是None . 如果你想对简化后顶层列表为空的情况做一些特殊处理，你需要单独检查。但至少在通过上面的函数运行列表之后，你可以检查仅使用例如if simplified_list == []:.)

Answer 8

从列表中删除空列表

我们可以使用列表推导方法来解决这个问题。

你可以参考下面的代码

# Initialize list =>
list_1 = [11,20,5,[],7,12,3,[],[],23]

# print list 
print("Original List: "+ str(list_1))

# remove empty list using list comprehension
output = [ i for i in list_1 if i!=[] ] 

# print output
print("list after empty list removed: " + str(output))

输出：

原始列表：[11, 20, 5, [ ], 7, 12, 3, [ ], [ ], 23]

删除空列表后的列表：[11, 20, 5, 7, 12, 3, 23]

Answer 9

简单的递归解决方案

a = [[1,2,3,[]],[],[],[],[4,5,[],7]]

def nested_check(alist):
    for item in alist[:]:
        if item == []:
            alist.remove(item)
        elif isinstance(item, list):
            nested_check(item)

nested_check(a)
print(a)

输出：

[[1, 2, 3], [4, 5, 7]]

Answer 10

只有当您在另一个列表中最多有一个列表时，它才会起作用。 [1,2,[1,2],3] 随着更多的列表相互嵌套，您只需要添加更多的循环。

a = [[1, 2, 3, 0, []], [], [], [], [4, 5, [], 7]]
print('list before:', a)
while [] in a:
    for i in a:
        if i == []:
            a.remove(i)
for i in a:
    for e in i:
        if e == []:
            i.remove(e)
print('list after:', a)

这就是我得到的结果：

list before: [[1, 2, 3, 0, []], [], [], [], [4, 5, [], 7]]
list after: [[1, 2, 3, 0], [4, 5, 7]]