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))

01 什么是函数递归

1.什么是函数递归
    函数递归调用(是一种特殊的嵌套调用):在调用一个函数的过程中,又直接或间接地调用了该函数本身
    递归必须要有两个明确的阶段:
        递推:一层一层递归调用下去,强调每进入下一层递归问题的规模都必须有所减少
        回溯:递归必须要有一个明确的结束条件,在满足条件时结束递推,开始一层一层回溯

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

2.为什么要用函数递归

3.如何用

import sys
print(sys.getrecursionlimit()) #查看默认值  1000
sys.setrecursionlimit(3000) #修改默认值为3000
def foo(n):
    print('from foo',n)
    foo(n+1)
foo(0)  #默认值 为1000 所以解释器运行到997(逼近1000),由于自我保护机制将进行报错

报错提醒:RecursionError: maximum recursion depth exceeded while calling a Python object
########################################
常规版本:

# age(5) = age(4) + 2
# age(4) = age(3) + 2
# age(3) = age(2) + 2
# age(2) = age(1) + 2
# age(1) = 26
 
# age(n) = age(n-1) + 2 #n > 1
# age(1) = 26           #n = 1

##################
递归版本
# def age(n):
#     if n == 1:
#         return 26
#     return age(n-1) + 2
#

# 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('not exists')
        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)

02 匿名函数

有名函数:基于函数名重复使用
def func():
    print('from func')
func()
func()

func()

匿名函数:没有绑定名字的下场是用一次就回收了

常规版本:
def func(x,y):  #func=函数的内存地址

    return x+y

匿名函数版本:
res=(lambda x,y:x+y)(1,2)  #x+y 相当于return x+y

print(res)

结果:3

###############################

max:求最大值
min:求最小值
map:映射
filter:过滤

sorted:排序

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

#max min map filter sorted
# salaries={
#     'egon':3000,
#     'alex':100000000,
#     'wupeiqi':10000,
#     'yuanhao':2000
# }

def func(k):

    return salaries[k]

print(max(salaries,key=func))  #next(iter_s)

#'egon',v1=func('egon')

#'alex',v2=func('alex')1
#'wupeiqi',v3=func('wueiqi')

#'yuanhao',v4=func('yuanhao')
结果:alex

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

# }

print(max(salaries,key=lambda k:salaries[k]))  #next(iter_s),key为salaries的比较依据(可更改)

print(min(salaries,key=lambda k:salaries[k]))  #next(iter_s)

################################################

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

# print(sorted(salaries,key=lambda k:salaries[k],reverse=True))

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

names=['张明言',‘刘华强’,‘小苹果’,‘大基佬’]

# aaa=map(lambda x:x+"_SB",names)
# print(aaa)
# print(list(aaa))

# print([name+"_SB" for name in names])

# 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))


阅读更多
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页