[函数递归、二分法、匿名函数]

一、函数递归

函数递归的调用：

是函数嵌套调用的一种特殊形式、

具体指的是 在调用一个函数过程中又直接或者间接的调用了自己、称之为函数递归调用

函数的递归调用就是一个重复过程,用函数实现循环

例如：

def f1():
    print(‘form f1‘)
    f1()  # 函数内又调用到了自己

f1()

间接调用本身
def f1():
    print(‘我是F1‘)
    f2()
def f2():
    print(‘我是F2‘)
    f1()
f1()

import sys   # 查看函数递归层级
print(sys.getrecursionlimit())

递归的本质就是循环:

一段代码的循环运行的方案有两种：

方案一 ：while、for循环

while True:
    print(111)
    print(222)
    print(333)

方案二：函数递归

def f1():
    print(111)
    print(222)
    print(333)
    f1()
f1()

二、需要强调的一点是：

递归不应该无限的调用下去，必须在满足某种条件下结束递归

例如：

def func(n):
    if n ==100:  # 满足条件 return
        return
    print(n)
    n += 2

    func(n)
func(0)

三、完整的递归应该分为了两个阶段：

1、回溯 ：一层一层调用下去

2、递推：向上一层一层返回

案例：

年龄：
age(5) = age(4) + 10    # 第五个人的年龄
age(4) = age(3) + 10    # 第四个人的年龄
age(3) = age(2) + 10	# 第三个人的年龄
age(2) = age(1) + 10	# 第二个人的年龄
age(1) = 18				# 第一个人的年龄

函数递归表达：
def age(n):
    if n == 0:
        return 18
    return age(n-1)+10
res = age(3)
print(res)

四、递归的应用

例如：

l = [1,2,[3,4]]
l1 = [x for x in l if type(x) is list]
print(l1)
for x in l :
    if type(x) in list:
        for y in x:
            # 如果x是列表、应该再循环、再判断,即重新运行本身的代码
            print(y)
    else:
        print(x)

要求：把列表里每一个值都取出来
l = [1,[2,[3,[4,[5,[6,[7,[8,[9]]]]]]]]]


def f1(list1):
    for x in list1:
        if type(x) is list:
            f1(x)
        else:
            print(x)

f1(l)

二分法：

算法：高效解决问题的方法

算法之二分法

需求：有一个按照从小到大顺序排列的数字列表
        需要从该数字列表中找到我们想要的一个数字
            如何做更高效？

方案一：整体遍历效率太低

nums = [-3,1,4,5,8,19,22,34,56]
find_num = 19

for num in nums:
    if num ==find_nums:
        print(‘find it‘)
        break

方案二：二分法

nums = [-3,1,4,5,8,19,22,34,56]
nums = [1,4,5,3,-1,6,8] # 无序的话sort排序即可解决
nums.sort()
find_num =  99

def binary_search(find_num,l):
    print(l)
    if len(l) == 0:
        print(‘值不存在‘)
        return
    mid_index = len(l) // 2
    mid_val= l[mid_index]

    if find_num >mid_val:
        l = l[mid_index+1:]
        binary_search(find_num,l)
    elif find_num < mid_val:
        l= l[:mid_index]
        binary_search(find_num,l)
    else:
        print(‘find it‘)

binary_search(find_num,nums)

一、匿名函数

1、def用于定义有名函数

def func(x,y):
     return x+y

2、lambda用于定义匿名函数

print(lambda x,y:x+y)

3、调用匿名函数

# 方式一：
# res = (lambda x,y:x+y)(1,2)
# print(res)

# 方式二：
# res=lambda x,y:x+y
# res = res(1,2)
# print(res)

4、匿名函数用于临时调用一次的函数：

更多的是将匿名与其他函数匿名使用

lambda x,y:x+y

aaa = {‘lili‘:900,
       ‘tom‘:1200,
       ‘jack‘:2100,
       ‘lxx‘:500}
找出薪资最高的人
========================= max的应用
# max 遍历值比较大小，找出最大值返回
def func(k):
    return aaa[k]
a= max(aaa,key=lambda k:aaa[k])  # key 指定比较依据
print(a)


========================= min的应用
# min 找最小值
a= min(aaa,key=lambda k:aaa[k])  # key 指定比较依据
print(a)

========================= sorted的应用
sorted排序 比较工资大小
res = sorted(aaa,key=lambda a:aaa [a])
print(res)

========================= map的应用（了解）  # 映射
l = [‘lxx‘,‘wxx‘,‘xxx‘,‘alex‘]
res = (name+‘_dsb‘ for name in l )   # 小括号得到的就是生成式
res = res.__next__()
print(res)

res1 = map(lambda name:name+‘_dsb‘,l)
res1 =  res1.__next__()
print(res1)   # 生成式
========================= filter的应用
l = [‘lxx_sb‘,‘egon_dsb‘,‘wxx‘]
res = [x for x in l if x.endswith(‘sb‘)]
print(res)

========================= reduce的应用
reduce
form functools import reduce
合并：可以合并数字也可以合并字符串
from functools import reduce
res = reduce(lambda x,y:x+y,[1,2,3,4])
print(res) # 10
res1 = reduce(lambda x,y:x+y,[‘a‘,‘b‘,‘c‘])
print(res1) # abc
 用来合并字符串、数字、等等。。。

[函数递归、二分法、匿名函数]

原文：https://www.cnblogs.com/liupengfei1123/p/14603377.html