day15 什么是递归/递归与回溯

上节课复习
1、生成器
def func():
yield
g=func()
next(g)

x=yield
2、三元表达式
res=x if 条件 else y
3、列表推导式，字典生成式，生成器表达式
l=[表达式 for i in 可迭代对象 if 条件]
g=(表达式 for i in 可迭代对象 if 条件)
d={k:v for i in 可迭代对象 if 条件}
4、max，zip
max(可迭代对象)
生成器=zip(可迭代对象1，可迭代对象2)
g=zip('hello',[1,2,3]) 
# print(g)
print(list(g))

什么是函数递归?

1.函数递归调用(是一种特殊的嵌套调用):在调用一个函数的过程中，直接或者间接调用了函数本身

 递归必须要有两个阶段:

　　递推:一层一层递归调用下去，强调每进入下一层递归问题的规模必须有所减少

　　回溯:递归必须要有一个明确的结果和条件，在满足该条件时结束递推阶段

　　　　开始一层一层回溯

　　递归的精髓在于通过不断重复逼近一个最终的结果

2.为什么要用函数递归

age(5)=age(4)+2
age(4)=age(3)+2
age(3)=age(2)+2
age(2)=age(1)+2
age(1)=26

　　

def age(n):
    if n==1:
        return 26
    res=age(n-1)+2
    return res
print(age(5))

l=[1,[2,[3,[4,[5,[6,[7,[8,[9,]]]]]]]]]
def tell(l):
    for item in l:
        if type(item) is list:
            #继续进入下一层递归
            tell(item)
        else:
            print(item)
tell(l)

二分法

有一个从小到大排列的整型数字列表 # 这种方法效率太低  算法就是解决问题对的最优方法，按照什么样的逻辑把问题高效的解决掉，这就是算法
nums=[1,3,7,11,22,34,55,78,111,115,137,149,246,371]
10 in nums
for item in nums:
    if item == 10:
        print('find it')
        break
else:
    print('not exists')

正确的操作

nums=[1,3,7,11,22,34,55,78,111,115,137,149,246,371]
def search(search_num,nums):
    print(nums)
    if len(nums)==0:
        print('不存在')
        return
    mid_index=len(nums)//2
    if search_num>nums[mid_index]:
        #in the right
        nums=nums[mid_index+1:]#列表这一刻被切空
        search(search_num,nums)
    elif search_num<nums[mid_index]:
        #in the left
        nums=nums[:mid_index]
        search(search_num,nums)
    else:
        print('find it')

search(31,nums)

匿名函数(没有名字)

#匿名函数:没有绑定名字的下场是用一次就回收了
# def func(x,y):#func=函数的内存地址
#     return x+y

# print(lambda x,y:x+y)  #这里的x+y相当于有名函数 return x+y
                        #匿名函数加括号就能运行
res=(lambda x,y:x+y)(1,2)
print(res) #这种太丑

f=lambda x,y:x+y
print(f)
print(f(1,2))
匿名函数与其他函数一起使用，用一次就丢掉了
#max min map filter sorted

匿名函数的应用

方式1 有名函数
salaries={'egon':3000,'alex':100000000,'wupeiqi':10000,'yuanhao':2000}  #比较字典key的大小，如果是列表不是字典的话可以

# max的工作原理
# 1.首先将可迭代对象变成迭代器对象
# 2.res=next(可迭代器对象),将res当作参数传给key指定的函数
# 然后将该函数的返回值当作判断依据

def func(k):
    return salaries[k]
print(max(salaries,key=func))

方式2:匿名函数
salaries={'egon':3000,'alex':100000000,'wupeiqi':10000,'yuanhao':2000}  #比较字典key的大小，如果是列表不是字典的话可以
print(max(salaries,key=lambda k:salaries[k]))
print(min(salaries,key=lambda k:salaries[k]))

匿名函数与其他函数的结合使用 

l=[10,1,3,-9,22]
l1=sorted(l,reverse=False)
l1=sorted(l)
print(l1)

l2=sorted(l,reverse=True)
print(l2)

map 的工作原理(映射)

names=['张明言','刘华强','苍井空','alex']

# map的工作原理
# 1 首先将可迭代对象变成迭代器对象
# 2 res=next(可迭代器对象),将res当作参数传给第一个参数指定的函数,然后将该函数的返回值当作map的结果之一
res=map(lambda x:x+"_SB",names)
print(res)
# print(list(res))
print(res.__next__())

fileter的工作原理(过滤)

# filter的工作原理
#1 首先将可迭代对象变成迭代器对象
#2 res=next(可迭代器对象),将res当作参数传给第一个参数指定的函数,然后filter会判断函数的返回值的真假,如果为真则留下res
names=['alexSB','egon','wxxSB','OLDBOYSB']
print([name for name in names if name.endswith('SB')])
aaa=filter(lambda x:x.endswith('SB'),names)
print(aaa)
print(list(aaa))

内置函数

稍后整理