Introduction

Présentation du module

getopt analyse les options passées en ligne de commande (version vieille école, Optparse le remplace).

Ce module analyse (parse) une suite d'arguments, par exemple contenu dans sys.argv, et retourne

• une suite de couples (option, argument),
• ainsi qu'une suite d'arguments non reconnus.

Les types d'options supportées sont :

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

Notons enfin que les options courtes (un seul tiret, une seule lettre, par exemple -a) et longues (ex. --noarg) peuvent être combinées.

Exemples de lignes de commandes analysables

Exemples de lignes de commandes lisibles par getopt :

• Options courtes

  python exemple.py
  python exemple.py -a
  python exemple.py -o foo
  python exemple.py -ofoo

• Options longues

  python exemple.py --version
  python exemple.py --v
  python exemple.py --output foo
  python exemple.py --output=foo

• Les deux réunies

  python exemple.py -u option --output foo

Utilisation du module

La fonction getopt

La fonction getopt accepte trois arguments :

  >>> import getopt
  >>> getopt.getopt(sys.argv[1:],
                    'ov:',
                    ['output=', 'verbose', 'version=',])

Son premier argument

Le premier argument de getopt est la suite des arguments à être analysé, et qui provient habituellement de sys.argv[1:] (on met de côté le nom du programme, contenu dans sys.arg[0]).

Son deuxième argument

Le deuxième argument concerne les options courtes (à un simple caractère, c'est-à-dire précédées d'un seul -, du type -o, -v arg, ou -varg).

Si une de ces options nécessite un argument, sa lettre est suivi d'un :

• dans l'exemple ci-dessus, -o ne nécessite pas d'argument,
• -v en a besoin d'un (message d'erreur sinon).

Son troisième argument

Le dernier argument est facultatif. C'est la suite des options longues : au moins un caractère, précédé de (du genre --version).

Le '=' signifie l'obligation d'un suffixe : dans notre exemple, sont acceptés --output=donnee ou --verbose tout court.

Enfin, quand il n'y a pas d'ambiguïté, getopt comprend le racourcissement des options longues :

• les options --o=toto et --verb seront reconnues,
• --v produira un message d'erreur.

Retour de fonction

Le résultat de getopt.getopt() est un couple de listes :

• la première liste est la liste des couples (option,argument);
• la deuxième liste est la liste des éléments non reconnus.

  >>> import getopt
  >>> print getopt.getopt(['-a', '-bval', '-c', 'val'], 'ab:c:')

  >>> print getopt.getopt([ '--noarg', '--witharg', 'val', '--witharg2=another' ],
                          ' ',
                          [ 'noarg', 'witharg=', 'witharg2=' ])

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

On peut alors parcourir la liste des options ainsi :

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

Exemples détaillés

Premier exemple, avec des options courtes

  >>> import getopt
  >>> print getopt.getopt(['-a', '-bval', '-c', 'val'], 'ab:c:')

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

Dans cet exemple, le premier argument est une liste (à nouveau, on prend habituellement sys.argv[1:]).

Le deuxième argument spécifie qu'il y aura trois options courtes : -a, -b et -c. Les : signifient que -b et -c nécessitent un argument.

La liste ['-a', '-bval', '-c', 'val'] est donc comprise par l'analyseur ainsi :

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

Deuxième exemple, avec des options longues

De même, avec des options longues :

  >>> print getopt.getopt([ '--noarg', '--witharg', 'val', '--witharg2=another' ],
                          ' ',
                          [ 'noarg', 'witharg=', 'witharg2=' ])

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

Condition d'arrêt de l'analyse

L'analyse des options s'arrête dès que le premier argument ne collant pas est rencontré.

Illustration

Par exemple, considérons le programme exemple.py suivant :

  >>> import getopt
  >>> options, reste = getopt.getopt(sys.argv[1:],
                                     'ov:',
                                     ['output=', 'verbose', 'version=',])

  python exemple.py -v pas_une_option --output foo

getopt reconnaîtra alors, pour couple option/argument :

  ('-v', ' ')

et pour reste :

  ['pas_une_option', '--output', 'foo']

Amélioration possible

Si cela pose problème, on peut remplacer getopt.getopt par getopt.gnu_getopt, qui reconnaîtra

  [('-v', ' '), ('--output', 'foo')]

pour liste (option,argument), et pour reste :

  ['pas_une_option']