Question

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

示例：

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

Output
11

我想如果这不仅适用于数字，还适用于字符串。

Answer 1

此函数计算列表的长度，将列表以外的任何对象计为长度1，并在列表项上递归以查找展平的长度，并且可以使用任何程度的嵌套直到解释器的最大堆栈深度。 / p>

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

注意：根据如何使用它，最好检查项是否可迭代，而不是检查它是否具有类型list，以便正确判断元组的大小等。但是，检查对象是否可迭代将产生计算字符串中每个字符的副作用，而不是给字符串长度为1，这可能是不合需要的。

Answer 2

作为替代方案，您可以将展平与 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 3

黑客解决方案，有人必须发布它。将列表转换为字符串（将繁重的提升/递归保留给__str__运算符）然后计算逗号，加1。

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

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

编辑：此黑客不会考虑空列表：我们必须删除[]元素：

>>> 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 4

这是一种替代解决方案，可能不是那么高效，因为它填充了一个新的扁平列表，最后返回：

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 5

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

 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来计算树中的叶子，然后对这些结果求和。基本情况是树是一片叶子，它是一片有一片叶子的树。叶子的数量与树的长度不同，后者是树枝的数量。

Answer 6

这是我的实施：

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 7

tuple或list的便捷方式

对于tuple

from nltk import flatten
Obj = (0.4, ((0.1, (0.05, 0.07)), (0.18, 0.2)))
print(len(flatten(list(Obj))))

对于List

 Obj = [[1,2,3],[3,5,[2,3]], [[3,2],[5,[4]]]]
 print(len(flatten((Obj))))

Answer 8

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

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

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

8 个答案: