Is there a Python equivalent of the Haskell 'let'

You could use a temporary list comprehension

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

or, equivalently, a generator expression

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

but both of those are pretty horrible.

Another (horrible) method is via a temporary lambda, which you call immediately

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

I think the recommended "Pythonic" way would just be to define a function, like

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

Recent python versions allows multiple for clauses in a generator expression, so you can now do something like:

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

which is similar to what Haskell provides too:

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

and denotationally equivalent to

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

There is no such thing. You could emulate it the same way let is desugared to lambda calculus (let x = foo in bar <=> (\x -> bar) (foo)).

The most readable alternative depends on the circumstances. For your specific example, I'd choose something like [barcode(productId), metric(size) for productId, (_, size) in zip(productIds, map(lookup, productIds))] (really ugly on second thought, it's easier if you don't need productId too, then you could use map) or an explicit for loop (in a generator):

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