一 內建函式的常用高階函式例項理解

'''2. 從指定2個數字範圍內中找出所有的迴文數字。
（迴文數字是值從左向右讀和從右向左讀都是一樣的數，例如：1221，242這樣的）
 輸入：1, 100
 輸出：[1,2,3,...,11, 22, ..., 100]'''
# data = range(1,100)
# def func(item):
#     return str(item) == str(item)[::-1]
# ret = filter(func,data)
# print(list(ret))

'''1. 提取列表中每個字串成員中的數字。
   輸入：["3Q", "250", "w3w", "=3=", "4_4"]
   輸出：["3", "250", "3", "3", "44"]'''

# def func(item):
#     w = ""
#     for i in item:
#         if 48 < ord(i) < 58:
#             w += i
#     return w
#
# data = ["3Q", "250", "w3w", "=3=", "4_4"]
# ret = map(func,data)
# print(list(ret))

'''1. 對下列資料進行排序
   輸入：(1, "B", 5, "QQ")
   輸出：[1, 5, 'B', 'QQ']'''
# data = (1, "B", 5, "QQ")
# ret = sorted(data, key=lambda x:str(x))
# print(ret) #[1, 5, 'B', 'QQ']

二 閉包函式例項理解

閉包函式宣告和執行過程中，外函式作用域下的區域性變數不會因為閉包函式執行結束而被記憶體回收刪除，而是與內部函式進行引用繫結，導致該變數會繼續保留在記憶體中，並且閉包函式還可以在其定義環境外被執行，並保持與該變數的關係。

例項：

1 編寫函式，計算兩個數字的平方的和，基於閉包原理快取計算的結果到記憶體中，當出現重複的引數時，直接從外函式的變數中提取結果。

 
"""
例項1：
首次輸入：7, 2 [首次出現，記錄到外函式的變數中]
結果：53 # 49+4
再次輸入：2, 3 [首次出現，記錄到外函式的變數中]
結果：13 # 4+9
再次輸入：7, 2 [重複輸入，直接從外函式的記錄中提取結果，不需要經過運算]
結果：53 # 49+4
"""
def outer():
    result = {
        # (7, 2): 53,
    }
    def inner(a, b):
        key = (a, b)
        if key in result:
            print("來自快取的結果：")
            return result[key]

        ret = a**2+b**2
        print("來自計算的結果：")
        result[key] = ret
        return ret

    return inner

calc = outer()

ret = calc(7,2)
print(ret)  #來自計算的結果：53

ret = calc(2,3)
print(ret)  #來自計算的結果:13

ret = calc(7,2)
print(ret)  #來自快取的結果：53

 三 遞迴函式例項理解

python在記憶體中是使用棧楨空間是用來執行函式的。呼叫函式就是開闢棧楨空間的過程，呼叫結束之後，會自動釋放棧楨空間。

每呼叫一次函式，就開闢一個棧楨空間，每結束一個函式，就釋放一層棧楨空間，遞迴本質上就是開闢和釋放棧楨空間的過程。

遞迴函式的執行需要佔用的空間記憶體等效能消耗遠比迴圈要高。使用遞迴時務必在函式呼叫前新增一個判斷條件，直到不滿足退出重複操作。如果遞迴的層數過多，層數達到1000層則報錯，將會被python直譯器強制終止遞迴。

建議大家針對簡單操作少用遞迴，多用迴圈，除非這個問題真的很適合使用遞迴。而針對複雜操作多用遞迴，少用迴圈，因為複雜操作情況下的迴圈程式碼（4層以上巢狀迴圈），很容易讓人懵逼。

以下為一些遞迴函式例項便於理解

"""
1. 編寫遞迴函式，計算任意數n的階乘。
1*2*3*4...*n  n 的階乘
採用遞迴的思路：
假設n=4
1*2*3*4        要計算4的階乘，先要計算3的階乘是多少
1*2*3          要計算3的階乘，先要計算2的階乘是多少
1*2            要計算2的階乘，先要計算1的階乘是多少
1              1的階乘就是1呀！！！
得到1的階乘1以後，
則2的階乘就是
fn(2) ---> fn(1)*2
則3的階乘就是
fn(3) ---> fn(2)*3
"""
# def fn(n):
#     if n == 1:
#         return 1
#     else:
#         return n*fn(n-1)
#
# ret = fn(4)
# print(ret) #24
"""
2. 編寫遞迴函式，輸出斐波那契數列的第n項。
斐波那契數列:
0,1,1,2,3,5,8,13,21,34,55...
計算第n項的數列
fa(n)  ---> fa(n-1) + fa(n-2)
假設n=5
fn(5)  ---> fa(4) + fa(3)
            fa(4) ----> fa(3) + fa(2)
                    fa(3) ---> fa(2) + fa(1)
                               fa(2) ---> fa(1) + fa(0)
                                             1       0
"""
# def fa(n):
#     if n == 0:
#         return 0
#     if n == 1:
#         return 1
#     return fa(n-2) + fa(n-1)
#
# print( fa(4) ) # 3

3. 思路：

"""
3. 編寫遞迴函式，輸出類似123454321這樣的迴文數字。
"""

def func(s):
    if s < 5:
        print(s, end="")
        func(s + 1)
    print(s, end="")

func(1)

4. 思路

4.編寫函式，基於遞迴原理，反轉字串
例項1：
輸入："12453"
結果："35421"

例項2：
輸入："abf"
結果："fba"
def fn(content):
    if content == "":
        return content
    else:
        return fn(content[1:]) + content[0]