Question

What I’m trying to do, is, given a list with an arbitrary number of other nested lists, recursively descend through the last value in the nested lists until I’ve reached the maximum depth, and then append a value to that list. An example might make this clearer:

>>> nested_list1 = [1, 2, 3, [4, 5, 6]]
>>> last_inner_append(nested_list1, 7)
[1, 2, 3, [4, 5, 6, 7]]

>>> nested_list2 = [1, 2, [3, 4], 5, 6]
>>> last_inner_append(nested_list2, 7)
[1, 2, [3, 4], 5, 6, 7]

The following code works, but it seems excessively tricky to me:

def add_to_inner_last(nested, item):
    nest_levels = [nested]
    try:
        nest_levels.append(nested[-1])
    except IndexError:                    # The empty list case
        nested.append(item)
        return
    while type(nest_levels[-1]) == list:
        try:
            nest_levels.append(nest_levels[-1][-1])
        except IndexError:                 # The empty inner list case
            nest_levels[-1].append(item)
            return
    nest_levels[-2].append(item)
    return

Some things I like about it:

• It works
• It handles the cases of strings at the end of lists, and the cases of empty lists

Some things I don’t like about it:

• I have to check the type of objects, because strings are also indexable
• The indexing system feels too magical–I won’t be able to understand this tomorrow
• It feels excessively clever to use the fact that appending to a referenced list affects all references

Some general questions I have about it:

• At first I was worried that appending to nest_levels was space inefficient, but then I realized that this is probably just a reference, and a new object is not created, right?
• This code is purely side effect producing (It always returns None). Should I be concerned about that?

Basically, while this code works (I think…), I’m wondering if there’s a better way to do this. By better I mean clearer or more pythonic. Potentially something with more explicit recursion? I had trouble defining a stopping point or a way to do this without producing side effects.

Edit:

To be clear, this method also needs to handle:

>>> last_inner_append([1,[2,[3,[4]]]], 5)
[1,[2,[3,[4,5]]]]

and:

>>> last_inner_append([1,[2,[3,[4,[]]]]], 5)
[1,[2,[3,[4,[5]]]]]

Answer 1

How about this:

def last_inner_append(x, y):
    try:
        if isinstance(x[-1], list):
            last_inner_append(x[-1], y)
            return x
    except IndexError:
        pass
    x.append(y)
    return x