如何计算巢列表中的项目？

Question

I'm trying to figure out how to count the number of items in a nest list. I'm stuck at how to even begin this. For example if I were to do NestLst([]) it would print 0 but if I do

NestLst([[2, [[9]], [1]], [[[[5]]], ['hat', 'bat'], [3.44], ['hat', ['bat']]]]

it would return 9. Any help on how to begin this or how to do this would be great.

Thanks!

Answer 1

import collections
def NestLst(seq):
    if isinstance(seq, str) or not isinstance(seq, collections.Iterable):
        return 1
    return sum(NestLst(x) for x in seq)

>>> NestLst([[2, [[9]], [1]], [[[[5]]], ['hat', 'bat'], [3.44], ['hat', ['bat']]]])
9

Answer 2

def total_length(l):
    if isinstance(l, list):
        return sum(total_length(x) for x in l)
    else:
        return 1

Answer 3

Your question contains the keyword: recursively . Create a function that iterates over the list and if it finds a non-list item, adds one to the count, and if it finds a list, calls itself recusively.

The issue with your code its that you are using length instead of a recursive call.

Here is a pythonic pseudocode:

def count(list):
    answer = 0
    for item in list:
        if item is not a list:
            answer += 1
        else:
            answer += number of items in the sublist (recursion will be useful here)

Answer 4

You could try to recursively call reduce() . Something like that:

>>> def accumulator(x,y):
...     if isinstance(y, list):
...         return reduce(accumulator,y,x)
...     else:
...         return x+1
... 
>>> reduce(accumulator, [10,20,30,40] ,0)
4
>>> reduce(accumulator, [10,[20,30],40] ,0)
4
>>> reduce(accumulator, [10,20,30,40,[]] ,0)
4
>>> reduce(accumulator, [10,[20,[30,[40]]]] ,0)
4
>>> reduce(accumulator, [10*i for i in range(1,5)] ,0)
4

Some notices:

• empty collections will count for 0 items (see last example)
• the 0 at the end the the reduce() call is the initial value. This might be a pitfall since when omitting it you still have a valid call, but the result will not be what you want. I strongly suggest wrapping the initial call in an utility function.