python开发函数进阶:递归函数

一,什么叫递归

#递归
#在一个函数里调用自己
#python递归最大层数限制 997
#最大层数限制是python默认的,可以做修改
#但是我们不建议你修改

例子和尚讲故事

 1 #!/usr/bin/env python
 2 #_*_coding:utf-8_*_
 3
 4 #:基础版本
 5 def story():
 6     print("从前有座山,山里有座庙,庙里有个老和尚讲故事,讲的什么呀?")
 7 while True:
 8     story()
 9
10 #:递归版本
11 def story():
12     #递归函数,在一个函数内调用自己
13     #最大递归层数做了一个限制:997
14     print("从前有座山,山里有座庙,庙里有个老和尚讲故事,讲的什么呀?")
15     story()
16     print(‘123‘)
17 story()

修改深度

 1 #!/usr/bin/env python
 2 #_*_coding:utf-8_*_
 3
 4 import sys #所有和python相关的设置和方法
 5 sys.setrecursionlimit(10000000)
 6 n = 0
 7 def f():
 8     global n
 9     n += 1
10     print(n)
11     f()
12 f()

二,递归实例

递归实现三级菜单

 1 #!/usr/bin/env python
 2 #_*_coding:utf-8_*_
 3
 4 #三级菜单,按B返回
 5 menu = {
 6     ‘北京‘: {
 7         ‘海淀‘: {
 8             ‘五道口‘: {
 9                 ‘soho‘: {},
10                 ‘网易‘: {},
11                 ‘google‘: {}
12             },
13             ‘中关村‘: {
14                 ‘爱奇艺‘: {},
15                 ‘汽车之家‘: {},
16                 ‘youku‘: {},
17             },
18             ‘上地‘: {
19                 ‘百度‘: {},
20             },
21         },
22         ‘昌平‘: {
23             ‘沙河‘: {
24                 ‘老男孩‘: {},
25                 ‘北航‘: {},
26             },
27             ‘天通苑‘: {},
28             ‘回龙观‘: {},
29         },
30         ‘朝阳‘: {},
31         ‘东城‘: {},
32     },
33     ‘上海‘: {
34         ‘闵行‘: {
35             "人民广场": {
36                 ‘炸鸡店‘: {}
37             }
38         },
39         ‘闸北‘: {
40             ‘火车战‘: {
41                 ‘携程‘: {}
42             }
43         },
44         ‘浦东‘: {},
45     },
46     ‘山东‘: {},
47 }
48 print(‘主菜单‘.center(40,‘=‘))
49 # while True:
50 #     for i in menu:print(i)
51 #     user1 = input(‘no 1>>>:‘)
52 #     if user1 == ‘b‘:break
53 #     if user1 == ‘q‘:exit()
54 #     if user1 not in menu:continue
55 #     if user1 in menu:
56 #         while True:
57 #             for i1 in menu[user1]: print(i1)
58 #             user2 = input(‘no 2>>>:‘)
59 #             if user2 == ‘b‘: break
60 #             if user2 == ‘q‘: exit()
61 #             if user2 not in menu[user1]: continue
62 #             if user2 in menu[user1]:
63 #                 while True:
64 #                     for i2 in menu[user1][user2]: print(i2)
65 #                     user3 = input(‘no 3>>>:‘)
66 #                     if user3 == ‘b‘: break
67 #                     if user3 == ‘q‘: exit()
68 #                     if user3 not in menu[user1][user2]: continue
69 #                     if user3 in menu[user1][user2]:
70 #                         while True:
71 #                             user4 = input(‘no 4>>>:‘)
72 #                             if user4 == ‘b‘:break
73 #                             if user4 == ‘q‘:exit()
74
75 def list(menu):    #menu being
76     while True:
77         for i in menu:
78             print(i)
79         k = input(‘>>>‘).strip()##beijng
80         if k == ‘b‘ or k ==‘q‘:    #k
81             return k #diyi beijing
82         if k in menu:
83             ret = list(menu[k])  #menu shahe
84             if ret == ‘q‘:return ‘q‘
85 index = list(menu)
86 print(index)

递归实现二分查找

 1 #!/usr/bin/env python
 2 #_*_coding:utf-8_*_
 3
 4 #二分查找算法
 5 #算法:计算的方法
 6 #有序的递增列表
 7 #查找的是数字
 8 l = [2,3,5,10,15,16,18,22,26]
 9 def find(l,aim): #l:列表 aim:要找的
10     mid = len(l)//2  #计算中点
11     if l[mid] > aim: #判断中间位置的值和目标值的大小关系
12         new_l = l[:mid] #[16,18] = [16,18,22,26][:mid]
13         return find(new_l,aim)
14     elif l[mid] < aim:#判断中间位置的值和目标值的大小关系
15         new_l = l[mid+1:]
16         return find(new_l,aim)
17     else:
18         return l[mid]
19 print(find(l,16))
20
21 #升级版二分法
22 #查找的是索引
23 l = [2,3,5,10,15,16,18,22,26]
24 def find2(l,aim,start,end):#[2,3,5,10,15,16,18,22,26]  0,8
25     mid = (end+start)//2  #4   #5+8/2=6  #start =5 end = 5 mid = 5
26     if start <  end:
27         if l[mid] > aim:  #15  17  #18 17
28             end = mid -1  #end =6-1 = 5
29             return find2(l,aim,start,end)
30         elif l[mid] < aim: #15  17
31             start = mid + 1  # start = 5
32             return find2(l, aim, start, end)
33         else:
34             return mid
35     else:
36         return "找不到"
37 print(find2(l,18,start=0,end = len(l)-1))
38
39 #高级版二分法
40 l = [2,3,5,10,15,16,18,22,26,30,32,35,41,42,43,55,56,66,67,69,72,76,82,83,88]
41 def func(l, aim,start = 0,end = len(l)-1 ):
42     mid = (start+end)//2
43     print(l[start:end+1])
44     if not l[start:end+1]:      #空就是False not 就是 true
45         return
46     elif aim > l[mid]:
47         return func(l,aim,mid+1,end)
48     elif aim < l[mid]:
49         return func(l,aim,start,mid-1)
50     elif aim == l[mid]:
51         print("bingo")
52         return mid
53 index = func(l,1)

三,总结

#递归解决的问题
#就是通过参数,来控制每一次调用缩小计算的规模
#适合的场景
#数据的规模在减小,但是解决问题的思路没有改变
#结束递归的标志:return

时间: 2024-10-18 22:45:34

python开发函数进阶:递归函数的相关文章

python开发函数进阶:匿名函数

一,匿名函数 #简单的需要用函数去解决的问题 匿名函数的函数体 只有一行#也叫lambda表达式# cal2(函数名) = lambda n(参数) : n*n(参数怎么处理,并且返回值)#参数可以有多个,用逗号隔开#匿名函数不管逻辑多复杂,只能写一行,且逻辑执行结束后的内容就是返回值#返回值和正常的函数一样可以是任意数据类型1.函数和匿名函数 1 #!/usr/bin/env python 2 #_*_coding:utf-8_*_ 3 4 def cal(n): 5 return n*n 6

python开发函数进阶:可迭代的&amp;迭代器&amp;生成器

一,可迭代的&可迭代对象 1.一个一个的取值就是可迭代的   iterable#str list tuple set dict#可迭代的 --对应的标志 __iter__ 2.判断一个变量是不是一个可迭代的 # print('__iter__' in dir(list))# print('__iter__' in dir([1,2,3])) 3.可迭代协议--凡是可迭代的内部都有一个__iter__方法 二,迭代器 1.将可迭代的转化成迭代器 1 #!/usr/bin/env python 2

python开发函数进阶:命名空间,作用域,函数的本质,闭包,内置方法(globales)

一,命名空间 #局部命名空间#全局命名空间#内置命名空间 #三者的顺序#加载顺序 硬盘上--内存里#内置-->全局(从上到下顺序加载进来的)-->局部(调用的时候加载) 1 #!/usr/bin/env python 2 #_*_coding:utf-8_*_ 3 4 #全局命名空间 5 a = 5 6 b = 8 7 #局部命名空间(函数) 8 def my_max(): 9 c = a if a > b else b 10 return c 11 m = my_max() 12 pr

python开发函数进阶:装饰器

一,装饰器本质 闭包函数 功能:就是在不改变原函数调用方式的情况下,在这个函数前后加上扩展功能 二,设计模式 开放封闭原则 *对扩展是开放的 *对修改是封闭的 三,代码解释 1 #!/usr/bin/env python 2 #_*_coding:utf-8_*_ 3 4 tag = False 5 6 def login(func): 7 def inner(*args,**kwargs): 8 global tag 9 if tag == False: 10 user = input('pl

python 匿名函数和递归函数

匿名函数lambda 匿名函数:lambda  x,y:x+y 上述解释:x,y分别是函数的函数,x+y是函数的返回值 匿名函数的命名规则,用lamdba 关键字标识,冒号(:)左侧表示函数接收的参数(a,b) ,冒号(:)右侧表示函数的返回值(a+b). 因为lamdba在创建时不需要命名,所以,叫匿名函数 等同于普通函数: def test(x,y): return x+y 匿名函数只是没有函数名,只要是配合内置函数使用 示例1: # filter##过滤(将布尔值为True的结果过滤出来)

python之函数进阶

一,引言 现在我有个问题,函数里面的变量,在函数外面能直接引用么? def func1(): m = 1 print(m) print(m) #这行报的错 报错了: NameError: name 'm' is not defined 上面为什么会报错呢?现在我们来分析一下python内部的原理是怎么样: 我们首先回忆一下Python代码运行的时候遇到函数是怎么做的,从Python解释器开始执行之后,就在内存中开辟里一个空间,每当遇到一个变量的时候,就把变量名和值之间对应的关系记录下来,但是当遇

Python基础——函数进阶

等待更新…………………… 后面再写 原文地址:https://www.cnblogs.com/mashangsir/p/11330231.html

Python 全栈开发:python函数进阶

python函数进阶 函数嵌套 函数对象 命名空间与作用域 闭包函数 装饰器 一.函数嵌套 函数的嵌套定义 def func1(): print('from func1') def func2(): #func2=内存地址 print('from func2') print(func2) func1() 函数的嵌套调用 # 比较两个数的大小 def max2(x,y): if x > y: return x else: return y # 比较三个数的大小 def max3(x,y,z): r

python基础_函数进阶

函数进阶 目标 函数参数和返回值的作用 函数的返回值 进阶 函数的参数 进阶 递归函数 01. 函数参数和返回值的作用 函数根据 有没有参数 以及 有没有返回值,可以 相互组合,一共有 4 种 组合形式 无参数,无返回值 无参数,有返回值 有参数,无返回值 有参数,有返回值 定义函数时,是否接收参数,或者是否返回结果,是根据 实际的功能需求 来决定的! 如果函数 内部处理的数据不确定,就可以将外界的数据以参数传递到函数内部 如果希望一个函数 执行完成后,向外界汇报执行结果,就可以增加函数的返回值