Introducción
Python es uno de los lenguajes de programación más populares en todo el mundo. En Python, los parámetros son parte de las definiciones de funciones. Le permiten especificar ciertos argumentos para una función. El argumento puede ser aceptado y aplicado por la función.
Sin embargo, no es posible que sepa en el momento de la codificación qué casos de uso exactos se pueden implementar con su código. Por lo tanto, por el bien de los futuros programadores y usuarios de su programa, es aconsejable pasar un número variable de argumentos a una función. Para hacer esto, debe usar parámetros especiales. Estos son *args y **kwargs. En este tutorial, aprenderemos todo sobre los parámetros *args y **kwargs en Python. También aprenderemos cómo ordenar argumentos y cómo aplicarlos en llamadas a funciones.
Requisitos previos
Para poder seguir los pasos del tutorial, hay algunos requisitos previos que debe preparar. Primero, debe tener Python 3 instalado en su servidor con un entorno de programación en funcionamiento. También debe tener instalado el programa para su sistema operativo particular (Ubuntu, CentOS, Debian, etc.).
¿Qué es *args y cómo funciona?
Comencemos por entender cómo *args funciona. La versión de un solo asterisco del parámetro se utiliza para enviar listas de argumentos de longitud variable sin palabras clave a las funciones. Tenga en cuenta que el asterisco es el elemento más crítico en ese parámetro.
Para entenderlo mejor, consideremos un ejemplo. A continuación se muestra una función típica que puede encontrar en su código, utilizando dos argumentos:
|
1 2 |
def multiply(x, y): print (x * y) |
Como puede ver, nuestros argumentos en la función anterior son x y y. Al llamar a la función, utilizará números correspondientes a x y y. Digamos que estamos pasando los enteros 5 y 4 para x y y respectivamente:
|
1 2 3 4 |
def multiply(x, y): print (x * y) multiply(5, 4) |
Ahora podemos ejecutar el código:
|
1 |
python lets_multiply.py |
La salida que recibiremos será la siguiente:
|
1 2 3 |
Salida: 20 |
La salida muestra que los enteros 5 y 4 se han multiplicado. Esto significa que la función multiply(x, y) funcionó.
Ahora, supongamos que eventualmente queremos multiplicar tres números en lugar de solo dos. Desafortunadamente, agregar un número adicional a la función anterior le dará un error como este:
|
1 2 3 4 |
def multiply(x, y): print (x * y) multiply(5, 4, 3) |
|
1 2 3 |
Salida: TypeError: multiply() takes 2 positional arguments but 3 were given |
Por lo tanto, si tiene alguna idea de que podría necesitar agregar más argumentos más adelante, aplique el parámetro *args para su conveniencia. Puede usarlo así:
|
1 2 3 4 5 6 7 8 9 10 |
def multiply(*args): z = 1 for num in args: z *= num print(z) multiply(4, 5) multiply(10, 9) multiply(2, 3, 4) multiply(3, 5, 10, 6) |
Simplemente reemplazamos los parámetros de función x y y con *args. Ejecutar este código le dará el producto para cada llamada a la función de esta manera:
|
1 2 3 4 5 6 |
Salida: 20 90 24 900 |
Por lo tanto, *args es ideal para usar cuando desea enviar listas de argumentos de longitud variable a su función. Debido a su capacidad, puede pasar tantos argumentos como desee a las llamadas de función. Como tal, este parámetro le permite construir un código más flexible que puede aceptar una buena cantidad de argumentos variables sin palabras clave en la función.
¿Qué es **kwargs y cómo funciona?
A continuación, tenemos la versión de doble asterisco de los parámetros que es **kwargs. A diferencia de la forma anterior, este parámetro le permite pasar diccionarios de argumentos de longitud variable con palabras clave a la función. Al igual que *args, los asteriscos dobles son el elemento más crítico del parámetro.
Al igual que hicimos en la sección anterior, puedes añadir tantos argumentos como quieras. La diferencia es que debes asignar palabras clave. Para entenderlo mejor, considera el siguiente ejemplo. Aquí, comenzaremos imprimiendo los **kwargs argumentos que queremos pasar a la función:
|
1 2 |
def print_kwargs(**kwargs): print(kwargs) |
Ahora, llamemos a la función. Como puedes ver, añadimos argumentos de palabra clave:
|
1 2 3 4 |
def print_kwargs(**kwargs): print(kwargs) print_kwargs(kwargs_1="Shark", kwargs_2=4.5, kwargs_3=True) |
Ejecutar el programa en este punto te mostrará esta salida:
|
1 |
python print_kwargs.py |
|
1 2 3 |
Salida: {'kwargs_3': True, 'kwargs_2': 4.5, 'kwargs_1': 'Shark'} |
Sin embargo, existe la posibilidad de que tu tipo de datos de diccionario esté desordenado. Esto depende en gran medida de la versión de Python 3 que utilices. Por ejemplo, cualquier versión posterior a Python 3.6 te devuelve los pares clave-valor en orden. Cualquier versión anterior mostrará la salida en orden aleatorio. El diccionario que crees se llamará kwargs. Ten en cuenta que puedes usarlo y manipularlo como cualquier otro diccionario en el sistema. Veamos cómo puedes dar al parámetro **kwargs un mayor uso y aplicación.
En el siguiente ejemplo, intentaremos crear una nueva función que saludará a un diccionario con nombres. Nuestro diccionario de muestra tendrá dos nombres:
|
1 2 3 4 5 |
def print_values(**kwargs): for key, value in kwargs.items(): print("El valor de {} es {}".format(key, value)) print_values(my_name="Sammy", your_name="Casey") |
Ejecutar el programa te dará esta salida:
|
1 |
python print_values.py |
|
1 2 3 4 |
Salida: El valor de your_name es Casey El valor de my_name es Sammy |
De manera similar al ejemplo anterior, los diccionarios pueden parecer desordenados. Como tal, el orden de los nombres Casey y Sammy puede invertirse en algunos casos.
A continuación, pasaremos argumentos adicionales a la función. Esto demostrará que puedes hacer que **kwargs acepte cualquier cantidad de argumentos que desees:
|
1 2 3 4 5 6 7 8 9 10 11 |
def print_values(**kwargs): for key, value in kwargs.items(): print("El valor de {} es {}".format(key, value)) print_values( name_1="Alex", name_2="Gray", name_3="Harper", name_4="Phoenix", name_5="Remy", name_6="Val") |
Ejecutar el programa te mostrará esta salida:
|
1 2 3 4 5 6 7 8 |
Salida: El valor de name_2 es Gray El valor de name_6 es Val El valor de name_4 es Phoenix El valor de name_5 es Remy El valor de name_3 es Harper El valor de name_1 es Alex |
Esta salida también puede estar desordenada. Independientemente de ello, estos ejemplos muestran que **kwargs le da a tu programa la flexibilidad de usar una cantidad de argumentos de palabra clave.
Cómo ordenar argumentos
Es importante tener en cuenta el orden establecido al ordenar un argumento en una función o llamada a función. Es el siguiente:
-
Argumentos posicionales formales
-
*args
-
Argumentos de palabra clave
-
**kwargs
Digamos que estás usando *args y **kwargs con parámetros posicionales explícitos. Esto significa que tu función se verá así:
|
1 2 |
def example(arg_1, arg_2, *args, **kwargs): ... |
Por otro lado, usar estos parámetros con parámetros de palabras clave con nombre le dará a su función la siguiente estructura general:
|
1 2 |
def example2(arg_1, arg_2, *args, kw_1="shark", kw_2="blobfish", **kwargs): ... |
No cumplir con el orden establecido le dará un error de sintaxis al ejecutar su código. Por lo tanto, es mejor evitar cometer el error en primer lugar.
Cómo usar *args y **kwargs en llamadas a funciones
Por último, le mostraremos cómo usar ambos parámetros para pasar argumentos a las funciones. Comenzaremos con un ejemplo que muestra *args:
|
1 2 3 4 5 6 7 8 |
def some_args(arg_1, arg_2, arg_3): print("arg_1:", arg_1) print("arg_2:", arg_2) print("arg_3:", arg_3) args = ("Sammy", "Casey", "Alex") some_args(*args) |
Hay tres parámetros en esta función: arg_1, arg_2, y arg_3. Debe crear una variable y establecerla en un iterable. En este caso, será una tupla. Luego, puede pasar la variable a la función usando la sintaxis del asterisco.
Observe la salida cuando ejecute el programa usando el python some_args.py comando:
|
1 2 3 4 5 |
Salida: arg_1: Sammy arg_2: Casey arg_3: Alex |
También es posible cambiar el programa a un tipo de datos de lista iterable tipo de datos con un nombre de variable diferente. El siguiente código combina *args con un parámetro con nombre:
|
1 2 3 4 5 6 7 8 |
def some_args(arg_1, arg_2, arg_3): print("arg_1:", arg_1) print("arg_2:", arg_2) print("arg_3:", arg_3) my_list = [2, 3] some_args(1, *my_list) |
La salida será la siguiente al ejecutar el programa:
|
1 2 3 4 5 |
Salida: arg_1: 1 arg_2: 2 arg_3: 3 |
Por otro lado, puede aplicar argumentos de palabras clave con **kwargs. Asegúrese de crear una variable que sea igual a un diccionario. Debe tener 2 pares clave-valor. Así es como pasaremos la variable a una función con 3 argumentos:
|
1 2 3 4 5 6 7 8 |
def some_kwargs(kwarg_1, kwarg_2, kwarg_3): print("kwarg_1:", kwarg_1) print("kwarg_2:", kwarg_2) print("kwarg_3:", kwarg_3) kwargs = {"kwarg_1": "Val", "kwarg_2": "Harper", "kwarg_3": "Remy"} some_kwargs(**kwargs) |
Use el python some_kwargs.py comando una vez más para ejecutar el programa:
|
1 2 3 4 5 |
Salida: kwarg_1: Val kwarg_2: Harper kwarg_3: Remy |
Conclusión
Al final de este tutorial, debería estar bien versado en qué son *args y **kwargs y cómo funcionan. Ahora puede aplicar estos parámetros a su propio código para hacer que su programa sea flexible para futuros usuarios. Son ideales para situaciones en las que no sabe cuántos argumentos se pueden usar. Solo asegúrese de tener cuidado con los elementos críticos de las funciones y parámetros.
Finalmente, aquí hay más recursos de nuestro blog que le ayudarán a trabajar con éxito con Python:
- El formato de archivo txt: trabajar con archivos de texto plano en Python 3
- Bucles en Python 3: uso de las instrucciones Break, Continue y Pass
- Importación de módulos en Python 3: una guía completa
- Uso de formateadores de cadenas en Python 3
- Programación con Python 3: ¿Cómo proceder para construir clases y definir objetos?
¡Feliz programación!
Comentarios
Aún no hay comentarios. Sea el primero.