Python'；s随机采样和堆栈溢出

我一直在从事一个大型Python科学项目，我遇到了一个堆栈溢出问题，它主要涉及

random.sample（）

和

多处理

。我有一个

Goo

对象，其中包含大量寻求交朋友的

Foo

。为此，他们使用

random.sample（）

随机选择属于

Goo

的

p

other

Foo

。完成后，程序停止

它是这样的：

福比

class Foo(object):
    def __init__(self):
        self.friends = []

goo.py：

from foo import Foo
import random

class Goo(object):
    def __init__(self, nfoo):
        self.foo_list = [Foo() for i in range(nfoo)]

    def sim_goo(self):
        for f in self.foo_list:
            candidates = random.sample(self.foo_list, 5)
            f.friends = candidates

和main.py：

from goo import Goo

def do_sim(argument):
    g = Goo(argument)
    g.sim_goo()
    return g

使用我运行：

这会引发一个

MaybeEncodingError:Error发送结果：“[]”。原因：“RecursionError（'酸洗对象时超过最大递归深度'，）”

当它与

para_list=[10，10]

一起工作时，我只能想象会出现错误，因为random.sample（）太大，当它从中选取的列表太大时无法处理，这在使用多处理时会出现问题。但是1000个食物并不多

有人知道另一种选择吗

谢谢你的时间

---

最好是，

为了对

Goo

对象进行pickle（将其传输到另一个进程），必须首先对其所有

Foo

进行pickle。要腌制每个

Foo

s，必须先腌制他们所有的朋友

Foo

s。要腌制那些

Foo

s。。。等等很可能会有一个贯穿所有1000个

Foo

s的友谊链（因此在酸洗过程中需要超过1000个堆栈深度）-但是默认递归限制（至少在我的Python副本上）只有1000个

---

如果你能接受1000个

Foo

s作为你的限制，你可能会稍微提高递归限制-

sys.setrecursionlimit（1050）

。如果你需要更多，就需要一种不同的方法。我想到的第一件事是将每个

Foo

的友谊作为索引列表存储到

Goo

的

Foo\u列表中，而不是实际引用其他
Foo
对象。
以便对
Goo
对象进行pickle（将其传输到另一个进程），所有的
Foo
s必须首先进行酸洗。要腌制每个
Foo
s，必须先腌制他们所有的朋友
Foo
s。要腌制那些
Foo
s。。。等等很可能会有一个贯穿所有1000个
Foo
s的友谊链（因此在酸洗过程中需要超过1000个堆栈深度）-但是默认递归限制（至少在我的Python副本上）只有1000个

如果你能接受1000个
Foo
s作为你的限制，你可能会稍微提高递归限制-
sys.setrecursionlimit（1050）
。如果你需要更多，就需要一种不同的方法。我想到的第一件事是将每个
Foo
的友谊作为索引列表存储到
Goo
的
Foo列表中，而不是实际引用其他
Foo
s。
什么是
dou sim
？这是代码的核心，可能也是问题的原因。您还可以尝试增加最大递归深度！我忘了添加main.py文件，这个文件很小，但是do_sim是在哪里编程的。现在已经完成了。是的，我试图增加最大递归深度，但似乎我需要达到疯狂的高递归深度才能工作，而且随着代码的增长，这是一种短视的方法。我是一名业余程序员，我认为更具Python风格的东西应该是可行的，因此我发表了这篇文章？这是代码的核心，可能也是问题的原因。您还可以尝试增加最大递归深度！我忘了添加main.py文件，这个文件很小，但是do_sim是在哪里编程的。现在已经完成了。是的，我试图增加最大递归深度，但似乎我需要达到疯狂的高递归深度才能工作，而且随着代码的增长，这是一种短视的方法。我是一名业余程序员，我认为更具Python风格的东西应该是可行的，因此我发表了这篇文章。谢谢！可能就是这样。尽管如此，当我不使用多处理时，它的工作没有任何问题。我可以做一个“do_sim（100000）”，它只需要时间，但没有堆栈溢出。这就是我一直困惑的地方。我一定会尝试使用索引！谢谢可能就是这样。尽管如此，当我不使用多处理时，它的工作没有任何问题。我可以做一个“do_sim（100000）”，它只需要时间，但没有堆栈溢出。这就是我一直困惑的地方。我一定会尝试使用索引！
from main import do_sim
from multiprocessing import Pool
pool = Pool(processes = 2)
para_list = [1000, 1000]
result = pool.map_async(sim_goo, para_list).get()