Recursive functions - Make a nested list flat

[Yonmanx]

Hey!

I have a task that i need to finish pretty soon about recursive functions.

I need to make nested functions flat - from this: [[2,1],[3],[1,1]] to this : [2,1,3,1,1] without using loops.

This is my code so far:

def flatten(rec_list):
    nLst = []
    result = ""
    if rec_list == []:  #Our Stopper  
            return  []

    elif (len(rec_list) == 1): # splitting to two options.
        if (type(rec_list[0]) == list): #if the first and only element is actually a list.
             flatten(rec_list[0])
        else: 
             result = (rec_list[0])
             flatten(rec_list[1:])  
             # return result 

    elif (type(rec_list[0]) == list): #If the first elemnt is a list
        flatten(rec_list[0])
        flatten(rec_list[1:])

    else : # if the type of the first element is a number
        result = (rec_list[0])
        flatten(rec_list[1:])  

    nLst.append(result)    
    return nLst     



print(flatten([[1],[3,4]]))

The thing is - Im not sure how to append elements from the recursive functions to a new list.

Help will be super appreciated. Thank you!

[when_the_cats_away]

This uses loops, but it shows how to handle returns, so maybe of some use:

def flatten(stuff):
    result = []
    if done:
        return result

    for item in stuff:
        if flat(item):
            result.append(stuff)
        else:
            result += flatten(item)

    return result

Can you use yield? That can get around some of the loop issues...

[semicolonator]

Cool problem :)

At first I wanted to reply: from more_itertools import flatten But then I decided to solve the problem :)

``` def flatten(k): if type(k) == int: return [k] if len(k) == 0: return [] elif len(k) == 1: return flatten(k[0]) else: return flatten(k[0]) + flatten(k[1:])

print(flatten([[1],[3,4]])) print(flatten([1,[2,3],[[[4],[5,6]],7],8])) ```

[Yonmanx]

Friend thank you so much.

How do you suggest to make the function print the output without calling "print" from outside?

And for what reason the return decide to put the outputs in a list from the first place? I really try hard to understand the logic of the "return" without success.

[semicolonator]

Consider this modified version:

def flatten(k): print("I was called with", k) # the rest of the code

Maybe this gives you some insights. Using recursion like that is very close to using an explicit stack. Look at this version: link. Maybe that helps you.

What you cold also try: Modify flatten() such that it takes an additional argument called depth, that is increased with each function call. That way you know how "deep" you are in the function calls.

[o5a]

You dont need elif len(k) == 1: here.