一、函數遞歸

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

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)

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

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

三、內置函數

待更新。。。。

day15_函數遞歸_匿名函數_內置函數