getopt — Análisis de opciones de línea de comando

Propósito:Análisis de opciones de línea de comando

El módulo getopt es el analizador de opciones de línea de comando original que soporta las convenciones establecidas por la función getopt de Unix. Analiza una secuencia de argumentos, como sys.argv y devuelve una secuencia de tuplas que contienen pares (opción, argumento) y una secuencia de argumentos no opcionales.

La sintaxis de opciones admitidas incluye opciones de forma corta y larga:

-a
-bval
-b val
--noarg
--witharg=val
--witharg val

Nota

getopt no está en desuso, pero argparse es mantenido más activamente y debe usarse para nuevos desarrollos.

Argumentos de funciones

La función getopt() toma tres argumentos:

  • El primer parámetro es la secuencia de argumentos a analizar. Esta generalmente proviene de sys.argv[1:] (ignorando el nombre del programa en sys.arg[0]).
  • El segundo argumento es la cadena de definición de opción para opciones de un sólo carácter. Si una de las opciones requiere un argumento, la letra es seguida por dos puntos.
  • El tercer argumento, si se usa, debería ser una secuencia de nombres de opciones largas. Las opciones largas pueden ser de más que una solo carácter, como --noarg o --witharg. Los nombres de las opciones en la secuencia no debe incluir el prefijo "--". Si una opción larga requiere un argumento, su nombre debe tener un sufijo "=".

Las opciones de forma corta y larga se pueden combinar en una sola llamada.

Opciones cortas

Este programa de ejemplo acepta tres opciones. La -a es un simple bandera, mientras que -b y -c requieren un argumento. La cadena de definición de la opción es "ab:c:".

getopt_short.py
import getopt

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

for opt in opts:
    print(opt)

El programa pasa una lista de valores de opciones simuladas a getopt() para mostrar la forma en que se procesan.

$ python3 getopt_short.py

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

Opciones largas

Para un programa que tiene dos opciones, --noarg y --witharg, la secuencia de argumento largo debe ser ['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)

Dado que este programa de muestra no toma ninguna opción de forma abreviada, el segundo argumento para getopt() es una cadena vacía.

$ python3 getopt_long.py

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

Un ejemplo completo

Este ejemplo es un programa más completo que tiene cinco opciones: -o, -v, --output, --verbose y --version. Las opciones -o, --output y --version requieren cada una argumento.

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('ERROR:', err)
    sys.exit(1)

print('OPTIONS   :', 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('REMAINING :', remainder)

El programa se puede llamar de varias maneras. Cuando se llama sin ningún argumento, se utiliza la configuración predeterminada.

$ python3 getopt_example.py

ARGV      : []
OPTIONS   : []
VERSION   : 1.0
VERBOSE   : False
OUTPUT    : default.out
REMAINING : []

Una opción de una sola letra puede separarse de su argumento por espacio en blanco.

$ python3 getopt_example.py -o foo

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

O la opción y el valor se pueden combinar en un solo argumento.

$ python3 getopt_example.py -ofoo

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

Una opción larga también puede separarse del valor.

$ python3 getopt_example.py --output foo

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

Cuando una opción larga se combina con su valor, el nombre de la opción y el valor debe estar separado por un solo =.

$ python3 getopt_example.py --output=foo

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

Abreviar opciones de forma larga

La opción larga no tiene que especificarse completamente en la línea de comando, siempre que se proporcione un prefijo único.

$ python3 getopt_example.py --o foo

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

Si no se proporciona un prefijo único, se genera una excepción.

$ python3 getopt_example.py --ver 2.0

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

Análisis de opciones de estilo GNU

Normalmente, el procesamiento de opciones se detiene tan pronto como el primer argumento no opción se encuentra.

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

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

Para mezclar argumentos opcionales y no opcionales en la línea de comando en cualquier orden, usa gnu_getopt() en su lugar.

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('ERROR:', err)
    sys.exit(1)

print('OPTIONS   :', 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('REMAINING :', remainder)

Después de cambiar la llamada en el ejemplo anterior, la diferencia se vuelve clara.

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

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

Finalizar el procesamiento de argumentos

Si getopt() encuentra «--» en los argumentos de entrada, se detiene el procesamiento de los argumentos restantes como opciones. Esta característica puede ser usada para pasar valores de argumentos que parecen opciones, como nombres de archivo que comienzan con un guión («-«).

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

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

Ver también