Как я могу заставить эту рекурсивную функцию Python возвращать плоский список?

Question

Посмотрите на эту простую функцию

def prime_factors(n):
    for i in range(2,n):
      if n % i == 0:
        return i, prime_factors(n / i)
    return n

Вот результат prime_factors(120)

(2, (2, (2, (3, 5))))

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

(2, 2, 2, 3, 5)

Есть ли простой способ сделать это?

Answer 1

def prime_factors(n):
  for i in range(2,n):
    if n % i == 0:
      return [i] + prime_factors(n / i)
  return [n]

Answer 2

def prime_factors(n):
    for i in range(2,n):
        if n % i == 0:
           yield i
           for p in prime_factors(n / i):
               yield p
           return
    yield n

Пример:

>>> tuple(prime_factors(100))
(2, 2, 5, 5)

Answer 3

Без изменения исходной функции, из Python Tricks :

def flatten(x):
    """flatten(sequence) -> list

    Returns a single, flat list which contains all elements retrieved
    from the sequence and all recursively contained sub-sequences
    (iterables).

    Examples:
    >>> [1, 2, [3,4], (5,6)]
    [1, 2, [3, 4], (5, 6)]
    >>> flatten([[[1,2,3], (42,None)], [4,5], [6], 7, MyVector(8,9,10)])
    [1, 2, 3, 42, None, 4, 5, 6, 7, 8, 9, 10]"""

    result = []
    for el in x:
        #if isinstance(el, (list, tuple)):
        if hasattr(el, "__iter__") and not isinstance(el, basestring):
            result.extend(flatten(el))
        else:
            result.append(el)
    return result

Answer 4

liw.fi предлагается в комментарии :

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

Вот реализация предложения liw.fi.

def prime_factors(n, factors=None):
    if factors is None:
        factors = []
    for i in range(2,n):
        if n % i == 0:
            factors.append(i)
            return prime_factors(n / i, factors)
    factors.append(n)
    return factors

Answer 5

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

<code>def flatten(S):
    if S == []:
        return S
    if isinstance(S[0], list):
        return flatten(S[0]) + flatten(S[1:])
    return S[:1] + flatten(S[1:])