查看该函数的帮助文件就更清晰了:

>>> help(sys.getrecursionlimit)
Help on built-in function getrecursionlimit in module sys:
getrecursionlimit(...)
    getrecursionlimit()
    Return the current value of the recursion limit, the maximum depth
    of the Python interpreter stack.  This limit prevents infinite
    recursion from causing an overflow of the C stack and crashing Python.
从上面的帮助信息可以看到，如果超过这个默认的最大递归深度，就会导致不可预测的错误，比如C栈溢出或其他错误。 下面用斐波那契数列的递归函数来测试下该方法，来看真正可行的最大递归深度.
 
>>> def fib(n):
...     if n == 1:
...         return 1
...     else:
...         return fib(n-1) + n
>>> fib(2989)
4468555
当执行到默认的3000附近，2989时，上面是可以执行到的。当递归深度到2900时就报错了。
 
>>> fib(2990)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 5, in fib
  File "<stdin>", line 5, in fib
  File "<stdin>", line 5, in fib
  [Previous line repeated 2985 more times]
  File "<stdin>", line 2, in fib
RecursionError: maximum recursion depth exceeded in comparison
maximum recursion depth exceeded in comparison
 
也就是最大的实际递归深度就是2989了，是否可以设置这个值大点呢？ 可以通过这个方法来设置:
 
>>> import sys
>>> sys.setrecursionlimit(10000)
>>> sys.getrecursionlimit()
10000
通过setrecursionlimit(10000)后再查看就是10000。再来测试下实际上的递归深度可以到多少，看是否在2989上有所增加呢?
 
可以看到我们设置最大递归深度10000，实际执行递归深度达到3400，不再报RecursionError错误，但会报关闭程序的提示。通过一个个单独调试，到3213还能显示正常答案。到3214就又报上面的提示了。
 
>>> fib(3213)
5163291
 
上面的是Python3.6.5得出的实际最大递归数字:3213。
 
同样一台计算机，用Python2.7.10，同样设置成默认最大递归深度10000，得出实际最大递归深度是4484
 
>>> fib(4484)
10055370
 
所以最终这个数字取决于计算机本身的计算能力和Python的版本，如果超过系统堆栈深度，Python无法支撑也就奔溃了。同样的PC，Python的版本不同，这个值都有差异。有的时候差异还很大。
                    Python对递归函数设置是有默认值。 可以通过下面命令来查看设置的默认值&amp;gt;&amp;gt;&amp;gt; import sys&amp;gt;&amp;gt;&amp;gt; sys.getrecursionlimit()3000查看该函数的帮助文件就更清晰了:&amp;gt;&amp;gt;&amp;gt; help(sys.getrecursionlimit)Help on built-in function getrecu...
				
但是，递归函数的实现很容易导致递归深度过大而导致[递归错误：递归深度超过最大限制]。然而，递归函数也有其缺点：递归层数过多时容易出现[递归错误：递归深度超过最大限制]，导致程序崩溃。然而，当n取值较大时，程序就会出现[递归错误：递归深度超过最大限制]。总之，Python中的递归函数虽然便于编写和理解，但在应用时需要注意递归深度限制问题，并尽可能使用循环实现代替递归实现。上述代码中，使用循环代替递归，可以有效避免递归深度过大而导致的错误。为了避免这种情况，可以增加递归深度限制，但这并不是解决问题的根本方法。
				
猜测是是try、except进入receive()函数子层数量太多了，嵌套太多超出python规定范围导致报错。。。以后估计不能使用这种结构了。。。
那么怎么才能让函数出错后继续运行呢？
我直接加个while True循环将try\except包裹就行了：
或者还可以使用尾递归？不过经过测试发现python貌似不支持尾递归。。。
参考文章：爬虫遇到栈溢出(stack overflow)的问题
				
给定一个二叉树，编写一个函数来获取这个树的最大宽度。树的宽度是所有层中的最大宽度。这个二叉树与满二叉树（full binary tree）结构相同，但一些节点为空。
每一层的宽度被定义为两个端点（该层最左和最右的非空节点，两端点间的null节点也计入长度）之间的长度。
示例 1:
         /   \
        3     2
       / \...
				
由于计算机栈的内存有限，而函数递归会调用到栈，所以函数的递归深度有限
用以下的代码可以求出在本机最大递归深度，用二分法测出来的。
不知道python和c++为什么差这么多
Python:
def get_dep(num):
    if num == 1:
        return 1
    else:
        return num * get_dep(num-1)
print(ge...
				
在 Python 中，可以使用 sys.setrecursionlimit() 函数来设置递归深度的限制。默认值为 1000，如果要将其设置为更大的值，可以这样设置：
import sys
sys.setrecursionlimit(10000)
这样设置以后，在整个 Python 程序中都会生效。
需要注意，如果递归深度设置过大，可能会导致程序运行时间和内存使用量增加，甚至可能会出现堆栈溢出错...
				
1. sys.setrecursionlimit(10000)
设置递归深度。Python里面默认的递归深度是很有限的，大概是900多的样子，当递归深度超过这个值的时候，就会引发这样的一个异常。解决的方式是手工设置递归调用深度 添加上这一句就可以
2. Keras  backend
from keras import backend as K
使用抽象 Keras 后端编写新代码，如果你希望你编写...
给定一个 N 叉树，找到其最大深度。最大深度是指从根节点到最远叶子节点的最长路径上的节点总数。
N 叉树输入按层序遍历序列化表示，每组子节点由空值分隔（请参见示例）。
示例 1：
输入：root = [1,null,3,2,4,null,5,6]
示例 2：
输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
				
Python中的递归排序是指通过递归的方式将一个未排序的序列分成两个部分，再对这两个部分进行递归排序，直到最后将整个序列排好序。
具体来说，递归排序的实现通常采用“分治”思想，即将一个大问题分解成若干个小问题，然后对每个小问题进行求解，最后再将小问题的解合并成大问题的解。在递归排序中，每次递归都将序列分为两个部分，然后对每个部分进行递归排序，最后将两个有序的部分合并成一个有序的序列。
下面是一个简单的递归排序的示例代码：
def merge_sort(arr):
    if len(arr) <= 1:
        return arr
    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
    return merge(left, right)
def merge(left, right):
    result = []
    i = j = 0
    while i < len(left) and j < len(right):
        if left[i] < right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
    result += left[i:]
    result += right[j:]
    return result
这个代码中的`merge_sort()`函数是递归排序的主函数，它首先判断序列的长度是否小于等于1，如果是，就直接返回该序列，否则将序列分为两个部分，然后对这两个部分进行递归排序。最后，使用`merge()`函数将排好序的两个部分合并成一个有序的序列。
在`merge()`函数中，使用两个指针i和j来遍历左右两个有序序列，比较它们的大小，然后将较小的值放入结果序列中。最后，将剩余的元素添加到结果序列的末尾，返回最终的结果序列。