"getopt" – Analyseur de style C pour les options de ligne de commande
*********************************************************************

**Code source :** Lib/getopt.py

Obsolète depuis la version 3.13: The "getopt" module is *soft
deprecated* and will not be developed further; development will
continue with the "argparse" module.

Note:

  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.

Ce module fournit deux fonctions et une exception :

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).

   Note:

     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 spécifié, doit être une liste de chaînes avec les
   noms des options longues qui doivent être prises en charge. Le
   premier "'--'" ne dois pas figurer dans le nom de l’option. Les
   options longues qui requièrent un argument doivent être suivies
   d’un signe égal ("'='"). Les arguments facultatifs ne sont pas pris
   en charge. Pour accepter uniquement les options longues,
   *shortopts* doit être une chaîne vide. Les options longues sur la
   ligne de commande peuvent être reconnues tant qu’elles fournissent
   un préfixe du nom de l’option qui correspond exactement à l’une des
   options acceptées. Par exemple, si *longopts* est "['foo',
   'frob']", l’option "--fo" correspondra à "--foo", mais "--f" ne
   correspondra pas de façon unique, donc "GetoptError" sera levé.

   La valeur de retour se compose de deux éléments : le premier est
   une liste de paires "(option, value)", la deuxième est la liste des
   arguments de programme laissés après que la liste d’options est été
   dépouillée (il s’agit d’une tranche de fin de *args*). Chaque paire
   option-valeur retournée a l’option comme premier élément, préfixée
   avec un trait d'union pour les options courtes (par exemple,
   "'-x'") ou deux tirets pour les options longues (par exemple, "'--
   long-option'"), et l’argument option comme deuxième élément, ou une
   chaîne vide si le option n’a aucun argument. Les options se
   trouvent dans la liste dans l’ordre dans lequel elles ont été
   trouvées, permettant ainsi plusieurs occurrences. Les options
   longues et courtes peuvent être mélangées.

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

   Cette fonction fonctionne comme "getopt()", sauf que le mode de
   *scan* GNU est utilisé par défaut. Cela signifie que les arguments
   option et non-option peuvent être **intermixés**. La fonction
   "getopt()" arrête le traitement des options dès qu’un argument de
   non-option est rencontré.

   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 pour "GetoptError" ; pour la rétrocompatibilité.

Un exemple utilisant uniquement les options de style 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']

L’utilisation de noms d’options longs est tout aussi simple :

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

Dans un script, l’utilisation typique ressemble à ceci :

   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()

Notez qu’une interface de ligne de commande équivalente peut être
produite avec moins de code et des messages d’erreur et d’aide plus
informatifs à l’aide du module "argparse" module :

   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 ..

Voir aussi:

  Module "argparse"
     Option de ligne de commande alternative et bibliothèque d’analyse
     d’arguments.
