函数-递归调用、匿名

1、什么是递归调用

递归调用：在函数调用过程当中，直接或间接地调用了函数自己，这就是函数的递归调用
1.递归的优势

递归函数的优势是定义简单，逻辑清晰。理论上，全部的递归函数均可以写成循环的方式，但循环的逻辑不如递归清晰。

使用递归函数须要注意防止栈溢出。在计算机中，函数调用是经过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。因为栈的大小不是无限的，因此，递归调用的次数过多，会致使栈溢出。能够试试fact(1000)：

2.递归的缺点

解决递归调用栈溢出的方法是经过尾递归优化，事实上尾递归和循环的效果是同样的，因此，把循环当作是一种特殊的尾递归函数也是能够的。

尾递归是指，在函数返回的时候，调用自身自己，而且，return语句不能包含表达式。这样，编译器或者解释器就能够把尾递归作优化，使递归自己不管调用多少次，都只占用一个栈帧，不会出现栈溢出的状况。

3.递归案例

#阶乘计算
def fact(n):
    if n==1:
        return 1
    return n * fact(n - 1)

分析
===> fact(5)
===> 5 * fact(4)
===> 5 * (4 * fact(3))
===> 5 * (4 * (3 * fact(2)))
===> 5 * (4 * (3 * (2 * fact(1))))
===> 5 * (4 * (3 * (2 * 1)))
===> 5 * (4 * (3 * 2))
===> 5 * (4 * 6)
===> 5 * 24
===> 120

4.二分法

#二分法
l = [1, 2, 10,33,53,71,73,75,77,85,101,201,202,999,11111]

def search(find_num,seq):
    if len(seq) == 0:
        print('not exists')
        return
    mid_index=len(seq)//2
    mid_num=seq[mid_index]
    print(seq,mid_num)
    if find_num > mid_num:
        #in the right
        seq=seq[mid_index+1:]
        search(find_num,seq)
    elif find_num < mid_num:
        #in the left
        seq=seq[:mid_index]
        search(find_num,seq)
    else:
        print('find it')

2、匿名函数　

当咱们在传入函数时，有些时候，不须要显式地定义函数，直接传入匿名函数更方便。

在Python中，对匿名函数提供了有限支持。仍是以map()函数为例，计算f(x)=x2时，除了定义一个f(x)的函数外，还能够直接传入匿名函数：

 

经过对比能够看出，匿名函数lambda x: x * x实际上就是：

def f(x):
    return x * x

关键字lambda表示匿名函数，冒号前面的x表示函数参数。

匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。

用匿名函数有个好处，由于函数没有名字，没必要担忧函数名冲突。此外，匿名函数也是一个函数对象，也能够把匿名函数赋值给一个变量，再利用变量来调用该函数：

f = lambda x: x * x
f(5)
结果25

一样，也能够把匿名函数做为返回值返回，好比：

def build(x, y):
    return lambda: x * x + y * y

3、max、min、lambda　　

1.max、min、lambda　

salaries={
'egon':3000,
'alex':100000000,
'wupeiqi':10000,
'yuanhao':2000
}

print(max(salaries.values()))
res=zip(salaries.vaues(),salaries.key())
print(max(res))
结果（100000，alex）

　　

salaries={
'egon':3000,
'alex':100000000,
'wupeiqi':10000,
'yuanhao':2000
}

print(max(salaries,key=lambda k:salaries[k]))#salarier每次迭代将字典的k值赋值给k
print(min(salaries,key=lambda k:salaries[k]))#salarier每次迭代将字典的k值赋值给k

print(sorted(salaries,key=lambda x:salaries[x])) 每次迭代将字典的k值赋值给x，默认是最小到大

print(sorted(salaries,key=lambda x:salaries[x],reverse=True)) #加reverse参数 True从大到小

　2.global

#应用
x=1000
def f1():
    global x#若是使用关键字global那么此时使用函数内定义的x
    x=0

f1()
print(x)

结果 x=0

3.map应用

l=["1",'2','3']
res=map(lambda x:x+'sb',l)#迭代l列表并将每一个元素加一个sb
print(list(res))
结果：
['1sb', '2sb', '3sb']

求每一个值得平方
nums=（1,2,3,4）
res=map（lambda x：x**2，nums）
print（linst（res））

4.reduce

l=[1,2,3,4]
print(reduce(lambda x,y:x+y,l))#先拿到一个初始值而后而后和后边的值累加

#带初始值的
print(reduce(lambda x,y:x+y,l,10))若是初始值是10的话那么每次结果跟10相加

5.filter

l=[1,2,3,4]
fes=filter(lambda x:x>2,l)
print(list(fes))


l=("hanhan_s","li_s")
fes=filter(lambda x:x.endswith("s"),l)