This is what I've tried:
def recursive_list_counter(l):
sum = 0
for e in l:
if type(e) == type([]):
#print e
sum += 1
recursive_list_counter(e)
return sum
# should be 6 if I count the first also
recursive_list_counter([[[13, 7], 90], 2, [1, 100, [5, [2]]], 8, 6])
I want to use recursion to retrieve the number of lists within a list, counting the original list also.
Your recursive call ignores what is returned. Add the return value:
def recursive_list_counter(l):
sum = 0
for e in l:
if isinstance(e, list):
sum += 1
sum += recursive_list_counter(e)
return sum
Note that the outer list is ignored in the count, so the call returns 5, not 6.
Furthermore, you should use isinstance() to test if an object is of a given type.
If you want to see 6, count the current list in the function, and leave counting nested lists to the recursive call:
def recursive_list_counter(l):
sum = 1
for e in l:
if isinstance(e, list):
sum += recursive_list_counter(e)
return sum
type(e) == type([]) this part
sum = 1 and lose sum += 1.For your given example, if all you have are numbers within lists, you can try converting to string and counting the number of [
>>> li = [[[13, 7], 90], 2, [1, 100, [5, [2]]], 8, 6]
>>> str(li).count('[')
6
str function takes lots of time.A true functional solution would be this:
def recursive_list_counter(li):
return 1 + sum(map(recursive_list_counter, li)) if isinstance(li, list) else 0
To count all elements in the list use this slightly altered version:
def recursive_element_counter(li):
return sum(map(recursive_element_counter, li)) if isinstance(li, list) else 1
I think this should do the trick. But I guess I was too slow, I already see 3 other answers. :P
#!/usr/bin/env python
def lcount(l):
count = 0
if isinstance(l, list):
count+=1
count+=sum([lcount(x) for x in l])
return count
list_ = [ [ [1, 2, 3], [1, 4, 5], [7, 8, 9]], [ 1, 2, 7], 1, 3, ]
print lcount(list_)
Three important points:
isinstance to check the typesum as a variable since it's already a built-in function not isinstance(l, list)) Here is your function :
def recursive_list_counter(l):
if not isinstance(l, list):
return 0
return 1 + sum(recursive_list_counter(e) for e in l)
Actually, the problem is very simple. Everytime you called recursive_list_counter, you create a new local variable sum, instead of incrementing the global one.
sum = 0
def recursive_list_counter(l):
global sum
for e in l:
if type(e) is list: #this is the same, but a better practice.
#print e
sum += 1
recursive_list_counter(e)
return sum
recursive_list_counter([[[13, 7], 90], 2, [1, 100, [5, [2]]], 8, 6]) #returns 5
You can also increment sum recursively:
if type(e) is list:
sum += 1
sum += recursive_list_counter(e)
Hope this helps!
is: type(e) is list; but it is much better to use isinstance() because then you allow for subclasses of list as well.