Tutorial de análisis de la línea de comandos de Python

El análisis de los argumentos de la línea de comandos se incluyó anteriormente en la biblioteca Python predeterminada "Argparse". Al permitir que los valores de entrada del usuario se analicen de alguna manera y luego se usen, "Argparse". Ofrece flexibilidad y reutiliza su código en lugar de establecer variables manualmente como parte del código.

Ejemplo 1

Implementaremos el código sucesivo para mostrar la estructura y el uso de una biblioteca de Argparse.

importar argparse
parser = argparse.Argumento de Parser ()
pasador.add_argument ('-name', type = str, required = true)
Args = analizador.parse_args ()
Imprimir ('Hola', Args.nombre)

La biblioteca "argparse" se importaría al comienzo del código. El analizador se inicializa mediante argumento (), por lo que podremos comenzar a agregar parámetros personalizados. Use el analizador.función add_argument () para agregar argumentos deseados. El "nombre", "tipo" y "requerido" se darán como argumentos de este método. El atributo 'requerido' es un booleano que indica si se ejecuta el siguiente campo de línea de comando, y el argumento "tipo" muestra el tipo de variable especificado como una entrada. Establecemos el valor del argumento de "tipo" como "str" ​​y "requerido" como "verdadero". La función parse_args () se llamará. Los "args.Nombre "El atributo parece ser el nombre de dicho argumento identificado con la función add_argument ().

El código anterior produce este tipo de resultado como se muestra:

Como podemos ver, esto planteará un error ya que el argumento de "nombre" es necesario pero falta. Cuando agregamos -name, obtenemos la siguiente salida:

Ejemplo 2

Hay ciertas situaciones en las que no queremos discutir sobre el nombre que podría usarse para la bandera. Uno puede utilizar un parámetro posicional para evitar tener que suministrar el indicador de nombre antes de ingresar el valor real.

Aquí, multiplicaremos los argumentos posicionales especificando los parámetros.

importar argparse
parser = argparse.Argumento de Parser ()
pasador.add_argument ('-i', type = int, requerido = true)
pasador.add_argument ('-j', type = int, requerido = true)
Args = analizador.parse_args ()
Producto = Args.yo * args.j
Imprimir ('Producto:', producto)

El analizador se generó por primera vez después de importar el módulo "Argparse". Las variables "I" y "J", se agregaron dos argumentos de tipo entero que deben ser verdaderos. Después de eso, las fórmulas del producto se aplicarán después de analizar los parámetros. Empleamos la función print () para mostrar el producto.

Ejemplo 3

En este caso, realizamos multiplicación sin especificar los parámetros posicionales.

importar argparse
parser = argparse.Argumento de Parser ()
pasador.add_argument ('k', type = int)
pasador.add_argument ('l', type = int)
Args = analizador.parse_args ()
Producto = Args.K * args.l
Imprimir ('Producto:', producto)

Primero, integrando el paquete "argparse", el analizador se construyó inicialmente utilizando el método argumentParser (). "K" y "L" son los dos argumentos especificados con el tipo entero. Aunque los argumentos posicionales mantienen una línea de comando más clara, no proporcionamos el atributo "requerido" aquí. Posteriormente, los parámetros dados se analizaron con la ayuda del método parse_args (). Definiremos una función de producto utilizando las variables "K" y "L". Para mostrar el resultado, utilizaremos la declaración de impresión.

Ejemplo 4

Los argumentos opcionales pueden ser útiles cada vez que deseamos proporcionar a un usuario alguna opción para usar la funcionalidad. Simplemente especificamos el parámetro opcional usando la función add_argument () para agregar un argumento opcional.

importar argparse
parser = argparse.Argumento de Parser ()
pasador.add_argument ('-name', type = str, required = true)
pasador.add_argument ('-class', type = int)
Args = analizador.parse_args ()
Si Args.Clase:
Imprimir (Args.nombre, 'en', args.Clase, 'clase.')
demás:
imprimir ('hey', args.Nombre + '!')

Comenzamos el programa incorporando la biblioteca "Argparse". Primero establecimos un analizador utilizando el método argumentParser () para ejecutar dos argumentos analizadores. Ahora, llamaremos a la función add_argument () para agregar diferentes parámetros. Estos argumentos incluyen dos variables, nombre y clase, donde el argumento de "nombre" es del tipo "cadena", y debe ser verdad. El parámetro "clase" tiene el tipo "entero".

Además, después de analizar los parámetros, utilizamos la condición "if-else". Dentro de esto, hemos estado aplicando la función print () dos veces, una vez por la instrucción "si" y otra vez por la instrucción "más", para representar la salida. Los argumentos en los métodos impresos () varían en ambos casos. Los argumentos dados en la primera función de impresión () incluyen nombre y clase. Al mismo tiempo, los argumentos presentados en el segundo método de impresión () incluyen args.nombre.

Después de ejecutar el código, obtenemos las dos salidas como se da a continuación. Obtenemos la primera salida después de usar los argumentos opcionales y el segundo sin los argumentos opcionales.

De las dos salidas diferentes anteriores, podemos observar que hay una diferencia entre ambas salidas debido al uso de los argumentos opcionales en uno y no en el otro.

Ejemplo 5

Imaginemos que, en lugar de pedirle al usuario que proporcione entradas "X" e "Y", queremos que el usuario ingrese una gama de números y el script, que luego devolvería el total de todos esos números. Como no podemos predecir cuántos valores ingresará un usuario, no es necesario crear un nuevo argumento para cada nuevo valor. El número (o entradas) que el argumento puede aceptar puede especificarse utilizando la opción "NARGS" en la función add_argument ().

Proporcionaremos múltiples argumentos de entrada e imprimiremos el resultado en este caso.

importar argparse
parser = argparse.Argumento de Parser ()
pasador.add_argument ('-valores', type = int, nargs = 5)
Args = analizador.parse_args ()
sum = suma (args.valores)
imprimir ('suma:', suma)

Iniciamos importando la biblioteca "Argparse", que se requiere para ejecutar el código anterior. Crearemos un analizador llamando al método argumento de argumento (). Esta función no contiene argumento. A continuación, se invocará el método add_argument (). Este método tiene tres parámetros. En el caso de múltiples argumentos de entrada, hemos utilizado el atributo "NARGS" dentro del método add_argument (). Ahora, llamaremos a la función parse_args () para analizar. Aplicamos el método suma () para encontrar la suma de los valores. Para representar la salida, utilizamos la declaración de impresión.

Ejemplo 6

¿Qué pasa si queremos la suma de más entradas que cinco valores?? Podemos hacer que el argumento acepte cualquier número de valores estableciendo nargs = "+".

importar argparse
parser = argparse.Argumento de Parser ()
pasador.add_argument ('-valores', type = int, nargs = '+')
Args = analizador.parse_args ()
sum = suma (args.valores)
imprimir ('suma:', suma)

Podemos ejecutar el script con casi cualquier número de valores de entrada. Aquí, usamos el mismo código que anteriormente, pero, en este código, cambiaremos 'nargs' = 5 a 'nargs' = '+'.

Conclusión

Este artículo cubrió una variedad de técnicas de análisis de la línea de comandos de Python, como argumentos simples, argumentos posicionales, argumentos opcionales y múltiples argumentos de entrada. También proporcionó ejemplos para ver cómo cambia la salida dependiendo de si un argumento se usa o no. Podemos utilizar ejemplos para examinar y comprender si un argumento es apropiado en una determinada circunstancia.