* args and * * kwargs? [duplicar]

Un lugar donde el uso de *args y **kwargs es bastante útil es para la subclase.

class Foo(object):
    def __init__(self, value1, value2):
        # do something with the values
        print value1, value2

class MyFoo(Foo):
    def __init__(self, *args, **kwargs):
        # do something else, don't care about the args
        print 'myfoo'
        super(MyFoo, self).__init__(*args, **kwargs)

De esta manera puede extender el comportamiento de la clase Foo, sin tener que saber demasiado sobre Foo. Esto puede ser muy conveniente si está programando una API que podría cambiar. MyFoo simplemente pasa todos los argumentos a la clase Foo.

Aquí hay un ejemplo que utiliza 3 tipos diferentes de parámetros.

def func(required_arg, *args, **kwargs):
    # required_arg is a positional-only parameter.
    print required_arg

    # args is a tuple of positional arguments,
    # because the parameter name has * prepended.
    if args: # If args is not empty.
        print args

    # kwargs is a dictionary of keyword arguments,
    # because the parameter name has ** prepended.
    if kwargs: # If kwargs is not empty.
        print kwargs

>>> func()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: func() takes at least 1 argument (0 given)

>>> func("required argument")
required argument

>>> func("required argument", 1, 2, '3')
required argument
(1, 2, '3')

>>> func("required argument", 1, 2, '3', keyword1=4, keyword2="foo")
required argument
(1, 2, '3')
{'keyword2': 'foo', 'keyword1': 4}

Aquí está uno de mis lugares favoritos para usar la sintaxis ** como en el ejemplo final de Dave Webb:

mynum = 1000
mystr = 'Hello World!'
print "{mystr} New-style formatting is {mynum}x more fun!".format(**locals())

No estoy seguro de si es terriblemente rápido en comparación con solo usar los nombres en sí, pero es mucho más fácil de escribir!

Un caso en el que *args y **kwargs son útiles es cuando se escriben funciones de envoltura (como decoradores) que necesitan ser capaces de aceptar argumentos arbitrarios para pasar a través de la función que se envuelve. Por ejemplo, un decorador simple que imprime los argumentos y el valor de retorno de la función que se envuelve:

def mydecorator( f ):
   @functools.wraps( f )
   def wrapper( *args, **kwargs ):
      print "Calling f", args, kwargs
      v = f( *args, **kwargs )
      print "f returned", v
      return v
   return wrapper

* args y * * kwargs son características especiales de Python. Piense en una función que podría tener un número desconocido de argumentos. Por ejemplo, por cualquier razón, desea tener una función que suma un número desconocido de números (y no desea usar la función suma incorporada). Así que escribe esta función:

def sumFunction(*args):
  result = 0
  for x in args:
    result += x
  return result

Y úsalo como: sumFunction (3,4,6,3,6,8,9).

**kwargs tiene una función diffrent. Con * * kwargs puede dar argumentos arbitrarios de palabras clave a una función y usted puede acceder a ellos como un dictonary.

def someFunction(**kwargs):
  if 'text' in kwargs:
    print kwargs['text']

Llamando a someFunction(text="foo") imprimirá foo.

Imagínese que tiene una función pero no quiere restringir el número de parámetros que toma. Ejemplo:

>>> import operator
>>> def multiply(*args):
...  return reduce(operator.mul, args)

Luego usa esta función como:

>>> multiply(1,2,3)
6

or

>>> numbers = [1,2,3]
>>> multiply(*numbers)
6

Los nombres *args y **kwargs o **kw son puramente por convención. Hace que sea más fácil para nosotros leer el código del otro

Un lugar que es útil es cuando se utiliza el módulo struct

struct.unpack() devuelve una tupla mientras que struct.pack() utiliza un número variable de argumentos. Al manipular datos es conveniente poder pasar una tupla a struck.pack() por ejemplo.

tuple_of_data = struct.unpack(format_str, data)
... manipulate the data
new_data = struct.pack(format_str, *tuple_of_data)

Sin esta habilidad te verías obligado a escribir

new_data = struct.pack(format_str, tuple_of_data[0], tuple_of_data[1], tuple_of_data[2],...)

Que también significa el si el format_str cambia y el tamaño de la tupla cambia, tendré que volver atrás y editar esa línea realmente larga

Tenga en cuenta que *args/**kwargs es parte de la sintaxis de llamada a funciones, y no es realmente un operador. Esto tiene un efecto secundario particular con el que me encontré, que es que no puede usar la expansión *args con la instrucción print, ya que print no es una función.

Esto parece razonable:

def myprint(*args):
    print *args

Desafortunadamente no compila (error de sintaxis).

Esto compila:

def myprint(*args):
    print args

Pero imprime los argumentos como una tupla, que no es lo que queremos.

Esta es la solución que resolví on:

def myprint(*args):
    for arg in args:
        print arg,
    print

Estos parámetros se usan típicamente para funciones proxy, por lo que el proxy puede pasar cualquier parámetro de entrada a la función de destino.

def foo(bar=2, baz=5):
    print bar, baz

def proxy(x, *args, **kwargs): # reqire parameter x and accept any number of additional arguments
    print x
    foo(*args, **kwargs) # applies the "non-x" parameter to foo

proxy(23, 5, baz='foo') # calls foo with bar=5 and baz=foo
proxy(6)# calls foo with its default arguments
proxy(7, bar='asdas') # calls foo with bar='asdas' and leave baz default argument

Pero dado que estos parámetros ocultan los nombres de los parámetros reales, es mejor evitarlos.

Puedes echar un vistazo a los documentos de python (docs.python.org en las FAQ), pero más específicamente para una buena explicación la misteriosa señorita args y el señor kwargs (cortesía de archive.org) (el enlace original muerto es aquí ).

En pocas palabras, ambos se utilizan cuando se utilizan parámetros opcionales para una función o método. Como dice Dave, * args se usa cuando no sabe cuántos argumentos se pueden pasar, y * * kwargs cuando desea manejar parámetros especificados por nombre y valor como en:

myfunction(myarg=1)