Parsing degli argomenti in Python

Se stai pianificando un progetto di data science o machine learning, non è raro iniziare a svilupparlo in un Jupyter Notebook. Offre interattività agli strumenti di calcolo, ti permette di eseguire rapidamente i tuoi moduli e così via. Ci sono molti motivi per scegliere i Jupyter Notebook come strumento principale, soprattutto per progetti di data science o machine learning. Tuttavia, questo tutorial non intende approfondire quell'aspetto.

Immagina di dover eseguire uno script Python come job batch per l’ingestione dei dati nel tuo progetto di data science. Oppure di dover eseguire uno script Python per distribuire un modello di machine learning su un server remoto. In casi come questi, eseguire semplicemente python your_script.py potrebbe non essere sufficiente. Potresti dover passare ulteriori opzioni o argomenti insieme a python your_script.py. Potresti già avere familiarità con l’uso di argomenti aggiuntivi quando esegui comandi (come ps, ls, ecc.) su un terminale Linux.

In questo tutorial imparerai a effettuare il parsing di argomenti aggiuntivi e opzioni dalla riga di comando passati insieme a uno script Python. Ecco il sommario dei contenuti di oggi:

• Un’introduzione di base al parsing degli argomenti
• Parsing degli argomenti in Python
  • Uso di sys.argv
  • Uso di getopt
  • Uso di argparse

Nota che questo tutorial presuppone una familiarità di base con Python.

Che cos’è il parsing degli argomenti?

Se usi Linux, probabilmente lo sai già, scommetto. Per ottenere un riepilogo dei file e delle cartelle presenti in una determinata directory, si usa spesso il comando ls. Un tipico output dell’esecuzione del comando ls è simile a questo:

Tuttavia, puoi fornire molte opzioni al comando ls, ad esempio -l. Vediamo come appare quell’output:

Passando l’opzione -l, ottieni più informazioni. Ora, in questo contesto c’è una piccola differenza tra un’opzione e un argomento. Per rimuovere un file o una cartella dalla directory di lavoro corrente si usa spesso il comando rm. Supponi di avere un file di testo chiamato demo.txt ed esegui rm demo.txt per rimuoverlo. In questo caso, demo.txt è l’argomento che hai applicato al comando rm. Se non passi alcun argomento al comando rm, otterrai un errore come questo:

Quindi, qual è la differenza tra un’opzione e un argomento? Ora è piuttosto evidente. Le opzioni sono facoltative da passare, mentre gli argomenti sono (spesso) necessari. Non è indispensabile passare nulla al comando ls perché produca un output.

Quando digiti ls -l o rm demo.txt, il sistema operativo effettua il parsing in un certo modo sotto il cofano. Questo meccanismo è generalmente definito dagli sviluppatori del sistema operativo ed è noto come parsing.

Se ti interessa conoscere più comandi Linux e le diverse opzioni e argomenti che supportano, è altamente consigliata la lettura del libro Unix Concepts and Applications.

Questa era un’introduzione di base al parsing degli argomenti. Quasi tutti i linguaggi di programmazione supportano il parsing degli argomenti. Python non fa eccezione. Ci sono tre modi molto diffusi per fare parsing degli argomenti in Python:

• sys.argv
• getopt
• argparse

Ora prenderai ciascuna delle opzioni sopra una alla volta e vedrai come usarle per analizzare argomenti (e opzioni). Andiamo in ordine cronologico.

Parsing degli argomenti con sys.argv

Partiamo semplice. In questo primo esempio, creerai un file Python chiamato demo1.py. Il tuo programma accetterà un numero arbitrario di argomenti passati dalla riga di comando (o terminale) durante l’esecuzione. Il programma stamperà gli argomenti passati e il numero totale di argomenti.

Per esempio, se esegui python demo1.py abc 123, il programma produrrà:

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

Nota che il primo argomento è sempre il nome del file Python. Ma il codice può essere modificato per escluderlo.

Passiamo ora al codice:

import sys

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

Per prima cosa hai importato il modulo Python sys, che è incluso in un’installazione standard di Python. Poi hai usato il sottomodulo argv, che restituisce l’elenco degli argomenti passati a uno script Python, dove argv[0] contiene il nome dello script. Se esegui sys.argv in una cella di codice come la seguente, ottieni l’elenco dei file di configurazione responsabili del corretto funzionamento del kernel IPython. Meglio non toccarli.

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']

Vediamo ora come usare il modulo getopt per analizzare argomenti (e opzioni).

Parsing degli argomenti con getopt

Rispetto a sys.argv, il modulo getopt offre molta più flessibilità. Progettiamo prima uno scenario di esempio e scriviamo il codice di conseguenza.

Mettiamo che tu abbia rilasciato uno script Python che non hai ancora documentato. Ma vuoi comunque fornire agli utenti un riscontro significativo quando eseguono quello script in un modo non previsto. Il tuo script Python svolge il semplice compito di sommare due numeri e restituire un output. L’unico vincolo è che l’utente deve passare gli input come argomenti da riga di comando insieme allo script Python.

In termini più pratici, idealmente lo script andrebbe eseguito così:

python add_numbers.py -a 3 -b 8

L’output dovrebbe essere 11. Qui, -a e -b sono le opzioni, e 3, 8 sono gli argomenti che fornisci allo script. Le opzioni non solo migliorano la leggibilità, ma aiutano anche a decidere il flusso di valutazione (pensa se stessi facendo una divisione invece di un’addizione). Vediamo innanzitutto il codice.

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)

L’idea è prima ottenere tutti gli argomenti con sys.argv e poi elaborarli di conseguenza. Passiamo ora alla riga di codice più importante: opts, args = getopt.getopt(argv, 'a:b:', ['foperand', 'soperand'])

La firma del metodo getopt() è la seguente:

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

• args è l’elenco degli argomenti presi dalla riga di comando.
• shortopts è dove specifichi le lettere delle opzioni. Se fornisci a:, significa che al tuo script deve essere passata l’opzione a seguita da un valore come suo argomento. Tecnicamente, qui puoi usare qualsiasi numero di opzioni. Quando passi queste opzioni dalla riga di comando, devono essere precedute da “-”.
• longopts è dove puoi specificare le versioni estese delle shortopts. Devono essere precedute da “--”.

Hai definito le shortopts come a:b:, il che significa che il tuo script Python accetterà due opzioni come lettere: “a” e “b”. Specificando “:” stai dichiarando esplicitamente che queste opzioni saranno seguite da argomenti.

Hai definito le longopts come ['foperand', 'soperand'], un modo per dire al codice di accettare f_operand e s_operand al posto di a e b come opzioni. Ma queste devono sempre essere precedute da --.

Il modulo getopt fornisce anche una comoda classe di eccezioni, GetoptError, per definire messaggi utili e guidare l’utente su come usare il tuo script Python. Per questo hai racchiuso la parte funzionale dello script in un blocco try e definito il blocco except di conseguenza.

Ecco come puoi eseguire lo script Python:

Nota che lo script sopra non è stato definito per gestire le longopts. Questo è qualcosa che puoi provare come esercizio.

Vediamo ora come usare argparse per il parsing degli argomenti.

Parsing degli argomenti con argparse

Dalle due opzioni viste sopra, è abbastanza evidente che non sono molto leggibili. Una volta visto argparse in azione, concorderai anche sul fatto che le due opzioni precedenti sono carenti in termini di flessibilità. Per capire l’uso di argparse, partiamo da uno snippet di codice che implementa lo scenario visto nella sezione precedente.

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'])))

Per cominciare, argparse, come gli altri due moduli discussi sopra, è incluso nell’installazione standard di Python. Inizi creando un’istanza dell’oggetto argparse. Il resto diventa molto più semplice da scrivere. Prendiamo ad esempio la seguente riga di codice:

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

Qui hai aggiunto l’argomento che ti aspetti venga fornito insieme allo script Python quando viene eseguito. Hai fornito la versione letterale dell’argomento insieme a quella estesa. Specificando required=True chiedi esplicitamente all’utente di fornire quel particolare argomento. Infine, hai aggiunto una descrizione significativa dell’argomento che verrà mostrata all’utente nel caso in cui non esegua lo script nel modo corretto.

La definizione dell’argomento è la stessa anche per il secondo argomento. Accedi agli argomenti forniti specificandone i rispettivi indici.

Lo snippet di codice sopra mostra chiaramente quanto sia facile e flessibile definire attività di parsing degli argomenti da riga di comando con argparse. Ecco come puoi sperimentare con lo script Python sopra:

Nota quanto sia diventato più semplice il processo con argparse.

E adesso?

Grazie per aver letto il tutorial di oggi fino alla fine. Ora conosci i moduli nativi di Python in grado di analizzare gli argomenti forniti dalla riga di comando insieme al tuo script Python. Come esercizio, puoi personalizzare di conseguenza i tuoi progetti di machine learning e data science per facilitare il parsing degli argomenti e trasformarli in utili utility da riga di comando. Non solo machine learning o data science, ma ovunque ti sembri abbastanza pertinente. Questo è tutto per il tutorial di oggi. Se vuoi migliorare le tue competenze in Python, potresti voler seguire il corso Python Data Science Toolbox (Parte 1) di DataCamp.