day15_函数递归_匿名函数_内置函数

Posted 2020-11-20 smart1san

一、函数递归

1. 定义：

递归调用（特殊的嵌套调用）：在调用一个函数的过程中，又直接或者间接地调用了该函数本身

2. 递归有两个明确的阶段：

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

　　回溯：递归必须有一个明确的结束条件，在满足该条件时结束递推

3. 精髓：通过不断地重复逼近一个最终的结果

4.使用：

4.1重复调用的结果

 1 # 一直重复调用
 2 def bar():
 3     print(‘from bar‘)
 4     foo()
 5 
 6 def foo():
 7     print(‘from foo‘)
 8     bar()
 9 foo()
10 
11 # RecursionError: maximum recursion depth exceeded while calling a Python object

View Code

4.2 重新设置最大递归深度

import sys
print(sys.getrecursionlimit())  # 最大递归层数
sys.setrecursionlimit(3000)   # 重新设置最大递归层数
print(sys.getrecursionlimit())
def foo(n):
    print(‘from foo‘,n)
    foo(n+1)
foo(0)

# from foo 2997Traceback (most recent call last):
# RecursionError: maximum recursion depth exceeded while calling a Python object

设置递归深度

4.3 例子

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

例子1

取出列表中的数字
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)

例子2

 1 list=[1,4,8,54,74,88,93,122,154,178,243,354,388,865]
 2 # 以前的做法：
 3 # for item in list:
 4 #     if item==10:
 5 #         print(‘find it‘)
 6 #         break
 7 # else:
 8 #     print(‘not exists‘)
 9  
10 def search(search_num,list):
11     print(list)
12     if len(list)==0:
13         print(‘not exists‘)
14         return 
15     # 列表数字的中间索引
16     mid_index=len(list)//2
17     if search_num<mid_index:
18         # 在左边
19         list=list[:mid_index]
20         # 把列表从左边取至中间索引位置
21         search(search_num,list)
22         # 继续查找
23     elif search_num>mid_index:
24         list=list[mid_index+1:]
25         search_num(search_num,list)
26     else:
27         print(‘find it‘)
28 search(66,list)

二分法?

二、匿名函数

1.定义：没有具体的函数名字，使用一次之后就回收了

def func(x,y):   #func=函数的内存地址
    return x+y

res=(lambda x,x+y)(2,3)
print(res)

max min map filter sorted

2. max 的工作原理（ min map filter sorted 与之类似）

取出字典中value的最大值
salaries={
    ‘cat‘:3000,
    ‘dog‘:100000000,
    ‘mouse‘:10000,
    ‘cattle‘:2000
}
# max的工作原理
# 1 首先将可迭代对象变成迭代器对象
# 2 res=next(迭代器对象),将res当作参数传给key指定的函数,然后将该函数的返回值当作判断依据
def func(k):
    return salaries[k]
print(max(salaries,key=func))  # next(iter_s)
# ‘cat‘, v1=func(‘cat‘)
# ‘dog‘, v2=func(‘dog‘)
# ‘mouse‘, v3=func(‘mouse‘)
# ‘cattle‘, v4=func(‘cattle‘)

匿名函数写法：

salaries = {
    ‘cat‘: 3000,
    ‘dog‘: 1000000,
    ‘mouse‘: 10000,
    ‘cattle‘: 2000
}
print(max(salaries, key=lambda k: salaries[k]))  # next(iter_s)
print(min(salaries, key=lambda k: salaries[k]))  # next(iter_s)

3. sorted

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

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

salaries = {
    ‘cat‘: 3000,
    ‘dog‘: 1000000,
    ‘mouse‘: 10000,
    ‘cattle‘: 2000
}
print(sorted(salaries,key=lambda k:salaries[k],reverse=True))

将字典中的value按大小排序

4. map

 

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

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

 

5.filter

names=[‘LuffyNB‘,‘Namy‘,‘BrookeNB‘,‘Sauro‘]
# filter的工作原理
#1 首先将可迭代对象变成迭代器对象
#2 res=next(可迭代器对象),将res当作参数传给第一个参数指定的函数,然后filter会判断函数的返回值的真假,如果为真则留下res

# print([name for name in names if name.endswith(‘NB‘)])

name=filter(lambda x:x.endswith(‘NB‘),names)
print(name)
print(list(name))

 

三、内置函数

待更新。。。。