精华内容
下载资源
问答
  • 今天小编就为大家分享一篇关于Python中最大递归深度值的探讨,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
  • python 最大递归深度问题

    千次阅读 2019-01-08 21:03:20
    python 递归深度 最近在学习算法相关内容, 当学习到快速排序时想到一个问题, 在最差情况下, 快速排序是否优于选择排序, 于是生成一个 3000 个元素的降序列表,分别使用选择排序和快速排序对其升序排序代码如下: # –*...

    python 递归深度

    最近在学习算法相关内容, 当学习到快速排序时想到一个问题, 在最差情况下, 快速排序是否优于选择排序, 于是生成一个 3000 个元素的降序列表,分别使用选择排序和快速排序对其升序排序代码如下:

    # –*– coding: utf-8 –*–
    # @Time      : 2019/1/8 20:27
    # @Author    : Damon_duanlei
    # @FileName  : selectionsort_with_quicksort.py
    # @BlogsAddr : https://blog.csdn.net/Damon_duanlei
    import copy
    import time
    
    
    def selection_sort(sort_list):
        new_list = []
        while len(sort_list):
            index = 0
            min_num = sort_list[0]
            for i in range(1, len(sort_list)):
                if min_num > sort_list[i]:
                    min_num = sort_list[i]
                    index = i
            new_list.append(sort_list.pop(index))
        return new_list
    
    
    def quick_sort(sort_list):
        if len(sort_list) < 2:
            return sort_list
        else:
            mark = sort_list[0]
            less = []
            great = []
            for i in sort_list[1:]:
                if i <= mark:
                    less.append(i)
                else:
                    great.append(i)
            return quick_sort(less) + [mark] + quick_sort(great)
    
    
    if __name__ == '__main__':
        list_a = [10000 - i for i in range(3000)]
        list_b = copy.deepcopy(list_a)
        t1 = time.time()
        new_list1 = selection_sort(list_a)
        t2 = time.time()
        new_list2 = quick_sort(list_b)
        t3 = time.time()
        print("选择排序用时:{}".format(t2 - t1))
        print("快速排序用时:{}".format(t3 - t2))
    
    
    

    运行结果:

    RecursionError: maximum recursion depth exceeded in comparison
    

    异常原因:

    程序运行超过了python允许的最大递归深度. python 解释器为了避免内存溢出和性能影响设置了最大递归深度为998, 当调用栈超过998层就会报错. 关于递归压栈问题可阅读 https://blog.csdn.net/Damon_duanlei/article/details/85939660 第三章内容

    解决方法:

    手动修改最大递归深度,代码如下:

    import sys
    
    sys.setrecursionlimit(3000) # 设置最大递归深度为3000
    

    修改最大递归深度后在运行原有代码:

    >>>
    选择排序用时:0.27227139472961426
    快速排序用时:0.37400031089782715
    

    注意: 递归最大深度与使用版本,电脑性能和系统有关, 本篇使用环境 win10 + python 3.6 递归最大深度3000左右, 有传言 Windows 系统允许最大递归深度为3000, 如何修改如哪位朋友知晓请留言告知.

    展开全文
  • 在函数调用时,为了保证...对于函数递归调用,会将大量的上下文信息入栈,如果递归深度过大,会导致线程栈空间不足而崩溃。 在Python中,为了防止栈崩溃,默认递归深度是有限的。 # 这是一个简单的递归函数 d...

     

    在函数调用时,为了保证能够正确返回,必须进行保存现场和恢复现场,也就是被调函数结束后能够回到主调函数中离开时的位置然后继续执行主调函数中的代码。这些现场或上下文信息保存在线程栈中,而线程栈的大小是有限的。

    对于函数递归调用,会将大量的上下文信息入栈,如果递归深度过大,会导致线程栈空间不足而崩溃。

    在Python中,为了防止栈崩溃,默认递归深度是有限的。

    # 这是一个简单的递归函数
    def demo(n=0):
        try:
            demo(n+1)
        except:
            print(n)
    
    demo()

    通过这个简单的无限递归,你会发现并没有无限下去,而是到了一个限度就没有递归了,这是默认的递归是有限度的。

    但是你可以通过修改默认递归深度来控制他例如:

    import sys
    # 如果确实需要很深的递归深度,可以使用sys模块中的setrecursionlimit()函数修改默认的最大深度限制。
    sys.setrecursionlimit(1000)
    # 这是一个简单的递归函数
    def demo(n=0):
        try:
            demo(n+1)
        except:
            print(n)
    
    demo()

    这次的递归深度明显就比上一次的不一样了。再用一个例子来说明一下:
     

    import sys
    from functools import lru_cache
    
    # 如果确实需要很深的递归深度,可以使用sys模块中的setrecursionlimit()函数修改默认的最大深度限制。
    sys.setrecursionlimit(3000)
    
    @lru_cache(maxsize=64)
    def cni(n, i):
        if n == i or i == 0:
            return 1
        return cni(n - 1, i) + cni(n - 1, i - 1)
    
    
    print(cni(900, 100))

    这也是一个修改默认的最大限制的递归了

    展开全文
  • 用以下的代码可以求出在本机最大递归深度,用二分法测出来的。 不知道python和c++为什么差这么多 Python: def get_dep(num): if num == 1: return 1 else: return num * get_dep(num-1) print(ge...

    由于计算机栈的内存有限,而函数递归会调用到栈,所以函数的递归深度有限
    用以下的代码可以求出在本机最大递归深度,用二分法测出来的。
    python和c++差这么多的原因可能是编译器分配的栈内存不同:
    栈的内存可以自己调整:
    Python:

    def get_dep(num):
        if num == 1:
            return 1
        else:
            return num * get_dep(num-1)
    print(get_dep(998))#最大为998
    

    C++:

    #include <iostream>
    
    using namespace std;
    typedef long long ll;
    ll get_dep(ll x)
    {
        if(x==1) return 1;
        else
            return x+get_dep(x-1);
    }
    
    int main()
    {
        cout << get_dep(43429) << endl;///最大为43429
        return 0;
    }
    
    展开全文
  • 在生成的.spec 文件中加入: import sys sys.setrecursionlimit(5000) 之后 运行 pyinstaller xxx.spec 大部分能够解决(解决了我的问题)

    在生成的.spec 文件中加入:

    import sys
    sys.setrecursionlimit(5000)

    之后 运行 pyinstaller xxx.spec

    大部分能够解决(解决了我的问题)

    展开全文
  • 这段时间用Python写了一个爬冲脚本,在抓取页面采用广度优先...在网上查了,发现python默认的递归深度是很有限的,大概是900多的样子,当递归深度超过这个值的时候,就会引发这样的一个异常。 解决的方式是手工设置...
  • Python中最大递归深度值探讨

    千次阅读 2018-12-28 22:20:32
    Python对递归函数设置是有默认值。 可以通过下面命令来查看设置的默认值 &gt;&gt;&gt; import sys &gt;&gt;&gt; sys.getrecursionlimit() 3000 查看该函数的帮助文件就更清晰了: &...
  • #设置最大深度 sys.setrecursionlimit(100000000) count = 0 def func(): global count count += 1 print(count) func() print(456) func() 这里我们设置的是100000000 但是实际只有3219 这是由电脑决定的,...
  • import sys sys.setrecursionlimit(100000) #例如这里设置为十万
  • 递归最大深度

    千次阅读 2018-05-08 16:04:00
    题外话:由于递归深度可控,一般写类似递归的方法时尽量使用迭代器,例如Fibonacci数列,在python高级中我会把迭代器实现Fibonacci数列的方法贴出来,而不是用递归。 递归深度尽量不去修改,用起来也会很绕。下面我...
  • python递归超过最大深度的问题

    千次阅读 2019-09-20 15:12:02
    python 默认的最大递归深度为1000。 可以通过代码进行设置 import sys sys.setrecursionlimit(100000)
  • #调整递归最大深度: import sys sys.getrecursionlimit(depth)
  • 最近写了个Python爬虫,运行时出现 RuntimeError: maximum recursion depth exceeded in cmp 错误,上网查资料发现Python遍历深度最大1000,超过就会报错! 写个程序测试下: #coding=utf-8 import sys def ...
  • 调整Python递归深度问题 可以利用内置sys模块调整Python的最大递归深度 ...
  • 在GBase数据库中,有时我们需要写含有递归算法的存储过程或者函数,运行时会收到报错如下: SQL错误[1465][HY000]:Recursive limit 0 (as set by the max_sp_recursion_depth variable) was exceeded for routine .....
  • 快速排序算法的递归深度

    千次阅读 2017-08-06 17:15:09
    题目:对n个记录的线性表进行快速排序为减少算法的递归深度,以下叙述正确的是(A)A、每次分区后,先处理较短的部分 B、每次分区后,先处理较长的部分 C、与算法每次分区后的处理顺序无关 D、以上三者都不对详解:...
  • JavaScript递归深度问题

    2016-08-24 13:42:00
    递归是有限的东西: function fact(num) { if (num <= 1) { return 1; } else { return fact(num - 1); } } 测试结果是35840成功,之后就失败了,递归只能这么多次...
  • 观察java中栈的最大递归深度

    千次阅读 2012-01-07 17:52:27
    无聊观察了一下,没有对jvm参数进行调整,直接用myeclipse进行跑application 9000附近 机器内存2g 附简单程序: public class StackSize { private int size = 1; public void stackLeak... public static
  • python 解释器为了避免内存溢出和性能影响设置了最大递归深度为998, 当调用栈超过998层就会报错 maximum recursion depth exceeded.
  • 点击打开链接/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} ... *...
  • python递归深度问题

    千次阅读 2018-02-13 16:07:50
    分析数据得出,有一组数据会出现递归1W次的情况,而python对于最大递归深度是有限制的 python最大递归深度限制可以查询: import sys sys.getrecursionlimit() # output:1000 由上述代码可以发现,python的最大...
  • 2.3.13在最佳、平均和最坏情况下,快速排序的递归深度分别是多少?这决定了系统为了追踪递归调用所需的栈的大小。在最坏情况下保证递归深度为数组大小的对数级的方法请见练习2.3.20。答:令排序数组长度为n1)最佳...
  • PHP的最大递归层数

    千次阅读 2017-09-02 10:39:23
    PHP的最大递归层数跟程序内存限额有关。php5默认允许一个程序使用128M的内存,因此当你的递归层数过大导致128M内存耗尽时,程序会产生一个致命错误并退出。   编辑php.ini文件可以更改PHP的最大内存使用限制: ;...
  • 发现了一个诡异的事情,使用str方法强制转换一个BeautifulSoup对象成字符串的时候报错了,提示是“maximum recursion depth exceeded while calling a Python object”,意思大致是“当调用该对象超过最大递归深度”...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 82,321
精华内容 32,928
关键字:

最大递归深度