1、递归函数
1.1、递归函数的限制
（1）递归一定要有退出条件，并且递归调用一定要执行到这个退出条件；如果没有退出条件，就是无限调用，会耗尽所有资源（栈空间）；
（2）递归调用的深度不易过深，Python对递归调用的深度做了限制，以保护解释器；
1.2、递归实例
①、递归实现斐波拉契数列
# version1：数学公式版本 def fib(n): return 1 if n<3 else fib(n-1)+fib(n-2) print(fib(10)) 分析：此版本虽然看着简洁明了，但是会有很大的效率问题，当n操作35以后计算结果就非常慢 # version2：利用上一次结果 def fib(n,a=0,b=1): # n=3 if n<3: return a+b else: a,b=b,a+b # 0,1=1,1 return fib(n-1,a,b) 分析：版本每次都利用了上一次运算的结果，所以效率相对于第一个版本来说，快了不少； # for循环实现 a,b=0,1 for i in range(10): a,b=b,a+b print(a) 分析：版本二就是根据for循环演变而来
②、递归实现阶乘
def fac(n,sum=1): if n==1: return 1 return n*fac(n-1) def fac(n,sum=1): sum=sum*n if n<2: return sum return fac(n-1,sum) # 版本二将每次计算的结果带入了下一次计算
③、将一个数逆序放入列表
nums='1234' print(nums[len(nums)-1]) l=[]
# for循环实现
for i in range(len(nums)-1,-1,-1):
l.append(nums[i])
print(l)
# 列表拼接实现 def revert(x): if x == -1: return [] return [nums[x]] + revert(x-1) print(revert(len(nums)-1))
# 字符串切片实现 def revert(x,target=[]): if x: target.append(x[-1]) revert(x[:-1]) return target print(revert(nums))
④、递归解决猴子吃桃问题
''' x d1=x//2-1 d2=d1//2-1 d3=d2//2-1 ... ... d9=d8//2-1 ==> 2(d9+1)=d8=d7/2-1 ''' peach=1 for i in range(9): peach=2*(peach+1) print(peach) ''' 这题得倒着推。第10天还没吃，就剩1个，说明第9天吃完一半再吃1个还剩1个，假设第9天还没吃之前有桃子p个，可得：p * 1/2 - 1 = 1，可得 p = 4。以此类推，即可手算出。 代码思路为：第10天还没吃之前的桃子数量初始化 p = 1，之后从9至1循环9次，根据上述公式反推为 p = (p+1) * 2 可得第1天还没吃之前的桃子数量。
for循环中的print()语句是为了验证推算过程而增加的。代码如下： p = 1 print('第10天吃之前就剩1个桃子') for i in range(9, 0, -1): p = (p+1) * 2 print('第%s天吃之前还有%s个桃子' % (i, p)) print('第1天共摘了%s个桃子' % p) ''' # 递归实现 def peach(n=10): if n == 1: return 1 return (peach(n-1)+1)*2 print(peach())
2、匿名函数
# 匿名函数：即没有名字的函数；
没有名字如何定义？
没有名字如何调用？
# Pyhton借用lambda表达式解决以上问题；
# 格式： lambda 参数列表:表达式 # 此表达式相当于函数体内的return 后面的语句；
# 特点：
①：使用lambda关键字来定义匿名函数；
②：参数列表不需要小括号；
③：冒号是用来分割参数列表和表达式的；
④：不需要使用return，表达式的值，就是匿名函数的返回值；
⑤：lambda表达式只能写在一行上，也被称为单行函数；（函数体内逻辑复杂的不适用）；
⑥：一般用于高阶函数传参时，可以简化代码；
# 自定义函数可以改写为lambda形式；
def fun(x,y): return x+y f=lambda x,y:x+y # 不建议这么用； # (1)相当于给lambda函数赋值函数名f， # (2)函数f的功能与fun函数的功能一样，即fun函数可以改写为下面lambda形式； print(fun) print(f) ''' <function fun at 0x000001CD55452E18> <function <lambda> at 0x000001CD558A9D08> '''
l=[x for x in (lambda *args:map(lambda x:x+1,args))(*range(5))] ''' 分析： (*range(5)) 先解构为(0,1,2,3,4) 传递给 *args, 然后执行map里面的函数； map(func,iter) ==> func=lambda x:x+1 iter=args, 然后x向iter也就是args中取值 [0,1,2,3,4] 经过func处理后返回为[1,2,3,4,5] ''' print(l) # [1, 2, 3, 4, 5] l=[x for x in (lambda *args:map(lambda x:(x+1,args),args))(*range(5))] ''' 分析：这个实例和上一个差不多，只是在内层lambda返回类型变了，返回的为一个二元组(x+1,args),这个的args=iter=(0,1,2,3,4) ''' print(l) [(1, (0, 1, 2, 3, 4)), (2, (0, 1, 2, 3, 4)), (3, (0, 1, 2, 3, 4)), (4, (0, 1, 2, 3, 4)), (5, (0, 1, 2, 3, 4))]
s = "this is a test" l=lambda x:' '.join(x.split()) print(l(s)) # 运行结果：this is a test c = lambda **Arg: Arg print(c()) # 返回一个空字典；
3、生成器与迭代器
3.1、迭代器
# 迭代：是一个重复的过程，每一次重复都是基于上一次的结果而来；
# 可迭代对象：凡是可调用__iter__方法的，都是可迭代对象（iterable）；
3.2、迭代器与可迭代对象的区别
①：凡是可用于for循环的对象，都是可迭代对象；
②：凡是可以作用于next()函数的对象，都是迭代器对象；
③：list、dict、str、等都是可迭代对象，并不是迭代器对象，因为next()函数无法调用他们，可以使用iter()函数将他们转换为迭代器对象；
3.3、for循环的原理
# 基于for循环可以完全不依赖索引取值；
d={'a':1,'b':2,'c':3}
for k in d:
print(d[k])
'''
1、执行in后对象的dic.__iter__()方法，得到一个迭代器对象iter_dic
2、执行next(iter_dic),将得到的值赋值给k; ==> d.__iter__().__next__() ==> k='a'然后执行循环体代码;
3、重复过程2，知道捕获异常StopIteration，循环结束；
'''
3.4、生成器generator：
①：生成器指的是生成器对象，可以由生成器表达式得到，也可以使用yield关键字得到一个生成器函数，调用这个函数可以得到一个生成器对象；
3.5、生成器函数：
①：函数体中包含yield语句的函数，返回生成器对象；
②：生成器对象是一个可迭代对象，也是一个迭代器；
③：生成器对象是延迟计算，惰性求值； # 节省内存空间；
④：在 Python中，使用yield返回的函数会变成一个生成器（generator）。在调用生成器的过程中，每次遇到yield时函数会暂停并保存当前所有的运行信息，返回yield的值。并在下一次执行next()方法时从当前位置继续运行。
''' 斐波拉切数列生成器实现 ''' def fib(n,a=0,b=1): for i in range(n): a,b=b,a+b yield a g=fib(10) for i in g: print(i) ################# def fib(n,a=0,b=1): count=0 while count<n: a,b=b,a+b count+=1 yield a for i in fib(10): print(i)
# yield 和return的功能类似，都可以返回值；但是不同的是return只能返回一次值，而yield可以返回多次值；（能够直接返回到函数内部，非常牛逼的功能）
def foo(count:int): print('start...') while True: yield count count+=1 g=foo(10) print('===>第一次next') print(next(g)) print('===>第二次next') print(next(g)) print('===>第三次next') print(next(g)) ''' ===>第一次next start... 10 ===>第二次next 11 ===>第三次next 12 '''
4、插入排序
# 插入排序分析
[0,1,9,8,5,6] 原始数列 哨兵每次从无序区拿第一个作为哨兵 [9,1,9,8,5,6] 第一趟：设定哨兵位等于s=9 ,有序区：1 无序区：9,8,5,6 拿有序区1和无序区9 比较大小 ， 1 不大于9 所以位置不改变， 比较后 有序区为：1,9 无序为：8,5,6； [8,1,9,8,5,6] 第二趟：s=8, 有序区为：1,9 无序为：8,5,6； 拿有序区9和无序8比较，9 > 8 => [8,1,9,9,5,6] =>j-1 => [8,1,8,9,5,6] [5,1,8,9,5,6] 第三趟：s=5 ,有序1,8,9 无序：5,6 9>5 ==> [5,1,8,9,9,6] ==> 8>5 ==> [5,1,8,8,9,6] ==> 1不大于5 ==>[5,1,5,8,9,6] 总结：每次比较将无序区域第一个数拿来作为比较的哨兵，然后将有序区数和哨兵依次比较，比哨兵大的数往后放， 直到比较到比哨兵小，然后将哨兵插入队列 ######代码实现############ def insert_Sort(l,nums=[0]): # nums=[0,1,9,8,5,6] ''' 实现插入排序 :param l: :return: ''' nums=nums+l for i in range(2,len(nums)): # i=3 nums[0]=nums[i] # num[0]=8 j=i-1 if nums[j] > nums[0]: while nums[j] > nums[0]: nums[j+1]=nums[j] j-=1 nums[j+1]=nums[0] # 插入哨兵 return nums[1:] l=[1,9,8,5,6] res=insert_Sort(l)