Рекурсивные функции

Question

Допустим, у меня есть рекурсивная функция, которая создает списки внутри списков. Он возвращает что-то вроде:

['a', ['b', ['c', ['d', []]]], 'z', []]

Позволяет назвать этот список LIST1

Затем у меня есть функция, которая берет этот список и очищает его для меня, фактически удаляя z.Lets вызывает этот список LIST2

[a,b,c,d]

Что я могу сделать, это вызвать мою первую функцию и получить мой список, а затем (находясь в оболочке python) вызвать мою функцию очистки в LIST1, чтобы преобразовать ее в LIST2. Я хотел бы, чтобы очистка работала сразу после возвращения LIST1, по сути, имея очистку, работающую в моей функции генератора списков.

Я озадачен тем, как я должен вызывать функцию, которая изменяет результат рекурсивной функции, не ломая рекурсивную функцию.

Я не хочу вдаваться в подробности моего кода, поскольку он довольно сложный и сильно вложенный, но задавайте вопросы, если вы хотите, чтобы я разъяснил.

Если это помогает визуализировать проблему, представьте ее проще. У меня есть функция, которая возвращает значение, я хочу, чтобы другая функция работала с этим значением, но внутри первой функции.

Приветствия

Answer 1

Это то, что вы пытались сделать?

import collections

result = ['a', ['b', ['c', ['d', []]]], 'z', []]

def get_result() :
    for r in result :
        yield r


def flatten(l):
    for el in l:
        if isinstance(el, collections.Iterable) and not isinstance(el, basestring):
            for sub in flatten(el):
                yield sub
        else:
            yield el


def remove_z(l) :
    for i in l :
        if i != 'z' :
            yield i

print [ l for l in remove_z(flatten(get_result()))]

И в результате получается

['a', 'b', 'c', 'd']

Отсюда вытекает функция 'flatten': https://stackoverflow.com/a/2158532/16718

Answer 2

Если вы не предоставите более подробную информацию о рекурсивной функции и функции очистки, вам будет трудно решить ваши проблемы

Тем не менее, я разработал тривиальный пример, который может быть похож на то, что вы делаете в настоящее время. Как вы заметили, как заметил @Daniel, вложение вызовов работает так, как должно быть

Вот пример

Учитывая

>>> def Wind(p):
    if not p:
        return []
    return [p[:1] + Wind(p[1:-1])+p[-1:]]

>>> Wind(range(1,10))
[[1, [2, [3, [4, [5, 5], 6], 7], 8], 9]]

и

>>> def UnWind(p):
    if not p:
        return []
    return p[:1] + UnWind(p[1:-1][0])+p[-1:]

чтобы вы могли видеть результат UnWind после того, как Wind работает достаточно хорошо.

>>> UnWind(Wind(range(1,10))[0])
[1, 2, 3, 4, 5, 5, 6, 7, 8, 9]

Answer 3

Я мог бы что-то упустить, но почему бы просто не вызвать функцию очистки окончательного результата рекурсивной функции? например,

result = cleanup(recursive())