Cómo analizar argumentos de línea de comandos en Python

¿Quieres ejecutar scripts Python con argumentos de línea de comandos? Aprende a analizar los argumentos de la línea de comandos utilizando los módulos sys, getopt y argparse de Python.

En Python, cuando quieras leer la entrada del usuario, utilizarás el método input() función. Sin embargo, para algunas aplicaciones, es posible que desee pasar ciertos argumentos al ejecutar el script en la línea de comandos.

En este tutorial, aprenderemos a ejecutar un Script en Python con opciones y argumentos en la línea de comandos. A continuación, aprenderemos a utilizar los módulos integrados de Python para analizar dichas opciones y argumentos.

¡Comencemos!

Comprender sys.argv en Python

Si has programado en C, sabrás que una de las formas más sencillas de pasar argumentos al programa es a través de la línea de comandos. Para ello, puede estructurar la función principal de la siguiente manera:

#include<stdio.h>

int main(int argc, char **argv){
    //argc: argument count
    //argv: argument vector
    
    //do something on the args

    return 0;
}

Toma, argc significa recuento de argumentos y argv significa vector de argumentos.

Ejecución de scripts de Python con argumentos de línea de comandos

En Python, puede ejecutar el script Python en la línea de comandos utilizando python3 filename.py. Al hacerlo, también puede introducir un número arbitrario de argumentos de línea de comandos:

$ python3 filename.py arg1 arg2 ... argn

El módulo sys proporciona soporte para acceder y procesar estos argumentos de línea de comandos. sys.argv es la lista de todos los argumentos de línea de comandos que pasamos cuando ejecutamos el script de Python.

He aquí un ejemplo en el que ejecutamos main.py con argumentos de línea de comandos:

$ python3 main.py hello world python script

Podemos recorrer el vector de argumentos con un simple bucle bucle for y función enumerar:

# main.py

import sys

for idx, arg in enumerate(sys.argv):
    print(f"arg{idx}: {arg}")

# Output
arg0:main.py
arg1:hello
arg2:world
arg3:python
arg4:script

Vemos que el primer argumento (en el índice 0) es el nombre del archivo Python. Y los argumentos subsiguientes comienzan en el índice 1.

Este es un programa de trabajo mínimo que acepta y procesa argumentos de línea de comandos. Sin embargo, vemos algunos problemas:

¿Cómo saben los usuarios del programa qué argumentos deben pasar?
¿Y qué defienden estos argumentos?

Esto no está muy claro. Para solucionar esto, puedes usar los módulos getopt o argparse. Y eso lo aprenderemos en las próximas secciones.✅

Análisis sintáctico de argumentos de la línea de comandos mediante getopt de Python

Vamos a aprender a analizar los argumentos de la línea de comandos utilizando el módulo getopt incorporado.

Después de importar getopt del getopt puede especificar los argumentos a analizar y las opciones cortas y largas con las que ejecutar el script. Necesitamos analizar todos los argumentos empezando por el índice 1 en sys.argv. Por lo tanto, la porción a analizar es sys.argv[1:].

Aquí, necesitaremos un message cadena y file nombre. Utilicemos m y f como opciones cortas y message y file como opciones largas.

Pero, ¿cómo nos aseguramos de que una opción concreta requiere un argumento?

En las opciones cortas, puede hacer que una opción requiera un argumento añadiendo dos puntos (:) después del nombre de la opción corta.
Del mismo modo, en las opciones largas, puede añadir un = después de la opción larga. Podemos capturar estas opciones y sus respectivos argumentos.

Añadiendo esto, tendremos el siguiente código en main.py:

# main.py

import sys
from getopt import getopt

opts, args = getopt(sys.argv[1:],'m:f:',['message=','file='])

print(opts)
print(args)

En este caso, la variable opts contiene las opciones y argumentos como una lista de tuplas. Cualquier otro argumento posicional que pasemos se recogerá en args variable.

Podemos pasar el mensaje y el nombre de archivo para ejecutar el script, y podemos utilizar las opciones cortas o las largas.

Ejecutando main.py usando las opciones largas, tenemos:

$ python3 main.py --message hello --file somefile.txt

Tenemos las opciones y los argumentos como tuplas en el archivo opts variable. Como no hemos pasado ningún argumento posicional, args es una lista vacía.

# Output
[('--message', 'hello'), ('--file', 'somefile.txt')]
[]

De forma equivalente, también podemos utilizar las opciones cortas como se muestra:

$ python3 main.py -m hello -f somefile.txt

# Output
[('-m', 'hello'), ('-f', 'somefile.txt')]
[]

⚠️ El -m en este ejemplo no debe confundirse con la opción de la línea de comandos -m que se utiliza para ejecutar un módulo como módulo principal al ejecutar un script de Python.

Por ejemplo, utilizará python3 -m unittest main.py para ejecutar unittest como módulo principal al ejecutar main.py.

Hemos mencionado que el resto de argumentos posicionales que pasemos se recogerán en el archivo args variable. He aquí un ejemplo:

$ python3 main.py -m hello -f somefile.txt another_argument

En args contiene el argumento posicional otro_argumento.

# Output
[('-m', 'hello'), ('-f', 'somefile.txt')]
['another_argument']

Toma, opts es una lista de tuplas. Así que podemos recorrerla, descomprimir la tupla y extraer los argumentos correspondientes a las opciones específicas.

Pero, ¿qué hacemos con el nombre del fichero y el mensaje después de haber procesado estos argumentos? Abriremos el fichero en modo escritura y escribiremos en él la cadena del mensaje convertida a mayúsculas.

# main.py
import sys
from getopt import getopt

opts, args = getopt(sys.argv[1:],'m:f:',['message=','file='])

print(opts)
print(args)

for option, argument in opts:
    if option == '-m':
        message = argument
    if option == '-f':
        file = argument

with open(file,'w') as f:
    f.write(message.upper())

Vamos a ejecutar main.py con las opciones cortas y los argumentos de la línea de comandos.

$ python main.py -m hello -f thisfile.txt
[('-m', 'hello'), ('-f', 'thisfile.txt')]
[]

Después de ejecutar main.py, podemos ver 'thisfile.txt' en nuestro directorio de trabajo. Contiene la cadena 'hola' convertida a mayúsculas ('HELLO').

$ ls
main.py  thisfile.txt

$ cat thisfile.txt
HELLO

Cómo analizar argumentos de la línea de comandos con Argparse

En argparse también integrado en la biblioteca estándar de Python, proporciona funciones para analizar argumentos de línea de comandos y crear interfaces de línea de comandos.

Para analizar los argumentos de la línea de comandos, importemos el archivo ArgumentParser del módulo argparse. Aquí, hemos instanciado arg_parser, an ArgumentParser objeto:

from argparse import ArgumentParser

arg_parser = ArgumentParser()

A continuación, nos gustaría añadir dos argumentos de línea de comandos:

message: la cadena de mensajes, y
file: el nombre del archivo con el que queremos trabajar.

Ahora llamamos al add_argument() método en arg_parser para añadir estos dos argumentos. En el add_argument() puede establecer help a una cadena (una descripción del argumento).

arg_parser.add_argument('message',help='message string')
arg_parser.add_argument('file',help='filename')

Hasta ahora, hemos instanciado arg_parser y añadido los argumentos de la línea de comandos. Cuando el programa se ejecuta en la línea de comandos, puede utilizar el comando parse_args() método en arg_parser para obtener los valores de los argumentos.

Aquí, capturamos el espacio de nombres del argumento en la variable args. Así que puede utilizar args.argument_name para obtener los valores de los argumentos.

Después de obtener los valores de los argumentos, escribimos el comando message con las mayúsculas y minúsculas intercambiadas (utilizando la swapcase() string) al método file.

args = arg_parser.parse_args()

message = args.message
file = args.file

with open(file,'w') as f:
     f.write(message.swapcase())

Poniendo todo junto, aquí está nuestro archivo main.py:

# main.py

from argparse import ArgumentParser

arg_parser = ArgumentParser()
arg_parser.add_argument('message',help='message string')
arg_parser.add_argument('file',help='filename')

args = arg_parser.parse_args()
print(args)

message = args.message
file = args.file

with open(file,'w') as f:
     f.write(message.swapcase())

Uso de los argumentos de la línea de comandos

Para comprender el uso de los argumentos al ejecutar main.py, puede utilizar la función --help opción larga como se muestra:

$ python3 main.py --help
usage: main.py [-h] message file

positional arguments:
  message     message string
  file        filename

optional arguments:
  -h, --help  show this help message and exit

Existen no argumentos opcionales y ambos message y file son obligatorio argumentos posicionales. Alternativamente, también puede utilizar la opción corta -h:

$ python3 main.py -h
usage: main.py [-h] message file

positional arguments:
  message     message string
  file        filename

optional arguments:
  -h, --help  show this help message and exit

Como se ha visto, ambos argumentos son posicionales por defecto. Así que si usted no pasa en uno o más de estos argumentos, se encontrará con errores.

En este caso, hemos introducido un argumento de posición (Hello) para la función message pero no hemos proporcionado ningún valor para la cadena file argumento.

Y obtenemos un error que indica que el file es necesario.

$ python3 main.py Hello
usage: main.py [-h] message file
main.py: error: the following arguments are required: file

Cuando ejecutamos main.py con ambos argumentos posicionales, vemos que el espacio de nombres args contiene los valores de los argumentos.

$ python3 main.py Hello file1.txt

# Output
Namespace(file='file1.txt', message='Hello')

Ahora, si examinamos el contenido del directorio de trabajo actual, veremos que el script crea el archivo 'archivo1.txt':

$ ls
file1.txt  main.py

La cadena de mensajes original es 'Hola'; después de intercambiar las mayúsculas y minúsculas, la cadena de mensajes en el archivo 'archivo1.txt' es 'hELLO'.

$ cat file1.txt
hELLO

Cómo hacer que los argumentos de la línea de comandos sean opcionales

Para que estos argumentos de línea de comandos opcionalpuede anteponer al nombre del argumento el prefijo --.

Modifiquemos main.py para que tanto el archivo message y el file argumentos opcionales.

# main.py

from argparse import ArgumentParser

arg_parser = ArgumentParser()
arg_parser.add_argument('--message',help='message string')
arg_parser.add_argument('--file',help='filename')

Como los argumentos de la línea de comandos son opcionales, podemos establecer valores por defecto para estos argumentos.

if args.message and args.file:
    message = args.message
    file = args.file
else:
    message = 'Python3'
    file = 'myfile.txt'

En este punto, el archivo main.py contiene el siguiente código:

# main.py

from argparse import ArgumentParser

arg_parser = ArgumentParser()
arg_parser.add_argument('--message',help='message string')
arg_parser.add_argument('--file',help='filename')

args = arg_parser.parse_args()
print(args)

if args.message and args.file:
    message = args.message
    file = args.file
else:
    message = 'Python3'
    file = 'myfile.txt'

with open(file,'w') as f:
     f.write(message.swapcase())

Si comprobamos el uso, vemos que tanto message y file are argumentos opcionales. Esto significa que ahora puede ejecutar main.py sin ambos argumentos.

$ python3 main.py --help
usage: main.py [-h] [--message MESSAGE] [--file FILE]

optional arguments:
  -h, --help         show this help message and exit
  --message MESSAGE  message string
  --file FILE        filename

$ python3 main.py

En el espacio de nombres de los argumentos, tanto file y message son None.

# Output
Namespace(file=None, message=None)

Vemos que por defecto file nombre y message Se utilizan 'miarchivo.txt' y 'Python3'. El archivo 'miarchivo.txt' está ahora en el directorio de trabajo:

$ ls
file1.txt  main.py  myfile.txt

Y contiene la cadena 'Python3' con las mayúsculas y minúsculas intercambiadas:

$ cat myfile.txt
pYTHON3

También puede utilizar tanto el --message y el --file para que el comando sea más legible.

$ python3 main.py --message Coding --file file2.txt

# Output
Namespace(file='file2.txt', message='Coding')

Vemos el 'archivo2.txt' en el directorio de trabajo:

$ ls
file1.txt  file2.txt  main.py  myfile.txt

Y contiene la cadena 'cODING' como se esperaba.

$ cat file2.txt
cODING

Conclusión

He aquí un resumen de lo que hemos aprendido en este tutorial:

Al igual que en el lenguaje de programación C, en Python se puede acceder a los argumentos de la línea de comandos mediante un bucle a través del vector de argumentos sys.argv. sys.argv[0] es el nombre del script de Python. Así que estamos interesados en analizar los argumentos sys.argv[1:].
Sin embargo, para mejorar la legibilidad y poder añadir opciones, puede utilizar los módulos getopt y argparse.
Puede utilizar el módulo getopt para analizar la lista de argumentos de la línea de comandos desde el índice 1 hasta el final de la lista. Puede especificar tanto opts cortas como opts largas.
Cuando una opción toma un argumento, puede especificar dos puntos (:) y = después de la opción corta y la opción larga, respectivamente.
Con el módulo argparse de Python, puede instanciar un archivo ArgumentParser y utilizar el objeto add_argument() para añadir un argumento posicional necesario. Utilice -- antes del nombre del argumento para que sea opcional.
Para recuperar los valores de los argumentos de la línea de comandos, llame a la función parse_args() en el ArgumentParser objeto.

A continuación, aprenda a realizar hash seguro en Python.

Bala Priya C

Autor