Python 需要帮助让这个递归函数工作吗

我有一个对象person，它在x，y位置定义了一个人

班级人员：
定义初始化（self，x，y）：
self.x=x
self.y=y
定义报告（自我）：
返回“Person（{}，{}）”格式（self.x，self.y）
#在新的x，y->x_new，y_new处创建一个人物的副本
def next（自我、x_移动、y_移动）：
#这不是实际运动的计算方式，而是用于演示
返回人（self.x+x_移动，self.y+y_移动）

我希望为这个人找到所有可能的行动，在未来的t_步骤。 可能的移动以数组为界（在任何给定时间都可能不同，因此这是一个示例）

x_可能=[-1,0,1]注意：在另一次代码运行期间，它可能是[3,5,2,4]，因此算法需要使用此数组来了解可能的移动

y_可能=[-1,0,1]

方法调用如下所示：

initial_person=person（0,0）
#人的所有可能动作，3个时间步进入未来
所有可能的人员移动=获取可能的人员移动（初始人员，3）

方法

get\u-apability\u-movements

必须返回一个元组数组，其中每个元组的结构如下：

(
x_new = FIRST movement of x from this branch of movements,
y_new = FIRST movement of y from this branch of movements,
next Person from the initial_person --> person_2 = initial_person.next(x_new, y_new),
next Person from the person_2       --> person_3 =       person_2.next(x_possible[i] , y_possible[j],
.
.
will have a person count equal to t_step from the method call
)

example:
initial_person = Person(0, 0)
# all possible movements for person, 3 time steps into the future
all_possible_movements_for_person = get_possible_movements(initial_person , 3)
all_possible_movements_for_person contains a large array of tuples with first entry:

# I am showing the movements made on the person in the tuple for example
(-1, -1, person(-1,-1), person2(-1,-1), person3(-1,-1))
- first element is 1 because the algorithm should pick the first x_movement to be -1 based on the
possible movements array.
- second is -1 for the same reason with y movements.
- the first person in the array is from doing the operation initial_person.next(-1,-1)
- the second person in the array is from doing the operation person1.next(-1,-1)
- the third person in the array is from doing the operation person2.next(-1,-1)


following similar logic, the next tuple in the output array would be:
(-1, -1, person(-1,-1), person2(-1,-1), person4(-1,0))
the person 4 object is new and is the next entry in the y_movements array to get that person.
then
(-1, -1, person(-1,-1), person2(-1,-1), person5(-1,1))
(-1, -1, person(-1,-1), person2(-1,-1), person6(0,-1))
(-1, -1, person(-1,-1), person2(-1,-1), person7(0,0))

输出看起来像，但请记住，在这个输出示例中，我使用字符串表示对象

我的尝试就在这里。。。。它没有输出接近我所需要的，我甚至不认为我已经接近了。我不擅长递归

x_可能=[-1,0,1]
y_可能=[-1,0,1]
班长：
定义初始化（self，x，y）：
self.x=x
self.y=y
定义报告（自我）：
返回“Person（{}，{}）”格式（self.x，self.y）
#在新的x，y->x_new，y_new处创建一个人物的副本
def next（自我、x_移动、y_移动）：
#这不是实际运动的计算方式，而是用于演示
返回人（self.x+x_移动，self.y+y_移动）
def获取可能的移动（c，n）：
locs=[]
获取人员递归（c，n，n，0，0，locs，（））
返回LOC
def get_people_递归（person、i、time_step、a_索引、b_索引、locs、tup）：
如果时间步长<0：
附加位置（tup）
回来
如果a_索引>=len（x_可能）或b_索引>=len（y_可能）：
回来
如果时间步=i：
tup+=（x_可能[a_索引]、y_可能[b_索引]）
c_next=person.next（x_可能[a_索引]、y_可能[b_索引]）
tup+=（c_next，）
get_people_递归（c_next，i，time_step-1，a_索引，b_索引，locs，copy.deepcopy（tup））
get_people_递归（c_next，i，time_step，a_index+1，b_index，locs，copy.deepcopy（tup））
所有人=获得可能的移动（人（0,0,1）
打印（len（所有人））
对于我所有的人：
印刷品（一）

这项研究的结果：

(-1, -1, Person(-1, -1), Person(-2, -2))
(-1, -1, Person(-1, -1), Person(-2, -2), Person(-2, -3))
(-1, -1, Person(-1, -1), Person(-2, -2), Person(-2, -3), Person(-1, -4))
(-1, -1, Person(-1, -1), 0, -1, Person(-1, -2), Person(-1, -3))
(-1, -1, Person(-1, -1), 0, -1, Person(-1, -2), Person(-1, -3), Person(0, -4))
(-1, -1, Person(-1, -1), 0, -1, Person(-1, -2), 1, -1, Person(0, -3), Person(1, -4))

---

可能有帮助也可能没有帮助的图表

您的代码很接近。匹配字符串输出的诀窍是保留一个

count

变量来构建结果字符串，或者保留一个静态类变量来计算ID

除此之外，递归遍历并推/弹出堆栈以存储路径。其他的都是

这是密码

import itertools

class Person:
    def __init__(self, n, a, b):
        self.n = n
        self.a = a
        self.b = b

    def __repr__(self):
        return f"Person{self.n}"

def produce_c(a, b, n):
    combos = list(itertools.product(a, b))
    count = 0

    def explore(pair, path=[]):
        nonlocal count
        count += 1
        path.append(Person(count, *pair))

        if len(path) == n:
            yield tuple(path)
        else:
            for pair in combos:
                yield from explore(pair, path)

        path.pop()

    for pair in combos:
        for path in explore(pair):
            yield (*pair, *path)

if __name__ == "__main__":
    for x in produce_c([-1, 0, 1], [-1, 0, 1], 3):
        print(x)

---

我确实不太明白这个问题。什么是“

C

”？你能更清楚地解释一下这个目的吗？预期的输出是巨大的，因此也许一个简单的输入->逻辑->输出的例子会使操作发生的情况更加明显。您必须使用这个

C

类和递归吗？看起来像某种产品逻辑，可能最好使用itertools。感谢您的澄清。C类只是一个带有a和b的对象。如果你想的话，可以称之为笛卡尔图上的x和y。然后调用C.next（ai，bi）将该图上的C“移动”到新位置ai，bi。然后从该方法返回一个新的C。我想一个很好的可视化方法是，我们试图在一个图上获得所有可能的“结束”位置，从初始值C开始。我们希望保持从初始值C开始的初始移动，这是元组中的前两个数字。元组中的其他C都是用于创建到该位置的路径的C。另外请注意，C的可能“移动”有界于a_可能和b_可能的边界内。这些不是x和y方向，而是完全用于定义CWe“运动”的其他方向。如果您描述您试图解决的实际问题以及建议的解决方案，那么CWe可以更好地回答您的问题。正在努力重写以使其更清晰。我想您离理解更近了。我们需要元组中的对象，因为它们将在程序的后面部分使用。这个程序非常大而且让人困惑，所以我试着把它拆分出来，尽我所能来说明我们的问题。我也把这张图放在一起，准确地显示我在这里需要什么。我们还需要C，因为它是一个具有许多函数的较大对象。我只是把所有的东西都去掉了，让这更简单。谢谢你的帮助！没问题。我添加了一个类并修复了一个bug，但它是相同的算法。闻起来有点过于简单了——这可能是一个错误。生成这些东西很容易，但为什么呢？如果这只是一个随机练习，那很酷，但我怀疑这可能是一些搜索问题或游戏的一部分，可能有更好的方法。如果你能看一下，我完全重编了介绍。除了更改类名之外，这个算法似乎基本上仍然满足您的需要，不是吗？如果没有，如果你不介意让我知道我错过了什么，我可以很容易地适应。你太棒了！不完全是我所需要的，但足够近，我找到了答案。这里对脚本进行了一些修改：。此外，我需要下一个def in Person类，因为在我的实际代码中，这两个类之间的关系基于在下一个方法中执行的一些计算和算法。