创建一个递归函数来循环生成生成列表的列表......等等

Question

首先，我使用的是 python。我有一个名为 tier1 的项目列表，它看起来像这样。tier1 = ['a1','a2,'a3',..,'an']我有 2 个函数，称为 functionA 和 functionZ。他们都将字符串作为参数并生成如下列表输出。这些列表必须在执行期间生成，并且从一开始就不可用。只有 tier1 可用。listOutput = functionA(tier1[0])。列表输出看起来像这样listOutput = ['b1','b2,'b3',..,'bn']下一次在 listOutput 上使用 functionA 假设项目'b1'，它将产生listOutput = functionA('b1')output: listOutput = ['bc1','bc2,'bc3',..,'bcn']这次当使用 functionA 时，假设是 'bc1'，它可能会变成空的，因此使用 functionZ 代替 'bc1' 并将输出存储在某处。listOutput = functionA('bc1')输出listOutput = []所以我用listOutput = functionZ('bc1')输出listOutput = ['series1','series2','series3',....,'seriesn']现在我必须回去尝试 bc2，直到 bcn 执行相同的逻辑。完成后，我将在“b2”上使用 functionA。等等。每个项目的深度是可变的。它看起来像这样只要 listOutput 不为空，就必须在 listOutput 项或 tier1 项上使用 functionA，直到它变为空。然后 functionZ 必须用于列表中 functionA 为空的任何项目。在tier1之后，listOutput也永远是一个list，同样要一个一个循环，同样的逻辑。我正在尝试基于此创建递归函数，但我被卡住了。到目前为止，我有，def recursivefunction (idnum): #idnum will be one of the list items from tier1 or the listOutputs produced    listOutput = functionA(idnum)    if not listOutput:        return functionZ(idnum)    else:        return recursivefunction(listOutput) 但是我的函数返回列表，我如何让它们更深入地进入每个列表直到使用 functionZ 并且一旦它被用来移动到列表中的下一个项目。我需要创建一种新的数据结构吗？我不知道从哪里开始，我应该寻找创建某种带有链表的类吗？

Answer 1

我理解你的问题的方式：

• 有一个输入列表tier1，它是一个字符串列表

• 有两个函数，A和Z

• A、应用于字符串时，返回字符串列表

• Z，当应用于字符串时，返回一些值（类型不清楚，假设字符串列表也是如此）

• 算法：

• 对于 的每个元素tier1，将 A 应用于该元素

• 如果结果为空列表，则将 Z 应用于该元素，不再进行进一步处理

• 否则，如果结果不为空，则应用列表中的算法

所以，在 Python 中：

from random import randint

# since you haven't shared what A and Z do, 

# I'm just having them do random stuff that matches your description

def function_a(s):

    # giving it a 75% chance to be empty

    if randint(1, 4) != 1:

        return []

    else:

        # otherwise between 1 and 4 random strings from some selection

        return [['a', 'b', 'c'][randint(0, 2)] for _ in range(randint(1,4))]

        # in the real case, I'm sure the result depends on `s` but it doesn't matter

def function_z(s):

    # otherwise between 0 and 4 random strings from some selection

    return [['x', 'y', 'z'][randint(0, 2)] for _ in range(randint(0,4))]

def solution(xs):

    # this is really the answer to your question:

    rs = []

    for x in xs:

        # first compute A of x

        r = function_a(x)

        # if that's the empty list

        if not r:

            # then we want Z of x instead

            r = function_z(x)

        else:

            # otherwise, it's the same algorithm applied to all of r

            r = solution(r)

        # whatever the result, append it to rs

        rs.append(r)

    return rs

tier1 = ['a1', 'a2', 'a3', 'a4']

print(solution(tier1))

请注意，function_a和function_z只是使用您指定的结果类型生成随机结果的函数。你没有分享 A 和 Z 的逻辑到底是什么，所以很难验证结果是否是你想要的。

但是，该功能solution完全按照您所说的去做-如果我理解您对它的解释有些复杂的话。

鉴于您的问题的解决方案基本上是这样的：

def solution(xs):

    rs = []

    for x in xs:

        r = function_a(x)

        if not r:

            r = function_z(x)

        else:

            r = solution(r)

        rs.append(r)

    return rs

甚至可以重写为：

def solution_brief(xs):

    return [function_z(r) if not r else solution(r) for r in [function_a(x) for x in xs]]

您应该重新检查您的问题描述。编程的关键是理解问题并将其分解为基本步骤。完成后，代码很快就会跟进。您是否喜欢第一个或第二个解决方案可能取决于经验，也可能取决于微小的性能差异。

顺便说一句，任何写成递归函数的解决方案，也可以写成纯粹的迭代——从内存和性能的角度来看，这通常是更可取的，但递归函数的优点是非常干净和简单，因此更容易维护。

把我的代码放在嘴边，这是同一问题的迭代解决方案，只是为了好玩（无论如何都不是最优的）：

def solution_iterative(xs):

    if not xs:

        return xs

    rs = xs.copy()

    stack_rs = [rs]

    stack_is = [0]

    while stack_rs:

        r = function_a(stack_rs[-1][stack_is[-1]])

        if not r:

            stack_rs[-1][stack_is[-1]] = function_z(stack_rs[-1][stack_is[-1]])

            stack_is[-1] += 1

        else:

            stack_rs[-1][stack_is[-1]] = r

            stack_rs.append(r)

            stack_is.append(0)

        while stack_is and stack_is[-1] >= len(stack_rs[-1]):

            stack_is.pop()

            stack_rs.pop()

            if stack_is:

                stack_is[-1] += 1

    return rs