Застрял рекурсии Python

Question

Моя основная функция рекурсии, как это:

input_string бы в этом формате = [[коровы свиньи осла], 'свинья собака']

keep_track = [] 
def recursion(input_string, finding_name): 
    list_names = list format 

[корова свинья осел] [свинья], [собака]

for item in list_names: 
     if item is A SINGLE WORLD: 

т.е. [свинья]

  if name is finding_name: 
       keep_track append name 
     else name is A LIST WITH MULTIPLE WORDS: 

т.е. [корова свинья осла]

  recursion([cow pig donkey], finding_name) 

[корова], [свинья], [осел]

Это где я застрять. Поскольку у меня есть оператор возврата в конце

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

ФУНКЦИЯ БЕЗ КОММЕНТАРИЕВ

keep_track = [] 
def recursion(input_string, finding_name): 
    list_names = basically would do this the first time 
    for item in list_names: 
     if item is A SINGLE WORLD: 
      if name is finding_name: 
       keep_track append name 
     else name is A LIST WITH MULTIPLE WORDS: 
      recursion(item, finding_name) 
    return list_names 

Answer 1

Ваш вопрос бардак, так что это очень трудно понять, что вы пытаетесь спросить. Через час все еще не ясно. Я собираюсь сделать попытку догадываться, чтобы ответить на вопрос, который, по-видимому, является вопросом.

Кажется, вам присвоен список строк, вложенных произвольно глубоко. Что-то вроде:

in_lst = ['horse', 'cow', 'dog', ['pig', 'pig', 'horse'], 'cat', 'sheep'] 

И вы хотите, чтобы в конечном итоге со списком, содержащим все вхождения конкретной строки

foo(in_lst, "pig") == ["pig", "pig"] 
foo(in_lst, "horse") == ["horse", "horse"] 
foo(in_lst, "dog") == ["dog"] 

Самый простой способ сделать это, вероятно, выравниваться список, затем процеживают (а не рекурсивно).

# Python3.3+ 
def flatten(lst): 
    for el in lst: 
     try: 
      yield from flatten(el) 
     except TypeError: 
      yield el 

# Python3, before 3.3 
def flatten(lst): 
    accum = [] 
    for el in lst: 
     if hasattr(el, "__iter__") and not isinstance(el, str): 
      accum.extend(flatten(el)) 
     else: 
      accum.append(el) 
    return accum 

# Python2 
def flatten(lst): 
    # same as Python3 before 3.3, except replace 
    ... 
     if hasattr(el, "__iter__") and not isinstance(el, str): 
    # with 
    ... 
     if hasattr(el, "__iter__") and not isinstance(el, basestring): 

def find_names(haystack, needle): 
    return filter(lambda el: el==needle, flatten(haystack)) 
    # or return [el for el in flatten(haystack) if el == needle] 

если вы ДОЛЖНЫ рекурсию непосредственно по какой-то причине (намек: не), а затем попробовать тот же метод, который я использовал при выпрямлении:

def find_names(haystack, needle): 
    accum = [] 
    for el in lst: 
     if hasattr(el, "__iter__") and not isinstance(el, str): 
      accum.extend(find_names(el, needle)) 
     elif el == needle: 
      accum.append(el) 
    return accum 

Хотя, возможно, было бы легче просто рассчитывать.

def find_names(haystack, needle): 
    return [needle] * sum(1 for el in flatten(haystack) if el==needle)