递归调用

递归练习： import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.util.Scanner; public class Teat1 { public static void main(String[] args) throws IOException { // 从键盘接收一个文件夹路径,统计该文件夹大小 // 文件夹内容删除 // File dir = getFir(); // System.out.println(getFileLength(dir)); File src = getFir(); // File dest = getFir(); // if (src.equals(dest)) { // System.out.println("目标文件夹是源文件夹得子文件夹"); // }else { // copy(src,dest); // } printLev(src, 0); } public static void printLev

注意事项： 该方法只是用于小型树型结构，当树结构数据较多的时候，递归时间较长，接口反应很慢，会接口调用超时 实体类 代码实现 private Menu treeRoot(List<Menu> sourceList, Menu rootMenu) { if (sourceList == null) { return null; } List<Menu> childList = new ArrayList<>(); for (Menu menu : sourceList) { String menuCode = rootMenu.getMenuCode(); String parentCode = menu.getParentCode(); if(menuCode.equals(parentCode)) { Menu menuChild = treeRoot(sourceList, menu); childList.add(menuChild); } } if(childList.size()==0) { return rootMenu; } rootMenu.setChildrens(childList); return rootMenu; } 来源： https://blog.csdn.net/qq_37663786/article/details/99674724

　　在手动编写一个FTP时，需要编写一个函数用来选择文件，返回文件路径。 　　这里选择了递归函数进行一次性的取值。 import os def choose_file(): while True: current_path = os.getcwd() path_list = os.listdir(current_path) for index,name in enumerate(path_list,1): print(index,name) choice = input('请输入您的选择,按0返回上一级>>>:').strip() if choice == '0': os.chdir(os.pardir) choose_file() # return if not choice.isdigit(): print('请输入数字') continue choice = int(choice) - 1 if choice not in range(0,len(path_list)): print('请输入正确的编号') continue path_name = path_list[choice] path = os.path.join(current_path,path_name) if os.path.isdir(path_name): os.chdir(path_name)

目录 第八章、函数递归与面向过程编程 一、什么是函数递归 二、为什么要用递归 三、面向过程编程的优点 第八章、函数递归与面向过程编程 一、什么是函数递归 递归就是函数调用函数本身，然后必须有结束条件，否则报错达到最大深度 while和递归类似，区别在于递归有递进和回归，而while有来无回 递归更多地是思想，他是用来解决某种问题的，比如汉诺塔问题 （虽然我到现在也没搞懂） 二、为什么要用递归 把规模大的较难解决的问题一步一步最小化问题，得到结果然后可以得到回归到本身问题的结果 三、面向过程编程的优点 什么是面向过程 机械式的思维方式，先干什么后干什么最后干什么 面向过程的优缺点 优点 ：流水线的简单 缺点 ：中间过程一旦出问题，后面全完蛋 耦合性高、拓展性差 来源： https://www.cnblogs.com/demiao/p/11359888.html

函数的调用: 　　当一个函数的运行期间调用另一个函数时，在运行被调函数之前，系统需要完成三件事： 　　　　1. 将所有的实际参数、返回地址(被调函数下一条语句的地址)等信息传递给被调函数保存 　　　　 2. 为被调函数的局部变量（也包括形参）分配存储空间 　　　　3. 将控制转移到被调函数的入口 　　从被调函数返回主调函数之前，系统也要完成三件事: 　　　　1. 保存被调函数的返回结果 　　　　2. 释放被调函数所占的存储空间 　　　　 3. 依照被调函数保存的返回地址将控制转移到调用函数 　　　当有多个函数相互调用时，按照“后调用先返回”的原则，上述函数之间信息传递和控制转移必须借助“栈”来实现，即系统将整个程序运行时所需的数据空间安排在一个栈中，每当调用一个函数时，就在栈顶分配一个存储区，进行压栈操作，每当一个函数退出时，就释放它的存储区，进行出栈操作，当前运行的函数永远都在栈顶位置。 　　 A函数调用A函数和A函数调用B函数在计算机看来是没有任何区别的，只不过用我们日常的思维方式理解比较怪异而已！ 1 #include<stdio.h> 2 3 void f(); 4 void g(); 5 void k(); 6 7 int main(){ 8 f(); 9 return 0; 10 } 11 void f(){ 12 printf("FFFF"); 13 g(); 14

•纯函数 •函数的柯里化 •函数组合 •Point Free •声明式与命令式代码 •核心概念 1.纯函数 什么是纯函数呢？ 对于相同的输入，永远会得到相同的输出，而且没有任何可观察的副作用，也不依赖外部环境的状态的函数，叫做纯函数。 举个栗子： 1 2 3 4 5 var xs = [1,2,3,4,5]; // Array.slice是纯函数，因为它没有副作用，对于固定的输入，输出总是固定的 xs.slice(0,3); xs.slice(0,3); xs.splice(0,3); // Array.splice会对原array造成影响，所以不纯 xs.splice(0,3); 　　 2.函数柯里化 传递给函数一部分参数来调用它，让它返回一个函数去处理剩下的参数。 我们有这样一个函数checkage： 1 var min = 18; <br> var checkage = age => age > min; 　　 这个函数并不纯，checkage 不仅取决于 age还有外部依赖的变量 min。 纯的 checkage 把关键数字 18 硬编码在函数内部，扩展性比较差，柯里化优雅的函数式解决。 1 2 3 var checkage = min => (age => age > min); var checkage18 = checkage(18); // 先将18作为参数

不知道有没有小伙伴跟我一样犯这样的懒，一些简单重复的工作，总是嫌麻烦，懒得一步步去做，还每次都重复一样的操作。比如解压zip或rar的包，也许你会说，不就解压嘛，有啥的。问题来了，如果只是一个简单的压缩包也是算了，关键是压缩包里还有压缩包，也不知道多少层，要一层层去解压，这就比较恶心了吧？如下图： 学习了Python的递归调用后，心想，为什么我不写一个脚本自动解压所有的压缩包呢？emmm....心动不如行动，说写就写，谁让我是这么懒的一个人呢，连解压都得自动化，哈哈哈。 那就来吧，先从最简单的开始，搞个zip包用命令行解压看看： # -*- coding: utf-8 -*- import zipfile import os path = r'C:\Users\ES-IT-PC-193\Desktop\aa\A.zip' z = zipfile.ZipFile(path, 'r') unzip_path = os.path.split(path)[0] #解压路径 z.extractall(path=unzip_path) 嗯，试了试，没问题，能正常解压。那接下来就是解决如果把压缩包里包含压缩包的也一块解压了，那我得把解压的命令封装成函数，然后循环解压就好了。这里正好用上了刚学不久的递归调用。 # -*- coding: utf-8 -*- # 2019/8/13 14:57

递归 ： 函数调用自己的过程 细节： 存在递推关系 ： 向下调用 ，向上回溯 要有临界值 （结束条件） 我最深刻的理解（藏在注释里哦）： 　　 1 def digui(num): 2 print(str(num)+'*') 3 if num > 0 : # 这里是临界值 4 digui(num - 1) # 这里调用本身的函数 5 else: 6 print('='*20) 7 print(num) # 逐次返回上一级的调用时会被打印 8 9 digui(3) ----执行结果---- 3* 2* 1* 0* ==================== 0 1 2 3 栗子们： 注释！ 看注释！ 1 # 斐波那契数列 通过递归 2 # 数学定义 ： 1，1，2, 3, ..., f(n)=f(n-2)+f(n-1) 3 4 def fi(n): 5 if n == 1 or n == 2: 6 return 1 7 m = fi(n-2) + fi(n-1) 8 return m 9 10 a = fi(20) 11 print(a)----执行结果---- 6765 # 用for循环数一遍 斐波那契 n = 20 ls = [1,1] for i in range(1,n+1): if i == 1 or i == 2: fi = 1 print(fi) else: fi = ls

目录 75递归 一、什么是函数递归 1.1直接调用 1.2间接调用 为什么要用递归 三、如何用递归 3.1 二分法的应用 75递归 递归的核心: 递进的时候能够达到一个结果,问题规模越来越小(不一定要真正的达到); 设置一个条件,能够让最后一次函数调用结束; 递归代码(递归更多的是一种思想,用来解决某种问题) 递归是函数调用函数本身,然后有结束条件 一、什么是函数递归 函数的嵌套调用是：函数嵌套函数。函数的递归调用：它是一种特殊的嵌套调用，但是它在调用一个函数的过程中，又直接或者间接的调用了它自身。 def foo(): print ('from foo') foo() foo() #这个会死循环 如果递归不断地调用函数自身，那么这个递归函数将会进入一个死循环，因此我们应该给递归函数一个明确的结束条件。 1.1直接调用 直接调用是指：直接在函数内部调用函数自身。 import sys print(f'最大递归层数：{sys.getrecursionlimit()}') #输出： 最大递归层数：1000 # 在python3中最大递归层数是1000层 import sys sys.setrecursionlimit(10000)# 可以修改递归层数 def foo(n): print('from foo',n) foo(n+1) foo(0) 1.2间接调用 间接调用指的是

一、全局解释器锁GIL： 　　官方的解释：掌握概念为主 """ In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple native threads from executing Python bytecodes at once. This lock is necessary mainly because CPython’s memory management is not thread-safe. """ 　（1）：python代码的执行由python虚拟机（解释器）来控制，加锁是为了保证同一时刻只有一个线程再运行 用来阻止同一个进程下的多个线程的同时执行（一个进程内多个进程无法实现并行，但可以实现并发） 　（2）：python解释器有很多种，最常见的就是cpython解释器，内部是由c语言编写的； GIL本质也是一把互斥锁：将并发变成串行，虽然牺牲了执行效率，但保证了数据的安全性； GIL的存在是因为Cpython解释器的内存管理不是线程安全的 垃圾回收机制： 　　1：引用计数（没有被定义使用的） 　　2：标记清除（） 　　3：分带回收（青春带，老年代） python的多线程没法利用多核优势 是不是就是没有用了?　　看情况讨论，而且肯定是有用的（3）