lambda函數

 

一.lambda函數介紹（匿名函數）

>>> def f(x):

... return x*2 ...  >>> f(3) 6 >>> g = lambda x: x*2 

>>> g(3) 6 >>> (lambda x: x*2)(3) 

6

二.例子

1.舉例刪除（沒有對比就沒有傷害）

清楚列表l，只留元素4 (遍歷刪除元素必定要當心)

 

 1 l=[1,2,3,4]
 2 for i in l:
 3     if i != 4:
 4         l.remove(i)
 5 print(l)
 6 
 7 
 8 
 9 
10 
11 [2, 4]

 

 

 

 

1 l=[1,2,3,4]
2 for i in range(len(l)):
3     if l[i] == 4:
4         del l[i]
5 print(l)
6 
7 
8 [1, 2, 3]

l=[1,2,3,4,5]
for i in range(len(l)):
    if l[i] == 4:
        del l[i]
print(l)


##會報錯
若是仍是按照上面的方法，設想一下，range開始的範圍是0-4，中間遍歷的時候刪除了一個元素4，這個時候列表變成了= [1,2,3,5],這時候就會報錯了，提示下標超出了數組的表示，
緣由就是上面說的遍歷的時候刪除了元素

 

 

 

 

l=[1,2,3,4,5]
l = [i for i in l if i !=4]
print(l)


[1, 2, 3, 5]                         #產生一個新序列，賦值給l

 

　

或者乾脆創建新的list存放要刪除的元素

l=[1,2,3,4,5]
dellsit = []
for i in l:
    if i == 4:
        dellsit.append(i)
for i in dellsit:
    l.remove(i)

print(l)





[1, 2, 3, 5]

　　

2.lambda 幹了！

salaries={
    'egon':3000,
    'alex':100000000,
    'wupeiqi':10000,
    'yuanhao':2000
}
print(max(salaries))    #默認取的ASICC碼大的
print(max(salaries.values()))
def get_value(k):
    return salaries[k]
print(max(salaries))
print(max(salaries,key=get_value))
i=iter(salaries)
print(next(i))          #隨機取的
print(next(i))
print(next(i))



yuanhao
100000000
yuanhao
alex
egon
alex
wupeiqi
yuanhao

　　

 1 f=lambda k:salaries[k]
 2 print(f)
 3 print(f('egon'))
 4 print(max(salaries,key=lambda  k:salaries[k]))    ##自帶return功能  5 print(min(salaries,key=lambda k:salaries[k]))
 6 
 7 
 8 
 9 
10 
11 <function <lambda> at 0x000000000075E1E0>
12 3000
13 alex
14 yuanhao

 

3. zip拉鍊

 1 zip()
 2 l1=[1,2,3]
 3 s='hel'
 4 for i in zip(l1,s):         ##zip後面跟這兩個加入字符類型，加入時字典中鍵值會自動加入
 5     print(i)
 6 
 7 
 8 
 9 
10 (1, 'h')
11 (2, 'e')
12 (3, 'l')

 

zip()
l1=[1,2,3]
s='hel'

print(salaries.keys(),salaries.values())
z=zip(salaries.values(),salaries.keys())
print(z)
# for i in z:
#     print(i)
print(max(z))
print(max((1,'a'),(1,'b')))                   ##根據第一個值比較大小




dict_keys(['yuanhao', 'wupeiqi', 'egon', 'alex']) dict_values([2000, 10000, 3000, 100000000])
<zip object at 0x0000000000A575C8>
(100000000, 'alex')
(1, 'b')

　　

4.sorted   

 1 l=[3,2,5,23,44,4]
 2 print(sorted(l))               #返回值是列表，默認是升序
 3 print(sorted(l,reverse=True))       #降序
 4 
 5 s='hello abc'
 6 print(sorted(s))          #空格在最前面
 7 
 8 
 9 
10 
11 
12 
13 
14 
15 [2, 3, 4, 5, 23, 44]
16 [44, 23, 5, 4, 3, 2]
17 [' ', 'a', 'b', 'c', 'e', 'h', 'l', 'l', 'o']

 

 1 salaries={
 2     'egon':3000,
 3     'alex':100000000,
 4     'wupeiqi':10000,
 5     'yuanhao':2000
 6 }
 7 
 8 print(sorted(salaries))
 9 print(sorted(salaries,key=lambda  x:salaries[x])) 　　　　　　　　
10 print(sorted(salaries,key=lambda x:salaries[x],reverse=True))   ##取反 11 
12 
13 
14 ['alex', 'egon', 'wupeiqi', 'yuanhao']
15 ['yuanhao', 'egon', 'wupeiqi', 'alex']
16 ['alex', 'wupeiqi', 'egon', 'yuanhao']

 

5.map  映射

m=map(lambda item:item**2,1)

name_l=['alex','zhejiangF4','yuanhao']
m=map(lambda name:name+'SB',name_l)　　　　　　##可迭代參數放到最後
print(list(m))





['alexSB', 'zhejiangF4SB', 'yuanhaoSB']

 

6.reduce    合併

 

from functools import reduce
l=list(range(100))
print(l)
print(reduce(lambda x,y:x+y,l,100))      ##後面還能夠加初始值






[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
5050

　　

7.filter 過濾器

name_l=[
    {'name':'egon','age':18},
    {'name':'dragonFire','age':1000},
    {'name':'gaoluchuan','age':9000},
    {'name':'fsw','age':10000},
]

f=filter(lambda d:d['age'] > 100,name_l)　　　　　　　　　　　　##後面變成一個迭代器，next傳給左邊函數   這構成了一個返回值True的時候才傳給下面
print(f)
for i in f:
    print(i)

#用filter來處理,獲得股票價格大於20的股票名字
shares={
   'IBM':36.6,
   'Lenovo':23.2,
   'oldboy':21.2,
   'ocean':10.2,
}

f=filter(lambda x:shares[x] > 30,shares)
print(f)
for i in f:
    print(i)

<filter object at 0x00000000006B17F0> {'age': 1000, 'name': 'dragonFire'} {'age': 9000, 'name': 'gaoluchuan'} {'age': 10000, 'name': 'fsw'}

　　

<filter object at 0x0000000000B61C88>
IBM

slice　

l=[1,2,3,4,5,6,7,8]
print(l[2:4])
s=slice(2,4)
print(l[s])
print(l[2:5:2])    ##後面爲步長
print(l[::-1])
print(l[::-2])









[3, 4]
[3, 4]
[3, 5]
[8, 7, 6, 5, 4, 3, 2, 1]
[8, 6, 4, 2]

　　

　　　　

 

 

 

 

 

三.注意

1.這是一個 lambda 函數，完成同上面普通函數相同的事情。注意這裏的簡短的語法：在參數列表周圍沒有括號，並且忽略了 return 關鍵字 (隱含存在，由於整個函數只有一行)。並且，該函數沒有函數名稱，可是能夠將它賦值給一個變量進行調用。

2.使用 lambda 函數時甚至不須要將它賦值給一個變量。這可能不是世上最有用的東西，它只是展現了 lambda 函數只是一個內聯函數。

 

3.總的來講，lambda 函數能夠接收任意多個參數 (包括可選參數) 而且返回單個表達式的值。lambda 函數不能包含命令，包含的表達式不能超過一個。不要試圖向 lambda 函數中塞入太多的東西；若是你須要更復雜的東西，應該定義一個普通函數，而後想讓它多長就多長。

 

4.注意
lambda 函數是一種風格問題。不必定非要使用它們；任何可以使用它們的地方，均可以定義一個單獨的普通函數來進行替換。我將它們用在須要封裝特殊的、非重用代碼上，避免令個人代碼充斥着大量單行函數。

---恢復內容結束---