Python：调用Python obj时超过了最大递归深度

Question

我已经构建了一个爬虫程序，它必须在大约500万个页面上运行（通过增加url ID），然后解析包含我需要的信息的页面。

在使用了一个运行在url上的算法（200K）并保存了好的和坏的结果之后，我发现I浪费了很多时间。我可以看到有一些返回的子标记，可以用来检查下一个有效的url。

你可以很快地看到子任务（前几个“好ID”中的一个）

510000011 # +8
510000029 # +18
510000037 # +8
510000045 # +8
510000052 # +7
510000060 # +8
510000078 # +18
510000086 # +8
510000094 # +8
510000102 # +8
510000110 # etc'
510000128
510000136
510000144
510000151
510000169
510000177
510000185
510000193
510000201

在爬行了大约20万个url之后，我知道我在浪费时间，需要优化它，所以我运行了一些统计数据，并构建了一个函数来检查url，同时将id增加到8\18\17\8（top returning subtrahends）等。

这就是功能-

def checkNextID(ID):
    global numOfRuns, curRes, lastResult
    while ID < lastResult:
        try:
            numOfRuns += 1
            if numOfRuns % 10 == 0:
                time.sleep(3) # sleep every 10 iterations
            if isValid(ID + 8):
                parseHTML(curRes)
                checkNextID(ID + 8)
                return 0
            if isValid(ID + 18):
                parseHTML(curRes)
                checkNextID(ID + 18)
                return 0
            if isValid(ID + 7):
                parseHTML(curRes)
                checkNextID(ID + 7)
                return 0
            if isValid(ID + 17):
                parseHTML(curRes)
                checkNextID(ID + 17)
                return 0
            if isValid(ID+6):
                parseHTML(curRes)
                checkNextID(ID + 6)
                return 0
            if isValid(ID + 16):
                parseHTML(curRes)
                checkNextID(ID + 16)
                return 0
            else:
                checkNextID(ID + 1)
                return 0
        except Exception, e:
            print "somethin went wrong: " + str(e)

基本上要做的是-checkNextID（ID）得到我知道的第一个包含数据减8的ID，因此第一次迭代将匹配第一个“if isValid”子句（isValid（ID+8）将返回True）。

lastResult是一个变量，它保存最后一个已知的url id，因此我们将一直运行，直到numOfRuns

isValid（）是一个函数，它获取一个ID+其中一个子数组，如果url包含我需要的内容，则返回True；如果url不包含我需要的数据，则返回False。

parseHTML是一个函数，它获取soup对象（curRes），解析所需的数据，然后将数据保存到csv，然后返回True。

如果isValid（）返回True，我们将调用parseHTML（），然后尝试检查下一个ID+子标记（通过调用checkNextID（ID+子标记），如果没有一个返回我要查找的内容，我将其增加1，然后再次检查，直到找到下一个有效的url。

您可以看到剩下的代码here

运行代码后，我得到了大约950~个好结果，突然出现了一个异常-

"somethin went wrong: maximum recursion depth exceeded while calling a Python object"

我可以在WireShark上看到scipt卡在id-510009541上（我的脚本是用510000003开始的），脚本尝试用这个id获取url几次，然后我注意到错误并停止了它。

我真的很兴奋看到我得到了同样的结果，但是比我的旧脚本快25-40倍，HTTP请求更少，非常精确，1000个好结果我只错过了1个结果，这是我发现的，不可能重复5百万次，我的旧脚本运行了30个小时，当我的新脚本在5-10分钟内给出960个结果时，我得到了14-15K个结果。

我读到了堆栈限制，但是对于我试图用Python实现的算法必须有一个解决方案（我不能回到我以前的“算法”，它永远不会结束）。

谢谢！

Answer 1

这将递归转换为循环：

def checkNextID(ID):
    global numOfRuns, curRes, lastResult
    while ID < lastResult:
        try:
            numOfRuns += 1
            if numOfRuns % 10 == 0:
                time.sleep(3) # sleep every 10 iterations
            if isValid(ID + 8):
                parseHTML(curRes)
                ID = ID + 8
            elif isValid(ID + 18):
                parseHTML(curRes)
                ID = ID + 18
            elif isValid(ID + 7):
                parseHTML(curRes)
                ID = ID + 7
            elif isValid(ID + 17):
                parseHTML(curRes)
                ID = ID + 17
            elif isValid(ID+6):
                parseHTML(curRes)
                ID = ID + 6
            elif isValid(ID + 16):
                parseHTML(curRes)
                ID = ID + 16
            else:
                ID = ID + 1
        except Exception, e:
            print "somethin went wrong: " + str(e)

Answer 2

Python不支持递归，因为它缺少TRE（Tail Recursion Elimination）。

这意味着对递归函数的每次调用都将创建一个函数调用堆栈，并且由于堆栈深度有一个限制（默认值为1000），您可以通过^{}签出（当然，您可以使用sys.setrecursionlimit更改堆栈深度，但不建议这样做），因此当程序达到此限制时，它将崩溃。

另一个答案已经为您提供了一个更好的方法来解决这个问题（即用简单循环替换递归），如果您仍然想使用递归，那么还有另一个解决方案，即使用许多在python中实现TRE的方法中的一个，比如one。

N.B:我的回答是为了让您更深入地了解为什么会出现错误，我不建议您使用我已经解释过的TRE，因为在您的情况下，循环会更好、更容易阅读。

Answer 3

可以通过以下方法增加堆栈的容量：

import sys
sys.setrecursionlimit(10000)