lenguaje - ¿Qué significa asterisco*en Python?
python tutorial (5)
Esta pregunta ya tiene una respuesta aquí:
¿Tiene * un significado especial en Python como lo tiene en C? Vi una función como esta en el libro de cocina de Python:
def get(self, *a, **kw)
¿Podría explicármelo o señalarme dónde puedo encontrar una respuesta? (Google interpreta el * como carácter comodín y, por lo tanto, no puedo encontrar una respuesta satisfactoria).
Muchas gracias.
Encuentro * útil cuando escribo una función que toma otra función de devolución de llamada como un parámetro:
def some_function(parm1, parm2, callback, *callback_args):
a = 1
b = 2
...
callback(a, b, *callback_args)
...
De esa manera, las personas que llaman pueden pasar parámetros extra arbitrarios que pasarán a su función de devolución de llamada. Lo bueno es que la función de devolución de llamada puede utilizar parámetros de función normales. Es decir, no necesita usar la * sintaxis en absoluto. Aquí hay un ejemplo:
def my_callback_function(a, b, x, y, z):
...
x = 5
y = 6
z = 7
some_function(''parm1'', ''parm2'', my_callback_function, x, y, z)
Por supuesto, los cierres ofrecen otra forma de hacer lo mismo sin requerir que pases x, y, yz a través de some_function () y en my_callback_function ()
Solo tengo una cosa para agregar que no estaba clara de las otras respuestas (por el bien de la integridad).
También puedes usar las estrellas al llamar a la función. Por ejemplo, digamos que tienes un código como este:
>>> def foo(*args):
... print(args)
...
>>> l = [1,2,3,4,5]
Puede pasar la lista l en foo como así ...
>>> foo(*l)
(1, 2, 3, 4, 5)
Puedes hacer lo mismo para los diccionarios ...
>>> def foo(**argd):
... print(argd)
...
>>> d = {''a'' : ''b'', ''c'' : ''d''}
>>> foo(**d)
{''a'': ''b'', ''c'': ''d''}
Todas las respuestas anteriores fueron perfectamente claras y completas, pero solo para el registro me gustaría confirmar que el significado de * y ** en python no tiene ninguna similitud con el significado de operadores de aspecto similar en C.
Se denominan operadores de desempaquetado de argumentos y desempaquetado de argumentos de palabras clave.
Una sola estrella significa que la variable ''a'' será una tupla de parámetros adicionales que se suministraron a la función. La estrella doble significa que la variable ''kw'' será un diccionario de tamaño variable de parámetros adicionales que se suministraron con palabras clave.
Aunque el comportamiento real está especificado, a veces puede ser muy poco intuitivo. Escribir algunas funciones de muestra y llamarlas con varios estilos de parámetros puede ayudarlo a comprender qué se permite y cuáles son los resultados.
def f0(a)
def f1(*a)
def f2(**a)
def f3(*a, **b)
etc...
Ver Definiciones de Funciones en la Referencia de Lenguaje.
Si el
*identifier
forma*identifier
está presente, se inicializa a una tupla que recibe cualquier exceso de parámetros posicionales, de forma predeterminada a la tupla vacía. Si el**identifier
formulario**identifier
está presente, se inicializa a un nuevo diccionario que recibe cualquier exceso de argumentos de palabras clave, de manera predeterminada a un nuevo diccionario vacío.
También, vea Llamadas de función .
Suponiendo que uno sabe qué son los argumentos posicionales y de palabras clave, aquí hay algunos ejemplos:
Ejemplo 1:
# Excess keyword argument (python 2) example:
def foo(a, b, c, **args):
print "a = %s" % (a,)
print "b = %s" % (b,)
print "c = %s" % (c,)
print args
foo(a="testa", d="excess", c="testc", b="testb", k="another_excess")
Como puede ver en el ejemplo anterior, solo tenemos los parámetros a, b, c
en la firma de la función foo
. Como d
y k
no están presentes, se colocan en el diccionario args. La salida del programa es:
a = testa
b = testb
c = testc
{''k'': ''another_excess'', ''d'': ''excess''}
Ejemplo 2:
# Excess positional argument (python 2) example:
def foo(a, b, c, *args):
print "a = %s" % (a,)
print "b = %s" % (b,)
print "c = %s" % (c,)
print args
foo("testa", "testb", "testc", "excess", "another_excess")
Aquí, ya que estamos probando argumentos posicionales, los excesos deben estar en el final, y *args
empaqueta en una tupla, por lo que la salida de este programa es:
a = testa
b = testb
c = testc
(''excess'', ''another_excess'')
También puede descomprimir un diccionario o una tupla en los argumentos de una función:
def foo(a,b,c,**args):
print "a=%s" % (a,)
print "b=%s" % (b,)
print "c=%s" % (c,)
print "args=%s" % (args,)
argdict = dict(a="testa", b="testb", c="testc", excessarg="string")
foo(**argdict)
Huellas dactilares:
a=testa
b=testb
c=testc
args={''excessarg'': ''string''}
Y
def foo(a,b,c,*args):
print "a=%s" % (a,)
print "b=%s" % (b,)
print "c=%s" % (c,)
print "args=%s" % (args,)
argtuple = ("testa","testb","testc","excess")
foo(*argtuple)
Huellas dactilares:
a=testa
b=testb
c=testc
args=(''excess'',)