How to construct a nested list from another list with "begin" and "end" flags in python?

I am trying to parse a file, which has a nested structure to the data it contains. The number nesting is arbitrary in depth, and each is demarcated by a string, e.g. 'begin' and 'end. I would like to construct a list (or dictionary, etc.) that preserves the nesting of the data structure in the file.

As a simple example, from a list that looks something like:

input = [0, 'begin', 1, 2, 'begin', 3, 4, 'end', 5, 'end', 6]

I want to get to:

[0, [1, 2, [3, 4], 5], 6]

I tried creating a recursive function to do this, but I was unable to get the correct output. (I would include my attempt at a solution, but I can't tell if I am close or not at all because of the recursion). How should this problem be tackled?

Edit to add my attempt (I hope this doesn't just confuse things):

input = [0, 'begin', 1, 2, 'begin', 3, 4, 'end', 5, 'end', 6]

def create_nest(items, nest):
    for i, item in enumerate(items):
        if item == 'begin':
            nest.append(create_nest(items[i+1:], []))
        elif item == 'end':
            return nest
        else:
            nest.append(item)

nested_list = []
create_nest(input, nested_list)

This outputs:

[0, [1, 2, [3, 4], 3, 4], 1, 2, [3, 4], 3, 4]

Done without recursion:

def collapse(lst):
    save = []
    curr = []
    for x in lst:
        if x == 'begin':
            save.append(curr) # remember what you had so far
            curr = []         # start over
        elif x == 'end':
            old = save.pop()  # get back what you had
            old.append(curr)  # add list you just finished
            curr = old        # pick up where you left off
        else:
            curr.append(x)
    return curr

Using a recursive function, an iterator to avoid having to keep track of the current item, and taking advantage of the mutability of lists:

def to_nested(inpt, out=None):
    it = iter(inpt)   # use an iterator
    if out is None: # optional: just to avoid using a list as default
        out = []    #
    for item in it:
        if item == 'begin': # if begin, let's start a new level
            out.append([])  # add a new list and pass this recursively
            to_nested(it, out=out[-1])
        elif item == 'end': # if end, let's finish this recursion
            return
        else:               # else, add an item to the current level
            out.append(item)
    return out

to_nested([0, 'begin', 1, 2, 'begin', 3, 4, 'end', 5, 'end', 6])
# [0, [1, 2, [3, 4], 5], 6]

Note that this assumes a correct format (as many ends as there are begins). If not, you would have to keep track of them.

modification of your approach using an iterator like I did

inpt = [0, 'begin', 1, 2, 'begin', 3, 4, 'end', 5, 'end', 6]

def create_nest(items, nest):
    items = iter(items)
    for item in items:
        if item == 'begin':
            nest.append(create_nest(items, []))
        elif item == 'end':
            return nest
        else:
            nest.append(item)
    return nest

nested_list = []
create_nest(inpt, nested_list)
# [0, [1, 2, [3, 4], 5], 6]

Linear datum are best processed with a linear procedure -

def parse(tokens):
  r = [[]]
  for t in tokens:
    match t:
      case 'begin':
        r.append([])
      case 'end':
        r[-2].append(r.pop())
      case _:
        r[-1].append(t)
  return r[0]

parse([0, 'begin', 1, 2, 'begin', 3, 4, 'end', 5, 'end', 6])

[0, [1, 2, [3, 4], 5], 6]

You can and should exceptions for malformed begin..end pairs -

def parse(tokens):
  r = [[]]
  for t in tokens:
    match t:
      case 'begin':
        r.append([])
      case 'end':
        if len(r) < 2:
          raise RuntimeError("unexpected 'end'")
        r[-2].append(r.pop())
      case _:
        r[-1].append(t)
  if len(r) > 1:
    raise RuntimeError("expected 'end'")
  return r[0]

parse([0, 'end', 'begin', 1, 2, 'begin', 3, 4, 'end', 5, 'end', 6])
# RuntimeError: unexpected 'end'

parse([0, 'begin', 1, 2, 'begin', 3, 4, 'end', 5, 6])
# RuntimeError: expected 'end'

Elegant as they may be, the recursive solutions here provided incorrect output for malformed inputs.