python 中lambda表达式

Posted 2020-10-29 zxf123

一、lambda函数

1、lambda函数基础：

lambda函数也叫匿名函数，即，函数没有具体的名称,而用def创建的方法是有名称的。如下：

[python] view plain copy
"""命名的foo函数"""  
def foo():return \'beginman\'  #Python中单行参数可以和标题写在一行  
"""lambda关键字创建匿名函数,该表达式同以上函数"""  
lambda:\'beginman\'    
上面的只是简单的用lambda创建一个函数对象，并没有保存它也没有调用它，时刻会被回收了。这里我们保存并调用：
[python] view plain copy
bar = lambda:\'beginman\'  
print bar()      #beginman  
从上面几个例子中，可易理解Python lambda语法：
[python] view plain copy
lambda [arg1[,arg2,arg3....argN]]:expression  
lambda语句中，冒号前是参数，可以有多个，用逗号隔开，冒号右边的返回值。lambda语句构建的其实是一个函数对象。
[python] view plain copy
print lambda:\'beginman\'   #<function <lambda> at 0x00B00A30>  
2、无参数

如果没有参数，则lambda冒号前面就没有，如以上例子。

3、有参数

[python] view plain copy
def add(x,y):return x+y  
add2 = lambda x,y:x+y  
print add2(1,2)     #3  
  
def sum(x,y=10):return x+y  
sum2 = lambda x,y=10:x+y  
print sum2(1)       #11  
print sum2(1,100)   #101  
二、lambda与def

上面的例子中，可知lambda函数只是创建简单的函数对象，是一个函数的单行版本，但是这种语句由于性能的原因，调用的时候绕过函数的栈分配。python lambda还有哪些和def不一样呢？

def与lambda的区别 : 它们的主要不同点是python def 是语句而python lambda是表达式 ，理解这点对你了解它们很重要。
使用lambda函数还有一些注意事项：  lambda 函数可以接收任意多个参数 (包括可选参数) 并且返回单个表达式的值。  lambda 函数不能包含命令，包含的表达式不能超过一个。

1 、python lambda会创建一个函数对象，但不会把这个函数对象赋给一个标识符，而def则会把函数对象赋值给一个变量。

[python] view plain copy
>>> def foo():return \'foo()\'  
>>> foo  
<function foo at 0x011A34F0>  
2、python lambda它只是一个表达式，而def则是一个语句。lambda表达式运行起来像一个函数，当被调用时创建一个框架对象。

三、lambda函数的用途

个人认为有以下：

1、对于单行函数，使用lambda可以省去定义函数的过程，让代码更加精简。

2、在非多次调用的函数的情况下，lambda表达式即用既得，提高性能

注意：如果for..in..if能做的，最好不要选择lambda

四、参考

http://www.cnblogs.com/coderzh/archive/2010/04/30/python-cookbook-lambda.html

http://www.cnblogs.com/wanpython/archive/2010/11/01/1865919.html



lambda表达式是起到一个函数速写的作用。允许在代码内嵌入一个函数的定义。
[python] view plain copy
list(filter(lambda x:True if x % 3 == 0 else False, range(100)))  
如上所示，使用lambda表达式定义了一个匿名函数，用于筛选100以内的3的倍数，并生成一个列表。
[python] view plain copy
def make_repeat(n):  
   return lambda s : s * n  
当然lambda也可以嵌套在一个函数内使用，如上，函数中嵌套了一个lambda表达式。
[python] view plain copy
double = make_repeat(2)  
double  
<function make_repeat.<locals>.<lambda> at 0x0000000003A01D90>  
然后，要使用的时候可以用一个变量来接收，显示double变量，double变量是一个函数，并且需要一个参数，参见lambda表达式，需要一个s参数。
[python] view plain copy
print(double(8))  
16  
最后，调用double变量，并且传入参数 8 ，得到返回值16。因为前面传入的n的值为 2 ，故 2 * 8 得到16。

内置BIF介绍：

filter()：简单的理解为过滤器，需要两个参数，function，和一个序列（字符串、列表、元组都是序列），过滤器会依次将序列的值传入function中，

　　　　如果返回True的话，将其重新生成一个列表返回。

[python] view plain copy
list(filter(lambda x:True if x % 3 == 0 else False, range(100)))  
[0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, 54, 57, 60, 63, 66, 69, 72, 75, 78, 81, 84, 87, 90, 93, 96, 99]  

[python] view plain copy
values = [\'1\', \'2\', \'-3\', \'-\', \'4\', \'N/A\', \'5\']  
def is_int(val):  
    try:  
        x = int(val)  
        return True  
    except ValueError:  
        return False  
ivals = list(filter(is_int, values))  
print(ivals)  
filter() 函数创建了一个迭代器，因此如果你想得到一个列表的话，就得像示例那样使. 用 list() 去转换。

zip()：字面意思理解，就是zip打包，可以将多个序列进行打包，它会将序列拆分，然后把第一个序列和第二个序列的元素依次组成元组，2个一组组合成列表。

　　　　不过要注意的是，这是以最短序列来组合的，就是说如果一个序列比较长，一个比较短的话，组合只会进行到断序列的最后一个元素，多余的部分会被抛弃。

[python] view plain copy
>>> str1 = "abcde"  
>>> str2 = "abcdefg"  
>>> list(zip(str1, str2))  
[(\'a\', \'a\'), (\'b\', \'b\'), (\'c\', \'c\'), (\'d\', \'d\'), (\'e\', \'e\')]  
map()：映射，用法和filter()类似，也是将序列放入函数进行运算，但是，不论运算结果为什么，map()都将忠实反馈，这是map()和filter()的主要区别。请注意，filter()和map()中的function都必要有一个返回值。
[python] view plain copy
>>> list(map(lambda x:True if x % 3 == 0 else False, range(100)))  
[True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True]  
我比较认同电影《教父》里的人生观： 第一步要努力实现自我价值，第二步要全力照顾好家人，第三步要尽可能帮助善良的人，第四步为族群发声，第五步为国家争荣誉。 事实上作为男人，前两步成功，人生已算得上圆满，做到第三步堪称伟大，而随意颠倒次序的那些人，一般不值得信任。


[plain] view plain copy
f = lambda x,y,z : x+y+z    
print f(1,2,3)    
g = lambda x,y=2,z=3 : x+y+z    
print g(1,z=4,y=5)    
#lambda表达式常用来编写跳转表（jump table），就是行为的列表或字典。例如：  
L = [(lambda x: x**2),    
    (lambda x: x**3),    
    (lambda x: x**4)]    
print L[0](2),L[1](2),L[2](2)    
    
D = {\'f1\':(lambda: 2+3),    
    \'f2\':(lambda: 2*3),    
    \'f3\':(lambda: 2**3)}    
print D[\'f1\'](),D[\'f2\'](),D[\'f3\']()    
#3，lambda表达式可以嵌套使用，但是从可读性的角度来说，应尽量避免使用嵌套的lambda表达式。  
#4，map函数可以在序列中映射函数进行操作。例如：  
def inc(x):    
    return x+10    
        
L = [1,2,3,4]    
print map(inc,L)    
   
print map((lambda x: x+10),L)   
  
#5，列表解析可以实现map函数同样的功能，而且往往比map要快。例如：  
print [x**2 for x in range(10)]    
print map((lambda x: x**2), range(10))  
#6，列表解析比map更强大。例如：  
print [x+y for x in range(5) if x%2 == 0 for y in range(10) if y%2 ==1]    
#7，生成器函数就像一般的函数，但它们被用作实现迭代协议，因此生成器函数只能在迭代语境中出现。例如：  
def gensquares(N):    
    for i in range(N):    
        yield i**2    
for i in gensquares(5):    
    print i,    
#8，所有的迭代内容（包括for循环、map调用、列表解析等等）将会自动调用iter函数，来看看是不是支持了迭代协议。  
#9，生成器表达式就像列表解析一样，但它们是扩在圆括号()中而不是方括号[]中。例如：  
for num in (x**2 for x in range(5)):    
    print num,    
#10，列表解析比for循环具有更好的性能。尽管如此，在编写Python代码时，性能不应该是最优先考虑的。  
#11，没有return语句时，函数将返回None对象。  
#12，函数设计的概念：  
  
#耦合性：只有在真正必要的情况下才使用全局变量  
#耦合性：不要改变可变类型的参数，除非调用者希望这样做  
#耦合性：避免直接改变另一个文件模块中的变量  
[plain] view plain copy
#聚合性：每一个函数都应有一个单一的、统一的目标  
#13，最后给个默认参数和可变参数的例子：  
def saver(x=[]): x.append(1) print x saver([2]) saver() saver() saver()