python Lambda 表达式

  1. 云栖社区>
  2. 博客>
  3. 正文

python Lambda 表达式

shadowcat 2016-11-15 13:35:00 浏览1280
展开阅读全文


来源:http://www.cnblogs.com/jydeng/p/4145188.html

一、lambda函数

1、lambda函数基础:

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

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

2、无参数

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

3、有参数

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则会把函数对象赋值给一个变量。

>>> 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表达式是起到一个函数速写的作用。允许在代码内嵌入一个函数的定义。
list(filter(lambda x:True if x % 3 == 0 else False, range(100)))
如上所示,使用lambda表达式定义了一个匿名函数,用于筛选100以内的3的倍数,并生成一个列表。
 def make_repeat(n):
    return lambda s : s * n
当然lambda也可以嵌套在一个函数内使用,如上,函数中嵌套了一个lambda表达式。
double = make_repeat(2)
double
<function make_repeat.<locals>.<lambda> at 0x0000000003A01D90>
然后,要使用的时候可以用一个变量来接收,显示double变量,double变量是一个函数,并且需要一个参数,参见lambda表达式,需要一个s参数。
print(double(8))
16

最后,调用double变量,并且传入参数 8 ,得到返回值16。因为前面传入的n的值为 2 ,故 2 * 8 得到16。

内置BIF介绍:

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

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

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]

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个一组组合成列表。

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

>>> 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都必要有一个返回值。
>>> 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]
我比较认同电影《教父》里的人生观: 第一步要努力实现自我价值,第二步要全力照顾好家人,第三步要尽可能帮助善良的人,第四步为族群发声,第五步为国家争荣誉。 事实上作为男人,前两步成功,人生已算得上圆满,做到第三步堪称伟大,而随意颠倒次序的那些人,一般不值得信任。


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,函数设计的概念:

#耦合性:只有在真正必要的情况下才使用全局变量
#耦合性:不要改变可变类型的参数,除非调用者希望这样做
#耦合性:避免直接改变另一个文件模块中的变量
#聚合性:每一个函数都应有一个单一的、统一的目标
#13,最后给个默认参数和可变参数的例子:
def saver(x=[]): x.append(1) print x saver([2]) saver() saver() saver()












网友评论

登录后评论
0/500
评论
shadowcat
+ 关注