Question

是否有一个与Haskell'let'表达式相当的Python，可以让我写出类似的东西：

list2 = [let (name,size)=lookup(productId) in (barcode(productId),metric(size)) 
            for productId in list]

如果没有，那么最具可读性的替代方案是什么？

添加以澄清let语法：

x = let (name,size)=lookup(productId) in (barcode(productId),metric(size))

相当于

(name,size) = lookup(productId)
x = (barcode(productId),metric(size))

但是第二个版本与列表推导不太相配。

Answer 1

您可以使用临时列表理解

[(barcode(productId), metric(size)) for name, size in [lookup(productId)]][0]

或等效的生成器表达式

next((barcode(productId), metric(size)) for name, size in [lookup(productId)])

但这两个都非常可怕。

另一种（可怕的）方法是通过一个临时的lambda，你立即调用

(lambda (name, size): (barcode(productId), metric(size)))(lookup(productId))

我认为推荐的“Pythonic”方式只是定义一个函数，比如

def barcode_metric(productId):
   name, size = lookup(productId)
   return barcode(productId), metric(size)
list2 = [barcode_metric(productId) for productId in list]

Answer 2

没有这样的事情。 可以模仿它let与lambda演算（let x = foo in bar＆lt; =＆gt; (\x -> bar) (foo)）相同的方式。

最具可读性的选择取决于具体情况。对于您的具体示例，我会选择类似[barcode(productId), metric(size) for productId, (_, size) in zip(productIds, map(lookup, productIds))]的内容（如果您不需要productId，那么在第二次考虑时会非常难看，那么您可以使用map）或者显式for循环（在生成器中）：

def barcodes_and_metrics(productIds): for productId in productIds: _, size = lookup(productId) yield barcode(productId), metric(size)

Answer 3

最近的python版本允许在生成器表达式中使用多个for子句，因此您现在可以执行以下操作：

list2 = [ barcode(productID), metric(size)
          for productID in list
          for (name,size) in (lookup(productID),) ]

与Haskell提供的类似：

list2 = [ (barcode productID, metric size)
        | productID <- list
        , let (name,size) = lookup productID ]

并且在表示上等同于

list2 = [ (barcode productID, metric size) 
        | productID <- list
        , (name,size) <- [lookup productID] ]

Answer 4

b0fh的答案中的多个for子句是我个人现在已经使用了一段时间的样式，因为我相信它提供了更多的清晰度，并且没有使用临时函数来混淆命名空间。但是，如果速度是一个问题，重要的是要记住，临时构建一个元素列表所花费的时间远远长于构造一个元组。

比较这个线程中各种解决方案的速度，我发现丑陋的lambda hack是最慢的，接着是嵌套的生成器，然后是b0fh的解决方案。然而，这些都被一元组赢家所超越：

list2 = [ barcode(productID), metric(size)
          for productID in list
          for (_, size) in (lookup(productID),) ]

这可能与OP的问题没那么相关，但是在其他情况下，通过使用单元组代替可能希望使用列表理解的情况下可以大大提高清晰度并获得速度虚拟迭代器的列表。

Answer 5

为了获得模糊可比的东西，您需要做两个理解或地图，或者定义一个新功能。尚未提出的一种方法是将其分解为两行。我相信这有点可读;虽然可能定义自己的功能是正确的方法：

pids_names_sizes = (pid, lookup(pid) for pid in list1)
list2 = [(barcode(pid), metric(size)) for pid, (name, size) in pids_names_sizes]

Answer 6

只猜测Haskell的作用，这里是替代方案。它使用Python中已知的“列表理解”。

[barcode(productId), metric(size)
    for (productId, (name, size)) in [
        (productId, lookup(productId)) for productId in list_]
]

您可以像其他人一样建议使用lambda:。

Answer 7

由于您要求最佳可读性，您可以考虑使用lambda选项，但只需稍加改动：初始化参数。以下是我自己使用的各种选项，从我尝试的第一个开始，到现在最常用的那个开始。

假设我们有一个函数（未显示），它将data_structure作为参数，你需要重复获取x。

首先尝试（根据2012年来自huon的回答）：

(lambda x:
    x * x + 42 * x)
  (data_structure['a']['b'])

对于多个符号，这会变得不那么可读，所以接下来我尝试了：

(lambda x, y:
    x * x + 42 * x + y)
  (x = data_structure['a']['b'],
   y = 16)

由于它重复了符号名称，因此仍然不易阅读。所以我试过了：

(lambda x = data_structure['a']['b'],
        y = 16:
  x * x + 42 * x + y)()

这几乎是一个'let'表达式。当然，作业的定位和格式是你的。

这个成语很容易通过首字母'（'和结尾'（）'来识别。

在函数式表达式中（也在Python中），许多括号往往会堆积在最后。奇怪的一个'''很容易被发现。

Answer 8

虽然您可以简单地将其写为：

list2 = [(barcode(pid), metric(lookup(pid)[1]))
         for pid in list]

您可以自己定义LET以获取：

list2 = [LET(('size', lookup(pid)[1]),
             lambda o: (barcode(pid), metric(o.size)))
         for pid in list]

甚至：

list2 = map(lambda pid: LET(('name_size', lookup(pid),
                             'size', lambda o: o.name_size[1]),
                            lambda o: (barcode(pid), metric(o.size))),
            list)

如下：

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)

Answer 9

class let:
    def __init__(self, var):
        self.x = var

    def __enter__(self):
        return self.x

    def __exit__(self, type, value, traceback):
        pass

with let(os.path) as p:
    print(p)

但这实际上与p = os.path相同，因为p的范围不限于with块。为此，您需要

class let:
    def __init__(self, var):
        self.value = var
    def __enter__(self):
        return self
    def __exit__(self, type, value, traceback):
        del var.value
        var.value = None

with let(os.path) as var:
    print(var.value)  # same as print(os.path)
print(var.value)  # same as print(None)

var.value在None的with块之外，但os.path在其中。

Answer 10

在 Python 3.8 中，添加了使用 := 运算符的赋值表达式：PEP 572。

这有点像 Haskell 中的 let，但不支持可迭代解包。

list2 = [
    (lookup_result := lookup(productId), # store tuple since iterable unpacking isn't supported
     name := lookup_result[0], # manually unpack tuple
     size := lookup_result[1],
     (barcode(productId), metric(size)))[-1] # put result as the last item in the tuple, then extract on the result using the (...)[-1]
    for productId in list1
]

请注意，这与普通的 Python 赋值一样。

有没有相当于Haskell'let'的Python

10 个答案: