如何使用递归从列表列表中打印数据

Question

Python. It is given list of list. How to make function which will data from list represent like 'moreline' string' like that every data will be shown in its new line, and in front of it are so many '*' as many as depth of data is.

Example : we have list [2, 4, [[3, 8], 1]] and now function has to make and return string, which function 'print' prints it out like this:

* 2
* 4
*** 3
*** 8
** 1

I have made for now just this and its not working

def Function(List):
    s=''
    Count=0
    for element in List:
        Count+=1
        if type(element)==type([]):
            s+=Function(element)

        else:
            s+=Count*'*'+str(element)+('\n')


    return s

if a replace return (s) with print(s) it report me an error ... but if i return s and than myself print that string it works normally , but once again not how it should

>>> Function([2, 4, [[3, 8], 1]])
'*2\n*4\n*3\n*8\n**1\n'
>>> print('*2\n*4\n*3\n*8\n**1\n')
*2
*4
*3
*8
**1

Where is the problem, I can't find it. What should I replace, remove, etc.?

Answer 1

You need to pass on count to recursive calls; local variables do not magically transfer to new function invocations:

def format_nested(lst, depth=1):
    s = []
    for element in lst:
        if isinstance(element, list):
            s.append(print_nested(element, depth + 1))
        else:
            s.append('{0} {1}\n'.format(depth * '*', element))
    return ''.join(s)

I addressed various other issues with the code:

• Use descriptive function and argument names. Function is not a great name.
• Use a list to build up elements of a string, then use str.join() ; it is faster than building up strings by concatenation.
• Only increment the depth counter when recursing, not for every element in current level of the list.
• Use isinstance() to test for specific types.
• String formatting makes it a little easier to build strings together with constant elements, such as a space and a newline.

Demo:

>>> format_nested([2, 4, [[3, 8], 1]])
'* 2\n* 4\n*** 3\n*** 8\n** 1\n'
>>> print format_nested([2, 4, [[3, 8], 1]])
* 2
* 4
*** 3
*** 8
** 1

Answer 2

def r(l, depth=0, ret=[]):
    if isinstance(l,list):
        for i in l:
            r(i, depth+1)
    else:
        ret.append('*' * depth + str(l))
    return ret

print '\n'.join(r([2, 4, [[3, 8], 1]]))

output:

*2
*4
***3
***8
**1

Answer 3

Often it's easier to express these things as a generator

L = [2, 4, [[3, 8], 1]]

def nest_gen(L):
    if isinstance(L, list):
        for i in L:
            for j in nest_gen(i):
                yield "*"+str(j)
    else:
        yield L

for row in nest_gen(L):
    print(row)

In Python3.3+ you can use yield from

L = [2, 4, [[3, 8], 1]]

def nest_gen(L):
    if isinstance(L, list):
        yield from ("*"+str(j) for i in L for j in nest_gen(i))
    else:
        yield L

for row in nest_gen(L):
    print(row)

Instead of catenating strings over and over, you can yield the depth/item as a tuple

L = [2, 4, [[3, 8], 1]]

def nest_gen(L):
    if isinstance(L, list):
        yield from ((j+1, k) for i in L for j, k in nest_gen(i))
    else:
        yield 0, L

for item in nest_gen(L):
    print("{:*>{}} {}".format('', *item))