如何获得任意嵌套的列表列表中的元素总数？

Question

我有一个分配给变量 my_list 的列表。 my_list 的值为 [[1,2,3],[3,5,[2,3]], [[3,2],[5,[4]]]]。我需要找到 my_list 的长度，但 len(my_list) 只有 returns 3. 我想要它 return 11. 是否有任何 Python 函数可以return my_list 嵌套列表和所有列表的全长。

示例：

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

Output
11

我希望这不仅适用于数字，也适用于字符串。

Answer 1

这是一个替代解决方案，可能性能不佳，因为它填充了一个新的扁平化列表，该列表在最后返回：

def flatten_list(ls, flattened_list=[]):
    for elem in ls:
        if not isinstance(elem, list): 
            flattened_list.append(elem)
        else:
            flatten_list(elem, flattened_list)
    return flattened_list

flatten_list直观的将列表展平，然后可以用len()函数计算新返回的展平列表的长度：

len(flatten_list(my_list))

Answer 2

此函数计算列表的长度，将列表以外的任何对象都计为长度 1，并递归列表项以找到展平的长度，并且适用于解释器最大堆栈深度的任何嵌套度.

def recursive_len(item):
    if type(item) == list:
        return sum(recursive_len(subitem) for subitem in item)
    else:
        return 1

注意：根据使用方式的不同，为了正确判断元组的大小，最好检查项是否可迭代而不是检查它是否具有类型list，等。但是，检查对象是否可迭代会产生副作用，即计算字符串中的每个字符而不是给字符串长度 1，这可能是不希望的。

Answer 3

您实际上是在寻找一种方法来计算树中叶子的数量。

 def is_leaf(tree):
        return type(tree) != list

def count_leaves(tree):
    if is_leaf(tree):
        return 1
    else:
        branch_counts = [count_leaves(b) for b in tree]
        return sum(branch_counts)

count_leaves 函数通过递归计算树枝的 branch_counts，然后对这些结果求和来计算树中的叶子数。基本情况是当树是一片叶子时，这是一棵有 1 个叶子的树。叶子的数量不同于树的长度，这是它的分支数。

Answer 4

这是我的实现：

def nestedList(check):
    returnValue = 0
    for i in xrange(0, len(check)):
        if(isinstance(check[i], list)):
            returnValue += nestedList(check[i])
        else:
            returnValue += 1
    return returnValue

Answer 5

作为替代方案，您可以使用 flatten 和 len:

from compiler.ast import flatten

my_list = [[1,2,3],[3,5,[2,3]], [[3,2],[5,[4]]]]

len(flatten(my_list))
11

PS。感谢@thefourtheye 指出，请注意：

2.6 版后已弃用：编译器包已在 Python 3.

中删除

可在此处找到备选方案：Python 3 replacement for deprecated compiler.ast flatten function

Answer 6

hack 解决方案，有人不得不 post 它。将列表转换为字符串（将繁重的工作/递归留给 __str__ 运算符）然后计算逗号，加 1.

>>> my_list = [[1,2,3],[3,5,[2,3]], [[3,2],[5,[4]]]]
>>> str(my_list).count(",")+1
11

（适用于整数和浮点数，当然不能用于字符串，因为它们可以包含逗号）

编辑：这个 hack 不考虑空列表：我们必须删除 [] 个元素：

>>> my_list = [[1,2,3],[3,5,[2,3]], [[3,2],[5,[4],[]]]]  # added empty list at the end
>>> s = str(my_list)
>>> s.count(",")-s.count("[]")+1   # still 11

Answer 7

这是我最好的尝试，利用递归，并且只使用标准库和视觉对象。我尽量不使用自定义库

def listlength(mylist, k=0, indent=''):
    for l1 in mylist:
        if isinstance(l1, list):
            k = listlength(l1, k, indent+'  ')
        else:
            print(indent+str(l1))
            k+=1
    return k

a = [[1,2,3],[3,5,[2,3]], [[3,2],[5,[4]]]]
listlength(a)
# 11

并且为了好的措施

a = []
x = listlength(a)
print('length={}'.format(x))
# length=0



a = [1,2,3]
x = listlength(a)
print('length={}'.format(x))
#1
#2
#3
#length=3


a = [[1,2,3]]
x = listlength(a)
print('length={}'.format(x))
#  1
#  2
#  3
#length=3


a = [[1,2,3],[1,2,3]]
x = listlength(a)
print('length={}'.format(x))
#  1
#  2
#  3
#  1
#  2
#  3
#length=6

a = [1,2,3, [1,2,3],[1,2,3]]
x = listlength(a)
print('length={}'.format(x))
#1
#2
#3
#  1
#  2
#  3
#  1
#  2
#  3
#length=9


a = [1,2,3, [1,2,3,[1,2,3]]]
x = listlength(a)
print('length={}'.format(x))
#1
#2
#3
#  1
#  2
#  3
#    1
#    2
#    3
#length=9


a = [ [1,2,3], [1,[1,2],3] ]
x = listlength(a)
print('length={}'.format(x))
#  1
#  2
#  3
#  1
#    1
#    2
#  3
#length=7

如何获得任意嵌套的列表列表中的元素总数？

How can I get the total number of elements in my arbitrarily nested list of lists?

python

list

python-2.7

nested-lists