Análisis de argumentos en Python

Si estás preparando un proyecto de ciencia de datos o de aprendizaje automático, es muy habitual empezar a desarrollarlo en un Jupyter Notebook. Te aporta interactividad, te permite ejecutar módulos al instante, etc. Hay muchos motivos para elegir Jupyter Notebooks como tu herramienta principal, sobre todo para proyectos de ciencia de datos o de machine learning. Aun así, este tutorial no va de eso.

Imagina que necesitas ejecutar un script de Python como tarea en lote para ingerir datos en tu proyecto de ciencia de datos. O que quieres desplegar un modelo de machine learning en un servidor remoto con un script de Python. En casos así, simplemente ejecutar python your_script.py puede no ser suficiente. Puede que tengas que pasar más opciones o argumentos junto con python your_script.py. Seguramente ya te suene usar argumentos adicionales al ejecutar comandos (como ps, ls, etc.) en una terminal Linux.

En este tutorial vas a aprender a analizar argumentos y opciones adicionales que se pasan por la línea de comandos junto con un script de Python. Aquí tienes el resumen de contenidos de hoy:

• Introducción básica al análisis de argumentos
• Análisis de argumentos en Python
  • Usando sys.argv
  • Usando getopt
  • Usando argparse

Nota: este tutorial asume que tienes nociones básicas de Python.

¿Qué es el análisis de argumentos?

Si usas Linux, esto ya te sonará, apuesto a ello. Para ver un resumen de los archivos y carpetas de un directorio concreto, se usa a menudo el comando ls. Una salida típica al ejecutar ls se ve así:

Sin embargo, puedes pasar muchas opciones al comando ls, por ejemplo -l. Veamos cómo cambia la salida:

Al pasar la opción -l, obtienes más información. Ahora bien, hay una ligera diferencia entre una opción y un argumento en este contexto. Para eliminar un archivo o carpeta del directorio de trabajo actual, se usa el comando rm. Supón que tienes un archivo de texto llamado demo.txt y ejecutas rm demo.txt para borrarlo. En este caso, demo.txt es el argumento que aplicas al comando rm. Si no pasas ningún argumento a rm, obtendrás un error como este:

Entonces, ¿cuál es la diferencia entre una opción y un argumento? Es bastante evidente: las opciones son opcionales, mientras que los argumentos suelen ser necesarios. No es imprescindible pasar nada a ls para que devuelva una salida.

Cuando escribes ls -l o rm demo.txt, el sistema operativo lo analiza internamente de una forma determinada. Este mecanismo lo especifican normalmente los desarrolladores del sistema operativo y se conoce como parsing o análisis.

Si te interesa conocer más comandos de Linux y las distintas opciones y argumentos que admiten, es muy recomendable el libro Unix Concepts and Applications.

Esta ha sido una introducción básica al análisis de argumentos. Casi todos los lenguajes de programación lo soportan, y Python no es una excepción. Hay tres formas muy extendidas de hacerlo en Python:

• sys.argv
• getopt
• argparse

Ahora vamos a ver cada una por separado y cómo usarlas para analizar argumentos (y opciones). Iremos en orden cronológico.

Análisis de argumentos con sys.argv

Empecemos sencillo. En este primer ejemplo, vas a crear un archivo de Python llamado demo1.py. Tu programa aceptará un número arbitrario de argumentos pasados desde la línea de comandos (o la terminal) al ejecutarse. El programa imprimirá los argumentos recibidos y el número total de argumentos.

Por ejemplo, si ejecutas python demo1.py abc 123, el programa devolvería:

Number of arguments: 3
Argument(s) passed: ['demo1.py', 'abc', '123']

Fíjate en que el primer argumento es siempre el nombre del archivo de Python. Pero puedes modificar el código para excluirlo.

Vamos con el código:

import sys

print('Number of arguments: {}'.format(len(sys.argv)))
print('Argument(s) passed: {}'.format(str(sys.argv)))

Primero importas el módulo estándar de Python sys. Después usas el submódulo argv, que devuelve la lista de argumentos pasados a un script de Python, donde argv[0] contiene el nombre del script. Si ejecutas sys.argv en una celda de código como la siguiente, obtendrás la lista de archivos de configuración que hacen que el kernel de IPython funcione correctamente. Mejor no tocarlos.

sys.argv

['/home/nbuser/anaconda3_501/lib/python3.6/site-packages/ipykernel/__main__.py',
 '-f',
 '/home/nbuser/.local/share/jupyter/runtime/kernel-dabba4f7-e3e0-4c39-99d2-261ba835c53f.json']

Veamos ahora cómo usar el módulo getopt para analizar argumentos (y opciones).

Análisis de argumentos con getopt

En comparación con sys.argv, el módulo getopt ofrece mucha más flexibilidad. Primero vamos a plantear un escenario de ejemplo y luego escribimos el código.

Digamos que has publicado un script de Python que aún no has documentado. Pero quieres dar a los usuarios mensajes útiles cuando lo ejecuten de una forma no prevista. Tu script hace una tarea sencilla: suma dos números y muestra el resultado. La única condición es que el usuario debe pasar las entradas como argumentos en la línea de comandos junto con el script.

Siendo prácticos, el script idealmente se ejecutaría así:

python add_numbers.py -a 3 -b 8

La salida debe ser 11. Aquí, -a y -b son las opciones, y 3 y 8 son los argumentos que pasas al script. Las opciones no solo mejoran la legibilidad, sino que también ayudan a decidir el flujo de evaluación (imagina que en lugar de sumar quisieras dividir). Veamos primero el código:

import getopt
import sys

# Get the arguments from the command-line except the filename
argv = sys.argv[1:]
sum = 0

try:
    # Define the getopt parameters
    opts, args = getopt.getopt(argv, 'a:b:', ['foperand', 'soperand'])
    # Check if the options' length is 2 (can be enhanced)
    if len(opts) == 0 and len(opts) > 2:
      print ('usage: add.py -a <first_operand> -b <second_operand>')
    else:
      # Iterate the options and get the corresponding values
      for opt, arg in opts:
         sum += int(arg)
      print('Sum is {}'.format(sum))

except getopt.GetoptError:
    # Print something useful
    print ('usage: add.py -a <first_operand> -b <second_operand>')
    sys.exit(2)

La idea es obtener primero todos los argumentos con sys.argv y después procesarlos. Vamos ahora a la línea más importante: opts, args = getopt.getopt(argv, 'a:b:', ['foperand', 'soperand'])

La firma del método getopt() es:

getopt.getopt(args, shortopts, longopts=[])

• args es la lista de argumentos tomada de la línea de comandos.
• shortopts es donde indicas las letras de opción. Si pones a:, significa que tu script debe recibir la opción a seguida de un valor como argumento. Técnicamente, puedes usar cualquier número de opciones aquí. Al pasarlas por la línea de comandos, deben ir precedidas de «-».
• longopts es donde puedes especificar las versiones extendidas de shortopts. Deben ir precedidas de «--».

Has definido shortopts como a:b:, lo que significa que tu script aceptará dos opciones con letras: «a» y «b». Al añadir «:» indicas explícitamente que estas opciones irán seguidas de argumentos.

Has definido longopts como ['foperand', 'soperand'], lo que indica que el código aceptará f_operand y s_operand en lugar de a y b como opciones. Pero siempre deben ir precedidas de --.

El módulo getopt también te ofrece la clase de excepción GetoptError para definir mensajes útiles y guiar al usuario sobre cómo usar tu script. Por eso has envuelto la parte funcional en un bloque try y has definido el bloque except en consecuencia.

Así puedes ejecutar el script de Python:

Nota: el script anterior no está preparado para manejar los longopts. Puedes añadirlo como ejercicio.

Veamos ahora cómo usar argparse para analizar argumentos.

Análisis de argumentos con argparse

Con las dos opciones anteriores, es fácil ver que no son especialmente legibles. Cuando veas argparse en acción, coincidirás en que también se quedan cortas en flexibilidad. Para entender cómo usar argparse, empecemos con un fragmento que implementa el escenario que viste en la sección anterior.

import argparse

# Construct the argument parser
ap = argparse.ArgumentParser()

# Add the arguments to the parser
ap.add_argument("-a", "--foperand", required=True,
   help="first operand")
ap.add_argument("-b", "--soperand", required=True,
   help="second operand")
args = vars(ap.parse_args())

# Calculate the sum
print("Sum is {}".format(int(args['foperand']) + int(args['soperand'])))

Para empezar, argparse, igual que los otros dos módulos, viene con la instalación estándar de Python. Instancias el objeto argparse y el resto se vuelve muy sencillo de escribir. Fíjate, por ejemplo, en esta línea:

ap.add_argument("-a", "--foperand", required=True, help="first operand")

Aquí añades el argumento que esperas que se pase al ejecutar el script. Proporcionas la versión corta del argumento y su forma extendida. Con required=True pides explícitamente al usuario que proporcione ese argumento. Por último, incluyes una descripción útil que se mostrará si no ejecuta el script correctamente.

La definición del segundo argumento es análoga. Accedes a los argumentos indicados mediante sus respectivas claves.

El fragmento anterior deja claro lo fácil y flexible que es definir tareas de análisis de argumentos con argparse. Así puedes probar el script:

Fíjate en lo mucho que se simplifica todo con argparse.

¿Qué sigue?

Gracias por llegar hasta el final. Ahora ya dominas los módulos nativos de Python que permiten analizar los argumentos que se pasan por la línea de comandos junto con tu script. Como ejercicio, puedes adaptar tus proyectos de machine learning y ciencia de datos para facilitar el análisis de argumentos y convertirlos en utilidades de línea de comandos. No solo en ML o ciencia de datos, sino siempre que te resulte útil. Eso es todo por hoy. Si quieres seguir mejorando tus habilidades en Python, quizá te interese el curso de DataCamp Python Data Science Toolbox (Part 1).