python是每个对象的最大重复深度吗？

Question

我正在重构 Python 信号处理框架，因为我们遇到了最大重复深度错误。

对该错误最可能的解释是，有时单个类的大量实例是从类的 init 方法递归创建的。事实上，模拟这种情况的实验会导致异常 RuntimeError: 'maximum recursion depth exceeded'。

当我将链中的下一个元素创建到管理这些对象的容器时，问题似乎消失了，尽管在我天真的理解中构建了相同深度的调用堆栈。我通过所有以前创建的对象调用创建。 （见示例代码）。

我倾向于得出结论，递归深度限制是以某种方式为每个对象设置的（无论是类还是实例）。当通过 init 递归创建时，可能会将所有内容放在类的堆栈中，就好像我们通过同一类的一系列实例递归创建它们一样，所有对象的递归深度都非常有限。

我正在为这个假设寻求一些证实，但发现很难得到证实或反驳。

import sys

class Chunk(object):
    pre=None
    post=None
    def __init__(self, container,pre):
        print 'Chunk Created'
        self.pre=pre
        self.container=container

    def create(self,x):
        if self.post == None:
            self.post=Chunk(self.container,self)
            newChunk =self.post
        else:
            newChunk =self.post.create(x+1)
        return newChunk

    def droprefs(self):
        print 'refcount droprefs start: ', sys.getrefcount(self)
        if not self.pre ==None:
            self.pre.droprefs()

        self.pre=None
        self.post=None
        self.container=None
        print 'refcount droprefs end: ', sys.getrefcount(self)

    def claimContainer(self):
        self.container.setmasterchunk(self)
        self.pre.droprefs()
        self.pre=None

class Container(object):
    masterchunk=None

    def __init__(self):
        self.masterchunk=Chunk(self, None)

    def setmasterchunk(self, chunk):
        print 'refcount 5: ', sys.getrefcount(self.masterchunk)
        self.masterchunk=chunk
        print 'refcount 6: ', sys.getrefcount(self.masterchunk)

    def testrecursion(self,n):

        for i in range(n):
            print 'refcount 6: ', sys.getrefcount(self.masterchunk)
            newChunk=self.masterchunk.create(1)

        return newChunk

    def testhistoryremoval(self,chunk):
        chunk.claimContainer()



if __name__ == '__main__':
    C=Container()
    middle=C.testrecursion(300)
    last=C.testrecursion(600)
    last=C.testhistoryremoval(middle)

    if middle== C.masterchunk:
        print 'SUCCESS'

补充说明：

显示最大递归深度的代码：

import sys
from time import sleep

class Chunk(object):
    pre=None
    post=None
    def __init__(self, container,pre,n):
        print 'Chunk Created'
        self.pre=pre
        self.container=container

        if n>0:
            self.post=Chunk(self.container,self,n-1)

    def droprefs(self):
        print 'refcount droprefs start: ', sys.getrefcount(self)
        if not self.pre ==None:
            self.pre.droprefs()

        self.pre=None
        self.post=None
        self.container=None
        print 'refcount droprefs end: ', sys.getrefcount(self)

    def claimContainer(self):
        self.container.setmasterchunk(self)
        self.pre.droprefs()
        self.pre=None

class Container(object):
    masterchunk=None

    def __init__(self):
        pass

    def setmasterchunk(self, chunk):
        print 'refcount 5: ', sys.getrefcount(self.masterchunk)
        self.masterchunk=chunk
        print 'refcount 6: ', sys.getrefcount(self.masterchunk)

    def testrecursion(self,n):
        self.masterchunk=Chunk(self,None,n)



if __name__ == '__main__':
    print('Try 10')
    C0=Container()
    C0.testrecursion(10)

    sleep(2)

    print('Try 1000')
    C1=Container()
    C1.testrecursion(1000)

Answer 1

在我使用的实现中，设置

sys.setrecursionlimit(907)

证明这是您达到的递归深度。

---

对于您的问题，答案是否定的。在 CPython 的源码中你可以看到递归深度是每个线程，而不是每个对象。

pystate.h:

typedef struct _ts {
    /* See Python/ceval.c for comments explaining most fields */

    //...
    int recursion_depth;
    //...
}

ceval.c:

/* the macro Py_EnterRecursiveCall() only calls _Py_CheckRecursiveCall()
   if the recursion_depth reaches _Py_CheckRecursionLimit.
   If USE_STACKCHECK, the macro decrements _Py_CheckRecursionLimit
   to guarantee that _Py_CheckRecursiveCall() is regularly called.
   Without USE_STACKCHECK, there is no need for this. */
int
_Py_CheckRecursiveCall(const char *where)
{
    PyThreadState *tstate = PyThreadState_GET();
    //...
    if (tstate->recursion_depth > recursion_limit) {
        --tstate->recursion_depth;
        tstate->overflowed = 1;
        PyErr_Format(PyExc_RecursionError,
                     "maximum recursion depth exceeded%s",
                     where);
        return -1;
     }
   //...
}

tstate 是线程状态的简写。

Answer 2

不，这是一个全局递归深度。您描述的情况意味着当您超过堆栈限制时，您会捕获异常并继续下一个对象。这个过程会删除相关的堆栈条目——将递归解开到它的起点。

您从下一个对象重新开始。如果这个不超过堆栈深度，它将顺利完成——之前的堆栈条目不会影响新的。

Answer 3

您可以将方法重写为迭代而不是递归。无论您的数据结构有多深，这都避免了递归深度错误的可能性。

create 方法会变成这样：

def create(self, x): # the `x` arg is not actually used for anything?
    chunk = self

    while chunk.post is not None:
        chunk = chunk.post

    chunk.post = Chunk(self.container, chunk)

    return self.post # this matches the old code but you may actually want `return self.post`

你可以用droprefs 做类似的事情。您当前的代码似乎从列表的末尾向前迭代，这可能是也可能不是您想要的。这是对迭代行为的直接翻译：

def droprefs(self):
    chunk = self

    while chunk:
        next = chunk.pre # this iterates backwards, to go forwards use `next = chunk.post`

        chunk.pre = None
        chunk.post = None
        chunk.container = None

        chunk = next

我还要注意，除非您希望外部代码包含对早期 Chunks 的引用，否则您可能根本不需要使用 droprefs。在claimContainer 执行self.pre = None 之后，垃圾收集器应该能够清理所有早期的Chunk 实例，因为不再有对它们的外部引用。摆脱它们对彼此的引用可能会使其工作得更快（因为 pre 和 post 属性形成引用循环），但这并不是绝对必要的。