Il modulo getopt è l'elaboratore originale di opzioni da riga di comando che supporta le convenzioni stabilite dalla funzione Unix getopt. Elabora una sequenza di argomenti tipo sys.argv e restituisce una sequenza di tuple che contengono coppie di valori opzione e argomento ed una sequenza di argomenti non abbinati ad una opzione.

La sintassi delle opzioni supportata comprende la versione corta e lunga:

• -a
• -bvalore
• -b valore
• --nessunargomento
• --conargomento=valore
• --conargomento valore

Argomenti della Funzione

La funzione getopt() riceve tre argomenti:

• Il primo è la sequenza di argomenti da analizzare. In genere deriva da sys.argv[1:] (viene ignorato il nome del programma in sys.argv[0]).
• Il secondo argomento è la stringa di definizione dell'opzione a carattere singolo. Se una delle opzioni richiede un argomento, la sua lettera viene seguita da :.
• Il terzo argomento, se usato, dovrebbe essere una sequenza di nomi di opzioni nella versione "lunga". La versione lunga delle opzioni può essere più di un singolo carattere, tipo --noarg oppure --witharg. I nomi dell'opzione nella sequenza non dovrebbero comprendere il prefisso --. Se una opzione lunga richiede un argomento, il suo nome dovrebbe avere come suffisso =.

La forma breve e la forma lunga possono essere combinate in una unica chiamata.

Forma Breve di Opzioni

Questo esempio accetta 3 opzioni, -a è un semplice flag, -b e c richiedono un argomento. La stringa della definizione dell'opzione dovrebbe essere "ab:c:".

# getopt_short.py

import getopt


opts, args = getopt.getopt(['-a', '-bval', '-c', 'val'], 'ab:c:')

for opt in opts:
    print(opt)

Il programma passa un elenco di valori di opzione simulati a getopt() per mostrare il modo nel quale sono elaborati.

$ python3 getopt_short.py

('-a', '')
('-b', 'val')
('-c', 'val')

Forma Lunga di Opzioni

Per un programma che accetta 2 opzioni, --noarg e --witharg la sequenza degli argomenti nella versione lunga dovrebbe essere [ 'noarg', 'witharg=' ].

# getopt_long.py

import getopt


opts, args = getopt.getopt(
    ['--noarg',
     '--witharg', 'val',
     '--witharg2=another'],
    '',
    ['noarg', 'witharg=', 'witharg2='],
)
for opt in opts:
    print(opt)

Visto che questo programma di esempio non accetta alcuna opzione nella versione breve, il secondo argomento per getopt() è una stringa vuota.

$ python3 getopt_long.py

('--noarg', '')
('--witharg', 'val')
('--witharg2', 'another')

Un Esempio Completo

Di sequito un programma di esempio più completo che richiede 5 opzioni: -o, -v, --output, --verbose, e --version. Le opzioni -o, --output, e --version richiedono ciascuna un argomento.

# getopt_example.py

import getopt
import sys


version = '1.0'
verbose = False
output_filename = 'default.out'

print('ARGV      :', sys.argv[1:])

try:
    options, remainder = getopt.getopt(
        sys.argv[1:],
        'o:v',
        ['output=',
         'verbose',
         'version=',
         ])
except getopt.GetoptError as err:
    print('ERRORE:', err)
    sys.exit(1)

print('OPZIONI   :', options)

for opt, arg in options:
    if opt in ('-o', '--output'):
        output_filename = arg
    elif opt in ('-v', '--verbose'):
        verbose = True
    elif opt == '--version':
        version = arg

print('VERSION   :', version)
print('VERBOSE   :', verbose)
print('OUTPUT    :', output_filename)
print('RIMANENTI :', remainder)

Il programma può essere chiamato in diversi modi. Quando viene chiamato senza argomenti, vengono utilizzate le impostazioni predefinte.

$ python3 getopt_example.py

ARGV      : []
OPZIONI   : []
VERSION   : 1.0
VERBOSE   : False
OUTPUT    : default.out
RIMANENTI : []

Un opzione breve (ad una lettera) può essere divisa dal proprio argomento da un carattere di spaziatura:

$ python3 getopt_example.py -o foo

ARGV      : ['-o', 'foo']
OPZIONI   : [('-o', 'foo')]
VERSION   : 1.0
VERBOSE   : False
OUTPUT    : foo
RIMANENTI : []

Oppure opzione e valore possono essere combinati in un singolo argomento:

$ python3 getopt_example.py -ofoo

ARGV      : ['-ofoo']
OPZIONI   : [('-o', 'foo')]
VERSION   : 1.0
VERBOSE   : False
OUTPUT    : foo
RIMANENTI : []

Allo stesso modo una opzione nella forma lunga può essere separata dal suo valore:

$ python3 getopt_example.py --output foo

ARGV      : ['--output', 'foo']
OPZIONI   : [('--output', 'foo')]
VERSION   : 1.0
VERBOSE   : False
OUTPUT    : foo
RIMANENTI : []

Quando una opzione lunga viene combinata con il suo valore, il nome dell'opzione ed il valore dovrebbero essere separati da un singolo =:

$ python3 getopt_example.py --output=foo

ARGV      : ['--output=foo']
OPZIONI   : [('--output', 'foo')]
VERSION   : 1.0
VERBOSE   : False
OUTPUT    : foo
RIMANENTI : []

Abbreviazione della Forma Lunga di Opzioni

L'opzione a forma lunga non necessita che sia passata interamente, fintanto che viene passato un prefisso univoco:

$ python3 getopt_example.py --o foo

ARGV      : ['--o', 'foo']
OPZIONI   : [('--output', 'foo')]
VERSION   : 1.0
VERBOSE   : False
OUTPUT    : foo
RIMANENTI : []

Se non viene passato un prefisso univoco viene sollevata una eccezione.

$ python3 getopt_example.py --ver 2.0

ARGV      : ['--ver', '2.0']
ERRORE: option --ver not a unique prefix

Elaborazione di Opzioni in Stile GNU

In genere, l'elaborazione delle opzioni si interrompe non appena viene rilevato il primo argomento che non appartiene ad una opzione.

$ python3 getopt_example.py -v not_an_option --output foo

ARGV      : ['-v', 'not_an_option', '--output', 'foo']
OPZIONI   : [('-v', '')]
VERSION   : 1.0
VERBOSE   : True
OUTPUT    : default.out
RIMANENTI : ['not_an_option', '--output', 'foo']

Per mescolare argomenti di opzione e non sulla riga di comando in qualsiasi ordine si utilizzi gnu_getopt().

# getopt_gnu.py

import getopt
import sys


version = '1.0'
verbose = False
output_filename = 'default.out'

print('ARGV      :', sys.argv[1:])

try:
    options, remainder = getopt.gnu_getopt(
        sys.argv[1:],
        'o:v',
        ['output=',
         'verbose',
         'version=',
         ])
except getopt.GetoptError as err:
    print('ERRORE:', err)
    sys.exit(1)

print('OPZIONI   :', options)

for opt, arg in options:
    if opt in ('-o', '--output'):
        output_filename = arg
    elif opt in ('-v', '--verbose'):
        verbose = True
    elif opt == '--version':
        version = arg

print('VERSION   :', version)
print('VERBOSE   :', verbose)
print('OUTPUT    :', output_filename)
print('RIMANENTE :', remainder)

Dopo avere modificato la chiamata nell'esempio precedente, la differenza appare chiara:

$ python3 getopt_gnu.py -v not_an_option --output foo

ARGV      : ['-v', 'not_an_option', '--output', 'foo']
OPZIONI   : [('-v', ''), ('--output', 'foo')]
VERSION   : 1.0
VERBOSE   : True
OUTPUT    : foo
RIMANENTE : ['not_an_option']

Fine dell'Elaborazione di Argomenti

Se getopt() trova -- negli argomenti in input, interrompe l'elaborazione degli argomenti restanti come opzioni. Questa caratteristica può essere usata per passare valori di argomento che sembrano opzioni, tipo nomi di file che iniziano con un trattino ("-").

$ python3getopt_example.py -v -- --output foo
ARGV      : ['-v', '--', '--output', 'foo']
OPZIONI   : [('-v', '')]
VERSION   : 1.0
VERBOSE   : True
OUTPUT    : default.out
RIMASTI   : ['--output', 'foo']