Conceptos básicos sobre el análisis de argumentos de la línea de comandos en Python

CLas aplicaciones ommand-line son uno de los tipos de aplicaciones más antiguos y más utilizados. Si es un usuario experimentado de Linux, es posible que apenas haya utilizado herramientas GUI en lugar de herramientas de línea de comandos para realizar la misma tarea. Por ejemplo, Anaconda, el administrador de paquetes de Python, tiene herramientas de línea de comandos llamadas Conda y una herramienta GUI llamada anaconda navigator.

Lo que hace que la aplicación de línea de comandos sea popular entre los desarrolladores es que consumen muy pocos recursos en comparación con su contraparte GUI y ofrecen un mejor rendimiento.

Python es un lenguaje simple y poderoso para crear aplicaciones de línea de comandos. Proporciona toneladas de bibliotecas ya escritas por muchos grandes programadores, lo que facilita nuestra tarea ya que no necesitamos reescribir el mismo código.

En este tutorial, le presentaré la biblioteca Argparse de Python, que puede analizar los argumentos de las aplicaciones de línea de comando. Esto es útil para crear excelentes interfaces de línea de comandos. Para seguir este tutorial, se recomienda tener instalada la última versión de Python. También tenemos un tutorial paso a paso sobre cómo actualizar Python a la última versión en Linux.

Índice

Introducción

El análisis de argumentos es un concepto importante que debemos utilizar para crear interfaces de línea de comandos potentes y fáciles de usar. Si ha utilizado aplicaciones de línea de comandos anteriormente, es posible que haya notado que podemos agregar argumentos a las aplicaciones de línea de comandos para configurar las opciones de la herramienta.

Por ejemplo, si ha utilizado el ls en Linux, que se usa para enumerar los elementos del directorio de trabajo actual, es posible que haya visto un resultado similar, como se muestra en la imagen de abajo.

comando ls en linux
comando ls en Linux

Como puede ver en la imagen, enumera los elementos del directorio actual. También podemos utilizar el ls comando de forma más beneficiosa dándole un argumento como lo hice en el siguiente comando.

ls -a

Ahora, al escribir este comando en la terminal, enumerará todos los elementos presentes en el directorio de trabajo actual, incluidos los elementos ocultos. Como puede ver, al proporcionar argumentos en el comando, podemos especificar fácilmente las opciones del comando de una manera amigable. Aquí es donde entran en juego los argumentos. Hacen que las aplicaciones de la línea de comandos sean más útiles y amigables.

Quizás se pregunte cuándo y cómo agregar argumentos de línea de comandos en sus aplicaciones. Imagine que está creando una aplicación que necesita la entrada del usuario del nombre de archivo que procesará la aplicación.

Podemos hacerlo de dos formas:

  • solicitando al usuario que agregue el nombre del archivo o
  • proporcionando al usuario que agregue el nombre del archivo como argumento al comando.

El primer truco es bueno, pero el segundo es más útil ya que el usuario puede dar todas las opciones en un comando, lo que lo hace más fácil de usar.

Python incluye una gran biblioteca llamada "argparse", que es útil para crear y analizar argumentos de línea de comando y puede construir interfaces de línea de comando poderosas para los usuarios muy fácilmente. Echemos un vistazo profundo a la biblioteca argparse de Python.

Biblioteca Argparse

los argumentar Library es una forma fácil y útil de analizar argumentos mientras se crean aplicaciones de línea de comandos en Python. Aunque hay otros argumentos para analizar bibliotecas como optparse, getopt, etc., el argumentar library es oficialmente la forma recomendada para analizar los argumentos de la línea de comandos.

También está disponible en la biblioteca estándar de Python, por lo que no necesitamos ninguna configuración manual. los argumentar la biblioteca se ha construido utilizando el optar biblioteca de Python, pero argumentar es más útil y amigable para los desarrolladores que el optar Biblioteca.

Demostración práctica de Argparse

Veamos una demostración práctica de cómo usar la biblioteca argparse para crear una interfaz de línea de comandos simple. Este programa aceptará una ruta y comprobará si la ruta existe o no y si existe, luego imprimirá si es un archivo o un directorio.

import os
import argparse

parser = argparse.ArgumentParser(`description = "Path Existence Checker")
parser.add_argument("--path", help="input a path to check if it exists")
args = parser.parse_args()
input_path = args.path
if os.path.isdir(input_path):
    print("The path Exists and it is a directory")
elif os.path.isfile(input_path):
    print("The path Exists and it is a file")
else:
    print("The path does not exist")

Al ejecutar el programa anterior, podemos verificar si la ruta existe o no.

demostración de analizar argumentos con argparse
demostración de analizar argumentos con argparse

También puede utilizar el -h argumento con el programa, que es el argumento predeterminado para mostrar mensajes de ayuda.

argparse mensaje de ayuda predeterminado
argparse mensaje de ayuda predeterminado

Déjame explicarte cómo funciona el programa anterior. En las dos primeras líneas, importamos los módulos que necesitaremos en el programa. los os El módulo se ha importado para comprobar si la ruta existe o no, y si es un archivo o un directorio. Si desea obtener más información sobre el os módulo, puede consultar nuestra guía sobre cómo trabajar con el sistema operativo en python.

En la siguiente línea, importamos la biblioteca argparse requerida para crear y analizar argumentos. En la tercera línea, creamos un objeto analizador usando la clase ArgumentParser de la biblioteca argparse. Esta clase también acepta una descripción de parámetro opcional, que se mostrará en el mensaje de ayuda.

En la siguiente línea, hemos creado un argumento llamado ruta usando el método add_argument () del objeto analizador y proporcionamos el detalle en el parámetro de ayuda que se mostrará en el mensaje de ayuda como hemos visto en la salida anterior.

A continuación, analizamos los argumentos utilizando el método parse_args () del objeto analizador y accedemos a la ruta de entrada del usuario como argumento. Obtuvimos la ruta que el usuario ingresó en el argumento y luego la usamos con el módulo os para verificar si es un archivo o carpeta. Si no está entre los dos, imprimirá que la ruta no existe.

Personalización

Veamos algunas de las personalizaciones que podemos hacer en nuestra interfaz de línea de comandos con la ayuda de la biblioteca argparse.

Ayuda de uso personalizado

Cuando ejecutamos el programa de demostración que creamos anteriormente con el -h , obtenemos la ayuda del programa como la salida que generó la biblioteca argparse. Si nota el mensaje de ayuda, hay una ayuda de uso en la línea superior que nos muestra cómo usarla.

En nuestro programa de demostración, tenemos la ayuda de uso estándar. Aún podemos personalizarlo fácilmente usando el parámetro de uso mientras creamos el objeto del analizador usando la clase ArgumentParser (). Mire el código a continuación, que se modificará en nuestro programa de demostración.

parser = argparse.ArgumentParser(description = "Path Existence Checker", usage="cla.py path")

Aquí está el resultado:

ayuda de uso personalizado en argparse
ayuda de uso personalizado en argparse

Como podemos ver en el resultado, la ayuda de uso se ha cambiado a la que especificamos en el parámetro de uso de la clase ArgumentParser ().

Personalización de argumentos

También podemos usar la biblioteca Argparse para personalizar los argumentos como si los argumentos serán requeridos o no, dando a un argumento un valor predeterminado.

Añadiendo valor predeterminado

Podemos dar a los argumentos un valor predeterminado usando el parámetro predeterminado para el add_argument () método. Por ejemplo, consulte el siguiente código.

import os
import argparse

parser = argparse.ArgumentParser(description = "Path Existence Checker", usage="cla.py path")
parser.add_argument("--path", help="input a path to check if it exists", default="filename.txt")
args = parser.parse_args()
input_path = args.path

if input_path == None:
    exit()
elif os.path.isdir(input_path):
    print("The path Exists and it is a directory")
elif os.path.isfile(input_path):
    print("The path Exists and it is a file")
else:
    print("The path does not exist")

Al ejecutar el programa anterior sin ningún argumento, obtendremos la siguiente salida. Como se muestra en la salida, el programa verifica la ruta filename.txt, que establecemos en el parámetro predeterminado.

dando un valor predeterminado a los argumentos
dando un valor predeterminado a los argumentos

Establecimiento de requisitos de argumentos

También podemos usar la biblioteca Argparse para establecer los requisitos del argumento, es decir, si los argumentos serán necesarios o no. Para hacerlo, necesitamos usar el parámetro requerido, como se muestra en el siguiente código.

import os
import argparse

parser = argparse.ArgumentParser(description = "Path Existence Checker", usage="cla.py path")
parser.add_argument("--path", help="input a path to check if it exists", default="filename.txt", required=True)
args = parser.parse_args()
input_path = args.path

if input_path == None:
    exit()
elif os.path.isdir(input_path):
    print("The path Exists and it is a directory")
elif os.path.isfile(input_path):
    print("The path Exists and it is a file")
else:
    print("The path does not exist")

Al ejecutar el código anterior sin ningún argumento, obtendrá un error que indica que se requieren los siguientes argumentos.

establecer los requisitos de los argumentos
establecer los requisitos de los argumentos

Tipo de argumento

También podemos establecer el tipo de datos utilizado en el argumento. Por ejemplo, si necesitamos la ruta, deberíamos dar un tipo de datos de cadena. Si un usuario ingresa un tipo de datos que no es una cadena, Argparser lo cambiará a una cadena. Para establecer el tipo predeterminado de un argumento, ejecute el siguiente código.

import os
import argparse

parser = argparse.ArgumentParser(description = "Path Existence Checker", usage="cla.py path")
parser.add_argument("--path", help="input a path to check if it exists", type=str)
args = parser.parse_args()
input_path = args.path

if input_path == None:
    exit()
elif os.path.isdir(input_path):
    print("The path Exists and it is a directory")
elif os.path.isfile(input_path):
    print("The path Exists and it is a file")
else:
    print("The path does not exist")

Producción:

especificando el tipo de datos de los argumentos
especificando el tipo de datos de los argumentos

Conclusión

Esto es solo lo básico para analizar argumentos usando la biblioteca Argparse. Después de seguir este tutorial, se recomienda leer la documentación oficial para explorar más trucos para usar esta biblioteca. Es posible que también desee ver la publicación sobre el uso de inicio de sesión en Python, que es muy útil para escribir aplicaciones grandes y depurar fácilmente.

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Subir