Opción de línea de comandos y análisis de argumentos usando argparse en Python

Los argumentos de la línea de comando son aquellos valores que se pasan durante la llamada del programa junto con la declaración de llamada. Por lo general, python usa sys.argvuna array para lidiar con tales argumentos, pero aquí describimos cómo se puede hacer más ingenioso y fácil de usar al emplear el argparsemódulo.

Módulo Argparse

El argparsemódulo en Python ayuda a crear un programa en un entorno de línea de comandos de una manera que parece no solo fácil de codificar sino que también mejora la interacción. El argparsemódulo también genera automáticamente mensajes de ayuda y uso y emite errores cuando los usuarios dan argumentos inválidos al programa.

Pasos para usar Argparse

1. Crear un analizador: Importar el módulo argparse es la primera forma de manejar el concepto. Después de haberlo importado, debe crear un analizador o un objeto ArgumentParser que almacenará toda la información necesaria que debe pasarse desde la línea de comandos de python.
   

   Sintaxis: clase argparse.ArgumentParser(prog=Ninguno, uso=Ninguno, descripción=Ninguno, epilog=Ninguno, padres=[], formatter_class=argparse.HelpFormatter, prefix_chars=’-‘, fromfile_prefix_chars=Ninguno, argument_default=Ninguno, conflict_handler= ‘error’, add_help=Verdadero, allow_abbrev=Verdadero)

   Parámetros:

   • prog – nombre del programa (predeterminado=sys.argv[0])
   • uso : la string describe el uso del programa (predeterminado: generado a partir de argumentos agregados al analizador)
   • descripción : texto que se muestra antes del argumento ayuda (predeterminado: ninguno)
   • epílogo : texto para mostrar después de la ayuda del argumento (predeterminado: ninguno)
   • padres : lista de objetos ArgumentParser cuyos argumentos también deben incluirse
   • formatter_class : clase para personalizar la salida de ayuda
   • prefix_chars : conjunto de caracteres que prefijan argumentos opcionales (predeterminado: ‘-‘)
   • fromfile_prefix_chars : conjunto de caracteres que prefijan archivos desde los cuales se deben leer argumentos adicionales (predeterminado: Ninguno)
   • argument_default : valor predeterminado global para los argumentos (predeterminado: ninguno)
   • conflict_handler : estrategia para resolver opciones en conflicto (generalmente innecesarias)
   • add_help : agregue una opción -h/–help al analizador (predeterminado: verdadero)
   • allow_abbrev : permite abreviar opciones largas si la abreviatura no es ambigua. (predeterminado: verdadero)

2. Adición de argumentos: el siguiente paso es llenar ArgumentParser con la información sobre los argumentos del programa. Esto implica una llamada al add_argument()método. Esta información le dice a ArgumentParser cómo tomar argumentos de la línea de comandos y convertirlos en objetos.
   

   Sintaxis: ArgumentParser.add_argument(name or flags…[, action][, nargs][, const][, default][, type][, options][, required][, help][, metavar][, dest] )

   Parámetros:

   • nombre o banderas : ya sea un nombre o una lista de strings de opciones
   • acción : tipo básico de acción que se realizará cuando se encuentre este argumento en la línea de comando
   • nargs : número de argumentos de la línea de comandos que deben consumirse
   • const : valor constante requerido por algunas selecciones de acción y nargs
   • predeterminado : valor producido si los argumentos están ausentes de la línea de comando
   • tipo : tipo al que se deben convertir los argumentos de la línea de comandos.
   • elecciones : un contenedor de los valores permitidos para el argumento
   • requerido : si se puede omitir la opción de la línea de comandos (solo opcionales)
   • ayuda : breve descripción de lo que hace el argumento
   • metavar : un nombre para el argumento en los mensajes de uso
   • dest : el nombre del atributo que se agregará al objeto devuelto por parse_args()

3. Análisis de argumentos: la información recopilada en el paso 2 se almacena y utiliza cuando los argumentos se analizan a través de parse_args(). Los datos se almacenan inicialmente en la array sys.argv en formato de string. Llamar a parse_args() con los datos de la línea de comandos primero los convierte al tipo de datos requerido y luego invoca la acción apropiada para producir un resultado.
   

   Sintaxis: ArgumentParser.parse_args(args=Ninguno, espacio de nombres=Ninguno)

   Parámetro:

   • args : lista de strings para analizar. El valor predeterminado se toma de sys.argv.
   • espacio de nombres : un objeto para tomar los atributos. El valor predeterminado es un nuevo objeto de espacio de nombres vacío.

   En la mayoría de los casos, esto significa que se creará un objeto de espacio de nombres simple a partir de atributos analizados desde la línea de comando:

   Namespace(accumulate=, integers=[ 2, 8, -7, 41 ])

Estos fueron los conceptos básicos con los que debe familiarizarse para manejar argparse. Los siguientes son algunos ejemplos para apoyar esta aplicación.

Ejemplo 1: para encontrar la suma de los argumentos de la línea de comandos usando argparse

import argparse
  
  
# Initialize the Parser
parser = argparse.ArgumentParser(description ='Process some integers.')
  
# Adding Arguments
parser.add_argument('integers', metavar ='N', 
                    type = int, nargs ='+',
                    help ='an integer for the accumulator')
  
parser.add_argument(dest ='accumulate', 
                    action ='store_const',
                    const = sum, 
                    help ='sum the integers')
  
args = parser.parse_args()
print(args.accumulate(args.integers))

Producción:

Ejemplo 2: programa para organizar las entradas de números enteros en orden ascendente

import argparse
  
  
# Initializing Parser
parser = argparse.ArgumentParser(description ='sort some integers.')
  
# Adding Argument
parser.add_argument('integers',
                    metavar ='N',
                    type = int,
                    nargs ='+',
                    help ='an integer for the accumulator')
  
parser.add_argument(dest ='accumulate',
                    action ='store_const',
                    const = sorted,
                    help ='arranges the integers in ascending order')
  
args = parser.parse_args()
print(args.accumulate(args.integers))

Producción:

Ejemplo 3: Para encontrar el promedio de los argumentos numéricos de la línea de comando ingresados

import argparse
  
  
# Initializing Parser
parser = argparse.ArgumentParser(description ='sort some integers.')
  
# Adding Argument
parser.add_argument('integers',
                    metavar ='N',
                    type = float,
                    nargs ='+',
                    help ='an integer for the accumulator')
  
parser.add_argument('sum',
                    action ='store_const',
                    const = sum)
  
parser.add_argument('len',
                    action ='store_const',
                    const = len)
  
args = parser.parse_args()
add = args.sum(args.integers)
length = args.len(args.integers)
average = add / length
print(average)

Producción: