Introduction

Le module argparse de Python est un outil puissant pour créer des interfaces de ligne de commande conviviales. Que vous développiez des scripts simples ou des applications complexes, savoir utiliser efficacement argparse peut améliorer considérablement la convivialité de vos programmes. Dans cet article, je vais vous expliquer tout ce que vous devez savoir pour maîtriser argparse, de l'analyse des arguments de base aux fonctionnalités avancées et aux meilleures pratiques.

Qu'est-ce que argparse ?

Le module argparse fournit un moyen simple de gérer les arguments de ligne de commande transmis à votre script Python. Il génère automatiquement des messages d'aide, gère la vérification du type et peut traiter les arguments facultatifs et positionnels.

Pourquoi utiliser argparse ?

• Messages d'aide automatiques : les utilisateurs peuvent facilement comprendre comment exécuter votre programme en utilisant l'option --help.
• Vérification de type : vous pouvez vous assurer que les entrées sont valides (par exemple, des entiers là où vous les attendez).
• Interfaces de ligne de commande lisibles : rend vos scripts plus professionnels et plus conviviaux.

Commençons par les bases !

Configuration d'argparse

Pour commencer à utiliser argparse, vous devez d'abord importer le module et créer un objet ArgumentParser :

import argparse

parser = argparse.ArgumentParser(description="Demo script for argparse.")

L'argument description ici est facultatif et aide à expliquer le but de votre script. Il apparaît lorsque les utilisateurs exécutent la commande --help.

Arguments de position

Les arguments positionnels sont le type d'argument le plus basique dans argparse. Ceux-ci sont obligatoires et doivent apparaître dans la commande dans le bon ordre.

parser.add_argument("name", help="Your name")
args = parser.parse_args()
print(f"Hello, {args.name}!")

Exécution du script :

$ python script.py Alice
Hello, Alice!

Si vous ne fournissez pas l'argument name, argparse générera une erreur :

$ python script.py
usage: script.py [-h] name
script.py: error: the following arguments are required: name

Arguments facultatifs

Les arguments facultatifs, comme leur nom l'indique, ne sont pas obligatoires. Ceux-ci commencent généralement par un ou deux tirets (- ou --) pour les distinguer des arguments de position.

parser.add_argument("-g", "--greeting", help="Custom greeting message", default="Hello")
args = parser.parse_args()
print(f"{args.greeting}, {args.name}!")

Exécution du script :

$ python script.py Alice --greeting Hi
Hi, Alice!

L'argument par défaut garantit qu'une valeur par défaut est utilisée si l'utilisateur ne fournit pas l'option :

$ python script.py Alice
Hello, Alice!

Types d'arguments

Par défaut, tous les arguments sont traités comme des chaînes. Mais vous pouvez spécifier le type d’argument que vous attendez. Par exemple, si vous avez besoin d'un entier :

parser.add_argument("age", type=int, help="Your age")
args = parser.parse_args()
print(f"{args.name} is {args.age} years old.")

Exécution du script :

$ python script.py Alice 25
Alice is 25 years old.

Si vous fournissez un type non valide (par exemple, une chaîne où un entier est attendu), argparse affichera automatiquement une erreur :

$ python script.py Alice twenty-five
usage: script.py [-h] name age
script.py: error: argument age: invalid int value: 'twenty-five'

Arguments de drapeau (options booléennes)

Les arguments Flag sont utiles pour activer ou désactiver certaines fonctionnalités. Ceux-ci ne prennent pas de valeur mais agissent comme des commutateurs. Utilisez l'option action="store_true" pour créer un indicateur.

parser.add_argument("-v", "--verbose", action="store_true", help="Enable verbose mode")
args = parser.parse_args()

if args.verbose:
    print("Verbose mode is on.")

Exécution du script :

$ python script.py Alice -v
Verbose mode is on.

Si vous ne fournissez pas l'indicateur, la valeur par défaut False est utilisée :

$ python script.py Alice

Noms d'options courts ou longs

argparse vous permet de définir des noms d'options courts et longs pour le même argument. Par exemple:

parser.add_argument("-g", "--greeting", help="Custom greeting message")

Vous pouvez utiliser soit la version courte (-g), soit la version longue (--greeting) :

$ python script.py Alice -g Hi
Hi, Alice!

$ python script.py Alice --greeting Hi
Hi, Alice!

Valeurs par défaut

Dans certains cas, vous souhaiterez peut-être définir des valeurs par défaut pour vos arguments facultatifs. Cela garantit que votre programme se comporte correctement même lorsqu'un argument est manquant.

parser.add_argument("-g", "--greeting", default="Hello", help="Greeting message")
args = parser.parse_args()
print(f"{args.greeting}, {args.name}!")

Gestion de plusieurs valeurs

Vous pouvez également spécifier des arguments qui acceptent plusieurs valeurs à l'aide de nargs. Par exemple, pour accepter plusieurs noms de fichiers :

parser.add_argument("files", nargs=" ", help="List of file names")
args = parser.parse_args()
print(f"Files to process: {args.files}")

Exécution du script :

$ python script.py file1.txt file2.txt file3.txt
Files to process: ['file1.txt', 'file2.txt', 'file3.txt']

Choix limitatifs

Vous pouvez restreindre les valeurs possibles d'un argument à l'aide de l'option de choix :

parser.add_argument("--format", choices=["json", "xml"], help="Output format")
args = parser.parse_args()
print(f"Output format: {args.format}")

Exécution du script :

$ python script.py Alice --format json
Output format: json

Si l'utilisateur fournit un choix non valide, argparse générera une erreur :

$ python script.py Alice --format csv
usage: script.py [-h] [--format {json,xml}] name
script.py: error: argument --format: invalid choice: 'csv' (choose from 'json', 'xml')

Combinaison d'arguments positionnels et facultatifs

Vous pouvez mélanger et faire correspondre des arguments positionnels et facultatifs dans le même script.

parser.add_argument("name", help="Your name")
parser.add_argument("--greeting", help="Custom greeting", default="Hello")
parser.add_argument("--verbose", action="store_true", help="Enable verbose output")

args = parser.parse_args()

if args.verbose:
    print(f"Running in verbose mode...")

print(f"{args.greeting}, {args.name}!")

Génération de messages d'aide

L'une des plus grandes forces d'argparse est son générateur de messages d'aide intégré. Lorsqu'un utilisateur exécute votre script avec l'indicateur -h ou --help, argparse affichera automatiquement les arguments et leurs descriptions.

$ python script.py -h
usage: script.py [-h] [--greeting GREETING] [--verbose] name

Demo script for argparse.

positional arguments:
  name             Your name

optional arguments:
  -h, --help       show this help message and exit
  --greeting GREETING
                   Custom greeting
  --verbose        Enable verbose output

Subparsers : gestion de plusieurs commandes

Si votre script comporte plusieurs sous-commandes (par exemple, git commit, git push), vous pouvez utiliser des sous-analyseurs pour les gérer.

parser = argparse.ArgumentParser(description="Git-like command-line tool")
subparsers = parser.add_subparsers(dest="command")

# Add "commit" subcommand
commit_parser = subparsers.add_parser("commit", help="Record changes to the repository")
commit_parser.add_argument("-m", "--message", help="Commit message", required=True)

# Add "push" subcommand
push_parser = subparsers.add_parser("push", help="Update remote refs")

args = parser.parse_args()

if args.command == "commit":
    print(f"Committing changes with message: {args.message}")
elif args.command == "push":
    print("Pushing changes to remote repository.")

Meilleures pratiques

Voici quelques bonnes pratiques à prendre en compte lors de l'utilisation d'argparse :

1. Toujours fournir un message d'aide : utilisez l'argument d'aide dans add_argument pour décrire le rôle de chaque option.
2. Utiliser des valeurs par défaut raisonnables : fournissez des valeurs par défaut le cas échéant pour garantir une exécution fluide sans nécessiter tous les arguments.
3. Valider les entrées : utilisez les choix et les types pour garantir que les utilisateurs fournissent des entrées valides.
4. Restez simple : essayez de ne pas surcharger votre script avec trop d'arguments, sauf si cela est absolument nécessaire.
5. Structurez vos commandes : pour les outils complexes, utilisez des sous-analyseurs pour séparer logiquement les différentes commandes.

Conclusion

Le module argparse est essentiel pour écrire des scripts Python professionnels et conviviaux. En tirant parti de ses fonctionnalités telles que les arguments positionnels et facultatifs, la vérification du type et les sous-analyseurs, vous pouvez créer des interfaces de ligne de commande intuitives et puissantes.

La prochaine fois que vous créerez un script Python, envisagez d'utiliser argparse pour le rendre plus flexible et accessible. Bon codage !

N'hésitez pas à me contacter si vous avez des questions ou des suggestions. Connectez-vous avec moi sur :

• LinkedIn
• GitHub