根据参数取消嵌套列表一定次数

Question

I am trying to unnest a list n number of times, where n is passed into the function. There can only be one value within the innermost list, its just the problem of removing brackets

I have tried:

def nest(x,n):
    newlist = [x]
    flatlist=[]
    if n > 0:
        for counter in range(n-1):
            newlist = [newlist]
        return newlist
    elif n<0:
        for sublist in x:
            for item in sublist:
                print(item)

        return flatlist
    else:
        return x

print(nest([[["hello"]]], -3))

but this only removes the outermost list irrespective of the number of lists this should unnest. The output of this is "[["hello"]]"

Answer 1

I don't really get the logic in your code when the n is negative, but if I understood the problem correctly, and you simply want to add/remove the brackets around your input list, the following code will do it:

def nest(x, n):
    if n > 0:
        for _ in range(n):
            x = [x]
    if n < 0:
        for _ in range(-n):
            x = x[0]    
    return x

Examples:

print(nest([[["hello"]]], 0))
# [[['hello']]]

print(nest([[["hello"]]], 2))
# [[[[['hello']]]]]

print(nest([[["hello"]]], -2))
# ['hello']

---

Note that if you specify n greater than the number of brackets, this can produce an unexpected result if the inner element is a string:

print(nest([[["hello"]]], -4))
# h

Probably, you wouldn't want that, so we need either simply return the inner element in this case, or raise an error:

def nest(x, n):
    if n > 0:
        for _ in range(n):
            x = [x]
    if n < 0:
        for _ in range(-n):
            if not isinstance(x, list):
                break  # or raise ValueError('Not enough nested levels to unpack')
            x = x[0]    
    return x

print(nest([[["hello"]]], -4))
# hello

Answer 2

This could work, you might need to adapt it.

def unnest(x):
    x2 = []
    for i in x:
        for j in i:
            x2.append(j)
    return x2


def nest(x,n):
    x2 = x
    for i in range(n):
        x2 = unnest(x2)
    return x2

Answer 3

This will nest as you want to:

lst1 = [[["hello"]]]
str1 = 'hello'

def nest(element, n):
    return [nest(element, n - 1)] if n else element

print(nest(str1, 5))
# [[[[['hello']]]]]

This will unpack lists of lists of lists... recursively.

def flatten_list(lst):
    """returns flat list"""
    if isinstance(lst, (list, tuple)):
        if len(lst) == 0:
            return []
        first, rest = lst[0], lst[1:]
        return flatten_list(first) + flatten_list(rest)
    else:
        return [lst]

def flatten_to_string(lst):
    """extracts flat list to string"""
    return flatten_list(lst)[0]


print(flatten_to_string([[["hello"]]]))
# hello

print(flatten_list([[[[[["hello"]]], [[["hello"]]]]]]))
# ['hello', 'hello']