¿Quiere ejecutar secuencias de comandos de Python con argumentos de línea de comandos? Aprenda a analizar argumentos de la línea de comandos con los módulos sys, getopt y argparse en Python.
En Python, cuando desee leer la entrada del usuario, usaría la función input(). Sin embargo, para algunas aplicaciones, es posible que desee pasar algunos argumentos al ejecutar el script en la línea de comandos.
En este tutorial, aprenderemos cómo ejecutar un script de Python con opciones y argumentos de línea de comandos. Luego aprenderemos a usar los módulos integrados de Python para analizar estas opciones y argumentos.
¡Empecemos!
Contenido del sitio
Entendiendo sys.argv en Python
Si has programado en C, sabes que una de las formas más sencillas de pasar argumentos al programa es a través de la línea de comandos. Para hacer esto, 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;
}
Aquí, argc significa número de argumentos y argv significa vector de argumentos.
Ejecutar scripts de Python con argumentos de línea de comando
En Python, puede ejecutar el script de Python en la línea de comando usando python3 filename.py. Al hacerlo, también puede pasar un número arbitrario de argumentos de línea de comando:
$ python3 filename.py arg1 arg2 ... argn
El módulo sys proporciona soporte listo para usar para acceder y procesar estos argumentos de la línea de comandos. sys.argv es la lista de todos los argumentos de la línea de comandos que pasamos cuando ejecutamos el script de Python.
Aquí hay un ejemplo donde ejecutamos main.py con argumentos de línea de comando:
$ python3 main.py hello world python script
Podemos recorrer el vector de argumento usando un bucle for simple y una función de enumeración:
# 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 siguientes argumentos comienzan en el índice 1.
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 pasar?
- ¿Y qué significan estos argumentos?
No está muy claro. Para resolver este problema, puede usar los módulos getopt o argparse. Y aprenderemos sobre ello en las siguientes secciones.✅
Análisis de argumentos de línea de comando usando getopt de Python
Aprendamos cómo analizar los argumentos de la línea de comando usando el módulo incorporado getopt.
Después de importar getopt desde el módulo getopt, puede especificar los argumentos para analizar y las opciones cortas y largas con las que ejecutar el script. Necesitamos analizar todos los argumentos a partir del índice 1 en sys.argv. El segmento a analizar es por lo tanto sys.argv[1:].
Aquí necesitaremos una cadena de mensaje y un nombre de archivo. Usemos m y f como opciones cortas y mensaje y archivo como opciones largas.
Pero, ¿cómo se asegura de que una opción específica requiera un argumento?
- En las opciones cortas, puede hacer que una opción requiera un argumento agregando dos puntos (:) después del nombre de la opción corta.
- De manera similar, en opciones largas, puede agregar un = firme después de la opción larga. Podemos capturar estas opciones y sus respectivos argumentos.
Agregándolos, 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)
Aquí, la variable opts contiene las opciones y los argumentos como una lista de tuplas. Cualquier otro argumento posicional que pasemos se recopilará en la variable args.
Podemos pasar el mensaje y el nombre del archivo para ejecutar el script, y podemos usar las opciones cortas o las opciones largas.
Ejecutando main.py usando opciones largas tenemos:
$ python3 main.py --message hello --file somefile.txt
Tenemos las opciones y argumentos como tuplas en la variable opts. Como no pasamos ningún argumento posicional, args es una lista vacía.
# Output
[('--message', 'hello'), ('--file', 'somefile.txt')]
[]
De manera equivalente, también podemos usar opciones cortas como se muestra:
$ python3 main.py -m hello -f somefile.txt
# Output
[('-m', 'hello'), ('-f', 'somefile.txt')]
[]
⚠️ La opción corta -m en este ejemplo no debe confundirse con el indicador de línea de comando -m que se usa para ejecutar un módulo como el módulo principal cuando se ejecuta un script de Python.
Por ejemplo, usaría python3 -m unittest main.py para ejecutar unittest como módulo principal al ejecutar main.py.
Mencionamos que cualquier otro argumento posicional que pasemos se recopilará en la variable args. Aquí un ejemplo :
$ python3 main.py -m hello -f somefile.txt another_argument
La lista de argumentos contiene el argumento posicional otro_argumento.
# Output
[('-m', 'hello'), ('-f', 'somefile.txt')]
['another_argument']
Aquí, opts es una lista de tuplas. Entonces podemos recorrerlo, desempaquetar la tupla y extraer los argumentos correspondientes a las opciones específicas.
Pero, ¿qué hacemos con el nombre del archivo y el mensaje después de procesar estos argumentos? Abriremos el archivo en modo de escritura y escribiremos la cadena de mensaje en mayúsculas convertida en el archivo.
# 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())
Ejecutemos main.py con opciones cortas y argumentos de línea de comando.
$ 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 (‘HOLA’).
$ ls main.py thisfile.txt
$ cat thisfile.txt HELLO
Cómo analizar argumentos de línea de comandos con Argparse
EL argumentar El módulo, que también forma parte de la biblioteca estándar de Python, proporciona funcionalidad para analizar argumentos de línea de comandos y también para crear interfaces de línea de comandos.
Para analizar los argumentos de la línea de comandos, importemos la clase ArgumentParser del módulo argparse. Aquí hemos instanciado arg_parser, un objeto ArgumentParser:
from argparse import ArgumentParser arg_parser = ArgumentParser()
A continuación, nos gustaría agregar dos argumentos de línea de comando:
- mensaje: la cadena del mensaje, y
- archivar: el nombre del archivo con el que nos gustaría trabajar.
Ahora llamamos al método add_argument() en arg_parser para agregar estos dos argumentos. En la llamada al método add_argument(), puede establecer ayuda en 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 agregado los argumentos de la línea de comando. Cuando el programa se ejecuta en la línea de comando, puede usar el método parse_args() en arg_parser para obtener los valores de los argumentos.
Aquí capturamos el espacio de nombres del argumento en la variable args. Entonces puede usar args.argument_name para obtener los valores de los argumentos.
Después de obtener los valores de los argumentos, escribimos la cadena del mensaje con mayúsculas y minúsculas (utilizando el método de cadena swapcase()) en el archivo.
args = arg_parser.parse_args()
message = args.message
file = args.file
with open(file,'w') as f:
f.write(message.swapcase())
Poniéndolo 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())
Comprender el uso de argumentos de línea de comando
Para comprender el uso de argumentos al ejecutar main.py, puede usar la opción larga –help 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
No hay argumentos opcionales, y el mensaje y el archivo son argumentos posicionales obligatorios. Alternativamente, también puede usar 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 puede ver, ambos argumentos son argumentos posicionales por defecto. Entonces, si no pasa uno o más de estos argumentos, encontrará errores.
Aquí pasamos un argumento posicional (Hola) para la cadena del mensaje, pero no proporcionamos ningún valor para el argumento del archivo.
Y recibimos un error que indica que se requiere el argumento del archivo.
$ python3 main.py Hello usage: main.py [-h] message file main.py: error: the following arguments are required: file
Cuando ejecutamos main.py con los dos argumentos posicionales, vemos que los argumentos del espacio de nombres contienen 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, vemos que el script crea el archivo ‘file1.txt’:
$ ls file1.txt main.py
La cadena del mensaje original es ‘Hola’; después de cambiar el caso, la cadena de mensaje en el archivo ‘file1.txt’ es ‘hELLO’.
$ cat file1.txt hELLO
Cómo hacer que los argumentos de la línea de comandos sean opcionales
Para hacer que estos argumentos de la línea de comandos sean opcionales, puede anteponer el nombre del argumento con –.
Modifiquemos main.py para que el mensaje y los argumentos del archivo sean 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')
Dado que los argumentos de la línea de comandos son opcionales, podemos establecer valores predeterminados 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 verificamos el uso, vemos que el mensaje y el archivo son argumentos opcionales. Esto significa que ahora puede ejecutar main.py sin estos dos 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 del argumento, el archivo y el mensaje son Ninguno.
# Output Namespace(file=None, message=None)
Vemos que se utilizan el nombre de archivo predeterminado y el mensaje ‘myfile.txt’ y ‘Python3’. El archivo ‘myfile.txt’ ahora está en el directorio de trabajo:
$ ls file1.txt main.py myfile.txt
Y contiene la cadena ‘Python3’ con mayúsculas y minúsculas intercambiadas:
$ cat myfile.txt pYTHON3
También puede usar los argumentos –message y –file para hacer que el comando sea más legible.
$ python3 main.py --message Coding --file file2.txt
# Output Namespace(file='file2.txt', message='Coding')
Vemos el ‘file2.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
Aquí hay un resumen de lo que aprendimos en este tutorial:
- De manera similar al lenguaje de programación C, en Python puede acceder a los argumentos de la línea de comando atravesando el vector de argumento sys.argv. sys.argv[0] es el nombre del script de Python. Por lo tanto, estamos interesados en analizar los argumentos sys.argv[1:].
- Sin embargo, para mejorar la legibilidad y poder agregar opciones, puede usar 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 opciones cortas como opciones 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 crear una instancia de un objeto ArgumentParser y usar el método add_argument() para agregar un argumento posicional requerido. Use — antes del nombre del argumento para que sea opcional.
- Para recuperar los valores de los argumentos desde la línea de comando, llame al método parse_args() en el objeto ArgumentParser.
A continuación, aprenda cómo realizar hash seguro en Python.
