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

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

In a script, typical usage is something like this:

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

Note that an equivalent command line interface could be produced with less code and more informative help and error messages by using the 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.