"getopt" --- C-style parser for command line options
****************************************************

**Código fuente:** Lib/getopt.py

Obsoleto desde la versión 3.13: The "getopt" module is *soft
deprecated* and will not be developed further; development will
continue with the "argparse" module.

Nota:

  The "getopt" module is a parser for command line options whose API
  is designed to be familiar to users of the C "getopt()" function.
  Users who are unfamiliar with the C "getopt()" function or who would
  like to write less code and get better help and error messages
  should consider using the "argparse" module instead.

======================================================================

This module helps scripts to parse the command line arguments in
"sys.argv". It supports the same conventions as the Unix "getopt()"
function (including the special meanings of arguments of the form
'"-"' and '"--"').  Long options similar to those supported by GNU
software may be used as well via an optional third argument.

Este módulo proporciona dos funciones y una excepción:

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

   Parses command line options and parameter list.  *args* is the
   argument list to be parsed, without the leading reference to the
   running program. Typically, this means "sys.argv[1:]". *shortopts*
   is the string of option letters that the script wants to recognize,
   with options that require an argument followed by a colon ("':'";
   i.e., the same format that Unix "getopt()" uses).

   Nota:

     Unlike GNU "getopt()", after a non-option argument, all further
     arguments are considered also non-options. This is similar to the
     way non-GNU Unix systems work.

   *longopts*, si se especifica, debe ser una lista de cadenas con los
   nombres de las opciones largas que deben admitirse. Los caracteres
   principales "'-'" no deben incluirse en el nombre de la opción. Las
   opciones largas que requieren un argumento deben ir seguidas de un
   signo igual ("'='"). Los argumentos opcionales no son compatibles.
   Para aceptar solo opciones largas, *shortopts* debe ser una cadena
   vacía. Las opciones largas en la línea de comando pueden
   reconocerse siempre que proporcionen un prefijo del nombre de la
   opción que coincida exactamente con una de las opciones aceptadas.
   Por ejemplo, si *longopts* es "['foo', 'frob']", la opción "--fo"
   coincidirá como "--foo", pero "--f" no coincidirá de forma
   exclusiva, por lo que se lanzará "GetoptError".

   El valor de retorno consta de dos elementos: el primero es una
   lista de pares "(option, value)"; el segundo es la lista de
   argumentos del programa que quedan después de que se eliminó la
   lista de opciones (esta es una porción final de *args*). Cada par
   de opción y valor retornado tiene la opción como su primer
   elemento, con un guión para las opciones cortas (por ejemplo,
   "'-x'") o dos guiones para las opciones largas (por ejemplo, "'--
   long-option'"), y el argumento de la opción como su segundo
   elemento, o una cadena vacía si la opción no tiene argumento. Las
   opciones aparecen en la lista en el mismo orden en que se
   encontraron, lo que permite múltiples ocurrencias. Las opciones
   largas y cortas pueden ser mixtas.

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

   Esta función funciona como "getopt()", excepto que el modo de
   escaneo estilo GNU se usa por defecto. Esto significa que los
   argumentos opcionales y no opcionales pueden estar mezclados. La
   función "getopt()" detiene el procesamiento de opciones tan pronto
   como se encuentra un argumento no-opcionales.

   If the first character of the option string is "'+'", or if the
   environment variable "POSIXLY_CORRECT" is set, then option
   processing stops as soon as a non-option argument is encountered.

exception getopt.GetoptError

   This is raised when an unrecognized option is found in the argument
   list or when an option requiring an argument is given none. The
   argument to the exception is a string indicating the cause of the
   error.  For long options, an argument given to an option which does
   not require one will also cause this exception to be raised.  The
   attributes "msg" and "opt" give the error message and related
   option; if there is no specific option to which the exception
   relates, "opt" is an empty string.

exception getopt.error

   Alias para "GetoptError"; para compatibilidad con versiones
   anteriores.

Un ejemplo que usa solo opciones de estilo Unix:

>>> import getopt
>>> args = '-a -b -cfoo -d bar a1 a2'.split()
>>> args
['-a', '-b', '-cfoo', '-d', 'bar', 'a1', 'a2']
>>> optlist, args = getopt.getopt(args, 'abc:d:')
>>> optlist
[('-a', ''), ('-b', ''), ('-c', 'foo'), ('-d', 'bar')]
>>> args
['a1', 'a2']

Usar nombres largos de opciones es igualmente fácil:

>>> s = '--condition=foo --testing --output-file abc.def -x a1 a2'
>>> args = s.split()
>>> args
['--condition=foo', '--testing', '--output-file', 'abc.def', '-x', 'a1', 'a2']
>>> optlist, args = getopt.getopt(args, 'x', [
...     'condition=', 'output-file=', 'testing'])
>>> optlist
[('--condition', 'foo'), ('--testing', ''), ('--output-file', 'abc.def'), ('-x', '')]
>>> args
['a1', 'a2']

En un script, el uso típico es algo como esto:

   import getopt, sys

   def main():
       try:
           opts, args = getopt.getopt(sys.argv[1:], "ho:v", ["help", "output="])
       except getopt.GetoptError as err:
           # print help information and exit:
           print(err)  # will print something like "option -a not recognized"
           usage()
           sys.exit(2)
       output = None
       verbose = False
       for o, a in opts:
           if o == "-v":
               verbose = True
           elif o in ("-h", "--help"):
               usage()
               sys.exit()
           elif o in ("-o", "--output"):
               output = a
           else:
               assert False, "unhandled option"
       # ...

   if __name__ == "__main__":
       main()

Tenga en cuenta que se podría generar una interfaz de línea de comando
equivalente con menos código y más ayuda informativa y mensajes de
error utilizando el módulo "argparse":

   import argparse

   if __name__ == '__main__':
       parser = argparse.ArgumentParser()
       parser.add_argument('-o', '--output')
       parser.add_argument('-v', dest='verbose', action='store_true')
       args = parser.parse_args()
       # ... do something with args.output ...
       # ... do something with args.verbose ..

Ver también:

  Módulo "argparse"
     Opción de línea de comando alternativa y biblioteca de análisis
     de argumentos.
