13

In Python 2 this code is OK:

f = lambda (m, k): m + k

m = [1,2,3,4]
k = [5,6,7,8]

print(map(f, zip(m, k)))

but in Python 3 the following error occurred:

f = lambda (m, k): m + k
^
SyntaxError: invalid syntax

If I remove parentheses in lambda expression then another error occurred:

TypeError: <lambda>() missing 1 required positional argument: 'k'

Also approach with tuple as single lambda argument works in Python 3, but it's not clear (hard for reading):

f = lambda args: args[0] + args[1]

How can I unpack values in the right way in Python 3?

Improve this question
2
  • map() applies f to each element of the provided iterable; in your given example, map() tries to pass (1, 5) into your function, which takes two arguments, but only one is provided, so it fails and gives you the error. Commented Jan 5, 2015 at 9:10
  • They removed it from functions, to play nicely with type hints (among others). See also my answer here: stackoverflow.com/a/54991720/1338797 Commented Mar 4, 2019 at 22:01

6 Answers 6

Reset to default
15

The removal of tuple unpacking is discussed in PEP 3113. Basically, you can't do this in Python 3. Under the headline Transition plan, you see that the "suggested" way of doing this is as your final code block:

lambda x_y: x_y[0] + x_y[1]
Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

9

You can use the same syntax in both Python 2 and Python 3 if you use itertools.starmap instead of map which unpacks the tuple items for us:

>>> from itertools import starmap
>>> f = lambda m, k: m + k
>>> list(starmap(f, zip(m, k)))
[6, 8, 10, 12]
Improve this answer

Comments

8

You may find this solution easier to read:

lambda mk: (lambda m,k: m + k)(*mk)

Additionally, I'd argue that the unpacking makes this more (1) Pythonic and (2) consistent with the manual unpacking of tuple arguments for named functions, required in Python 3 by PEP 3113.

Improve this answer

2 Comments

Very nice, although a bit intricate (is it a synonym for "pythonic", BTW?). THIS approach will win hands down for more than 2-tuples! Indices are bad. Just think: lambda abcdef: abcdef[0] + abcdef[2] - abcdef[1] // abcdef[4]?
This a natural functional programming workaround to the scenario at hand, for those into functional programming. I just wonder how does the the extra function wrapping escape the original limitation prior to going down the rabbit hole in the PEP.
4

You cannot use parentheses in Python3 to unpack arguments in lambda functions (PEP 3113), Try:

f = lambda m, k: m + k

To make it work with your code, you should use:

lambda mk: mk[0] + mk[1]
Improve this answer

3 Comments

Is it work with map(f, zip(m, k))? As for (I've wrote) TypeError occurred.
@Alexei Then you should try lambda mk: mk[0] + mk[1]. I didn't look at the rest of your code before I posted the answer :)
Thank you for your attention. I think it's some strange decision in Python evolution...
1

Or you can just sum() to add numbers without unpack:

f = lambda args: sum(args)
Improve this answer

1 Comment

Thank you for your answer =) But that was just simple example. In really my lambda more complicated. Moreover I think just sum function can be used without being wrapped in lambda.
1

Just use

map(f, m, k)

Note that f can be

from operator import add
map(add, m, k)
Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.