Python: Is There Syntax-level Support For Unpacking, From Tuples, The Arguments To An *anonymous* Function?

Suppose we have the following: args = (4,7,5) def foo(a,b,c): return a*b%c Python conveniently allows tuple unpacking: foo(4,7,5) # returns 3 foo(*args) #

Solution 1:

In python2 it was possible to use tuple-unpacking for this:

>>>deffunc((a,b,c)):...return a+b+c...>>>func((1,2,3))
6

However this feature was removed in python3. See PEP 3113. The reasons why it was removed are:

• They are very difficult to introspect

• They don't introduce any functionality since you can create a function like:

  def func(a_b_c):
     a,b,c = a_b_c
  

  And achieve the same result

• They provided ugly error messages

With this removal python currently does not support what you want with any syntax nor any stdlib function.

Since this syntax was removed with a PEP I highly doubt that the core developers will accept your unpack_into function. However there may be a small chance to add something like that into the functools module which should contain this kind of things. You should probably ask to the python developers about this, but be sure to provide good arguments to support your request.

Solution 2:

starmap! It's in the itertools package.

From my examples:

list(map(lambda t: foo(*t), listoftuples))

becomes

list(starmap(foo, listoftuples))

See why it's called starmap? And with anonymous functions:

defunpackInto(func): returnlambda t: func(*t)
list(map(unpackInto(lambda a, b, c: a*b%c), listoftuples))

becomes

list(starmap(lambda a, b, c: a*b%c, listoftuples))

A simple four-letter prefix, star, is the "asterisk" I was looking for.

So, yes, there is standard library support for unpacking parameters from tuples into anonymous functions but only for map, via starmap.

No, there is no syntax-level support, but there was syntax level support in python 2. See Bakuriu's answer. The last would become:

list(map(lambda (a, b, c): a*b%c, listoftuples))

Which is even more concise. It's almost a shame it had to be taken away.

Then again, lambda is rarely as concise or readable as a list comprehension:

[a*b%cfor a, b,cin listoftuples]

Solution 3:

If foo is a function consisting of a single expression (i.e., can be written as a lambda), and it's a throwaway function so you don't need to save it for later, and you want to apply it to a list, don't use a function at all. Use a list comprehension:

[a*b%cfor a, b,cin list_of_tuples]

This is more clear and more concise than anything involving a lambda and map, and eliminates the need for passing arguments at all.

More generally, if your function is a one-shot throwaway, it's not that important if it uses "ugly magic numbers" as in lambda t: t[0]*t[1]%t[2]. If you're willing to take time to make it look good, then you can also take time to write it as an actual function instead of cramming it into a lambda.

Solution 4:

Yes of course, lambda is no different from any other function, e.g.:

lambda *args: pprint.pprint(args)
lambda *args: foo(args[0], args[7], args[-1])

and conversely:

l1 = lambda a, b, c: ...
l1(*range(3))

in addition, functools provides for partial evlauation:

importfunctoolsfoo= lambda a, b, c, d: Nonepart= functools.partial(foo, 1, 2)
part(3, 4)