() translation by (you can also view the original English article)
En este tutorial, me centraré en argumentos (*args
) y argumentos de palabra clave (*kwargs
) en Python.
Te enseñaré qué son args y kwargs y, lo que es más importante, cómo usarlos — es decir, cómo incorporar un número ilimitado de argumentos y argumentos de palabra clave en funciones.
¿Qué son los Args?
*args
se utilizan para pasar argumentos que no son de palabra clave. Algunos ejemplos de argumentos que no son de palabra clave son fun(3,4), fun("foo", "bar")
.
*args
se utilizan normalmente como medida para evitar que el programa falle si no sabemos cuántos argumentos se pasarán a la función. Esto se usa en C++ así como en otros lenguajes de programación.
¿Qué son los Kwargs?
**kwargs
es un diccionario de argumentos de palabra clave. **
nos permite pasar cualquier número de argumentos de palabra clave. Un argumento de palabra clave es básicamente un diccionario.
Un ejemplo de un argumento de palabra clave es fun(foo=2, bar=7)
.
**kwargs
son como *args
excepto que declaras las variables y la cantidad dentro de los argumentos de la función.
Dónde usar Args y Kwargs
Args y kwargs son útiles cuando quieres:
- Reducir la reescritura de código.
- Hacer que tu código sea legible.
- Reutilizar tu código
Uso de Args y Kwargs en funciones
Veamos cómo se usan kwargs y args en las funciones.
Args
La siguiente función tiene tres argumentos. Los tres argumentos se han definido explícitamente, por lo que más o menos provocará un error en el programa.
1 |
def add(a, b,c): |
2 |
print(a+b+c) |
3 |
|
4 |
print add(2,3,4) |
5 |
Ejecutemos la función. La función agregará los tres números, dando el siguiente resultado:
1 |
Output |
2 |
|
3 |
9 |
¿Qué pasaría si tuviéramos que pasar cuatro argumentos en la función en lugar de los tres requeridos? Recibiremos un error como se muestra a continuación.
Esto se debe a que solo se definieron tres parámetros en la función, pero hemos pasado cuatro argumentos posicionales al llamar a la función.
1 |
def add(a, b,c): |
2 |
print(a+b+c) |
3 |
|
4 |
print add(2,3,4,5) |
5 |
|
6 |
|
7 |
|
8 |
1 |
Output |
2 |
TypeError: add() takes 3 positional arguments but 4 were given |
3 |
En el segundo ejemplo a continuación, el *
es para argumentos que no son de palabra clave y se pasa a la función. En lugar de tener argumentos definidos, reemplazamos a
, b
y c
con un solo parámetro (*args
).
Observa cómo el uso de *args
facilita el uso de cualquier número de argumentos sin tener que cambiar tu código. *args
proporcionan más flexibilidad a tu código ya que puede tener tantos argumentos como desees en el futuro.
1 |
def add(*args): |
2 |
total = 0 |
3 |
for arg in args: |
4 |
total+=arg |
5 |
print total |
6 |
1 |
Scenario 1 |
2 |
print add(1,2,5) |
3 |
|
4 |
Output |
5 |
8 |
6 |
1 |
Scenario 2 |
2 |
print add(1,2,5,6) |
3 |
|
4 |
output |
5 |
14 |
6 |
1 |
Scenario 3 |
2 |
print add(1,2,5,8) |
3 |
|
4 |
Output |
5 |
16 |
Más ejemplos
Crea una función simple como se muestra:
1 |
def func(*args): |
2 |
# *args means for however many arguments you take in, it will catch them all
|
3 |
|
4 |
for arg in args: |
5 |
print arg |
6 |
Prueba la función usando una combinación de números enteros y cadenas:
1 |
def func(*args): |
2 |
# *args means for however many arguments you take in, it will catch them all
|
3 |
|
4 |
for arg in args: |
5 |
print arg |
6 |
|
7 |
print func(11,3,4,5,"tuts") |
1 |
Output |
2 |
|
3 |
11 |
4 |
3 |
5 |
4 |
6 |
5 |
7 |
tuts |
¿Y si tuviéramos que pasar una lista como argumento? Prueba la función con una lista reemplazando los argumentos anteriores con una lista, l = [11,3,4,5, "tuts"]
.
1 |
def func(*args): |
2 |
# *args means for however many arguments you take in, it will catch them all
|
3 |
|
4 |
for arg in args: |
5 |
print arg |
6 |
|
7 |
|
8 |
l = [11,3,4,5,"tuts"] |
9 |
|
10 |
print func(l) |
1 |
This prints the list as a whole, |
2 |
This is because its interpreting the list as one item. |
3 |
|
4 |
Output |
5 |
|
6 |
[11,3,4,5,"tuts] |
En el ejemplo anterior, también puedes usar *args
para desempaquetar argumentos que ya están en una lista o una tupla para que todos los elementos de la lista se pasen como parámetros diferentes.
Usando la misma función:
1 |
def func(*args): |
2 |
# *args means for however many arguments you take in, it will catch them all
|
3 |
|
4 |
for arg in args: |
5 |
print(arg) |
6 |
|
7 |
l = [11,3,4,5,"tuts"] |
8 |
|
9 |
print(func(*l)) |
1 |
The * will unpack the list and output each individual list item. |
2 |
|
3 |
|
4 |
Output |
5 |
11 |
6 |
3 |
7 |
4 |
8 |
5 |
9 |
tuts |
Kwargs
kwargs te permiten pasar argumentos de palabra clave a una función. Se utilizan cuando no estás seguro del número de argumentos de palabra clave que se pasarán en la función.
Escribe una función my_func
y pasa (x= 10, y =20)
como argumentos de palabra clave como se muestra a continuación:
1 |
def my_func(x=10,y=20): |
2 |
print x,y |
1 |
This prints out the values of x and y |
2 |
|
3 |
Output
|
4 |
|
5 |
10,20 |
Kwargs se puede utilizar para desempaquetar pares de diccionario clave, valor. Esto se hace usando la notación de doble asterisco (**
). Es importante tener en cuenta que cada clave debe coincidir con un valor.
Este es un ejemplo típico de cómo se hace. La siguiente función toma países como claves y sus capitales como valores. Luego imprime una sentencia que itera sobre los kwargs e indica a cada palabra clave el valor que se le asigna.
1 |
def capital_cities(**kwargs): |
2 |
# initialize an empty list to store the result
|
3 |
result = [] |
4 |
for key, value in kwargs.items(): |
5 |
result.append("The capital city of {} is {} .format (key,value) |
6 |
|
7 |
return result
|
Puedes llamar a la función con los argumentos que quieras.
1 |
def capital_cities(**kwargs): |
2 |
# initialize an empty list to store the result
|
3 |
result = [] |
4 |
for key, value in kwargs.items(): |
5 |
result.append("The capital city of {} is {} .format (key,value) |
6 |
|
7 |
return result
|
8 |
print capital_city(China = "Beijing",Cairo = "Egypt",Rome = "Italy")) |
1 |
output |
2 |
|
3 |
['The capital city of China is Beijing', 'The capital city of Cairo is Egypt','The capital city of Rome is Italy'] |
4 |
Para un ejemplo más complejo, supón que tenemos un modelo para un cliente que se parece a esto:
1 |
class Customer( models.Model ): |
2 |
first_name = models.CharField(max_length = 100, null = True) |
3 |
last_name = models.CharField(max_length = 100) |
4 |
username =models.Charfield(max_length =100) |
5 |
email = models.EmailField(max_length = 100) |
6 |
password = models.CharField(max_length =100) |
Puedes utilizar kwargs para realizar tanto entradas de datos como consultas de datos desde objetos de modelo. Escribamos una vista de función para crear un nuevo cliente.
1 |
kwargs = {"first_name":"John","last_name":"Doe", |
2 |
"username': "johndoe","email"johndoe@gmail.com", |
3 |
"password":"1234"} |
4 |
|
5 |
new_user = User(**kwargs) |
6 |
new_user.save() |
A continuación se explica cómo realizar una consulta del cliente que acabamos de crear utilizando kwargs.
1 |
filter_customer = { |
2 |
'email':johndoe@gmail.com, |
3 |
'username': johndoe, |
4 |
}
|
5 |
|
6 |
Customer.objects.filter(**filter_customer) |
Usando Args y Kwargs en una función
Cuando se utilizan args y kwargs en la misma definición de función, *args
debe aparecer antes de **kwargs
.
1 |
class MyFunction(Foo): |
2 |
|
3 |
def __init__(self, *args, **kwargs): |
4 |
|
5 |
|
6 |
print 'my function' |
7 |
|
8 |
super(MyFunction, self).__init__(*args, **kwargs) |
Ejemplo:
1 |
def Func(*args,**kwargs): |
2 |
|
3 |
for arg in args: |
4 |
print arg |
5 |
for item in kwargs.items(): |
6 |
print item |
Recuerda que args
debe ir antes que kwargs
.
1 |
def Func(*args,**kwargs): |
2 |
|
3 |
for arg in args: |
4 |
print arg |
5 |
for item in kwargs.items(): |
6 |
print item |
7 |
|
8 |
print Func(1,x=7,u=8) |
1 |
Output |
2 |
|
3 |
1 |
4 |
('x', 7) |
5 |
('u', 8) |
Conclusión
Espero que este tutorial te haya ayudado a comprender args y kwargs.
A continuación se muestran algunos consejos para recordar al usar args y kwargs:
-
*args
y**kwargs
son sintaxis especiales que se utilizan en funciones para pasar un número variable de argumentos a una función. -
*args
ocurre antes que**kwargs
en una definición de función. -
*args
y**kwargs
se utilizan mejor en situaciones en las que el número de entradas seguirá siendo relativamente pequeño. - Puedes utilizar el nombre que quieras;
args
ykwargs
son solo por convención y no un requisito. Por ejemplo, puedes usar*foo
en lugar de*args
o**foo
en lugar de**kwargs
.
La documentación oficial de Python ofrece mucha información para mayor estudio. Además, no dudes en ver lo que tenemos disponible para la venta y para estudiar en el marketplace, y no dudes en hacer cualquier pregunta y brindar tu valiosa retroalimentación utilizando los comentarios abajo.