Cómo agregar argumentos de línea de comandos a un script de python

Si ha desarrollado un script o aplicación de Python destinado a ejecutarse principalmente en emuladores terminales o incluso aplicaciones de GUI, agregar argumentos de línea de comandos puede mejorar su uso, legibilidad de código, estructura de la aplicación y facilidad de uso general de la aplicación para los usuarios finales. Estos argumentos de la línea de comandos también se denominan "opciones" o "conmutadores" y funcionan de manera similar a los argumentos que generalmente ve en scripts bash y otros programas basados ​​en C / c ++.

Para agregar argumentos a los scripts de Python, tendrá que usar un módulo incorporado llamado "Argparse". Como su nombre indica, analiza los argumentos de la línea de comandos utilizados al lanzar un script o aplicación de Python. Estos argumentos analizados también son verificados por el módulo "Argparse" para garantizar que sean de "tipo" adecuados. Se plantean errores si hay valores no válidos en los argumentos.

El uso del módulo argparse se puede entender mejor a través de ejemplos. A continuación se muestran algunas muestras de código que lo harán comenzar con el módulo Argparse.

Ejemplo 1: Generar el argumento y el mensaje de ayuda

Considere la muestra de código a continuación:

importar argparse
parser = argparse.ArgumentParser (descripción = 'un programa de prueba.')
Args = analizador.parse_args ()

La primera declaración importa el módulo "Argparse". A continuación, se crea una nueva instancia de objeto "Argumento Parser" y se suministra una descripción breve para el programa como argumento. El objeto argumento de Parser es necesario para convertir los valores de argumento de la línea de comando a los tipos de datos entendidos por Python. Esto se realiza mediante el método "parse_args" del objeto ArgumentParser, como se muestra en la última declaración.

Suponiendo que haya guardado la muestra de código establecida anteriormente en un archivo llamado "Prueba.py ”, ejecutar los comandos a continuación le dará mensajes de ayuda relacionados con el programa.

ps ./prueba.py -h
ps ./prueba.py --help

Debería obtener alguna salida similar a esta:

Uso: prueba.py [-h]
Un programa de prueba.
Argumentos opcionales:
-H, --Help Muestra este mensaje de ayuda y salida

Tenga en cuenta que no se ha agregado lógica para manejar argumentos analizados y convertirlos a objetos a la muestra de código mencionada anteriormente. Por lo tanto, los mensajes de ayuda para argumentos individuales no se muestran en la salida. Una vez que agregue la lógica para manejar los valores de los argumentos analizados en su programa, los mensajes de ayuda comenzarán a mostrar la descripción de los argumentos individuales.

Ejemplo 2: manejar un argumento de cadena

Para agregar argumentos aceptables por su script de Python, debe usar el método "add_argument". Eche un vistazo al siguiente código:

importar argparse
parser = argparse.ArgumentParser (descripción = 'un programa de prueba.')
pasador.add_argument ("print_string", ayuda = "Imprime el argumento suministrado.")
Args = analizador.parse_args ()
Imprimir (Args.print_string)

Se ha agregado una nueva declaración que muestra el uso del método "add_argument". Cualquier argumento agregado al lanzar el script será tratado como un objeto "print_string" por "argumentoparser".

Tenga en cuenta que, por defecto, el método "add_argument" trata los valores recuperados de los argumentos como cadenas, por lo que no tiene que especificar explícitamente el "tipo" en este caso. También se asigna un valor predeterminado de "ninguno" a argumentos adicionales, a menos que se anule.

Una vez más, eche un vistazo al mensaje de ayuda:

Uso: prueba.py [-h] [print_string]
Un programa de prueba.
Argumentos posicionales:
print_string imprime el argumento suministrado.
Argumentos opcionales:
-H, --Help Muestra este mensaje de ayuda y salida

Una de las líneas en la salida dice "Argumentos posicionales". Dado que no se define ninguna palabra clave para el argumento, actualmente el argumento se trata como un "argumento posicional" donde el orden y la posición de argumento suministrado tienen un efecto directo en el programa. Los argumentos posicionales también son obligatorios, a menos que cambie manualmente su comportamiento.

Para definir y analizar argumentos opcionales, puede usar "-" (Double Dash) y cambiar sus valores predeterminados usando el argumento "predeterminado".

importar argparse
parser = argparse.ArgumentParser (descripción = 'un programa de prueba.')
pasador.add_argument ("-print_string", ayuda = "Imprime el argumento suministrado.", default =" una cadena aleatoria.")
Args = analizador.parse_args ()
Imprimir (Args.print_string)

Ahora cuando ejecuta "Prueba.script py "sin ningún argumento, debe obtener" una cadena aleatoria."Como salida. También puede usar opcionalmente la palabra clave "-print_string" para imprimir cualquier cadena de su elección.

ps ./prueba.py --print_string linuxhint.com linuxhint.comunicarse

Tenga en cuenta que puede hacer un argumento opcional obligatorio utilizando un argumento adicional "requerido = verdadero".

Por último, también puede definir versiones abreviadas del argumento usando "-" (tablero único) para reducir la verbosidad.

importar argparse
parser = argparse.ArgumentParser (descripción = 'un programa de prueba.')
pasador.add_argument ("-p", "--print_string", ayuda = "Imprime el argumento suministrado.", default =" una cadena aleatoria.")
Args = analizador.parse_args ()
Imprimir (Args.print_string)

Ejecutar el siguiente comando debe darle el mismo resultado que el anterior:

ps ./prueba.py -p linuxhint.comunicarse

Ejemplo 3: manejar un argumento entero

Para manejar los argumentos que necesitan valores enteros, debe establecer la palabra clave "tipo" en "INT" para permitir la validación y lanzar errores en caso de que no se cumpla la condición.

importar argparse
parser = argparse.ArgumentParser (descripción = 'un programa de prueba.')
pasador.add_argument ("-p", "--print_string", ayuda = "Imprime el argumento suministrado.", tipo = int)
Args = analizador.parse_args ()
Imprimir (Args.print_string)

Intente ejecutar el siguiente comando:

ps ./prueba.py -p linuxhint.comunicarse

Debe recibir un error como este:

Uso: prueba.py [-h] [-p print_string]
prueba.Py: Error: Argumento -P/-Print_String: Inválido Int Valor: 'Linuxhint.com '

Suministrar un valor entero le dará el resultado correcto:

ps ./prueba.py -p 1000 1000

Ejemplo 4: Manejar el verdadero y falso toggles

Puede aprobar argumentos sin ningún valor para tratarlos como banderas verdaderas y falsas utilizando el argumento de "acción".

importar argparse
parser = argparse.ArgumentParser (descripción = 'un programa de prueba.')
pasador.add_argument ("-p", "--print_string", ayuda = "Imprime el argumento suministrado.", action =" store_true ")
Args = analizador.parse_args ()
Imprimir (Args.print_string)

Ejecute el comando a continuación para obtener un simple "verdadero" como salida:

ps ./prueba.py -p

Si ejecuta el script sin el argumento "-p", se asignará un valor "falso". El valor "store_true" de la palabra clave "acción" asigna un valor "verdadero" a la variable "print_string" siempre que el argumento "-p" se especifica explícitamente, de lo contrario se asigna falso a la variable.

Ejemplo 5: Trate los valores de argumentos como lista

Si desea obtener múltiples valores a la vez y almacenarlos en la lista, debe proporcionar una palabra clave "NARGS" en el siguiente formato:

importar argparse
parser = argparse.ArgumentParser (descripción = 'un programa de prueba.')
pasador.add_argument ("-p", "--print_string", ayuda = "Imprime el argumento suministrado.", nargs = '*')
Args = analizador.parse_args ()
Imprimir (Args.print_string)

Ejecute el siguiente comando para probar el código anterior:

ps ./prueba.py -p "A" "B"

Deberías obtener algo de salida como esta:

['A', 'B']

Conclusión

El módulo "Argparse" es bastante completo con toneladas de opciones para modificar el comportamiento de las aplicaciones de la línea de comandos y los valores suministrados por los usuarios de los usuarios. Estos ejemplos solo tocan el uso básico del módulo "Argparse". Para aplicaciones avanzadas y complejas, es posible que necesite diferentes implementaciones. Visite la documentación oficial para una explicación completa del módulo.