What is the good python3 equivalent for auto tuple unpacking in lambda?

Consider the following python2 code

    In [5]: points = [ (1,2), (2,3)]

    In [6]: min(points, key=lambda (x, y): (x*x + y*y))
    Out[6]: (1, 2)

This is not supported in python3 and I have to do the following:

    >>> min(points, key=lambda p: p[0]*p[0] + p[1]*p[1])
    (1, 2)

This is very ugly. If the lambda was a function, I could do

    def some_name_to_think_of(p):
      x, y = p
      return x*x + y*y

Removing this feature in python3 forces the code to either do the ugly way(with magic indexes) or create unnecessary functions(The most bothering part is to think of good names for these unnecessary functions)

I think the feature should be added back at least to lambdas alone. Is there a good alternative?

Update: I am using the following helper extending the idea in the answer

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

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

Update2: A cleaner version for star

    import functools

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

No, there is no other way. You covered it all. The way to go would be to raise this issue on the Python ideas mailing list, but be prepared to argue a lot over there to gain some traction.

Actually, just not to say "there is no way out", a third way could be to implement one more level of lambda calling just to unfold the parameters - but that would be at once more inefficient and harder to read than your two suggestions:

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

From: stackoverflow.com/q/21892989