是否可能在 python lambda 表达式中包含多个语句？

将表达式放在列表中可能会模拟多个表达式:

例如:

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

这对语句不起作用。

可以使用 min 和 index 在 O (n)时间内完成，而不是使用 sort 或 heapq。

首先创建除了原始列表的最小值之外的所有内容的新列表:

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)

是的，它确实很丑陋，但它应该算法便宜。另外，由于这个帖子中的一些人希望看到列表理解:

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

这正是 Monad中的 bind函数的用途。

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

实际上，在 python 中的 lambda 表达式中可以有多个语句。它并不完全是微不足道的，但在你的例子中，下列作品:

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

您必须确保每个语句不返回任何内容，或者如果它包装了(。.及虚假)。结果是最后一次计算返回的结果。

例如:

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

在 python 中，将多个语句组合成单个语句的一种方法是使用“ and”关键字作为短路操作符。然后您可以直接使用这个语句作为 lambda 表达式的一部分。

这类似于在 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")

转念一想，用“ or”代替“ and”可能更好，因为许多函数在成功时返回“0”或“无”。然后你可以去掉上面例子中的包装函式:

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


junky("a", "b")

’和’操作将计算表达式，直到它得到第一个零返回值。在此之后，它短路。 一，一，零，一 计算: 1和1和0，并删除1

‘ or’operation 将计算这些表达式，直到它得到第一个非零返回值。

0或0或1或0 计算0或0或1，并删除0

我会给你另一个解决方案，让你的 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: [o.a, o.b])
gives: [1, 2]


Bindings down the chain can depend on
the ones above them through a lambda.
ex: LET(('a', 1,
'b', lambda o: o.a + 1),
lambda o: o.b)
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]

实际上有一种方法可以在 lambda 中使用多个语句。 我的解决办法是:

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


x = lambda l: exec("l.sort(); return l[1]")


map(x, lst)

是的。您可以这样定义它，然后用以下内容包装您的多个表达式:

计划开始:

Start = lambda * x: x [-1]

Common Lisp 程序:

Prog = lambda * x: x [-1]

不使用 lambda 函数有更好的解决方案。但是如果我们真的想使用 lambda 函数，这里有一个处理多个语句的通用解决方案: Map (lambda x: x [1] if (x.sort ()) else x [1] ，lst)

您并不真正关心语句返回什么。

是的，这是可能的。请尝试下面的代码片段。

x = [('human', 1), ('i', 2), ('am', 1), ('.', 1), ('love', 1), ('python', 3), ('', 1),
('run', 1), ('is', 2), ('robust', 1), ('hello', 1), ('spark', 2), ('to', 1), ('analysis', 2), ('on', 1), ('big', 1), ('data', 1), ('with', 1), ('analysis', 1), ('great', 1)
]


rdd_filter = rdd1_word_cnt_sum.filter(lambda x: 'python' in x or 'human' in x or 'big' in x)
rdd_filter.collect()

来演示 lambda x:[f1(),f2()]效应，它使我们能够在 lambda中执行多个函数。它还演示了单行 if else 条件，如果您真的想缩小代码。

• 注意，f1()也可以是 lambda 函数(递归 lambda 或 Lambda 中的 lambda) ，并且内部 lambda 可以是 你自己选。
• 你也可以把 exec (’语句’)例如 lambda x:[exec('a=[1]'),exec('b=2')]

Touch (linux)命令的一个 python 实现，如果不存在空文件，它会创建空文件。

def touch(fpath):
check= os.path.exists(fpath)
(lambda fname1:[open(fname1,"w+",errors="ignore").write(""),print('Touched',fname1)]
if not check else None) (fpath)

将打印[触摸 fpath]其中 fpath是文件路径给出的输入。如果文件已经存在，则不执行任何操作。

(lambda x: [ f(x), f2(x) ] ) (inp) <-我们将‘ inp’作为输入传递给 lambda，在本例中是 fpath。

在分析了以上提供的所有解决方案后，我想出了这个组合，它似乎对我最有用:

func = lambda *args, **kwargs: "return value" if [
print("function 1..."),
print("function n"),
["for loop" for x in range(10)]
] else None

很漂亮吧？ 请记住，必须有东西在列表中，所以它的真值。 另外一件事是 list 可以被 set 替换，看起来更像 C 风格的代码，但是在这种情况下，你不能把 list 放在里面，因为它们不是 hashabe

我在一行使用 lambas 创建了一个类:

(code := lambda *exps, ret = None: [exp for exp in list(exps) + [ret]][-1])(Car := type("Car", (object,), {"__init__": lambda self, brand, color, electro = False: code(setattr(self, "brand", brand), setattr(self, "color", color), setattr(self, "electro", electro), setattr(self, "running", False)), "start": lambda self: code(code(print("Car was already running, it exploded.\nLMAO"), quit()) if self.running else None, setattr(self, "running", True), print("Vrooom")), "stop": lambda self: code(code(print("Car was off already, it exploded.\nLMAO"), quit()) if not self.running else None, setattr(self, "running", False), print("!Vrooom")), "repaint": lambda self, new_color: code(setattr(self, "color", new_color), print(f"Splash Splash, your car is now {new_color}")), "drive": lambda self: code(print("Vrooom") if self.running else code(print("Car was not started, it exploded.\nLMAO"), quit())), "is_on": lambda self: code(ret = self.running)}), car := Car("lamborghini", "#ff7400"), car.start(), car.drive(), car.is_on(), car.drive(), car.stop(), car.is_on(), car.stop())

更易读的变体:

(
code :=
lambda *exps, ret = None:
[
exp
for exp
in list(exps) + [ret]
][-1]
)(


Car := type(
"Car",
(object,),
{
"__init__": lambda self, brand, color, electro = False: code(
setattr(self, "brand", brand),
setattr(self, "color", color),
setattr(self, "electro", electro),
setattr(self, "running", False)


),
"start": lambda self: code(
code(
print("Car was already running, it exploded.\nLMAO"),
quit()
) if self.running
else None,
setattr(self, "running", True),
print("Vrooom")
),
"stop": lambda self: code(
code(
print("Car was off already, it exploded.\nLMAO"),
quit()
) if not self.running
else None,
setattr(self, "running", False),
print("!Vrooom")
),
"repaint": lambda self, new_color: code(
setattr(self, "color", new_color),
print(f"Splash Splash, your car is now {new_color}")
),
"drive": lambda self: code(
print("Vrooom") if self.running
else code(
print("Car was not started, it exploded.\nLMAO"),
quit()
)
),
"is_on": lambda self: code(
ret = self.running
)
}
),


car := Car("lamborghini", "#ff7400"),
car.start(),
car.drive(),
car.is_on(),
car.drive(),
car.stop(),
car.is_on(),
car.stop()
)

我在这里使用了 lambda 函数，它接受任意数量的参数，并将 ret 参数 default 返回给 Nothing，以便能够在被“ ,”分割的一行中有更多的表达式。

在阅读这个长长的答案列表时，我想出了一个滥用元组的简洁方法:

lambda x: (expr1(x), expr2(x), ..., result(x))[-1]

这将生成一个 lambda，该 lambda 计算所有表达式并返回最后一个表达式的值。这只有在那些表达式有副作用的情况下才有意义，比如 print()或 sort()。

普通赋值(=)不是表达式，所以如果你想在 lambda 中赋值一个变量，你必须使用 :=操作符(在 Python 3.8中添加) ，它也返回赋值:

lambda: (answer := 42, question := compute(answer), question)[-1]

但上述方法只适用于局部变量赋值。为了分配一个元素，你必须使用 d.update({'key': 'value'})，但是即使使用 list也没有类似的选项，必须使用 l.__setitem__(index, value)。与删除相同: 标准容器支持等效于 del x[item]的 x.pop(index)，但也返回被删除的值，但是如果它不可用，则必须直接使用 x.__delitem__(index)。

要影响全局变量，您必须修改 globals()返回的 dict:

lambda: (g := globals(), g.__setitem__('answer', 42), g.__delitem__('question'), None)[-1]

可以使用列表、字典或甚至集来代替元组将表达式分组成一个表达式，但元组更快(主要是因为它是不可变的) ，而且似乎没有任何缺点。

还有，不要在生产代码中使用这些内容！漂亮请！

我可以给你三种方法:

map(lambda x: sorted(x)[1], lst))
map(lambda x: min(x[:x.index(min(x))]+x[x.index(min(x))+1:]), lst)
map(lambda x: min([num for num in x if num != min(x)]), lst)

我知道这是个老问题，但它有更相关的答案。因此，基于水仙313的回答，我有一个小小的修正:

原文: Map (lambda x: sort (x)[1] ，lst))

实际情况: Map (lambda x: (sort (x)[1] ，lst))

我知道这是一个很小的东西，这是相当明显的，但它不会工作，如果没有缺少括号。问题是 lambda 表达式不能接受多个参数，但它们可以接受多个操作的列表/元组。