¿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 argumentossys.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 objetoadd_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 elArgumentParser
objeto.
A continuación, aprenda a realizar hash seguro en Python.