递归调用

递归 ​ 在计算机程序中，描述迭代的一种方法是使用循环，比如Python语言中的while循环和for循环。另一种完全不同的迭代实现方法就是递归 ​ 递归是一种技术，这种技术通过一个函数在执行过程中直接或间接一次或多次调用其本身，或者通过一种数据结构在其表示中依赖于相同类型的结构更小的实例。 ​ 在计算机，递归提供了用于执行迭代任务的优雅并且强大的替代方案。事实上，一些编程语言不明确支持循环结构，而是直接依靠递归来表示迭代。大多数现代编程语言都是通过和传统函数调用相同的机制支持函数的递归调用。当函数的一次调用需要进行递归调用时，该调用被挂起，知道递归调用完成 count=0 def f1(): global count if count>99:#结束最后一次函数调用 return count+=1 print(count) f1()#调用自己 f1() 来源： https://www.cnblogs.com/MrYang161/p/11353920.html

函数递归 递归，递是递进的意思，归是归来的意思 递归就是用函数在调用一个函数的过程中，又直接或间接地调用了它自身。这样函数会一层一层的递进进去，如果没有条件的话，他就会无限循环。如果有条件的话，当运行到条件中断时，它就会一层一层的回来，直到最初的函数 直接调用 直接调用指的是直接在函数内部调用函数自身 mport sys # 修改递归层数 sys.setrecursionlimit(10000) def foo(n): print('from foo',n) foo(n+1) foo(0) 这个函数会递归10000次 间接调用 间接调用指的是不在原函数体内调用函数，而是通过其他方法间接调用函数自身 def bar(): print('from bar') foo() def foo(): print('from foo') bar() bar() 这段代码会无限循环 from foo from bar 直至到达Python最大递归深度的时候，后面就会循环报错 递归核心 递归本质上还是解决问题的，并不为了让一段代码陷入死循环。所以一般在递进的时候，为了达到一个结果，使问题规模越来越小（不一定要真正达到），可以设置一个条件，能够让最后偶一次函数调用结束 所以，递归更多的是一种思想 下面就用递归来实现几个简单的功能 递归实现从0到100的打印 count = 1 # 2 # 3 def

函数递归及面向过程编程 一、函数递归 1.1什么是递归 递归就是函数调用函数本身,然后有结束条件。 一般解决无法求解但不断靠近的值，比如利用二分法找具体的数字，汉诺塔等 让我们举个栗子，比如要实现0-99的和，用while循环为： num = 0 count = 0 while count<100: print(count) count += 1 num +=count print(num) 接下来我们用递归函数对他进行一个实现 count = 0 def f1(): global count #下面的count是全局的count if count >100: return count += 1 print(count) f1() f1() 以上就是一个递归函数，他其实在不断调用自身，同时他又一个结束条件就是当count<100的时候，调用就结束，输出count。 递归更多地是一种思想，他是用来解决某种问题 1.2 为什么要用递归 把规模大的、较难解决的问题变成规模较小的、易解决的同一问题。规模较小的问题又变成规模更小的问题，并且小到一定程度可以直接得出它的解，从而得到原来问题的解。 1.3 总结 1、递归一定要有一个明确的结束条件 2、每进入下一次递归，问题的规模都应该减少 3、递归效率不高，递归层次过多会变成死循环，导致栈溢出 二、面向过程编程 2.1 什么是面向过程编程

8.14 函数递归 函数的嵌套调用是：函数嵌套函数。函数的递归调用：它是一种特殊的嵌套调用，但是它在调用一个函数的过程中，又直接或间接地调用了它自身。 递归必须要有两个明确的阶段： 递推：一层一层递归调用下去， 进入下一层递归的问题规模都将会减小 回溯： 递归必须要有一个明确的结束条件 ，在满足该条件开始一层一层回溯。 递归的精髓在于通过不断地重复逼近一个最终的结果。 例如，已知一个人的年龄为16，后面每个人的年龄都是前一个人的年龄+2，求第n个人的年龄： age = 16 def age_func(n): global age if n == 0: return age age += 2 return age_func(n-1) print(age_func(5)) # 26 ''' age_func(5) --> age = 18 --> return age_func(4) # return 26 age_func(4) --> age = 20 --> return age_func(3) age_func(3) --> age = 22 --> return age_func(2) age_func(2) --> age = 24 --> return age_func(1) == return age_func(0) == return age == return 26

一 GIL (全局解释器锁） 1.什么是GIL：指的是全局解释器锁，本质也是一把互斥锁。主要是保证同一进程下的多个线程将不可能在同一时间使用解释器，从而保证了解释器的数据安全 (同一个进程内多个线程无法实现并行但是可以实现并发) 。 2.注意： 1）：GIL仅存在cpython解释器中，其他解释器不存在，并不是python语言的缺点。 2）：GIL保护的是解释器级别数据的安全（比如对象的引用计数，垃圾分代数据等等），对于程序中自定义的数据没有任何保护效果所以自定义共享数据要自己加锁。 3.GIL加锁与解锁的时机 加锁：在调用解释器时立即加锁 解锁时机：当线程遇到IO操作和超过设定的时间值时解锁。 总结： 1.单核下无论是IO密集还是计算密集GIL都不会产生任何影响 2.多核下对于IO密集任务，GIL会有细微的影响，基本可以忽略 3.Cpython中IO密集任务应该采用多线程，计算密集型应该采用多进程 GIL的优点： 保证了CPython中的内存管理是线程安全的 GIL的缺点： 互斥锁的特性使得多线程无法并行 二 死锁（相互等待，互不释放） 1.什么是死锁： 当程序出现了不止一把锁,分别被不同的线程持有, 有一个资源 要想使用必须同时具备两把锁 这时候程序就会进程无限卡死状态 ,这就称之为死锁 2. mutexA = Lock() mutexB = Lock() class

一、什么是函数递归？ 函数的嵌套调用是：函数嵌套函数。函数的递归调用：它是一种特殊的嵌套调用，但是它在调用一个函数的过程中，又直接或间接地调用了它自身。 1.1直接调用 直接调用指的是：直接在函数内部调用函数自身。 import sys print(sys.getrecursionlimit()) #打印最大递归层数：3000 import sys sys.setrecursionlimit(10000) def f(n): print('from f',n) f(0) 1.2间接调用 间接调用指的是：不在原函数体内调用函数自身，而是通过其他的方法间接调用函数自身。 def func1(): print('func1') func2() def func2(): print('func2') func1() 递归必须要有两个明确的阶段： 1.递归：一层一层递归调用下去，进入下一层递归的问题规模都将会减小 ​ 2.回溯：递归必须要有一个明确的结束条件，在满足该条件开始一层一层回溯。 递归的精髓在于通过不断地重复逼近一个最终的结果。 二、为什么要用递归 递归的本质就是干重复的活，但是仅仅是普通的重复，我们使用while循环就可以了。 比如：计算1+...+5的和 def sum1(i): if i == 5: return i res = sum1(i+1)+i print(res)

递归：函数调用自身 核心：递进的时候能够达到一个结果，问题规模越来越小(不一定要真正的达到)；设置一个条件，能够让最后一次函数调用结束 练习： ​ 第一个人的姓名是16岁，后面每个人的年龄都比前一个大2岁，求第6个人的年龄 age = 16 def age_func(x): global age # 设置为全局变量 if x == 0:#递归的终止条件 return age return age_func(x - 1) + 2 age_func(5) ''' age_func(5) return age_func(4) + 2 age_func(4) return age_func(3) + 2 age_func(3) return age_func(2) + 2 age_func(2) return age_func(1) + 2 age_func(1) return age_func(0) + 2 age_func(0) teturn 16 再往回退 age_func(1) return 18 age_func(2) return 20 age_func(3) return 22 age_func(4) return 24 age_func(5) return 26 完毕 ''' 常见内置方法 # bytes():解码字符 res = '你好'.encode('utf8')

/*--> */ /*--> */ Python学习day15-函数进阶（3） 函数递归 递归的调用 递归的两个阶段 递归的本质 递归最好的体现之一，汉诺塔问题 内置函数 面向过程编程 Python学习day15-函数进阶（3） 函数递归 递归，很多语言中都会有这个概念，或者说这应该是一种思想，可以比较简便的解决一些无法直接得到答案的算法问题。 递归的调用 递归的调用其实就是函数的一种嵌套的调用，但是它在调用一个函数的时候又直接或间接地调用了它自身，以此形成一种循环调用的关系，直到接近或达到我们设置的条件为止。 递归的两个阶段 递归一般要有的两个比较明确的阶段是： 递推：一层一层调用下去，进入下一层递归的问题的规模一定是变小的，不然递归会无限调用下去直到报错。 回溯：即递归必须有一个明确的结束条件，在满足该结束条件之后递归会一层一层的回溯，在此之前递归会一层一层的调用，占用新的内存空间，不会释放。 所以递归的精髓就在于通过不断的重复逼近一个最终的结果。 递归的本质 递归的本质就是干重复的事情，那么仅仅是普通的重复，为什么不直接用循环呢，普通的循环更节省空间和时间。 下例中可以解释这个问题： x 1 lis = [1,[2,[3,[4,[5,[6,]]]]]] 2 ​ 3 def tell (lis): 4 for i in lis: 5 if type(i) is list: 6

目录 递归 函数自我嵌套 调用 直接调用 间接调用 为什么要用递归呢 如何使用递归 内置函数 掌握 了解 面向对象方法 面向过程编程 注册 分层实现功能 递归 递归的本质就是函数调用自身，当然也会有一些限制条件，在这里我们思考一个问题，你能递归你自己吗？或者说人能调用自己吗？ 暂且不论... 函数自我嵌套 def foo(): print('from foo') foo() foo() # 进入死循环 你看，这几行代码一执行就陷入了死循环，所以递归肯定需要一个明确的限制条件 调用 直接调用 直接调用就是直接在函数内部调用自身 import sys # 修改递归层数 sys.setrecursionlimit(10000) def foo(n): print('from foo',n) foo(n+1) foo(0) 间接调用 间接调指的是不在函数体内调用函数自身，而是通过其他方法间接调用函数自身 def bar(): print('from bar') foo() def foo(): print('from foo') bar() bar() 那么递归呢，有两个明确的阶段： 递推：一层一层递归调用下去，进入下一层递归的问题规模都将会减小 回溯：递归必须要有一个明确的结束条件，在满足该条件开始一层一层回溯。 递归的精髓在于通过不断地重复逼近一个最终的结果。 ''' ... age

递归函数：指调用自己的函数。 一.递归的特点 1.函数一般使用if-else或分支语句来实现。 2.存在一个或多个条件用来停止递归。 3.每次递归调用会使问题逼近终止条件或情况，直到转化为该条件或情况为止。 （递归递归先递后归，递：层层递进只到最终条件为止，归：带着得到的结果一层层返回到原问题。） 二.递归的分类 递归分为两种，直接递归和间接递归。 1.直接递归即函数直接自己调用自己。 代码示例： #include <iostream> using namespace std; int fac(int); int main() { cout << "输入一个数: "; int n; cin >> n; cout << n << "的阶乘 为" << fac(n); return 0; } int fac(int n) { if (n == 0) return 1; else return n * fac(n - 1); } 2.间接递归可以是A函数调用B函数时，B函数反过来调用A函数。也可以是A函数数调用B函数，B函数调用C函数，C函数调用A函数。 三.递归辅助函数（recursive helper function) 递归辅助函数是递归程序设计中常用的一种方法。 下面是运用递归来检查字符串是否是回文的函数代码 bool isPalindrome(const string& s)