11/11/2022 16:50 Tutoriel Argparse — documentation Python 3.11.
3.11.0 Aller
Tutoriel Argparse
auteur: Tshepang Lekhonkhobe
Ce didacticiel est destiné à être une introduction en douceur à argparse , le module d'analyse de ligne de commande recommandé dans la bibliothèque standard
Python.
Noter: Il existe deux autres modules qui remplissent la même tâche, à savoir getopt (un équivalent getopt() du langage C) et le déprécié optparse . Notez
également qu'il argparse est basé sur optparse , et donc très similaire en termes d'utilisation.
Notions
Montrons le type de fonctionnalité que nous allons explorer dans ce tutoriel d'introduction en utilisant la commande ls :
$ ls
cpython devguide prog.py pypy rm-unused-function.patch
$ ls pypy
ctypes_configure demo dotviewer include lib_pypy lib-python ...
$ ls -l
total 20
drwxr-xr-x 19 wena wena 4096 Feb 18 18:51 cpython
drwxr-xr-x 4 wena wena 4096 Feb 8 12:04 devguide
-rwxr-xr-x 1 wena wena 535 Feb 19 00:05 prog.py
drwxr-xr-x 14 wena wena 4096 Feb 7 00:59 pypy
-rw-r--r-- 1 wena wena 741 Feb 18 01:01 rm-unused-function.patch
$ ls --help
Usage: ls [OPTION]... [FILE]...
List information about the FILEs (the current directory by default).
Sort entries alphabetically if none of -cftuvSUX nor --sort is specified.
...
Quelques concepts que nous pouvons apprendre des quatre commandes :
La commande ls est utile lorsqu'elle est exécutée sans aucune option. Il affiche par défaut le contenu du répertoire courant.
Si on veut au-delà de ce qu'il propose par défaut, on lui en dit un peu plus. Dans ce cas, nous voulons qu'il affiche un répertoire différent, pypy . Ce que nous
avons fait, c'est spécifier ce qu'on appelle un argument positionnel. Il est nommé ainsi parce que le programme doit savoir quoi faire avec la valeur, uniquement
https://docs.python.org/3/howto/argparse.html 1/16
11/11/2022 16:50 Tutoriel Argparse — documentation Python 3.11.0
en fonction de l'endroit où elle apparaît sur la ligne de commande. Ce concept est plus pertinent pour une commande comme cp , dont l'utilisation la plus
3.11.0 Aller
basique est . La première position est ce que vous voulez copier, et la deuxième position est l' endroit où vous voulez le copier . cp SRC DEST
Maintenant, disons que nous voulons changer le comportement du programme. Dans notre exemple, nous affichons plus d'informations pour chaque fichier au
lieu de simplement afficher les noms de fichiers. Le -l dans ce cas est connu comme un argument facultatif.
C'est un extrait du texte d'aide. Il est très utile dans la mesure où vous pouvez rencontrer un programme que vous n'avez jamais utilisé auparavant et
comprendre comment il fonctionne simplement en lisant son texte d'aide.
Les bases
Commençons par un exemple très simple qui ne fait (presque) rien :
import argparse
parser = argparse.ArgumentParser()
parser.parse_args()
Voici le résultat de l'exécution du code :
$ python3 prog.py
$ python3 prog.py --help
usage: prog.py [-h]
options:
-h, --help show this help message and exit
$ python3 prog.py --verbose
usage: prog.py [-h]
prog.py: error: unrecognized arguments: --verbose
$ python3 prog.py foo
usage: prog.py [-h]
prog.py: error: unrecognized arguments: foo
Voici ce qui se passe :
L'exécution du script sans aucune option n'affiche rien sur stdout. Pas si utile.
La seconde commence à montrer l'utilité du argparse module. Nous n'avons presque rien fait, mais nous recevons déjà un gentil message d'aide.
L' --help option, qui peut également être abrégée en -h , est la seule option que nous obtenons gratuitement (c'est-à-dire qu'il n'est pas nécessaire de la
spécifier). Spécifier quoi que ce soit d'autre entraîne une erreur. Mais même dans ce cas, nous recevons un message d'utilisation utile, également gratuit.
Présentation des arguments positionnels
https://docs.python.org/3/howto/argparse.html 2/16
11/11/2022 16:50 Tutoriel Argparse — documentation Python 3.11.0
Un exemple:
3.11.0 Aller
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("echo")
args = parser.parse_args()
print(args.echo)
Et en exécutant le code :
$ python3 prog.py
usage: prog.py [-h] echo
prog.py: error: the following arguments are required: echo
$ python3 prog.py --help
usage: prog.py [-h] echo
positional arguments:
echo
options:
-h, --help show this help message and exit
$ python3 prog.py foo
foo
Voici ce qui se passe :
Nous avons ajouté la add_argument() méthode, qui est ce que nous utilisons pour spécifier les options de ligne de commande que le programme est prêt à
accepter. Dans ce cas, je l'ai nommé de echo manière à ce qu'il corresponde à sa fonction.
L'appel de notre programme nous oblige maintenant à spécifier une option.
La parse_args() méthode renvoie en fait certaines données à partir des options spécifiées, dans ce cas, echo .
La variable est une forme de « magie » qui argparse s'exécute gratuitement (c'est-à-dire qu'il n'est pas nécessaire de spécifier dans quelle variable cette valeur
est stockée). Vous remarquerez également que son nom correspond à l'argument de chaîne donné à la méthode, echo .
Notez cependant que, bien que l'affichage de l'aide soit agréable et tout, il n'est actuellement pas aussi utile qu'il pourrait l'être. Par exemple, nous voyons que nous
avons obtenu echo comme argument positionnel, mais nous ne savons pas ce qu'il fait, autrement qu'en devinant ou en lisant le code source. Alors, rendons-le un
peu plus utile:
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("echo", help="echo the string you use here")
()
https://docs.python.org/3/howto/argparse.html 3/16
11/11/2022 16:50 Tutoriel Argparse — documentation Python 3.11.0
args = parser.parse_args()
print(args.echo)
3.11.0 Aller
Et on obtient :
$ python3 prog.py -h
usage: prog.py [-h] echo
positional arguments:
echo echo the string you use here
options:
-h, --help show this help message and exit
Maintenant, que diriez-vous de faire quelque chose d'encore plus utile :
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("square", help="display a square of a given number")
args = parser.parse_args()
print(args.square**2)
Voici le résultat de l'exécution du code :
$ python3 prog.py 4
Traceback (most recent call last):
File "prog.py", line 5, in <module>
print(args.square**2)
TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'int'
Cela ne s'est pas si bien passé. C'est parce que argparse traite les options que nous lui donnons comme des chaînes, sauf indication contraire. Alors, disons de
argparse traiter cette entrée comme un entier :
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("square", help="display a square of a given number",
type=int)
args = parser.parse_args()
print(args.square**2)
Voici le résultat de l'exécution du code :
https://docs.python.org/3/howto/argparse.html 4/16
11/11/2022 16:50 Tutoriel Argparse — documentation Python 3.11.0
3.11.0 Aller
$ python3 prog.py 4
16
$ python3 prog.py four
usage: prog.py [-h] square
prog.py: error: argument square: invalid int value: 'four'
Cela s'est bien passé. Le programme s'arrête même utilement sur une mauvaise entrée illégale avant de continuer.
Présentation des arguments optionnels
Jusqu'à présent, nous avons joué avec des arguments positionnels. Voyons comment ajouter des éléments facultatifs :
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("--verbosity", help="increase output verbosity")
args = parser.parse_args()
if args.verbosity:
print("verbosity turned on")
Et la sortie :
$ python3 prog.py --verbosity 1
verbosity turned on
$ python3 prog.py
$ python3 prog.py --help
usage: prog.py [-h] [--verbosity VERBOSITY]
options:
-h, --help show this help message and exit
--verbosity VERBOSITY
increase output verbosity
$ python3 prog.py --verbosity
usage: prog.py [-h] [--verbosity VERBOSITY]
prog.py: error: argument --verbosity: expected one argument
Voici ce qui se passe :
Le programme est écrit de manière à afficher quelque chose lorsque cela --verbosity est spécifié et à ne rien afficher dans le cas contraire.
P t l' ti t f it f lt ti il ' d' l d l' é ti d ll N t déf t i tf lt tif
https://docs.python.org/3/howto/argparse.html 5/16
11/11/2022 16:50 Tutoriel Argparse — documentation Python 3.11.0
Pour montrer que l'option est en fait facultative, il n'y a pas d'erreur lors de l'exécution du programme sans elle. Notez que par défaut, si un argument facultatif
n'est pas3.11.0
utilisé, la variable pertinente, dans ce cas args.verbosity , est donnée None comme valeur, raison pour laquelle elle échoue au test de vérité de l'Aller
if instruction.
Le message d'aide est un peu différent.
Lors de l'utilisation de l' --verbosity option, il faut également spécifier une valeur, n'importe quelle valeur.
L'exemple ci-dessus accepte des valeurs entières arbitraires pour --verbosity , mais pour notre programme simple, seules deux valeurs sont réellement utiles,
True ou False . Modifions le code en conséquence :
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("--verbose", help="increase output verbosity",
action="store_true")
args = parser.parse_args()
if args.verbose:
print("verbosity turned on")
Et la sortie :
$ python3 prog.py --verbose
verbosity turned on
$ python3 prog.py --verbose 1
usage: prog.py [-h] [--verbose]
prog.py: error: unrecognized arguments: 1
$ python3 prog.py --help
usage: prog.py [-h] [--verbose]
options:
-h, --help show this help message and exit
--verbose increase output verbosity
Voici ce qui se passe :
L'option est maintenant plus un indicateur que quelque chose qui nécessite une valeur. Nous avons même changé le nom de l'option pour correspondre à cette
idée. Notez que nous spécifions maintenant un nouveau mot-clé, action et lui donnons la valeur "store_true" . Cela signifie que, si l'option est spécifiée,
affectez la valeur True à args.verbose . Ne pas le préciser implique False .
Il se plaint lorsque vous spécifiez une valeur, dans le véritable esprit de ce que sont réellement les drapeaux.
Notez le texte d'aide différent.
Options courtes
https://docs.python.org/3/howto/argparse.html 6/16
11/11/2022 16:50 Tutoriel Argparse — documentation Python 3.11.0
3.11.0 Aller
Si vous êtes familier avec l'utilisation de la ligne de commande, vous remarquerez que je n'ai pas encore abordé le sujet des versions courtes des options. C'est
assez simple :
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("-v", "--verbose", help="increase output verbosity",
action="store_true")
args = parser.parse_args()
if args.verbose:
print("verbosity turned on")
Et voilà :
$ python3 prog.py -v
verbosity turned on
$ python3 prog.py --help
usage: prog.py [-h] [-v]
options:
-h, --help show this help message and exit
-v, --verbose increase output verbosity
Notez que la nouvelle capacité est également reflétée dans le texte d'aide.
Combinaison d'arguments positionnels et optionnels
Notre programme ne cesse de gagner en complexité :
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("square", type=int,
help="display a square of a given number")
parser.add_argument("-v", "--verbose", action="store_true",
help="increase output verbosity")
args = parser.parse_args()
answer = args.square**2
if args.verbose:
print(f"the square of {args.square} equals {answer}")
else:
https://docs.python.org/3/howto/argparse.html 7/16
11/11/2022 16:50 Tutoriel Argparse — documentation Python 3.11.0
else:
print(answer)
3.11.0 Aller
Et maintenant la sortie :
$ python3 prog.py
usage: prog.py [-h] [-v] square
prog.py: error: the following arguments are required: square
$ python3 prog.py 4
16
$ python3 prog.py 4 --verbose
the square of 4 equals 16
$ python3 prog.py --verbose 4
the square of 4 equals 16
Nous avons ramené un argument positionnel, d'où la plainte.
Notez que l'ordre n'a pas d'importance.
Que diriez-vous de redonner à notre programme la possibilité d'avoir plusieurs valeurs de verbosité et de pouvoir les utiliser :
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("square", type=int,
help="display a square of a given number")
parser.add_argument("-v", "--verbosity", type=int,
help="increase output verbosity")
args = parser.parse_args()
answer = args.square**2
if args.verbosity == 2:
print(f"the square of {args.square} equals {answer}")
elif args.verbosity == 1:
print(f"{args.square}^2 == {answer}")
else:
print(answer)
Et la sortie :
$ python3 prog.py 4
16
$ python3 prog.py 4 -v
usage: prog.py [-h] [-v VERBOSITY] square
prog.py: error: argument -v/--verbosity: expected one argument
$ python3 prog.py 4 -v 1
https://docs.python.org/3/howto/argparse.html 8/16
11/11/2022 16:50 Tutoriel Argparse — documentation Python 3.11.0
$ python3 prog.py 4 v 1
4^2 == 16
3.11.0 Aller
$ python3 prog.py 4 -v 2
the square of 4 equals 16
$ python3 prog.py 4 -v 3
16
Ils ont tous l'air bien sauf le dernier, qui expose un bogue dans notre programme. Corrigeons le problème en limitant les valeurs que l' --verbosity option peut
accepter :
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("square", type=int,
help="display a square of a given number")
parser.add_argument("-v", "--verbosity", type=int, choices=[0, 1, 2],
help="increase output verbosity")
args = parser.parse_args()
answer = args.square**2
if args.verbosity == 2:
print(f"the square of {args.square} equals {answer}")
elif args.verbosity == 1:
print(f"{args.square}^2 == {answer}")
else:
print(answer)
Et la sortie :
$ python3 prog.py 4 -v 3
usage: prog.py [-h] [-v {0,1,2}] square
prog.py: error: argument -v/--verbosity: invalid choice: 3 (choose from 0, 1, 2)
$ python3 prog.py 4 -h
usage: prog.py [-h] [-v {0,1,2}] square
positional arguments:
square display a square of a given number
options:
-h, --help show this help message and exit
-v {0,1,2}, --verbosity {0,1,2}
increase output verbosity
Notez que la modification se reflète également dans le message d'erreur ainsi que dans la chaîne d'aide.
https://docs.python.org/3/howto/argparse.html 9/16
11/11/2022 16:50 Tutoriel Argparse — documentation Python 3.11.0
3.11.0 Aller
Maintenant, utilisons une approche différente pour jouer avec la verbosité, ce qui est assez courant. Cela correspond également à la façon dont l'exécutable
CPython gère son propre argument de verbosité (vérifiez la sortie de ): python --help
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("square", type=int,
help="display the square of a given number")
parser.add_argument("-v", "--verbosity", action="count",
help="increase output verbosity")
args = parser.parse_args()
answer = args.square**2
if args.verbosity == 2:
print(f"the square of {args.square} equals {answer}")
elif args.verbosity == 1:
print(f"{args.square}^2 == {answer}")
else:
print(answer)
Nous avons introduit une autre action, "count", pour compter le nombre d'occurrences d'options spécifiques.
$ python3 prog.py 4
16
$ python3 prog.py 4 -v
4^2 == 16
$ python3 prog.py 4 -vv
the square of 4 equals 16
$ python3 prog.py 4 --verbosity --verbosity
the square of 4 equals 16
$ python3 prog.py 4 -v 1
usage: prog.py [-h] [-v] square
prog.py: error: unrecognized arguments: 1
$ python3 prog.py 4 -h
usage: prog.py [-h] [-v] square
positional arguments:
square display a square of a given number
options:
-h, --help show this help message and exit
-v, --verbosity increase output verbosity
$ python3 prog py 4 vvv
https://docs.python.org/3/howto/argparse.html 10/16
11/11/2022 16:50 Tutoriel Argparse — documentation Python 3.11.0
$ python3 prog.py 4 -vvv
16 3.11.0 Aller
Oui, c'est maintenant plus un drapeau (similaire à action="store_true" ) dans la version précédente de notre script. Cela devrait expliquer la plainte.
Il se comporte également de la même manière que l'action "store_true".
Voici maintenant une démonstration de ce que donne l'action « compter ». Vous avez probablement déjà vu ce genre d'utilisation auparavant.
Et si vous ne spécifiez pas le -v drapeau, ce drapeau est considéré comme ayant une None valeur.
Comme on pouvait s'y attendre, en spécifiant la forme longue du drapeau, nous devrions obtenir la même sortie.
Malheureusement, notre sortie d'aide n'est pas très informative sur la nouvelle capacité acquise par notre script, mais cela peut toujours être corrigé en
améliorant la documentation de notre script (par exemple via l' help argument mot-clé).
Cette dernière sortie expose un bogue dans notre programme.
Réparons :
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("square", type=int,
help="display a square of a given number")
parser.add_argument("-v", "--verbosity", action="count",
help="increase output verbosity")
args = parser.parse_args()
answer = args.square**2
# bugfix: replace == with >=
if args.verbosity >= 2:
print(f"the square of {args.square} equals {answer}")
elif args.verbosity >= 1:
print(f"{args.square}^2 == {answer}")
else:
print(answer)
Et voilà ce que ça donne :
$ python3 prog.py 4 -vvv
the square of 4 equals 16
$ python3 prog.py 4 -vvvv
the square of 4 equals 16
$ python3 prog.py 4
Traceback (most recent call last):
File "prog.py", line 11, in <module>
if args.verbosity >= 2:
TypeError: '>=' not supported between instances of 'NoneType' and 'int'
https://docs.python.org/3/howto/argparse.html 11/16
11/11/2022 16:50 Tutoriel Argparse — documentation Python 3.11.0
3.11.0 Aller
La première sortie s'est bien déroulée et corrige le bug que nous avions auparavant. Autrement dit, nous voulons que toute valeur >= 2 soit aussi détaillée que
possible.
Troisième sortie pas si bonne.
Corrigeons ce bug :
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("square", type=int,
help="display a square of a given number")
parser.add_argument("-v", "--verbosity", action="count", default=0,
help="increase output verbosity")
args = parser.parse_args()
answer = args.square**2
if args.verbosity >= 2:
print(f"the square of {args.square} equals {answer}")
elif args.verbosity >= 1:
print(f"{args.square}^2 == {answer}")
else:
print(answer)
Nous venons d'introduire un autre mot-clé, default . Nous l'avons défini 0 sur afin de le rendre comparable aux autres valeurs int. Rappelez-vous que par défaut, si
un argument optionnel n'est pas spécifié, il obtient la None valeur, et cela ne peut pas être comparé à une valeur int (d'où l' TypeError exception).
Et:
$ python3 prog.py 4
16
Vous pouvez aller assez loin simplement avec ce que nous avons appris jusqu'à présent, et nous n'avons fait qu'effleurer la surface. Le argparse module est très
puissant et nous en explorerons un peu plus avant de terminer ce didacticiel.
Devenir un peu plus avancé
Et si nous voulions étendre notre petit programme pour effectuer d'autres pouvoirs, pas seulement des carrés :
import argparse
parser = argparse.ArgumentParser()
https://docs.python.org/3/howto/argparse.html 12/16
11/11/2022 16:50 Tutoriel Argparse — documentation Python 3.11.0
p gp g ()
parser.add_argument("x", type=int, help="the base")
3.11.0 Aller
parser.add_argument("y", type=int, help="the exponent")
parser.add_argument("-v", "--verbosity", action="count", default=0)
args = parser.parse_args()
answer = args.x**args.y
if args.verbosity >= 2:
print(f"{args.x} to the power {args.y} equals {answer}")
elif args.verbosity >= 1:
print(f"{args.x}^{args.y} == {answer}")
else:
print(answer)
Production:
$ python3 prog.py
usage: prog.py [-h] [-v] x y
prog.py: error: the following arguments are required: x, y
$ python3 prog.py -h
usage: prog.py [-h] [-v] x y
positional arguments:
x the base
y the exponent
options:
-h, --help show this help message and exit
-v, --verbosity
$ python3 prog.py 4 2 -v
4^2 == 16
Notez que jusqu'à présent, nous avons utilisé le niveau de verbosité pour modifier le texte affiché. L'exemple suivant utilise à la place le niveau de verbosité pour
afficher davantage de texte :
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("x", type=int, help="the base")
parser.add_argument("y", type=int, help="the exponent")
parser.add_argument("-v", "--verbosity", action="count", default=0)
args = parser.parse_args()
answer = args.x**args.y
if args.verbosity >= 2:
print(f"Running '{__file__}'")
if b i
https://docs.python.org/3/howto/argparse.html 13/16
11/11/2022 16:50 Tutoriel Argparse — documentation Python 3.11.0
if args.verbosity >= 1:
3.11.0 Aller
print(f"{args.x}^{args.y} == ", end="")
print(answer)
Production:
$ python3 prog.py 4 2
16
$ python3 prog.py 4 2 -v
4^2 == 16
$ python3 prog.py 4 2 -vv
Running 'prog.py'
4^2 == 16
Options conflictuelles
Jusqu'à présent, nous avons travaillé avec deux méthodes d'une argparse.ArgumentParser instance. Introduisons-en un troisième,
add_mutually_exclusive_group() . Cela nous permet de spécifier des options qui entrent en conflit les unes avec les autres. Modifions également le reste du
programme pour que la nouvelle fonctionnalité ait plus de sens : nous allons introduire l' --quiet option, qui sera l'inverse de celle- --verbose ci :
import argparse
parser = argparse.ArgumentParser()
group = parser.add_mutually_exclusive_group()
group.add_argument("-v", "--verbose", action="store_true")
group.add_argument("-q", "--quiet", action="store_true")
parser.add_argument("x", type=int, help="the base")
parser.add_argument("y", type=int, help="the exponent")
args = parser.parse_args()
answer = args.x**args.y
if args.quiet:
print(answer)
elif args.verbose:
print(f"{args.x} to the power {args.y} equals {answer}")
else:
print(f"{args.x}^{args.y} == {answer}")
Notre programme est maintenant plus simple et nous avons perdu certaines fonctionnalités pour des raisons de démonstration. Quoi qu'il en soit, voici la sortie :
https://docs.python.org/3/howto/argparse.html 14/16
11/11/2022 16:51 Tutoriel Argparse — documentation Python 3.11.0
$ python3 prog.py 4 2
3.11.0 Aller
4^2 == 16
$ python3 prog.py 4 2 -q
16
$ python3 prog.py 4 2 -v
4 to the power 2 equals 16
$ python3 prog.py 4 2 -vq
usage: prog.py [-h] [-v | -q] x y
prog.py: error: argument -q/--quiet: not allowed with argument -v/--verbose
$ python3 prog.py 4 2 -v --quiet
usage: prog.py [-h] [-v | -q] x y
prog.py: error: argument -q/--quiet: not allowed with argument -v/--verbose
Cela devrait être facile à suivre. J'ai ajouté cette dernière sortie afin que vous puissiez voir le type de flexibilité que vous obtenez, c'est-à-dire mélanger les options
de forme longue avec celles de forme courte.
Avant de conclure, vous souhaitez probablement indiquer à vos utilisateurs l'objectif principal de votre programme, juste au cas où ils ne le sauraient pas :
import argparse
parser = argparse.ArgumentParser(description="calculate X to the power of Y")
group = parser.add_mutually_exclusive_group()
group.add_argument("-v", "--verbose", action="store_true")
group.add_argument("-q", "--quiet", action="store_true")
parser.add_argument("x", type=int, help="the base")
parser.add_argument("y", type=int, help="the exponent")
args = parser.parse_args()
answer = args.x**args.y
if args.quiet:
print(answer)
elif args.verbose:
print(f"{args.x} to the power {args.y} equals {answer}")
else:
print(f"{args.x}^{args.y} == {answer}")
Notez cette légère différence dans le texte d'utilisation. Notez le , qui nous indique que nous pouvons soit utiliser soit , mais pas les deux en même temps : [-v |
-q] -v -q
$ python3 prog.py --help
usage: prog.py [-h] [-v | -q] x y
https://docs.python.org/3/howto/argparse.html 15/16
11/11/2022 16:51 Tutoriel Argparse — documentation Python 3.11.0
calculate X to the power of Y
3.11.0 Aller
positional arguments:
x the base
y the exponent
options:
-h, --help show this help message and exit
-v, --verbose
-q, --quiet
Conclusion
Le argparse module offre bien plus que ce qui est montré ici. Ses documents sont assez détaillés et complets, et pleins d'exemples. Après avoir parcouru ce
tutoriel, vous devriez facilement les digérer sans vous sentir dépassé.
https://docs.python.org/3/howto/argparse.html 16/16
