一、 什么是函數(shù)遞歸調(diào)用
    函數(shù)的遞歸調(diào)用是函數(shù)嵌套調(diào)用的一種特殊形式,在調(diào)用一個(gè)函數(shù)的過程中又直接或者間接地調(diào)用該函數(shù)
    本身,稱之為函數(shù)的遞歸調(diào)用

    遞歸調(diào)用必須有兩個(gè)明確的階段:
        1. 回溯: 一次次遞歸調(diào)用下去,說白了就一個(gè)重復(fù)的過程,但需要注意的是每一次重復(fù)問題的規(guī)模都應(yīng)該有所減少,直到逼近一個(gè)最終的結(jié)果,即回溯階段一定要有一個(gè)明確的結(jié)束條件
        2. 遞推: 往回一層一層推算出結(jié)果

成都創(chuàng)新互聯(lián)專注于中衛(wèi)企業(yè)網(wǎng)站建設(shè),響應(yīng)式網(wǎng)站開發(fā),商城網(wǎng)站開發(fā)。中衛(wèi)網(wǎng)站建設(shè)公司,為中衛(wèi)等地區(qū)提供建站服務(wù)。全流程按需制作網(wǎng)站，專業(yè)設(shè)計(jì)，全程項(xiàng)目跟蹤，成都創(chuàng)新互聯(lián)專業(yè)和態(tài)度為您提供的服務(wù)

import sys
print(sys.getrecursionlimit())
sys.setrecursionlimit(2048)

def foo(n):
    print('from foo',n)
    foo(n+1)
foo(0)

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

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

# 遞歸調(diào)用就是一個(gè)重復(fù)的過程,但是每一次重復(fù)問題的規(guī)模都應(yīng)該有所減少,并且應(yīng)該在滿足某種條件的情況下結(jié)束重復(fù),開始進(jìn)入遞推階段

def age(n):
    if n == 1:
        return 10
    return age(n-1) + 2
print(age(5))
-------------------------------------------
18

l=[1,[2,[3,[4,[5,[6,[7,[8,[9,[10,[11,]]]]]]]]]]]
def search(l):
    for item in l:
        if type(item) is not list:
            # 不是列表直接打印
            print(item)
        else:
            # 判斷是列表則繼續(xù)循環(huán),判斷...
            search(item)
search(l)
----------------------------------------------------------
1
2
3
4
5
6
7
8
9
10
11

算法:是如何高效率地解決某一個(gè)問題的方法/套路
# 二分法

nums=[13,15,17,23,31,53,74,81,93,102,103,201,303,403,503,777]
find_num=503

def binary_search(nums,find_num):
    print(nums)
    if len(nums) == 0:
        print('not exists')
        return
    mid_index=len(nums) // 2
    if find_num > nums[mid_index]:
        # in the right
        nums=nums[mid_index+1:]   # 切一半
        # 重新執(zhí)行二分的邏輯
        binary_search(nums,find_num)
    elif find_num < nums[mid_index]:
        #in the left
        nums=nums[0:mid_index]
        # 重新執(zhí)行二分的邏輯
        binary_search(nums,find_num)
    else:
        print('find it')

# binary_search(nums,find_num)
binary_search(nums,94)
--------------------------------------------------------------------
[13, 15, 17, 23, 31, 53, 74, 81, 93, 102, 103, 201, 303, 403, 503, 777]
[102, 103, 201, 303, 403, 503, 777]
[102, 103, 201]
[102]
[]
not exists

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

l=[0,1,2,3,4,5,6,7,8,9]
def search(l,num):
    print(l)
    if len(l)==0:
        print("not")
        return
    my_index=len(l) // 2          # 10/2 =5  ##//地板除，取整數(shù)
    if num > l[my_index]:
        l=l [my_index+1:]            #5+1
        search(l,num)
    elif num < l[my_index]:
        l=l[0:my_index]
        search(l,num)
    else:
        print("find it")
search(l,3)
---------------------------------------------------------------------------------------------------------------
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4]
[3, 4]
[3]
find it

二、三元表達(dá)式

def max2(x, y):
    # if x > y:
    #     return x
    # else:
    #     return y
    return x if x > y else y
# 三元表達(dá)式實(shí)現(xiàn)的效果就是:條件成立的情況下返回一個(gè)值,不成立的情況下返回另外一種值

# res=條件成立情況下返回的值  if 條件 else 條件不成立情況下返回的值
name=input('your name: ').strip()
res="SB" if name == 'lqz' else "NB"
print(res)

三、列表生成式、字典生成式

names=['alex','lqz','yyh','fm']
l=[]
for name in names:
    res=name + '_DSB'
    l.append(res)
print(l)
l=[name + '_DSB' for name in names]
print(l)
---------------------------------------------------
['alex_DSB', 'lqz_DSB', 'yyh_DSB', 'fm_DSB']
['alex_DSB', 'lqz_DSB', 'yyh_DSB', 'fm_DSB']

names=['alex_sb','lqz_sb','yyh_sb','fm_sb','egon']
l=[]
for name in names:
    if name.endswith('sb'):
        l.append(name)
print(l)
l=[name for name in names if name.endswith('sb')]
print(l)
--------------------------------------------------------
['alex_sb', 'lqz_sb', 'yyh_sb', 'fm_sb']
['alex_sb', 'lqz_sb', 'yyh_sb', 'fm_sb']

items=[
    ('name','egon'),
    ('age',18),
    ('sex','male'),
]
dic=dict(items)
print(dic)
------------------------------------
{'name': 'egon', 'age': 18, 'sex': 'male'}

# 補(bǔ)充

l=['a','b','c','d']
for i,v in enumerate(l):
    print(i,v)
-------------------------------------------
0 a
1 b
2 c
3 d

keys=['name','age','sex']
vals=['egon',18,'male']
dic={}
for i,k in enumerate(keys):
    # print(i,k)
    dic[k]=vals[i]
print(dic)
dic={k:vals[i] for i,k in enumerate(keys)}
print(dic)
dic={k:vals[i] for i,k in enumerate(keys) if i > 0}
print(dic)
----------------------------------------------------------
{'name': 'egon', 'age': 18, 'sex': 'male'}
{'name': 'egon', 'age': 18, 'sex': 'male'}
{'age': 18, 'sex': 'male'}

print({i:i for i in range(10)})
print({i for i in range(10)})
print({i for i in 'hello'})
-------------------------------------------
{0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9}
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
{'l', 'h', 'o', 'e'}

四、匿名函數(shù)

1 匿名函數(shù)：就是沒有名字的函數(shù)

2 為何要用：
    用于僅僅臨時(shí)使用一次的場景，沒有重復(fù)使用的需求

def sum2(x,y):
    return x+y
print(lambda x,y:x+y)
print((lambda x,y:x+y)(1,2))
---------------------------------------
 at 0x0000022BFE155510>
3

# 匿名函數(shù)的精髓就是沒有名字，為其綁定名字是沒有意義的

f=lambda x,y:x+y
print(f)
print(f(1,2))
--------------------------------------
 at 0x000002E84DFB2EA0>
3

# 匿名函數(shù)與內(nèi)置函數(shù)結(jié)合使用

# max,min,sorted,map,filter,reduce

salaries={
    'egon':300000,
    'alex':100000000,
    'wupeiqi':10000,
    'yuanhao':2000
}
# 求薪資最高的那個(gè)人名：即比較的是value，但取結(jié)果是key
res=max(salaries)
print(res)
-----------------------------------------------------------
yuanhao

# 可以通過max函數(shù)的key參數(shù)來改變max函數(shù)的比較依據(jù)，運(yùn)行原理：
# max函數(shù)會(huì)“for循環(huán)”出一個(gè)值，然后將該值傳給key指定的函數(shù)
# 調(diào)用key指定的函數(shù)，將拿到的返回值當(dāng)作比較依據(jù)

salaries={
    'egon':300000,
    'alex':100000000,
    'wupeiqi':10000,
    'yuanhao':2000
}
def func(name):
    # 返回一個(gè)人的薪資
    return salaries[name]
res=max(salaries,key=func)  #'egon'
print(res)
------------------------------------------------------
alex

d={"a":1,"b":2,'c':3}
print(max(d))
def func(k):
    return d[k]
print(func("a"))   # 函數(shù)根據(jù)key取對(duì)應(yīng)的value
res=max(d,key=func)
print(res)
# 匿名函數(shù)寫法
print(max(d,key=lambda s:d[s]))
--------------------------------------------
c
1
c
c

# 求最大值

salaries={
    'egon':300000,
    'alex':100000000,
    'wupeiqi':10000,
    'yuanhao':2000
}
res=max(salaries,key=lambda name:salaries[name])  #'egon'
print(res)
-----------------------------------------------------
alex

# 求最小值

salaries={
    'egon':300000,
    'alex':100000000,
    'wupeiqi':10000,
    'yuanhao':2000
}
res=min(salaries,key=lambda name:salaries[name])  #'egon'
print(res)
-------------------------------------------------------
yuanhao

# sorted排序

nums=[11,33,22,9,31]
res=sorted(nums,reverse=True)
print(nums)
print(res)
salaries={
    'egon':300000,
    'alex':100000000,
    'wupeiqi':10000,
    'yuanhao':2000
}
for v in salaries.values():
    print(v)
res=sorted(salaries.values())
print(res)
res=sorted(salaries,key=lambda name:salaries[name],reverse=True)
print(res)
------------------------------------------------------------------------
[11, 33, 22, 9, 31]
[33, 31, 22, 11, 9]
300000
100000000
10000
2000
[2000, 10000, 300000, 100000000]
['alex', 'egon', 'wupeiqi', 'yuanhao']

map：把一個(gè)列表按照我們自定義的映射規(guī)則映射成一個(gè)新的列表

names=['alex','lxx','wxx','yxx']
res=map(lambda name: name + "dSB", names)
print(list(res))
----------------------------------------------
['alexdSB', 'lxxdSB', 'wxxdSB', 'yxxdSB']

filter: 從一個(gè)列表中過濾出符合我們過濾規(guī)則的值

運(yùn)行原理：相當(dāng)于for循環(huán)取出每一個(gè)人名，然后傳給匿名函數(shù)，將調(diào)用匿名函數(shù)返回值為True的那個(gè)人名給留下來

names=['alex_sb','lxx_sb','wxx_sb','egon','yxx']
res=filter(lambda name:name.endswith('sb'),names)
print(list(res))
print([name for name in names if name.endswith('sb')])
------------------------------------------------------------
['alex_sb', 'lxx_sb', 'wxx_sb']
['alex_sb', 'lxx_sb', 'wxx_sb']

# reduce: 把多個(gè)值合并成一個(gè)結(jié)果

from functools import reduce
l=['a','b','c','d']
res=reduce(lambda x,y:x+y,l,'A')
# 'A','a' => 'Aa'
# 'Aa','b'=>'Aab'
# 'Aab','c'=>'Aabc'
# 'Aabc','d'=>'Aabcd'
print(res)
---------------------------------------
Aabcd

------------------------------------------------------------------------------------------------------------------------------

from functools import reduce
l=['a','b','c','d']
res=reduce(lambda x,y:x+y,l)
# 'a','b'=>'ab'
print(res)
res=reduce(lambda x,y:x+y,range(1,101))
# 1,2=>3
# 3,3=>6
print(res)
----------------------------------------------------------------------------
abcd
5050

作業(yè)：

作業(yè)：
    1 使用遞歸打印斐波那契數(shù)列(前兩個(gè)數(shù)的和得到第三個(gè)數(shù)，如：0 1 1 2 3 4 7...)

    2 一個(gè)嵌套很多層的列表，如l=［1,2,[3,[4,5,6,[7,8,[9,10,[11,12,13,[14,15]]]]]]］，用遞歸取出所有的值

    3 編寫用戶登錄裝飾器，在登錄成功后無需重新登錄，同一賬號(hào)重復(fù)輸錯(cuò)三次密碼則鎖定5分鐘
    
    4、求文件a.txt中總共包含的字符個(gè)數(shù)？思考為何在第一次之后的n次sum求和得到的結(jié)果為0？（需要使用sum函數(shù)）
    5、文件shopping.txt內(nèi)容如下

        mac,20000,3
        lenovo,3000,10
        tesla,1000000,10
        chicken,200,1
        求總共花了多少錢？

    打印出所有商品的信息，格式為[{'name':'xxx','price':333,'count':3},...]

    求單價(jià)大于10000的商品信息,格式同上

明日默寫：
    二分查找