Есть ли эквивалент Python для Haskell 'let'

Вы можете использовать временное понимание списка

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

или, что то же самое, генераторное выражение

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

но и то, и другое ужасно.

Другой (ужасный) метод - через временную лямбду, которую вы вызываете немедленно

(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]

Последние версии 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] ]

Такого нет. Вы можете эмулировать его таким же образом, как let обессахаживается до лямбда-исчисления (let x = foo in bar ‹=> (\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)

Несколько предложений for в ответе b0fh - это стиль, который я лично использую уже некоторое время, так как я считаю, что он обеспечивает большую ясность и не загромождает пространство имен временными функциями. Однако, если скорость является проблемой, важно помнить, что временное создание списка из одного элемента занимает заметно больше времени, чем создание списка из одного кортежа.

Сравнивая скорость различных решений в этой ветке, я обнаружил, что уродливый лямбда-хак самый медленный, за ним следуют вложенные генераторы, а затем решение от b0fh. Однако все они были превзойдены победителем с одним кортежем:

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

Это может быть не так важно для вопроса OP, но есть и другие случаи, когда ясность может быть значительно улучшена, а скорость увеличена в случаях, когда можно использовать понимание списка, используя один кортеж вместо списков для фиктивных итераторов.

Только догадываясь о том, что делает Haskell, вот альтернатива. Он использует то, что известно в Python как «понимание списка».

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

Вы можете включить использование 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)()

Это почти читается как выражение «пусть». Позиционирование и форматирование заданий, конечно же, ваше.

Эту идиому легко узнать по началу '(' и окончанию '()'.

В функциональных выражениях (также и в Python) многие круглые скобки имеют тенденцию накапливаться в конце. Нечетный '(' легко заметить.

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 внутри него.

Чтобы получить что-то смутно сопоставимое, вам нужно либо сделать два понимания или карты, либо определить новую функцию. Один подход, который еще не был предложен, состоит в том, чтобы разбить его на две строки вот так. Я считаю, что это несколько читабельно; хотя, вероятно, правильно определить свою собственную функцию:

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

Хотя вы можете просто написать это как:

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)

В Python 3.8 были добавлены выражения присваивания с использованием оператора :=: PEP 572 .

Это можно использовать как let в Haskell, хотя итерируемая распаковка не поддерживается.

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.