是否有可能在Python lambdaexpression式中有多个语句?

我是一个python新手试图达到以下目的:

我有一个列表清单:

lst = [[567,345,234],[253,465,756, 2345],[333,777,111, 555]] 

我想把lst映射到另一个只包含每个子列表中次数最less的列表。 所以结果应该是:

 [345, 465, 333] 

例如,如果我只是对最小的数字感兴趣,我可以这样做:

 map(lambda x: min(x),lst) 

我希望我能做到这一点:

 map(lambda x: sort(x)[1],lst) 

但sorting不连锁。 (返回None)

既不是这样允许的:

 map(lambda x: sort(x); x[1],lst) #hence the multiple statement question 

有没有办法做到这一点在Python中的地图,但没有定义一个命名函数 ? (比如用ruby中的匿名块很容易)

我可以给出几个不同的答案,从你的具体问题到更普遍的问题。 所以从最具体到最一般:

问:你可以把多个语句放入lambda?

答:不,但实际上你不需要使用lambda。 您可以将语句放在def 。 即:

 def second_lowest(l): l.sort() return l[1] map(second_lowest, lst) 

问:你能通过sorting列表从lambda中获得第二个最低的项目吗?

答:是的。 正如alex的答案指出的那样, sorted()是创build新列表的sorting版本,而不是就地sorting,并且可以被链接。 请注意,这可能是你应该使用的 – 对于你的地图在原始列表上有副作用是不好的做法。

问:我应该如何从列表中的每个列表中获得第二低的项目。

A. sorted(l)[1]实际上并不是最好的办法。 它具有O(N log(N))复杂度,而O(n)解存在。 这可以在heapq模块中find。

 >>> import heapq >>> l = [5,2,6,8,3,5] >>> heapq.nsmallest(l, 2) [2, 3] 

所以只需使用:

 map(lambda x: heapq.nsmallest(x,2)[1], list_of_lists) 

使用列表理解通常也被认为更清晰,这完全避免了lambda:

 [heapq.nsmallest(x,2)[1] for x in list_of_lists] 

将这些语句放在一个列表中可以模拟多个语句:

例如:

 lambda x: [f1(x), f2(x), f3(x), x+1] 

时间旅行在这里。 如果您通常希望在lambda中包含多个语句,则可以将其他lambda作为parameter passing给该lambda。

 (lambda x, f: list((y[1] for y in f(x))))(lst, lambda x: (sorted(y) for y in x)) 

你实际上不能有多个语句,但是你可以通过传递lambdaexpression式来模拟lambdaexpression式。

编辑:时间旅行者回报! 您也可以滥用布尔expression式的行为(记住短路规则和真实性)来链式操作。 使用三元运算符可以为您提供更多的function。 同样,你不能有多个语句 ,但你当然可以有很多的函数调用。 这个例子用一堆数据做一些随意的垃圾,但是,这表明你可以做一些有趣的事情。 print语句是返回None的函数的示例(与.sort()方法一样),但是它们也帮助显示lambda正在做什么。

 >>> (lambda x: print(x) or x+1)(10) 10 11 >>> f = (lambda x: x[::2] if print(x) or x.sort() else print(enumerate(x[::-1]) if print(x) else filter(lambda (i, y): print((i, y)) or (i % 3 and y % 2), enumerate(x[::-1])))) >>> from random import shuffle >>> l = list(range(100)) >>> shuffle(l) >>> f(l) [84, 58, 7, 99, 17, 14, 60, 35, 12, 56, 26, 48, 55, 40, 28, 52, 31, 39, 43, 96, 64, 63, 54, 37, 79, 25, 46, 72, 10, 59, 24, 68, 23, 13, 34, 41, 94, 29, 62, 2, 50, 32, 11, 97, 98, 3, 70, 93, 1, 36, 87, 47, 20, 73, 45, 0, 65, 57, 6, 76, 16, 85, 95, 61, 4, 77, 21, 81, 82, 30, 53, 51, 42, 67, 74, 8, 15, 83, 5, 9, 78, 66, 44, 27, 19, 91, 90, 18, 49, 86, 22, 75, 71, 88, 92, 33, 89, 69, 80, 38] [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] (0, 99) (1, 98) (2, 97) (3, 96) (4, 95) (5, 94) (6, 93) (7, 92) (8, 91) (9, 90) (10, 89) (11, 88) (12, 87) (13, 86) (14, 85) (15, 84) (16, 83) (17, 82) (18, 81) (19, 80) (20, 79) (21, 78) (22, 77) (23, 76) (24, 75) (25, 74) (26, 73) (27, 72) (28, 71) (29, 70) (30, 69) (31, 68) (32, 67) (33, 66) (34, 65) (35, 64) (36, 63) (37, 62) (38, 61) (39, 60) (40, 59) (41, 58) (42, 57) (43, 56) (44, 55) (45, 54) (46, 53) (47, 52) (48, 51) (49, 50) (50, 49) (51, 48) (52, 47) (53, 46) (54, 45) (55, 44) (56, 43) (57, 42) (58, 41) (59, 40) (60, 39) (61, 38) (62, 37) (63, 36) (64, 35) (65, 34) (66, 33) (67, 32) (68, 31) (69, 30) (70, 29) (71, 28) (72, 27) (73, 26) (74, 25) (75, 24) (76, 23) (77, 22) (78, 21) (79, 20) (80, 19) (81, 18) (82, 17) (83, 16) (84, 15) (85, 14) (86, 13) (87, 12) (88, 11) (89, 10) (90, 9) (91, 8) (92, 7) (93, 6) (94, 5) (95, 4) (96, 3) (97, 2) (98, 1) (99, 0) [(2, 97), (4, 95), (8, 91), (10, 89), (14, 85), (16, 83), (20, 79), (22, 77), (26, 73), (28, 71), (32, 67), (34, 65), (38, 61), (40, 59), (44, 55), (46, 53), (50, 49), (52, 47), (56, 43), (58, 41), (62, 37), (64, 35), (68, 31), (70, 29), (74, 25), (76, 23), (80, 19), (82, 17), (86, 13), (88, 11), (92, 7), (94, 5), (98, 1)] 

使用sorting函数 ,如下所示:

 map(lambda x: sorted(x)[1],lst) 

或者,如果你想避免lambda,并有一个生成器,而不是一个列表:

(sorting(col)[1] col in lst)

从这里使用begin(): http : //www.reddit.com/r/Python/comments/hms4z/ask_pyreddit_if_you_were_making_your_own/c1wycci

 Python 3.2 (r32:88445, Mar 25 2011, 19:28:28) [GCC 4.5.2] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>> lst = [[567,345,234],[253,465,756, 2345],[333,777,111, 555]] >>> begin = lambda *args: args[-1] >>> list(map(lambda x: begin(x.sort(), x[1]), lst)) [345, 465, 333] 

你实际上可以在python的lambdaexpression式中有多个语句。 这不是微不足道的,但在你的例子中,以下工作:

 map(lambda x: x.sort() or x[1],lst) 

你必须确保每个语句不返回任何东西,或者如果它包含在(..和False)中。 结果是上次评估返回的结果。

例:

 >>> f = (lambda : (print(1) and False) or (print(2) and False) or (print(3) and False)) >>> f() 1 2 3 

在python中将多个语句组合成单个语句的方法是使用“和”关键字作为短路操作符。 那么你可以直接使用这个单一语句作为lambdaexpression式的一部分。

这与使用“&&”作为诸如bash之类的shell语言中的短路操作符类似。

还要注意:你可以通过包装函数来修改一个函数语句来返回一个真正的值。

例:

 def p2(*args): print(*args) return 1 # a true value junky = lambda x, y: p2('hi') and p2('there') and p2(x) and p2(y) junky("a", "b") 

第二个想法,它可能更好地使用“或”而不是“和”,因为许多函数成功返回0或无。 那么你可以去掉上面例子中的包装函数:

 junky = lambda x, y: print('hi') or print('there') or print(x) or print(y) junky("a", "b") 

'和'操作将评估expression式,直到达到第一个零返回值。 之后它短路。 1和1以及0和1评估:1和1和0,并且下降1

'或'操作将评估expression式,直到达到第一个非零返回值。 之后它短路。

0或0或1或0评估0或0或1,然后下降0

你可以在O(n)时间使用min和index来代替sort或heapq。

首先创build除原始列表的最小值以外的所有内容的新列表:

 new_list = lst[:lst.index(min(lst))] + lst[lst.index(min(lst))+1:] 

然后取新的列表的最小值:

 second_smallest = min(new_list) 

现在所有在一起的lambda:

 map(lambda x: min(x[:x.index(min(x))] + x[x.index(min(x))+1:]), lst) 

是的,这真的很丑,但它应该是algorithm便宜。 也因为这个线程中的一些人想看到列表parsing:

 [min(x[:x.index(min(x))] + x[x.index(min(x))+1:]) for x in lst] 

这正是Monad中的bind函数所使用的。

使用bind函数,可以将多个lambda组合成一个lambda,每个lambda表示一个语句。

我会给你另一个解决scheme,让你的lambda调用一个函数。

 def multiple_statements(x, y): print('hi') print('there') print(x) print(y) return 1 junky = lambda x, y: multiple_statements(x, y) junky('a', 'b'); 

让我向你展示一个可怕而可怕的黑客:

 import types def _obj(): return lambda: None def LET(bindings, body, env=None): '''Introduce local bindings. ex: LET(('a', 1, 'b', 2), lambda o: [oa, ob]) gives: [1, 2] Bindings down the chain can depend on the ones above them through a lambda. ex: LET(('a', 1, 'b', lambda o: oa + 1), lambda o: ob) gives: 2 ''' if len(bindings) == 0: return body(env) env = env or _obj() k, v = bindings[:2] if isinstance(v, types.FunctionType): v = v(env) setattr(env, k, v) return LET(bindings[2:], body, env) 

您现在可以使用这个LET表单:

 map(lambda x: LET(('_', x.sort()), lambda _: x[1]), lst) 

这给出: [345, 465, 333]