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 (遍历删除元素一定要小心)

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





[2, 4]

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


[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

　　

f=lambda k:salaries[k]
print(f)
print(f('egon'))
print(max(salaries,key=lambda  k:salaries[k]))    ##自带return功能
print(min(salaries,key=lambda k:salaries[k]))





<function <lambda> at 0x000000000075E1E0>
3000
alex
yuanhao

3. zip拉链

zip()
l1=[1,2,3]
s='hel'
for i in zip(l1,s):         ##zip后面跟这两个加入字符类型，加入时字典中键值会自动加入
    print(i)




(1, 'h')
(2, 'e')
(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   

l=[3,2,5,23,44,4]
print(sorted(l))               #返回值是列表，默认是升序
print(sorted(l,reverse=True))       #降序

s='hello abc'
print(sorted(s))          #空格在最前面








[2, 3, 4, 5, 23, 44]
[44, 23, 5, 4, 3, 2]
[' ', 'a', 'b', 'c', 'e', 'h', 'l', 'l', 'o']

salaries={
    'egon':3000,
    'alex':100000000,
    'wupeiqi':10000,
    'yuanhao':2000
}

print(sorted(salaries))
print(sorted(salaries,key=lambda  x:salaries[x])) 　　　　　　　　
print(sorted(salaries,key=lambda x:salaries[x],reverse=True))   ##取反



['alex', 'egon', 'wupeiqi', 'yuanhao']
['yuanhao', 'egon', 'wupeiqi', 'alex']
['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 函数是一种风格问题。不一定非要使用它们；任何能够使用它们的地方，都可以定义一个单独的普通函数来进行替换。我将它们用在需要封装特殊的、非重用代码上，避免令我的代码充斥着大量单行函数。

---恢复内容结束---