一 匿名函數(lamda)

為及解決簡單的一些需求而設計的一句話函數

函數名 = lamba參數:返回值
f = lambda n: n*n      求n的n次方
print(f(9))

註意

函數 的參數可以有多個,多個參數之間用逗號,隔開.

匿名函數不管有多復雜,只能寫一行,且邏輯結束後直接返回數據

返回值和正常的數據一樣,可以是任意數據類型

小註意點

匿名函數之所以叫匿名函數是因為我們通過__name__查看的時候,是沒有名字的統一交lamda,

正常函數調用查看名字
def func(n):
    return n*n
print(func.__name__)    #func

與__doc__     差不多
 

二,sorted函數 (有返回值)

排序函數 sorted(iterable, key = mone, reverse = False)

key: 排序規則(排序函數),在sorted內部會將可叠代對象中的每一個元素傳遞給這個函數的參數,根據函數運算的結果進行排序.

reverse:默認是升序,reverse = True 是降序

lst = [23,4,12,3,7]
lst_new = sorted(lst)
print(lst)
print(lst_new)

# 和函數搭配使用
lst = [23,4,12,3,7]
def func(n):
    return n % 2
 

s = sorted(lst,key = func)
print(s)

# 根據字符串串?長度進?行行排序
lst = ["麻花藤", "岡本次郎", "中央情報局", "狐仙"]
# 計算字符串串?長度
def func(s):
return len(s)
print(sorted(lst, key=func))

# 和lambda搭配使用
lst = [23,4,12,3,7]
s = sorted(lst,key = lambda n :n + 1)
print(s)

三 filter 函數

篩選函數 filter(function,literable)

function: 用來篩選函數,在filter函數中自動的八iterable中的元素傳遞給function,然後根據function返回的True或者是 False來判斷是否保留此項數據

ll = [23,4,12,3,7]
s = filter(lambda x: x % 2 == 0,ll)
print(s)  #得到的是篩選對象 <filter object at 0x0046FE10>
print(list(s))  #[4, 12]

lst = [{"id":1, "name":‘alex‘, "age":18},
{"id":2, "name":‘wusir‘, "age":16},
{"id":3, "name":‘taibai‘, "age":17}]
s = filter(lambda x: x["age"] >16,lst)
print(s)#<filter object at 0x002D0A10>
print(list(s))#[{‘id‘: 1, ‘name‘: ‘alex‘, ‘age‘: 18}, {‘id‘: 3, ‘name‘: ‘taibai‘, ‘age‘: 17}]

四 map

映射函數 map(function,literable)可以對可叠代對象的每一個元素進行映射,分別取執行function

# def func(n):
#     return n*n
# lst = [1,3,45,2]
# s = map(func,lst)
# print(s)#<map object at 0x001EF970>
# print(list(s))#[1, 9, 2025, 4]

# 與lambda使用
lst= [1,2,3,1,78]
s = map(lambda x:x*x,lst)
print(list(s))

# 計算兩個列表中相同位置的數據的和  有水桶效應(map)
lst1 = [1,3,5,7,3,23,54]
lst2 = [34,7,8,45,9,22,3,33]
s = map(lambda x,y:x + y ,lst1,lst2)
print(list(s))  #[35, 10, 13, 52, 12, 45, 57]

五 遞歸

在函數中調用函數本身,就是遞歸,在Python中遞歸的最大深度就是1000,其實不到1000就會報錯

def func():
    print("小仙女")
    func()
func()

def foo(n):
    print(n)
    n += 1
    foo(n)
foo(1)

遞歸的應用: 遞歸用return 出口

我們可以用遞歸來遍歷各種樹形結構,比如我們的文件系統,可以使用遞歸來遍歷該文件夾中的所有文件

import os
def read(filepath, n):
files = os.listdir(filepath) # 獲取到當前文件夾中的所有?文件
for fi in files: # 遍歷?文件夾中的?文件, 這裏裏獲取的是本層文件名
fi_d = os.path.join(filepath,fi) # 加入文件夾 獲取到文件夾+文件
if os.path.isdir(fi_d): # 如果該路路徑下的文件是文件夾
print("\t"*n, fi)
read(fi_d, n+1) # 繼續進?行行相同的操作
else:
print("\t"*n, fi) # 遞歸出口. 最終在這裏裏隱含著return
#遞歸遍歷?目錄下所有?文件
read(‘../oldboy/‘, 0)

六 二分查找

每次能夠砍掉一半的數據,查找效率非常高,但是只有有序的序列才能用

lst = [2, 3, 4, 5, 6, 7, 8, 9, 12, 45, 90, 95,112,134]
def func(left ,right,n):
    if left <= right:
        mid = (left + right) // 2   #中間索引位置
        if n > lst[mid]:
            left = mid +1
            return func(left ,right,n)
        elif n < lst[mid]:
            right = mid -1
            return func(left ,right,n)
        else:
            print("找到了")
            return mid   找到返回索引,那麽上面的都要加上return在調用

　　　　###return func(left ,right,n)

    else:
        print("mei")
        return -1  #找不到返回-1
ret = func(0,len(lst)-1,77)
print(ret)

註意  也可以將下面綠色的部分只寫一次,放在我標註的上面代碼我標註綠色的地方

return func(left ,right,n)

============================================================
普通版本

n = 8
# lst = [2, 3, 4, 5, 6, 7, 8, 9, 12, 45, 90, 95,112,134]
# left = 0
# right = len(lst) -1
# while left <= right:
#     mid = (left + right)
#     if n > lst[mid]:
#         left += 1
#         continue
#     elif n < lst[mid]:
#         right -= 1
#         continue
#     else:
#         print("找到了")
#         break
# else:
#     print("mei")

另類的二分法

def binary_search(ls, target):
    left = 0
    right = len(ls) - 1
    if left > right:
        print("不在這裏")
    middle = (left + right) // 2
    if target < ls[middle]:
        return binary_search(ls[:middle], target)
    elif target > ls[middle]:
        return binary_search(ls[middle+1:], target)
    else:
        print("在這裏")
binary_search(lst, 567)

遞歸,二分法,lambda,filter,map,sorted