How to migrate lambda from python2 to python3 and handle removed tuple parameter unpacking in python3

The direct approach is to index into the tuple:

lambda x_y_z: (x_y_z[0][0], x_y_z[1], x_y_z[2])

You can mechanically apply this approach in any case that unpacks an indexable sequence argument, like a tuple or list. I think this one is kind of ugly, but it's fine as a first step to get your tests passing on Python 3 before a more thorough refactor.

If you're upgrading by hand anyway, you could instead nest lambdas to emulate parameter unpacking:

lambda x_y_z: (lambda x, y, z: x[0], y, z)(*x_y_z)

It's debatable whether this is more or less readable than the direct approach. I find the names easier to read than the numbers, but it's at the cost of a more complex expression. You probably shouldn't always upgrade lambdas this way because nested parameter tuples would take too many lambdas to unpack. But this approach would also be able to unpack iterators, which can't be directly indexed.

Note that you can still unpack as before by using a def in advance and an assignment statement, which may be the most readable:

def spam(x_y_z):
    x, y, z = x_y_z
    return x[0], y, z

This approach will also work on iterator arguments and for nested tuples. But you will have to come up with an appropriate function name each time.

can you explain me the meaning of *x_y_z ?

In that context (inside a call), the * passes the contents of an iterable object as positional arguments, instead of the iterable itself. Maybe an example would help:

>>> def show_args(*args):
...     print(args)
...
>>> show_args([1,2,3], 'abc')
([1, 2, 3], 'abc')
>>> show_args(*[1,2,3], *'abc')
(1, 2, 3, 'a', 'b', 'c')