python递归报错 RuntimeError: maximum recursion depth exceeded

最新推荐文章于 2024-06-05 10:38:45 发布
最新推荐文章于 2024-06-05 10:38:45 发布
阅读量2.2k 收藏 2
点赞数 2
CC 4.0 BY-SA版权
分类专栏： python 网络爬虫 文章标签： python 递归 爬虫
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_28766327/article/details/78227590
本文介绍了在Python中遇到的递归深度限制问题及其解决办法。通过调整系统递归限制，可以有效避免运行时错误，确保递归算法正常执行。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

递归是我们常用的一种编程方法，通俗的说就是样一个方法自己调用自己。
今天写爬虫的时候，使用递归出现如下错误

RuntimeError: maximum recursion depth exceeded

查询资料，这个问题出现是因为python有递归深度限制。但是这个递归深度的限制是可以手动设置的。

解决方法：

import sys
sys.setrecursionlimit(100000)

实测可用

RuntimeError: maximum recursion depth exceeded
jacke121的专栏
02-02 2748
RuntimeError: maximum recursion depth exceeded 然后长时间运行后出现 RuntimeError: maximum recursion depth exceeded，之后去stackoverflow查发现是python自身的递归深度是999，也就是最多支持return get_detail 999次，import sys sys.setrecu
python递归深度报错--RuntimeError: maximum recursion depth exceeded
wenyusuran的专栏
07-27 3617
代码上传至https://github.com/gatieme/AderXCoding/blob/master/python/error/depth-exceeded.py 问题 这段时间用Python写了一个爬虫脚本，在抓取页面采用广度优先遍历抓取。但是当遍历到1000左右时就会出现莫名其妙的错误，  通过pdb调试发现是： RuntimeError: maximum recursi...
Python递归（recursion）专题
weixin_30855761的博客
02-11 407
我想把Python中的递归作为一个专题讨论一下。我在学习的时候，尝试使用“Python递归”作为关键词，在Google和百度中搜索，发现结果大部分是对某个具体例子的递归应用讨论，而对我这样的小白来说，切入点有点高。而我现在需要做的，是从基础概念开始。 想到讨论递归问题，是因为那个著名的“字典序”问题，但还是先从最基本的递归概念开始。我希望我讨论完了这个，自己对递归也有一个基本的了解了。...
python递归深度报错: RuntimeError: maximum recursion depth exceeded
iMeta
03-21 1291
这段时间用Python写了一个爬虫脚本，在抓取页面采用广度优先遍历抓取。但是当遍历到900多时就会出现莫名其妙的错误，通过pdb调试发现是：RuntimeError: maximum recursion depth exceeded在网上查了，发现python默认的递归深度是很有限的，大概是900多的样子，当递归深度超过这个值的时候，就会引发这样的一个异常。解决的方式是手工设置递归调用深度，方式为i
Python RuntimeError: maximum recursion depth exceeded in cmp 超过最大递归深度错误
xfyangle的博客
02-24 6443
说明：Python运行版本Python2.7.12 最近写了个Python爬虫，运行时出现 RuntimeError: maximum recursion depth exceeded in cmp 错误，上网查资料发现Python遍历深度在最大1000，超过就会报错！ 写个程序测试下： #coding=utf-8 import sys def func(depth): depth
pyinstaller打包报错： RecursionError: maximum recursion depth exceeded
热门推荐
lucyTheSlayer的博客
07-13 1万+
今天给以前写的python脚本用pyinstaller打包的时候，居然报错了： ... File "d:\programdata\anaconda3\lib\ast.py", line 253, in visit return visitor(node) File "d:\programdata\anaconda3\lib\ast.py", line 261, in gener...
RecursionError: maximum recursion depth exceeded
jacke121的专栏
05-16 3112
pyinstaller打包报错： RecursionError: maximum recursion depth exceeded 放开那禽兽冲我来 2018-07-13 14:53:41 10363 收藏 12 展开 今天给以前写的python脚本用pyinstaller打包的时候，居然报错了： ... File "d:\programdata\anaconda3\lib\ast.py", line 253, in visit return visitor(node) Fil...
python 最大递归次数 RuntimeError: maximum recursion depth exceeded
PlusTang
05-31 1万+
帮别人看代码，偶然遇到这个问题，原来python解释器有一个默认的最大迭代次数是999。举个例子：def recursion(n): if (n <= 1): return print n recursion(n - 1)print "test 999" recursion(999) #正常运行print "test 1000" recursion(100
python-RuntimeError: maximum recursion depth exceeded(运行错误：超过最大递归深度)
Juunnry的博客
07-28 2999
这段时间用Python写了一个爬冲脚本，在抓取页面采用广度优先遍历抓取。   但是当遍历到900多时就会出现莫名其妙的错误，通过pdb调试发现是： RuntimeError: maximum recursion depth exceeded 在网上查了，发现python默认的递归深度是很有限的，大概是900多的样子，当递归深度超过这个值的时候，就会引发这样的一个异常。 解决的方式是手工设置...
python RuntimeError: maximum recursion depth exceeded
s37
08-11 645
RuntimeError: maximum recursion depth exceeded 当用python写程序时，递归深度默认为1000,当超出1000时就会报错， 此时需要设置一个大的递归值来避免报错，程序如下： import sys sys.setrecursionlimit(2000) def func(depth): depth += 1 print("depth
启动django项目报错：RuntimeError: maximum recursion depth exceeded while calling a Python object...
weixin_33727510的博客
06-03 807
2019独角兽企业重金招聘Python工程师标准>>> ...
RuntimeError: maximum recursion depth exceeded while calling a Python object
蛋蛋的专栏
08-16 1720
今天执行如下命令发生错误： solver = caffe.SGDSolver('/media/vipsl1/data/Alexnet/solver.prototxt') solver.net.copy_from('/home/vipsl1/models/bvlc_alexnet/caffe_alexnet_model.caffemodel') RuntimeError: maximum rec...
python中简单的递归（断点报错的小福利）
10-19 281
首先要先理解什么是递归？ 在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。 下面讲了一个很简单的递归函数 def clac(n): print(n) if int(n/2) &amp;amp;gt;0: return clac(int(n/2)) print(&amp;quot;-&amp;amp;gt;&amp;quot;,n) clac(10) ...
scrapy RuntimeError: maximum recursion depth exceeded while calling a Python object 超出python最大递归数异常
weixin_46246967的博客
07-27 263
scrapy RuntimeError: maximum recursion depth exceeded while calling a Python object 超出python最大递归数异常
【Python】解决Python报错：RuntimeError: maximum recursion depth exceeded in comparison
科技改变人类，技术成就未来
06-05 788
解决Python报错：RuntimeError: maximum recursion depth exceeded in comparison
报错信息：RecursionError: maximum recursion depth exceeded while calling a Python object，但是看起来递归并没有达到1000次
最新发布
07-27
<think>我们正在讨论一个特殊场景：用户遇到了RecursionError，但实际递归深度并未达到1000次（默认限制）。这看起来违反直觉，但确实可能发生。以下我将分析可能原因并提供解决方案。 ### 原因分析 1. **多线程/异步环境中的递归限制** 在Python中，递归深度限制是**针对每个线程独立计算**的。如果程序使用多线程，每个线程的递归深度单独计数。但若主线程或其他线程同时进行深层递归，可能触发全局限制[^1][^2]。 2. **递归函数内调用其他递归函数** 递归函数A调用递归函数B时，两者的调用栈会叠加。例如： ```python def func_A(n): if n == 0: return func_B(n) # 调用另一个递归函数 def func_B(n): if n == 0: return func_A(n-1) # 互相调用 ``` 此时总递归深度为`func_A`和`func_B`的调用次数之和，即使单函数未超限，总和也可能超限[^3]。 3. **C扩展或内置函数递归** 部分C扩展模块（如NumPy、Pandas）或Python内置函数（如`__str__`、`__repr__`）可能隐式递归。例如： ```python class Node: def __init__(self, children): self.children = children def __repr__(self): return f"Node({self.children})" # 递归调用子节点的__repr__ # 循环引用导致无限递归 node = Node([]) node.children.append(node) print(node) # 触发RecursionError ``` 此类递归不直接可见，但会消耗栈深度[^4]。 4. **装饰器或元类导致的间接递归** 装饰器可能意外增加递归深度。例如： ```python def debug_decorator(func): def wrapper(*args): print("Calling", func.__name__) return func(*args) # 调用原函数 return wrapper @debug_decorator def recursive_func(n): if n == 0: return recursive_func(n-1) # 实际递归深度 = n + 装饰器调用次数 ``` 5. **系统栈空间不足** 操作系统对线程栈大小有限制（如Linux默认8MB）。即使递归次数较少，若单次调用占用栈过大（如大型局部变量），也可能提前触发栈溢出[^5]。 ### 解决方案 #### 1. 检查代码中的间接递归 - 排查是否存在函数间相互调用（如A→B→A）。 - 使用`sys._getframe().f_back`跟踪调用栈： ```python import sys def print_stack(depth=0): frame = sys._getframe() stack = [] while frame: stack.append(f"{frame.f_code.co_name}:{frame.f_lineno}") frame = frame.f_back print(f"Current depth: {len(stack)}") print("Stack trace:\n" + "\n".join(stack[-10:])) # 打印最后10层 ``` #### 2. 避免对象自引用 - 对包含循环引用的对象，重写`__repr__`或`__str__`方法： ```python class Node: def __init__(self, children): self.children = children def __repr__(self): return "Node(children)" # 避免递归输出子节点 ``` #### 3. 增加线程栈大小 - 对于多线程场景，可通过`threading.stack_size()`调整： ```python import threading threading.stack_size(1024*1024*32) # 32MB ``` 注意：必须在创建线程前设置。 #### 4. 使用迭代重写递归 将递归改为迭代（参考前文方法），这是最彻底的解决方案。 #### 5. 监控实际递归深度 在递归函数中添加计数器： ```python import sys def recursive_func(n, depth=0): if depth > 500: # 设置安全阈值 raise RuntimeError("Depth exceeds safe limit") # ...正常递归逻辑... recursive_func(n-1, depth+1) ``` ### 特殊情况：递归深度未达1000却报错 若递归深度明显小于1000仍报错，可能是： - **局部变量过大**：单个函数调用占用大量栈空间（如`local_var = [0]*1000000`）。 **解决**：减少栈占用，或用堆分配（如`global`或`heapq`）。 - **第三方库bug**：如旧版pyinstaller或tokenizer的已知问题[^4][^5]。 **解决**：更新库版本或应用补丁。 ### 总结流程 ```mermaid graph TD A[出现RecursionError但递归深度<1000] --> B{检查原因} B --> C1[多线程/异步环境] B --> C2[函数间递归调用] B --> C3[隐式递归（如__repr__）] B --> C4[局部变量过大] B --> C5[第三方库问题] C1 --> D1[增加线程栈大小] C2 --> D2[改为迭代或消除交叉递归] C3 --> D3[重写特殊方法] C4 --> D4[减少栈占用] C5 --> D5[更新库版本] ``` 通过以上方法，您可定位并解决非常规递归深度问题。若仍无法解决，建议提供最小可复现代码以便进一步分析。 §§相关问题§§ 1. 如何检测Python程序中的循环引用？ 2. 在多线程环境中如何安全地使用递归？ 3. 如何计算Python函数的栈空间占用？ 4. 哪些Python内置函数可能导致隐式递归？ 5. 如何为包含递归的Python程序设置线程栈大小？ [^1]: 引用自：RecursionError: maximum recursion depth exceeded原因及解决办法。 [^2]: 引用自：【Python】解决Python报错：RecursionError: maximum recursion depth exceeded。 [^3]: 引用自：Python报错：RecursionError: maximum recursion depth exceeded。 [^4]: 引用自：tokenizer出现RecursionError: maximum recursion depth exceeded while getting the str of an object的解决方案。 [^5]: 引用自：Python：pyinstaller报错【A RecursionError maximum recursion depth exceeded occurred】。</think>### Python RecursionError 但递归深度未达1000的原因与解决方案 当出现 `RecursionError: maximum recursion depth exceeded` 但实际递归调用次数未达到默认1000次限制时，通常有以下特殊原因及解决方案： --- #### 一、常见原因分析 1. **隐式递归调用** - 对象方法（如 `__str__`, `__repr__`, `__getattr__`）被意外递归调用 - **示例**： ```python class Node: def __init__(self, value): self.value = value self.children = [] def __repr__(self): # 错误：递归调用子节点的__repr__ return f"Node({self.value}, {self.children})" root = Node(1) child = Node(2) root.children.append(child) child.children.append(root) # 循环引用 print(root) # 触发RecursionError ``` *引用自对象循环引用场景[^4]* 2. **装饰器叠加递归** - 多层装饰器导致实际调用深度倍增 - **示例**： ```python def debug_decorator(func): def wrapper(*args): print(f"Calling {func.__name__}") return func(*args) # 装饰器本身增加调用深度 return wrapper @debug_decorator def recursive_func(n): if n <= 0: return recursive_func(n-1) # 实际深度 = n * 装饰器层数 ``` 3. **第三方库内部递归** - 使用库（如NLTK、SpaCy）时，其内部实现存在递归调用 - 典型场景：复杂文本解析、语法树生成[^4] 4. **系统栈空间不足** - 单次递归调用占用过大栈空间（如大型局部变量） - 递归深度远小于1000时即触发系统级栈溢出 5. **元类/metaclass 递归** - 元类中的 `__new__` 或 `__prepare__` 方法意外递归 --- #### 二、针对性解决方案 ##### 1. 对象循环引用问题 ```python class Node: def __init__(self, value): self.value = value self.children = [] def __repr__(self): # 安全方案：限制递归深度 return f"Node({self.value}, children_count={len(self.children)})" ``` ##### 2. 装饰器深度优化 ```python import functools def debug_decorator(func): @functools.wraps(func) def wrapper(*args): # 添加深度监控 if wrapper.depth > 100: raise RuntimeError("Depth limit reached") wrapper.depth += 1 result = func(*args) wrapper.depth -= 1 return result wrapper.depth = 0 return wrapper ``` ##### 3. 第三方库问题处理 - **步骤**： 1. 更新库到最新版本 2. 限制输入规模（如缩短文本长度） 3. 替换为迭代型工具（如SpaCy的`nlp.pipe`替代逐句处理） ##### 4. 栈空间优化 ```python def recursive_func(n, large_data=None): # 将大型数据移出栈帧 large_data = large_data or [] # 使用生成器减少内存占用 if n <= 0: yield else: yield from recursive_func(n-1, large_data) ``` ##### 5. 元类递归预防 ```python class SafeMeta(type): def __new__(cls, name, bases, dct): # 避免在__new__中创建同类实例 if not hasattr(cls, '_creating'): cls._creating = True instance = super().__new__(cls, name, bases, dct) delattr(cls, '_creating') return instance else: raise RuntimeError("Recursive metaclass call") ``` --- #### 三、调试工具与方法 1. **调用栈分析** ```python import sys import traceback def recursive_func(n): if n % 50 == 0: # 每50层打印栈信息 traceback.print_stack(limit=5) # ...递归逻辑... ``` 2. **深度监控装饰器** ```python def depth_monitor(func): def wrapper(*args, **kwargs): wrapper.count += 1 if wrapper.count > 500: raise RuntimeError(f"Depth exceeded at {wrapper.count}") result = func(*args, **kwargs) wrapper.count -= 1 return result wrapper.count = 0 return wrapper ``` 3. **内存分析工具** ```bash pip install memory-profiler mprof run --include-children your_script.py ``` --- #### 四、根本性预防策略 | **方案** | **适用场景** | **优势** | |-----------------------|----------------------------|-----------------------------| | 迭代替代递归 | 算法可改写 | 彻底避免递归限制 | | 尾递归优化 | 函数式编程场景 | 减少栈空间占用 | | 显式栈管理 | 复杂递归逻辑 | 完全控制调用深度 | | 分治+循环 | 大数据处理 | 并行处理能力 | > **关键提示**：当递归深度异常时，优先检查是否有**间接递归**（如通过属性访问触发的方法调用）而非直接递归调用[^4]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值