如何检查 python 的列表列表中是否存在值？

Question

我有一个列表列表：

lst = [[[1,2,3],[3,4,5]],[1,[2,34,5,[45,67]]]]

我想检查列表中是否存在一个值，例如 67。 我已经看过 StackOverflow 问题：

如何检查列表列表中是否存在列表列表？

但它只显示了一种检查值是否在列表列表中的方法。

无论列表有多深，我将如何搜索列表？

Answer 1

如果您的列表不大并且您想要简单的解决方案，那么您可以将列表转换为字符串并检查该字符串中数字的字符串值，请参见以下示例：

lst = [[[1,2,3],[3,4,5]],[1,[2,34,5,[45,67]]]]
lst1 = str(lst)
print(lst)
print(str(67) in lst1)

output 是：

[[[1, 2, 3], [3, 4, 5]], [1, [2, 34, 5, [45, 67]]]]
True

Answer 2

递归。

from typing import List, Tuple, Any, Union

RecursiveList = Union[List['RecursiveList'], Any]

def multiindex(lst: List[RecursiveList], item) -> Tuple[int]:
    for idx, elem in enumerate(lst):
        if elem == item:
            return (idx,)
        else:
            # try to call it recursively. 
            # if the current element isn't iterable, enumerate() will throw a TypeError
            # which we can just ignore
            try:
                return (idx,) + multiindex(elem, item)
            except (TypeError, ValueError):
                continue
    raise ValueError(f'{item} is not in list')

l = [[[1,2,3],[3,4,5]],[1,[2,34,5,[45,67]]]]
print(multiindex(l, 67))
# (1, 1, 3, 1)

我们可以通过简单地检查我们是否得到一个 ValueError 来测试它是否包含在搜索它，就像我们使用普通的list.index() 。 或者，只需修改方法以返回 boolean 而不是抛出ValueError ：

def multicontains(lst: List[RecursiveList], item) -> bool:
    for idx, elem in enumerate(lst):
        if elem == item:
            return True
        else:
            try:
                sublist_contains = multicontains(elem, item)
                if sublist_contains:
                    return True
            except TypeError:
                continue
    return False

Answer 3

除了将列表转换为字符串外，您还可以在展平列表中搜索项目。

为了使列表变平，我们可以使用来自collections.abc的Iterable class 。

from collections.abc import Iterable


def get_flatten(ar):
  if isinstance(ar, Iterable):
    return [inner_iterable for i in ar for inner_iterable in get_flatten(i)]
  return [ar]

def get_searched_result(ar, item):
  return item in get_flatten(ar)


if __name__ == "__main__":
  lst = [[[1,2,3],[3,4,5]],[1,[2,34,5,[45,67]]]]
  item = 67
  print(f"{item} in {lst}: {get_searched_result(lst, item)}")


  item = 32
  print(f"{item} in {lst}: {get_searched_result(lst, item)}")

Output：

67 in [[[1, 2, 3], [3, 4, 5]], [1, [2, 34, 5, [45, 67]]]]: True
32 in [[[1, 2, 3], [3, 4, 5]], [1, [2, 34, 5, [45, 67]]]]: False

参考：

• 可从 collections.abc 迭代
• 获取扁平化列表

Answer 4

另一种没有任何库的嵌套列表的递归方式。 一旦找到值，它就会返回。

def find_nested(lst, val):
  if val in lst:
    return True
  for e in lst:
    if e.__class__ == list and find_nested(e, val):
      return True
  return False

因此，例如：

lst = [[[1,2,3],[3,4,5]],[1,[2,34,5,[45,67]]],1]

find_nested(lst, 1) #=> True --- it returns at first call
find_nested(lst, 67) #=> True
find_nested(lst, 670) #=> False

find_nested(lst, [3,4,5]) #=> True

您可以编辑该方法，以便它还返回找到该值的列表。 或者让它 go 并检查返回每个包含该元素的列表的所有嵌套列表。 或者你需要的任何行为。