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

一、函数递归

1. 定义：

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

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

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

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

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

4.使用：

4.1重复调用的结果

# 一直重复调用
def bar():
    print('from bar')
    foo()

def foo():
    print('from foo')
    bar()
foo()

# RecursionError: maximum recursion depth exceeded while calling a Python object

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

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

list=[1,4,8,54,74,88,93,122,154,178,243,354,388,865]
# 以前的做法：
# for item in list:
#     if item==10:
#         print('find it')
#         break
# else:
#     print('not exists')
 
def search(search_num,list):
    print(list)
    if len(list)==0:
        print('not exists')
        return 
    # 列表数字的中间索引
    mid_index=len(list)//2
    if search_num<mid_index:
        # 在左边
        list=list[:mid_index]
        # 把列表从左边取至中间索引位置
        search(search_num,list)
        # 继续查找
    elif search_num>mid_index:
        list=list[mid_index+1:]
        search_num(search_num,list)
    else:
        print('find it')
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))

sort 和 sorted 的区别：

　　sort 是应用在列表list上的方法，sorted 可以对所有可迭代的对象进行排序操作。

　　list 返回的是对已经存在的列表进行操作，而内建函数 sorted 返回的是一个新的 list,而不是在原来的列表基础上进行操作。

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

三、内置函数

 3.1 需掌握的内置函数

需掌握的内置函数即上表常见的函数

salaries={
    'dada':3000,
    'zixi':100000,
    'aulu':100000,
    'namy':2000
}
# 因为字典迭代取值的是 key 值，所以比较大小的返回值也是key
print(max(salaries))
print(min(salaries))

# 通过value来实现比较大小
print(max(salaries.values()))
print(min(salaries.values()))

# 但是一般我们都是通过比较value的值，然后取出key的值
# 若value值相同，则比较key值的大小
print(max(salaries,key=lambda k:salaries[k]))

# zip 方式实现
# 先比较的是values,若value都相同，则比较keys
x=zip(salaries.values(),salaries.keys())
# print(max(x))
print(x)
# 注意：此时的x是一个迭代器对象，不可以再次取值比较大小
print(max(x)) # ValueError: max() arg is an empty sequence

# sorted 用法：sorted(interable,key=None,reverse=false)
# 比较的是字典key值的大小，并将顺序放至一个列表当中
print(sorted(salaries,key=None,reverse=False))

3.2 内置函数之面向对象中的重点