for - tuple python

Python `map` y desempaquetado de argumentos

Question

Yo sé eso

map(function, arguments)

es equivalente a

for argument in arguments:
    function(argument)

¿Es posible usar la función de mapa para hacer lo siguiente?

for arg, kwargs in arguments:
    function(arg, **kwargs)

Answer 1

Para el caso de argumentos posicionales solamente, puede utilizar itertools.starmap(fun, args) :

Devuelve un iterador cuyos valores se devuelven desde la función evaluada con una tupla de argumento tomada de la secuencia dada.

Ejemplo:

from itertools import starmap

def f(i, arg):
    print(arg * (i+1))

for _ in starmap(f, enumerate(["a", "b", "c"])):
    pass

huellas dactilares:

a
bb
ccc

Answer 2

Puedes con un lambda:

map(lambda a: function(a[0], **a[1]), arguments)

o podría usar una expresión generadora o una lista de comprensión, según lo que desee:

(function(a, **k) for a, k in arguments)
[function(a, **k) for a, k in arguments]

En Python 2, map() devuelve una lista (de modo que la comprensión de la lista es equivalente), en Python 3, map() es un generador (de modo que la expresión del generador puede reemplazarlo).

No hay un método de biblioteca estándar o incorporado que haga esto directamente; El caso de uso es demasiado especializado.

Answer 3

Seguí corriendo en la misma necesidad y terminé haciendo la siguiente función:

def kwarg_map(element_constructor, **kwarg_lists):
    """
    A helper function for when you want to construct a chain of objects with individual arguments for each one.  Can
    be easier to read than a list expansion.

    :param element_constructor: A function of the form object = fcn(**kwargs)
    :param kwarg_lists: A dict of lists, where the index identifies two which element its corresponding value will go.
    :return: A list of objects.

    e.g. Initializing a chain of layers:
        layer_sizes = [784, 240, 240, 10]
        layers = kwarg_map(
            Layer,
            n_in = layer_sizes[:-1],
            n_out = layer_sizes[1:],
            activation = [''tanh'', ''tanh'', ''softmax''],
            )

    is equivalent to:
        layers = [Layer(n_in=784, n_out=240, activation=''tanh''), Layer(n_in=240, n_out=240, activation=''tanh''), Layer(n_in=240, n_out=10, activation=''softmax'')]
    """
    all_lens = [len(v) for v in kwarg_lists.values()]
    assert len(kwarg_lists)>0, "You need to specify at least list of arguments (otherwise you don''t need this function)"
    n_elements = all_lens[0]
    assert all(n_elements == le for le in all_lens), ''Inconsistent lengths: %s'' % (all_lens, )
    return [element_constructor(**{k: v[i] for k, v in kwarg_lists.iteritems()}) for i in xrange(n_elements)]

Answer 4

Solo debe recordar que el mapa pasará los argumentos a la función como una tupla en lugar de argumentos separados. Si no puede cambiar su función original, puede llamarlo con una función auxiliar:

def f(tup):
    args, kwargs = tup
    function(args, **kwargs)

map(f, arguments)