How can I simulate 2.x's tuple unpacking for lambda parameters, using 3.x?

According to http://www.python.org/dev/peps/pep-3113/ tuple unpacking are gone, and 2to3 will translate them like so:

As tuple parameters are used by lambdas because of the single
expression limitation, they must also be supported. This is done by
having the expected sequence argument bound to a single parameter and
then indexing on that parameter:

lambda (x, y): x + y

will be translated into:

lambda x_y: x_y[0] + x_y[1]

Which is quite similar to your implementation.

I don’t know any good general alternatives to the Python 2 arguments unpacking behaviour. Here’s a couple of suggestion that might be useful in some cases:

• if you can’t think of a name; use the name of the keyword parameter:

  def key(p): # more specific name would be better
      x, y = p
      return x**2 + y**3
  
  result = min(points, key=key)
  

• you could see if a namedtuple makes your code more readable if the list is used in multiple places:

  from collections import namedtuple
  from itertools import starmap
  
  points = [ (1,2), (2,3)]
  Point = namedtuple('Point', 'x y')
  points = list(starmap(Point, points))
  
  result = min(points, key=lambda p: p.x**2 + p.y**3)
  

Based on Cuadue suggestion and your comment on unpacking still being present in comprehensions, you can use, using numpy.argmin :

result = points[numpy.argmin(x*x + y*y for x, y in points)]

While the destructuring arguments was removed in Python3, it was not removed from comprehensions. It is possible to abuse it to obtain similar behavior in Python 3.

For example:

points = [(1,2), (2,3)]
print(min(points, key=lambda y: next(x*x + y*y for (x,y) in [y])))

In comparison with the accepted answer of using a wrapper, this solution is able to completely destructure the arguments while the wrapper only destructures the first level. That is, you can do

values = [(('A',1),'a'), (('B',0),'b')]
print(min(values, key=lambda y: next(b for ((a,b),c) in (y,))))

In comparison to the accepted answer using an unwrapper lambda:

values = [(('A',1),'a'), (('B',0),'b')]
print(min(points, key=lambda p: (lambda a,b: (lambda x,y: (y))(*a))(*p)))

Alternatively one can also use a list instead of a tuple.

values = [(('A',1),'a'), (('B',0),'b')]
print(min(points, key=lambda y: next(b for (a,b),c in [y])))

This is just to suggest that it can be done, and should not be taken as a recommendation. However, IMO, this is better than the hack of using using multiple expressions in a tuple and returning the last one.

Another option is to write it into a generator producing a tuple where the key is the first element. Tuples are compared starting from beginning to end so the tuple with the smallest first element is returned. You can then index into the result to get the value.

min((x * x + y * y, (x, y)) for x, y in points)[1]

Consider whether you need to unpack the tuple in the first place:

min(points, key=lambda p: sum(x**2 for x in p))

or whether you need to supply explicit names when unpacking:

min(points, key=lambda p: abs(complex(*p)**2)

I think the better syntax is x * x + y * y let x, y = point, let keyword should be more carefully chosen.

The double lambda is the closest version.
lambda point: (lambda x, y: x * x + y * y)(*point)

High order function helper would be useful in case we give it a proper name.

def destruct_tuple(f):
  return lambda args: f(*args)

destruct_tuple(lambda x, y: x * x + y * y)

There may be a real solution to this, using PyFunctional!

Although not currently supported, I’ve submitted a tuple arg unpacking feature request to support:

(
    seq((1, 2), (3, 4))
    .map(unpack=lambda a, b: a + b)
)  # => [3, 7]

_{Since questions on Stack Overflow are not supposed to contain the answer in the question, nor have explicit "update" sections, I am converting OP’s original "updates" to a proper answer and making it community wiki.}

_{OP originally claimed that this solution was "extending the idea in the answer". I cannot discern which answer that meant, or which idea. The idea is functionally the same as anthony.hl’s answer, but that came years later. Considering the state of answers at the time, I think this qualifies as OP’s original work.)}

Make a wrapper function that generalizes the process of unpacking the arguments, like so:

def star(f):
    return lambda args: f(*args)

Now we can use this to transform the lambda we want to write, into one that will receive the argument properly:

min(points, key=star(lambda x,y: (x*x + y*y))

We can further clean this up by using functools.wraps:

import functools

def star(f):
    @functools.wraps(f)
    def f_inner(args):
        return f(*args)
    return f_inner