內置函數：

https://www.processon.com/view/link/5adc6062e4b04721d63171eb?pw=3218

匿名函數：lambda

lambda 語法： lambda 參數： 表達式

lambda存在意義就是對簡單函數的簡潔表示。

# 現有兩元組 ((‘a‘),(‘b‘)), ((‘c‘), (‘d‘))，請用python中的匿名函數生成[{‘a‘:‘c‘}, {‘b‘:‘d‘}]

# t1 = ((‘a‘),(‘b‘))
# t2 = ((‘c‘), (‘d‘))
# print(list(zip(t1, t2)))
# def func(t):
 

#     return {t[0]: t[1]}
# m1 = map(func,zip(t1, t2) )
# print(list(m1))
# ==
# m1 = map(lambda t: {t[0]: t[1]}, zip(t1, t2))
# print(list(m1))

以下代碼的輸出是什麽？ 請給出答案並解釋

# def multipliers():
#     return [lambda x: i*x for i in range(4)]
"""
def  multipliers():
    retun [lambda x: i*x,lambda x: i*x,lambda x: i*x,lambda x: i*x]
每次循環i都會被重新賦值給，最終i == 3
 
"""
# 
# print([m(2) for m in multipliers()])
# 結果：
# [6, 6, 6, 6]
‘‘‘
執行[lambda x: i*x,lambda x: i*x,lambda x: i*x,lambda x: i*x]這個四個函數x都==2，i== 3
‘‘‘

# 想要產生 0， 2， 4， 6的話，可以修改為生成器表達式，因為生成器默認是取值的時候才會執行的，所以i分別取值為[0,1,2,3]
# def multipliers():
#     return (lambda x: i*x for i in range(4))
#
 
 print([m(2) for m in multipliers()])

1.map函數，我們使用map函數將會對列表中的所有元素進行操作。map有兩個參數（函數，列表），它會在內部遍歷列表中的每一個元素，執行傳遞過來的函數參數。在輸出到新列表中。

1 li = [11, 22, 33]
2 new_list = map(lambda a: a + 100, li)
輸出：[111, 122, 133]

當然，map還可以完成多個數組的相加：

1 li = [11, 22, 33]
2 sl = [1, 2, 3]
3 new_list = map(lambda a, b: a + b, li, sl)
4 print new_list
輸出：[12, 24, 36]

2.reduce函數，對於序列內所有元素進行累計操作：

1 lst = [11,22,33]
2 func2 = reduce(lambda arg1,arg2:arg1+arg2,lst)
3 print ‘func2:‘,func2
輸出：func2: 66

3.filter函數，他可以根據條件對數據進行過濾：

1 li = [11, 22, 33]
2 new_list = filter(lambda arg: arg > 22, li)
3 print new_list
輸出：[33]

遞歸函數

我們先來講一個故事，講的什麽呢？從前有座山，山裏有座廟，廟裏有個老和尚講故事，講的什麽呢？

從前有座山，山裏有座廟，廟裏有個老和尚講故事，講的什麽呢？

從前有座山，山裏有座廟，廟裏有個老和尚講故事，講的什麽呢？

從前有座山，山裏有座廟，廟裏有個老和尚講故事，講的什麽呢.....

.這個故事你們不喊停我能講一天！我們說，生活中的例子也能被寫成程序，剛剛這個故事，讓你們寫，你們怎麽寫呀？

while True:
    story = "
    從前有個山，山裏有座廟，廟裏老和尚講故事，
    講的什麽呢？   
    "
    print(story)

函數的執行方式：

def story():
    s = """
    從前有個山，山裏有座廟，廟裏老和尚講故事，
    講的什麽呢？
    """
    print(s)
    
while True:
    story()

遞歸的方式實現：

def story():
    s = """
    從前有個山，山裏有座廟，廟裏老和尚講故事，
    講的什麽呢？
    """
    print(s)
    story()
    
story()

初識遞歸

# 遞歸調用： 在調用一個函數的過程中，直接或者間接又調用函數的本身，稱之為遞歸函數
# 遞歸必備的兩個階段1、遞推，2、回溯

　　遞歸的最大深度——997

# def func(n):
#     print(‘--->‘, n)
#     func(n+1)
# func(0)  #-->RecursionError: maximum recursion depth exceeded while calling a Python object

# python默認的最大遞歸層數是998層

import sys
# print(sys.getrecursionlimit())  獲取最大遞歸層數
# sys.setrecursionlimit()  設置遞歸深度

"""
setrecursionlimit(n)

Set the maximum depth of the Python interpreter stack to n.  This
limit prevents infinite recursion from causing an overflow of the C
stack and crashing Python.  The highest possible limit is platform-
dependent.
"""

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

# 遞歸打印list中子元素不包含list的元素
# l1 = [1, [2, [3, [4, [5, [6]]]]]]
# def func(l):
#     for n in l:
#         if type(n) is list:
#             func(n)
#         else:
#             print(n)
#
# func(l1)

# 遞歸總結
# 1、必須有一個明確的結束條件
# 2、每次進入更深一層遞歸時，問題規模比上次遞歸應所有減少
# 3、遞歸效率不高



遞歸函數與三級菜單

menu = {
    ‘北京‘: {
        ‘海澱‘: {
            ‘五道口‘: {
                ‘soho‘: {},
                ‘網易‘: {},
                ‘google‘: {}
            },
            ‘中關村‘: {
                ‘愛奇藝‘: {},
                ‘汽車之家‘: {},
                ‘youku‘: {},
            },
            ‘上地‘: {
                ‘百度‘: {},
            },
        },
        ‘昌平‘: {
            ‘沙河‘: {
                ‘老男孩‘: {},
                ‘北航‘: {},
            },
            ‘天通苑‘: {},
            ‘回龍觀‘: {},
        },
        ‘朝陽‘: {},
        ‘東城‘: {},
    },
    ‘上海‘: {
        ‘閔行‘: {
            "人民廣場": {
                ‘炸雞店‘: {}
            }
        },
        ‘閘北‘: {
            ‘火車戰‘: {
                ‘攜程‘: {}
            }
        },
        ‘浦東‘: {},
    },
    ‘山東‘: {},
}

menu

遞歸實現三級菜單

l = [menu]
while l:
    for key in l[-1]:print(key)
    k = input(‘input>>‘).strip()   # 北京
    if k in l[-1].keys() and l[-1][k]:l.append(l[-1][k])
    elif k == ‘b‘:l.pop()
    elif k == ‘q‘:break

day4之內置函數、匿名函數，遞歸函數