Python es un lenguaje de programación poderoso que permite a los desarrolladores crear una variedad de aplicaciones, desde scripts básicos hasta sistemas de software grandes. Una de las tareas de programación más comunes es crear interfaces de línea de comandos (CLIs), que permiten a los usuarios interactuar con programas a través de una terminal o línea de comandos. Las CLIs son esenciales para la creación de scripts, la automatización y en casos donde una interfaz gráfica de usuario es poco práctica.
Manejar los parámetros de la línea de comandos es una parte importante del diseño de CLIs. Estos argumentos permiten a los usuarios influir en el comportamiento de un programa al proporcionar parámetros de entrada mientras se ejecuta. Sin la capacidad de evaluar estos factores, los programas serían menos versátiles y más difíciles de ajustar para tareas específicas.
Python proporciona varios módulos para analizar argumentos de línea de comandos, pero el módulo argparse se destaca por su simplicidad y exhaustividad. El módulo argparse facilita el desarrollo de interfaces funcionales de línea de comandos. Maneja automáticamente el análisis de parámetros, muestra instrucciones útiles y proporciona errores cuando los usuarios proporcionan información incorrecta.
En este tutorial, veremos cómo utilizar el paquete Python argparse. Comenzaremos con una visión general de las interfaces de línea de comandos en Python y la importancia de analizar la entrada de la línea de comandos. Luego discutiremos el módulo argparse y sus beneficios.
Visión general de las Interfaces de Línea de Comandos en Python
Las interfaces de línea de comandos son programas que funcionan exclusivamente con comandos basados en texto. Los usuarios ingresan comandos en un terminal o línea de comandos, que típicamente incluyen argumentos y opciones que modifican el comportamiento del programa. Las CLIs son útiles porque se pueden automatizar e integrar fácilmente con otras tecnologías.
En Python, se crea una CLI desarrollando un script que acepta entradas de línea de comandos. Esta entrada generalmente se presenta como una lista de argumentos a los que el script puede acceder e interpretar. Para programas básicos, manejar manualmente estos argumentos a través de la lista sys.argv puede ser suficiente. Sin embargo, cuando la complejidad del programa aumenta, procesar los argumentos manualmente se vuelve ineficiente y propenso a errores.
Importancia del Análisis de Argumentos de Línea de Comandos
El análisis de argumentos de línea de comandos es necesario por numerosas razones:
- Flexibilidad: Al tomar parámetros, un programa puede realizar múltiples tareas o actuar sobre diferentes conjuntos de datos sin cambiar el código. Los usuarios pueden especificar archivos para procesar, configurar ajustes y seleccionar modos de operación.
- Facilidad de uso: Un análisis adecuado de argumentos permite al programa mostrar mensajes útiles, instruir al usuario sobre cómo usar el programa y manejar errores de manera adecuada.
- Mantenibilidad: El uso de un módulo de análisis dedicado, como argparse, hace que tu código sea más claro y fácil de mantener. Separa la lógica utilizada para analizar los argumentos de la operación principal del programa.
Introducción al Módulo argparse y sus Beneficios
El módulo argparse es parte de la biblioteca estándar de Python. Por lo tanto, se puede utilizar sin instalar paquetes adicionales. Ofrece una interfaz sencilla y consistente para analizar las entradas de línea de comandos. Algunas de las ventajas de utilizar argparse son:
- Generación automática de ayuda: Genera mensajes de ayuda y uso basados en los argumentos del código.
- Manejo de errores: Muestra mensajes de error útiles cuando los usuarios ingresan argumentos no válidos.
- Conversión de tipos: Puede convertir automáticamente cadenas de parámetros al tipo de datos adecuado.
- Soporta tanto argumentos posicionales necesarios como argumentos opcionales con simplicidad.
- Valores predeterminados: Te permite proporcionar valores predeterminados para parámetros que el usuario no suministra.
argparse permite a los desarrolladores centrarse en la funcionalidad principal de su programa mientras dependen de una base sólida para gestionar la entrada por línea de comandos.
Configuración de argparse y uso básico
Ahora que hemos cubierto la importancia de analizar argumentos de línea de comandos y las ventajas de usar argparse, veamos cómo configurarlo y usarlo en un script de Python.
Instalación e importación de argparse
No es necesario instalar nada por separado porque argparse es parte de la biblioteca estándar de Python. Puedes importarlo al principio de tu script.
import argparse
Esta línea carga el módulo argparse en tu script, lo que te permite utilizar su funcionalidad para analizar argumentos de línea de comandos.
Creación de un sencillo analizador de argumentos
El primer paso para utilizar argparse es generar un objeto analizador. Este objeto almacenará información sobre los argumentos que acepta tu programa y analizará la entrada por línea de comandos.
parser = argparse.ArgumentParser(description='Process some integers.')
En este ejemplo, creamos un objeto ArgumentParser() y describimos el programa. Cuando el usuario selecciona la opción de ayuda (-h o --help), esta descripción se mostrará.
Añadiendo argumentos posicionales y opcionales
Ahora que hemos desarrollado el analizador, podemos especificar los argumentos que aceptará nuestro programa.
Añadiendo argumentos posicionales
Los argumentos posicionales son esenciales y deben presentarse en un orden preciso. Por ejemplo, considera un script que suma dos números. Podemos definir dos argumentos posicionales para los números:
parser.add_argument('num1', type=int, help='The first number to add.') parser.add_argument('num2', type=int, help='The second number to add.')
En este código, num1 y num2 se refieren a los parámetros posicionales.
type=int indica que los parámetros deben convertirse a enteros. El argumento de ayuda especifica una descripción que aparecerá en el mensaje de ayuda.
Agregando argumentos opcionales
Los argumentos opcionales no son necesarios y suelen proporcionar opciones adicionales o cambiar el comportamiento del programa. Por lo general, van precedidos de uno o dos guiones. Agregaremos un argumento opcional para habilitar la salida detallada:
parser.add_argument('-v', '--verbose', action='store_true', help='Increase output verbosity.')
Aquí:
- La opción corta es
-v(por ejemplo,-v).--verbosees una opción larga. action='store_true'indica que si se selecciona la opción, el atributo verbose se establecerá enTrue; de lo contrario, seráFalse.- El argumento
helpespecifica una descripción para el mensaje de ayuda.
Analizando argumentos y accediendo a sus valores
Después de especificar todos los argumentos, necesitamos analizar la entrada de la línea de comandos. Usa el método .parse_args() para lograr esto.
args = parser.parse_args()
Los parámetros analizados ahora se almacenan en la variable args como atributos. Podemos acceder a ellos usando notación de punto.
result = args.num1 + args.num2 print('The sum of {} and {} is {}'.format(args.num1, args.num2, result)) if args.verbose: print('Verbose mode is enabled.')
Juntando todo, aquí tienes un script completo que suma dos números e incluye un modo verbose opcional:
import argparse parser = argparse.ArgumentParser(description='Add two integers.') parser.add_argument('num1', type=int, help='The first number to add.') parser.add_argument('num2', type=int, help='The second number to add.') parser.add_argument('-v', '--verbose', action='store_true', help='Increase output verbosity.') args = parser.parse_args() result = args.num1 + args.num2 print('The sum of {} and {} is {}'.format(args.num1, args.num2, result)) if args.verbose: print('Calculation completed successfully.')
Puedes ejecutar este script desde la línea de comandos y proporcionar los argumentos posicionales requeridos:
python add_numbers.py 3 5 The sum of 3 and 5 is 8
Si incluyes la opción -v o --verbose, el script imprimirá el mensaje adicional detallado:
python add_numbers.py 3 5 --verbose The sum of 3 and 5 is 8 Calculation completed successfully.
Si el usuario ejecuta el script con la opción -h o --help, argparse mostrará un mensaje de ayuda generado automáticamente:
python add_numbers.py -h usage: add_numbers.py [-h] [-v] num1 num2 Add two integers. positional arguments: num1 The first number to add. num2 The second number to add. optional arguments: -h, --help show this help message and exit -v, --verbose Increase output verbosity.
Esta característica hace que tu programa sea más amigable proporcionando instrucciones claras sobre cómo utilizarlo.
Manejo Avanzado de Argumentos
Cuando desarrollas programas de línea de comandos en Python, es posible que te encuentres con escenarios que requieren un análisis de argumentos más complejo. El módulo argparse de Python incluye varias funciones para abordar estos requisitos complejos, lo que te permite desarrollar interfaces flexibles y amigables al usuario.
Usando nargs para múltiples argumentos
Hay situaciones en las que tu aplicación necesita aceptar numerosos valores para el mismo argumento. Por ejemplo, supongamos que deseas crear un script que procese varios archivos a la vez. El parámetro nargs en argparse te permite especificar cuántos argumentos de línea de comandos deben ser leídos.
Así es como se usa nargs para aceptar múltiples nombres de archivos:
import argparse parser = argparse.ArgumentParser(description='Process multiple files.') parser.add_argument('filenames', nargs='+', help='List of files to process.') args = parser.parse_args() for filename in args.filenames: print(f'Processing file: {filename}') # Agrega aquí tu código de procesamiento de archivos
En este caso, nargs='+' indica al analizador que espere uno o más argumentos en nombres de archivo. El usuario puede proporcionar tantos nombres de archivos como sea necesario, y se guardarán en una lista llamada args.filenames.
Si deseas aceptar una cantidad específica de argumentos, establece nargs en ese número. Por ejemplo, nargs=2 requiere exactamente dos parámetros.
Implementando opciones para limitar los valores de los argumentos
A veces, quieres limitar un argumento a un rango especificado de valores válidos. Esto garantiza que el usuario ofrezca una entrada válida, evitando así errores o acciones inesperadas. El parámetro de opciones te permite especificar los valores permitidos para un argumento.
Considera un script que ejecuta múltiples actividades dependiendo de un modo seleccionado por el usuario.
import argparse parser = argparse.ArgumentParser(description='Perform actions in different modes.') parser.add_argument('--mode', choices=['backup', 'restore', 'delete'], required=True, help='Mode of operation.') args = parser.parse_args() if args.mode == 'backup': print('Backing up data...') # Código de respaldo aquí elif args.mode == 'restore': print('Restoring data...') # Código de restauración aquí elif args.mode == 'delete': print('Deleting data...') # Código de eliminación aquí
En este script, el argumento --modo debe ser una de las opciones. Si el usuario ingresa un valor que no está en la lista, argparse devolverá un mensaje de error.
Manejo de banderas booleanas y conmutadores
Las banderas booleanas son opciones que habilitan o deshabilitan funcionalidades específicas en tu aplicación. Típicamente se definen sin un valor, simplemente incluyendo la bandera en el comando. Puedes manejar estas banderas en argparse con el parámetro action.
Por ejemplo, incluyamos un modo de depuración en un script:
import argparse parser = argparse.ArgumentParser(description='A script with debug mode.') parser.add_argument('--debug', action='store_true', help='Enable debug output.') args = parser.parse_args() if args.debug: print('Debug mode is enabled.') # Información de depuración adicional aquí else: print('Debug mode is disabled.')
Usando action='store_true', la bandera --depuración establecerá args.debug como True cuando esté presente y False de lo contrario.
Estableciendo valores predeterminados y argumentos requeridos
Los argumentos opcionales frecuentemente incluyen valores predeterminados sensatos. Esto significa que si el usuario no especifica el argumento, la aplicación usará el valor predeterminado. El argumento default te permite especificar un valor predeterminado.
Aquí tienes un ejemplo:
import argparse parser = argparse.ArgumentParser(description='Adjust program settings.') parser.add_argument('--timeout', type=int, default=30, help='Timeout in seconds.') args = parser.parse_args() print(f'Timeout is set to {args.timeout} seconds.')
En este escenario, si el usuario no especifica --timeout, el valor predeterminado es de 30 segundos.
Para hacer obligatorio un argumento opcional, set required=True.
import argparse parser = argparse.ArgumentParser(description='Send a message.') parser.add_argument('--recipient', required=True, help='Recipient of the message.') args = parser.parse_args() print(f'Sending message to {args.recipient}.')
El script ahora requerirá el argumento --recipient.
Personalización de mensajes de ayuda y error
Proporcionar mensajes claros y útiles a los usuarios es un componente esencial para desarrollar un programa de línea de comandos efectivo. El módulo argparse de Python crea automáticamente mensajes de ayuda, pero puedes modificar estos mensajes para que se ajusten mejor a tus necesidades.
Generación de mensajes de ayuda automáticos
Por defecto, argparse genera un mensaje de ayuda, al cual se puede acceder utilizando las opciones -h o --help. Este mensaje contiene el uso del programa, una descripción e información sobre cada argumento.
Por ejemplo:
import argparse parser = argparse.ArgumentParser(description='Calculate factorial of a number.') parser.add_argument('number', type=int, help='The number to calculate the factorial for.') args = parser.parse_args()
Cuando un usuario ejecuta el script con -h, verá:
usage: script.py [-h] number Calculate factorial of a number. positional arguments: number The number to calculate the factorial for. optional arguments: -h, --help show this help message and exit
Este mensaje de ayuda automático proporciona información útil sin requerir esfuerzo adicional.
Personalización de descripciones de ayuda y mensajes de uso
Aunque los mensajes de ayuda predeterminados son útiles, es posible que desees modificarlos para proporcionar información adicional o para adaptarlos a una estructura específica. Puedes cambiar la descripción, epílogo y texto de uso en el ArgumentParser.
Por ejemplo, para incluir un epílogo y personalizar el mensaje de uso:
import argparse parser = argparse.ArgumentParser( description='Convert temperatures between Celsius and Fahrenheit.', epilog='Enjoy using the temperature converter!', usage='%(prog)s [options] temperature') parser.add_argument('temperature', type=float, help='Temperature value to convert.') parser.add_argument('--to-fahrenheit', action='store_true', help='Convert Celsius to Fahrenheit.') parser.add_argument('--to-celsius', action='store_true', help='Convert Fahrenheit to Celsius.') args = parser.parse_args()
Ahora, cuando el usuario consulte el mensaje de ayuda, incluirá la descripción personalizada, uso y epílogo:
python file.py --help usage: p.py [options] temperature Convert temperatures between Celsius and Fahrenheit. positional arguments: temperature Temperature value to convert. options: -h, --help show this help message and exit --to-fahrenheit Convert Celsius to Fahrenheit. --to-celsius Convert Fahrenheit to Celsius.
–to-fahrenheit Convertir Celsius a Fahrenheit.
–to-celsius Convertir Fahrenheit a Celsius.
Gestión de manejo de errores y retroalimentación del usuario
import argparse import sys class CustomArgumentParser(argparse.ArgumentParser): def error(self, message): print(f'Error: {message}') self.print_help() sys.exit(2) parser = CustomArgumentParser(description='Divide two numbers.') parser.add_argument('numerator', type=float, help='The numerator.') parser.add_argument('denominator', type=float, help='The denominator.') args = parser.parse_args() if args.denominator == 0: parser.error('Denominator cannot be zero.') result = args.numerator / args.denominator print(f'Result: {result}')
Si un usuario ingresa argumentos inválidos, argparse mostrará un mensaje de error y saldrá del programa. Puedes modificar este comportamiento para brindar retroalimentación más útil o manejar fallas de manera diferente.
Python file.py 6 0 Error: Denominator cannot be zero. usage: file.py [-h] numerator denominator Divide two numbers. positional arguments: numerator The numerator. denominator The denominator. options: -h, --help show this help message and exit
Un enfoque es anular el método de error en una subclase de ArgumentParser:
import argparse import os parser = argparse.ArgumentParser(description='Read a file and display its contents.') parser.add_argument('filepath', help='Path to the file.') args = parser.parse_args() if not os.path.exists(args.filepath): parser.error(f"The file {args.filepath} does not exist.") with open(args.filepath, 'r') as file: contents = file.read() print(contents)
Si el usuario intenta dividir por cero en este script, la aplicación mostrará una advertencia de error y texto de ayuda, dirigiendo al usuario a proporcionar datos válidos.
python app..py file usage: p.py [-h] filepath app.py: error: The file file does not exist.
También puedes incluir manejo de errores personalizado en tu script. Por ejemplo, para gestionar rutas de archivo inválidas:
Ejecutar el script con una ruta no válida mostrará el siguiente error:
Ejemplos del Mundo Real y Casos de Uso
Entender cómo usar el módulo argparse en entornos del mundo real hará que su funcionalidad sea más clara. Veamos algunas instancias de cómo usar argparse en aplicaciones del mundo real.
Creando una calculadora de línea de comandos
import argparse parser = argparse.ArgumentParser(description='Simple command-line calculator.') parser.add_argument('num1', type=float, help='First number.') parser.add_argument('operator', choices=['+', '-', '*', '/'], help='Operation to perform.') parser.add_argument('num2', type=float, help='Second number.') args = parser.parse_args() if args.operator == '+': result = args.num1 + args.num2 elif args.operator == '-': result = args.num1 - args.num2 elif args.operator == '*': result = args.num1 * args.num2 elif args.operator == '/': if args.num2 == 0: print('Error: Division by zero is not allowed.') exit(1) result = args.num1 / args.num2 print(f'The result is: {result}')
Supongamos que necesitas desarrollar una calculadora simple que pueda realizar operaciones aritméticas básicas desde la línea de comandos. Esta calculadora debería aceptar dos números y un operador para ejecutar la operación solicitada.
python calculator.py 10 + 5 The result is: 15.0
Así es como puedes abordar esta tarea:
En este script, se utiliza el módulo argparse para definir tres argumentos posicionales: dos números y un operador. El argumento choices limita el operador a símbolos aritméticos válidos. Cuando el usuario ejecuta el script, pueden realizar estos cálculos:
Esta calculadora básica muestra cómo las opciones de línea de comandos pueden mejorar la flexibilidad e interactividad de un programa.
Creando un script de procesamiento de archivos con múltiples opciones
import argparse parser = argparse.ArgumentParser(description='Process text files.') parser.add_argument('input_file', help='Path to the input file.') parser.add_argument('-o', '--output', help='Path to the output file.') parser.add_argument('-m', '--mode', choices=['uppercase', 'lowercase'], default='uppercase', help='Processing mode.') parser.add_argument('-v', '--verbose', action='store_true', help='Enable verbose output.') args = parser.parse_args() Supongamos que necesitas un script que procese archivos de texto y proporcione opciones como designar un archivo de salida, seleccionar un modo de procesamiento y habilitar la salida detallada. with open(args.input_file, 'r') as file: content = file.read() if args.verbose: print(f'Reading from {args.input_file}') Aquí tienes un ejemplo de cómo podrías configurarlo: if args.mode == 'uppercase': processed_content = content.upper() else: processed_content = content.lower() if args.verbose: print('Processing content') # Leer el archivo de entrada if args.output: with open(args.output, 'w') as file: file.write(processed_content) if args.verbose: print(f'Writing output to {args.output}') else: print(processed_content)
# Procesar el contenido
python text_processor.py input.txt -o output.txt --mode lowercase -v Reading from input.txt Processing content Writing output to output.txt
# Escribir en el archivo de salida o imprimir en la consola
Este script acepta un archivo de entrada y tiene opciones para el archivo de salida, modo de procesamiento y salida detallada. Los usuarios pueden modificar cómo se comporta el script sin alterar el código.
Desarrollando una herramienta CLI con subcomandos
import argparse parser = argparse.ArgumentParser(description='Manage tasks.') subparsers = parser.add_subparsers(dest='command', required=True) En aplicaciones más complicadas, pueden ser necesarios subcomandos, similar a cómo funciona git usando comandos como git commit y git push. El móduloargparseproporciona subanalizadores para este propósito. parser_add = subparsers.add_parser('add', help='Add a new task.') parser_add.add_argument('name', help='Name of the task.') parser_add.add_argument('-p', '--priority', type=int, choices=range(1, 6), default=3, help='Priority of the task.') Aquí tienes cómo hacer una herramienta CLI con subcomandos: parser_list = subparsers.add_parser('list', help='List all tasks.') parser_list.add_argument('-a', '--all', action='store_true', help='List all tasks, including completed ones.') # Subcomando 'add' parser_complete = subparsers.add_parser('complete', help='Mark a task as completed.') parser_complete.add_argument('task_id', type=int, help='ID of the task to complete.') args = parser.parse_args() if args.command == 'add': print(f"Adding task '{args.name}' with priority {args.priority}") # Subcomando 'list' elif args.command == 'list': print('Listing tasks') if args.all: print('Including completed tasks') # Subcomando 'complete' elif args.command == 'complete': print(f'Marking task {args.task_id} as completed') # Código para agregar la tarea
# Código para listar tareas
# Código para completar la tarea
python task_manager.py add "Write report" -p 2 Adding task 'Write report' with priority 2
En este ejemplo, el script tiene tres subcomandos: add, list y complete. Cada subcomando tiene sus argumentos. Cuando los usuarios ejecutan el script, ingresan el subcomando y cualquier otro parámetro.
python task_manager.py list Listing tasks
Por ejemplo:
python task_manager.py complete 3 Marking task 3 as completed
Listando tareas
Marcar tareas como completadas:
subparsers te permiten crear herramientas de línea de comandos complejas que están bien organizadas y son fáciles de extender, lo que te permite construir aplicaciones que pueden hacer múltiples cosas en una sola interfaz.
Mejores prácticas y consejos para argparse de Python
Desarrollar programas de línea de comandos implica más que simplemente escribir código que funcione. También implica escribir código que sea limpio, mantenible y amigable para el usuario.
A continuación, se presentan algunas mejores prácticas al trabajar con el módulo argparse.
Organizando el código para la legibilidad y el mantenimiento
Cuando tus scripts se vuelven más complejos, es crítico mantener tu código organizado para una mejor comprensión y mantenimiento. Un enfoque para lograr esto es utilizar funciones y clases para organizar secciones distintas de tu código.
Dividir tu programa en partes más pequeñas y reutilizables facilita la gestión y elimina la duplicación de código.
Por ejemplo, en un script de gestión de tareas, podrías definir diferentes funciones para agregar tareas, listar tareas y completar tareas. Esta división te permite concentrarte en un aspecto de la lógica a la vez, haciendo que tu código sea más claro.
Otra técnica efectiva es separar tu lógica de análisis de argumentos del resto de tu código. Colocar todas las definiciones de argumentos y el análisis al inicio de tu script, o en una función dedicada, facilita que otros comprendan cómo tu programa maneja la entrada.
Usar nombres de variables apropiados también mejora la legibilidad. Elige nombres de variables que reflejen su propósito, para que cualquier persona que revise tu código pueda entender lo que está sucediendo. Incluir comentarios y docstrings para explicar lo que hacen tus funciones y cualquier detalle clave puede ayudar a aumentar la comprensión.
Pruebas y depuración de aplicaciones de línea de comandos
Probar tus aplicaciones es crítico para asegurar que funcionen correctamente y detectar fallos desde el principio. Escribir pruebas unitarias con marcos de prueba de Python como unittest o pytest es un excelente enfoque para probar tu código. Estas pruebas te permiten simular diversas entradas y asegurarte de que tus funciones funcionen correctamente.
Por ejemplo, puedes probar múltiples escenarios simulando las entradas de la línea de comandos en lugar de ejecutar el script desde la línea de comandos. Esta estrategia te permite asegurarte de que el análisis de argumentos funcione como se espera y que tu aplicación maneje correctamente varios escenarios.
Manejar excepciones de manera adecuada también es vital. Usando bloques try-except, puedes capturar errores y ofrecer mensajes útiles al usuario. Esto hace que tu aplicación sea más estable y fácil de usar.
Considera incluir una bandera de depuración en tu script también. Esta bandera puede habilitar una salida adicional que te permita rastrear la ejecución del programa cuando algo sale mal. Tener esta opción facilita el diagnóstico de problemas durante el desarrollo y mantenimiento.
Comparando argparse con otras bibliotecas de análisis de argumentos
Mientras que argparse es una utilidad valiosa en la biblioteca estándar de Python, hay bibliotecas adicionales disponibles que proporcionan métodos alternativos para analizar argumentos de línea de comandos. Entender estas opciones te ayudará a seleccionar la herramienta adecuada para tu proyecto.
Una de esas bibliotecas es Click. Click es un paquete de terceros para crear interfaces de línea de comandos con decoradores. Tiene una sintaxis más intuitiva y es ideal para aplicaciones sofisticadas. Por ejemplo, puedes usar decoradores de Python para crear comandos y opciones, haciendo que tu código sea más compacto y comprensible.
Docopt es otra opción que te permite definir la interfaz de línea de comandos utilizando el docstring del programa. Docopt analiza automáticamente el mensaje de ayuda y construye el analizador de argumentos cuando las instrucciones de uso están incluidas en el docstring. Este enfoque es elegante y adecuado para scripts simples que requieren una especificación más legible para humanos.
Al elegir qué biblioteca utilizar, considera las demandas de tu proyecto. Si deseas eliminar dependencias externas y quieres una herramienta que pueda manejar la mayoría de situaciones, argparse es una excelente solución. Si buscas una sintaxis más intuitiva y estás trabajando en una aplicación compleja, Click podría ser más adecuado. Docopt es una buena opción para programas pequeños con interfaces sencillas.
Conclusión
A lo largo de este artículo, hemos visto cómo usar el módulo argparse de Python para desarrollar programas de línea de comandos en Python. Al trabajar a través de ejemplos del mundo real, aprendimos a crear scripts realistas que reciben la entrada del usuario y realizan tareas relevantes.