Quelle est la différence entre les arguments positionnels et les arguments optionnels dans le module argparse de Python ?

Introduction

Le module argparse de Python est un outil puissant pour créer des interfaces en ligne de commande (CLI - Command-Line Interface) pour vos applications. Dans ce tutoriel, nous explorerons les différences entre les arguments positionnels et les arguments optionnels, ainsi que la manière de les utiliser efficacement pour créer des programmes Python flexibles et conviviaux pour l'utilisateur.

Skills Graph

Comprendre les bases d'Argparse

Le module argparse en Python est un outil puissant pour créer des interfaces en ligne de commande (CLI - Command-Line Interface) pour vos applications. Il vous permet de définir et d'analyser les arguments de la ligne de commande, facilitant ainsi la gestion des entrées utilisateur et la personnalisation du comportement de votre programme.

Dans cette étape, nous allons apprendre les bases du module argparse et créer notre premier programme simple en ligne de commande.

Qu'est-ce qu'argparse ?

Lorsque vous exécutez un script Python depuis la ligne de commande, vous avez souvent besoin de fournir des informations supplémentaires ou de configurer le comportement du script. Le module argparse offre un moyen pratique de :

• Définir quels arguments de ligne de commande votre programme accepte
• Convertir les arguments de ligne de commande en types de données appropriés
• Générer des messages d'utilisation utiles
• Gérer les erreurs lorsque les utilisateurs fournissent des entrées invalides

Créons un exemple simple pour comprendre les bases de argparse.

Créer votre premier programme argparse

1. Dans l'IDE Web, créez un nouveau fichier appelé hello_argparse.py dans le répertoire /home/labex/project.

2. Ajoutez le code suivant au fichier :

import argparse

## Create an argument parser
parser = argparse.ArgumentParser(description="A simple greeting program")

## Add a name argument
parser.add_argument("name", help="The name to greet")

## Parse the arguments
args = parser.parse_args()

## Use the arguments in our program
print(f"Hello, {args.name}!")

3. Enregistrez le fichier.

4. Ouvrez un terminal et exécutez le programme en fournissant un nom en tant qu'argument :

python /home/labex/project/hello_argparse.py Alice

5. Vous devriez voir la sortie suivante :

Hello, Alice!

6. Essayez maintenant d'exécuter le programme sans aucun argument :

python /home/labex/project/hello_argparse.py

7. Vous verrez un message d'erreur comme celui-ci :

usage: hello_argparse.py [-h] name
hello_argparse.py: error: the following arguments are required: name

Cet exemple de base montre comment argparse fonctionne. Nous avons défini un programme simple qui prend un nom en entrée et affiche un message de salutation. Remarquez comment argparse génère automatiquement un message d'erreur lorsque vous ne fournissez pas l'argument requis.

Dans les étapes suivantes, nous approfondirons les deux principaux types d'arguments : les arguments positionnels et les arguments optionnels.

Travailler avec les arguments positionnels

Les arguments positionnels sont le type d'arguments le plus simple dans argparse. Ils sont appelés "positionnels" car leur signification est déterminée par leur position dans la ligne de commande.

Caractéristiques des arguments positionnels

• Ils sont généralement requis (sauf s'ils sont explicitement rendus optionnels)
• Ils n'utilisent pas de drapeaux ou de préfixes (comme - ou --)
• L'ordre est important
• Ils sont utilisés pour les entrées essentielles dont votre programme a besoin pour fonctionner

Créons un programme qui utilise des arguments positionnels pour effectuer des opérations arithmétiques de base.

Créer une calculatrice avec des arguments positionnels

1. Dans l'IDE Web, créez un nouveau fichier appelé calculator.py dans le répertoire /home/labex/project.

2. Ajoutez le code suivant au fichier :

import argparse

## Create an argument parser
parser = argparse.ArgumentParser(description="A simple calculator")

## Add positional arguments
parser.add_argument("operation", help="The operation to perform (add, subtract, multiply, divide)")
parser.add_argument("x", type=float, help="The first number")
parser.add_argument("y", type=float, help="The second number")

## Parse the arguments
args = parser.parse_args()

## Perform the calculation based on the operation
if args.operation == "add":
    result = args.x + args.y
elif args.operation == "subtract":
    result = args.x - args.y
elif args.operation == "multiply":
    result = args.x * args.y
elif args.operation == "divide":
    if args.y == 0:
        print("Error: Cannot divide by zero")
        exit(1)
    result = args.x / args.y
else:
    print(f"Error: Unknown operation '{args.operation}'")
    print("Valid operations are: add, subtract, multiply, divide")
    exit(1)

## Display the result
print(f"Result: {result}")

3. Enregistrez le fichier.

4. Exécutez le programme avec différentes opérations :

python /home/labex/project/calculator.py add 5 3

5. Vous devriez voir la sortie suivante :

Result: 8.0

6. Essayez d'autres opérations :

python /home/labex/project/calculator.py multiply 4 7

Sortie :

Result: 28.0

Fonctionnalités supplémentaires des arguments positionnels

Vous pouvez également personnaliser les arguments positionnels de diverses manières :

1. Les faire accepter plusieurs valeurs avec nargs
2. Fournir des valeurs par défaut avec default
3. Restreindre les valeurs à un ensemble de choix avec choices

Modifions notre calculatrice pour inclure le paramètre choices pour l'opération :

1. Ouvrez calculator.py dans l'IDE Web.

2. Modifiez l'argument d'opération pour inclure le paramètre choices :

parser.add_argument("operation",
                    choices=["add", "subtract", "multiply", "divide"],
                    help="The operation to perform")

3. Enregistrez le fichier.

4. Exécutez le programme avec une opération valide :

python /home/labex/project/calculator.py add 5 3

5. Vous devriez voir la même sortie que précédemment :

Result: 8.0

6. Essayez maintenant avec une opération invalide :

python /home/labex/project/calculator.py power 2 3

7. Vous verrez un message d'erreur :

usage: calculator.py [-h] {add,subtract,multiply,divide} x y
calculator.py: error: argument operation: invalid choice: 'power' (choose from 'add', 'subtract', 'multiply', 'divide')

Le paramètre choices garantit que les utilisateurs ne peuvent utiliser que les opérations que vous avez définies et fournit des messages d'erreur utiles lorsqu'ils essaient d'utiliser une opération invalide.

Les arguments positionnels sont parfaits pour les entrées essentielles sans lesquelles votre programme ne peut pas fonctionner. Cependant, parfois, vous avez besoin de fournir des options qui ne sont pas requises ou qui ont des valeurs par défaut. C'est là que les arguments optionnels entrent en jeu, que nous explorerons dans l'étape suivante.

Travailler avec les arguments optionnels

Les arguments optionnels offrent une grande flexibilité dans les interfaces en ligne de commande. Contrairement aux arguments positionnels, les arguments optionnels :

• Sont préfixés par des tirets (généralement - pour les formes courtes et -- pour les formes longues)
• Peuvent être omis (le programme utilisera les valeurs par défaut si elles sont fournies)
• Peuvent être fournis dans n'importe quel ordre
• Sont idéaux pour les options de configuration qui ne sont pas essentielles au fonctionnement du programme

Créons un programme qui démontre l'utilisation d'arguments optionnels.

Créer un programme de salutation avec des arguments optionnels

1. Dans l'IDE Web, créez un nouveau fichier appelé greeting.py dans le répertoire /home/labex/project.

2. Ajoutez le code suivant au fichier :

import argparse

## Create an argument parser
parser = argparse.ArgumentParser(description="A customizable greeting program")

## Add optional arguments
parser.add_argument("-n", "--name", default="World", help="The name to greet (default: World)")
parser.add_argument("-g", "--greeting", default="Hello", help="The greeting to use (default: Hello)")
parser.add_argument("-c", "--count", type=int, default=1, help="Number of times to display the greeting (default: 1)")

## Parse the arguments
args = parser.parse_args()

## Display the greeting
for _ in range(args.count):
    print(f"{args.greeting}, {args.name}!")

3. Enregistrez le fichier.

4. Exécutez le programme sans aucun argument :

python /home/labex/project/greeting.py

5. Vous devriez voir le message de salutation par défaut :

Hello, World!

6. Essayez maintenant de personnaliser le message de salutation avec des arguments optionnels :

python /home/labex/project/greeting.py --name Alice --greeting Hi

7. Vous devriez voir le message de salutation personnalisé :

Hi, Alice!

8. Vous pouvez également utiliser les formes courtes des arguments :

python /home/labex/project/greeting.py -n Bob -g Hey -c 3

9. Cela devrait afficher le message de salutation trois fois :

Hey, Bob!
Hey, Bob!
Hey, Bob!

Types d'arguments optionnels

argparse prend en charge plusieurs types d'arguments optionnels :

1. Arguments indicateurs (flag arguments): Des indicateurs booléens qui sont soit présents, soit absents

2. Arguments avec valeurs: Des arguments optionnels qui prennent des valeurs

Modifions notre programme de salutation pour inclure un argument indicateur :

1. Ouvrez greeting.py dans l'IDE Web.

2. Ajoutez un argument indicateur pour afficher le message en majuscules :

import argparse

## Create an argument parser
parser = argparse.ArgumentParser(description="A customizable greeting program")

## Add optional arguments
parser.add_argument("-n", "--name", default="World", help="The name to greet (default: World)")
parser.add_argument("-g", "--greeting", default="Hello", help="The greeting to use (default: Hello)")
parser.add_argument("-c", "--count", type=int, default=1, help="Number of times to display the greeting (default: 1)")
parser.add_argument("-u", "--uppercase", action="store_true", help="Display the greeting in uppercase")

## Parse the arguments
args = parser.parse_args()

## Create the greeting message
message = f"{args.greeting}, {args.name}!"

## Convert to uppercase if requested
if args.uppercase:
    message = message.upper()

## Display the greeting
for _ in range(args.count):
    print(message)

3. Enregistrez le fichier.

4. Exécutez le programme avec l'indicateur pour les majuscules :

python /home/labex/project/greeting.py -n Charlie -u

5. Vous devriez voir le message de salutation en majuscules :

HELLO, CHARLIE!

Le paramètre action="store_true" signifie que l'indicateur ne prend pas de valeur - il est soit présent (True), soit absent (False).

Les arguments optionnels rendent vos interfaces en ligne de commande plus flexibles et plus conviviales. Ils permettent aux utilisateurs de personnaliser le comportement de votre programme sans avoir à fournir toutes les informations à chaque fois.

Dans l'étape suivante, nous verrons comment combiner des arguments positionnels et optionnels dans un même programme.

Combinaison d'arguments positionnels et optionnels

La plupart des programmes en ligne de commande sophistiqués utilisent une combinaison d'arguments positionnels et optionnels. Les arguments positionnels sont parfaits pour les entrées essentielles dont votre programme a besoin, tandis que les arguments optionnels offrent de la flexibilité et des options de configuration.

Créons un programme de traitement de fichiers qui montre comment combiner efficacement ces deux types d'arguments.

Création d'un programme de traitement de fichiers

1. Dans l'IDE Web, créez un nouveau fichier appelé file_processor.py dans le répertoire /home/labex/project.

2. Ajoutez le code suivant au fichier :

import argparse
import os

## Create an argument parser
parser = argparse.ArgumentParser(description="A file processing utility")

## Add positional arguments
parser.add_argument("filename", help="The file to process")

## Add optional arguments
parser.add_argument("-c", "--count", action="store_true", help="Count lines in the file")
parser.add_argument("-s", "--search", help="Search for a string in the file")
parser.add_argument("-o", "--output", help="Output results to this file instead of console")
parser.add_argument("-v", "--verbose", action="store_true", help="Display detailed information")

## Parse the arguments
args = parser.parse_args()

## Check if the file exists
if not os.path.isfile(args.filename):
    print(f"Error: The file '{args.filename}' does not exist.")
    exit(1)

## Process the file
results = []

## Display verbose information if requested
if args.verbose:
    print(f"Processing file: {args.filename}")
    print(f"File size: {os.path.getsize(args.filename)} bytes")

## Open and process the file
with open(args.filename, 'r') as file:
    content = file.readlines()

    ## Count lines if requested
    if args.count:
        line_count = len(content)
        results.append(f"Line count: {line_count}")

    ## Search for string if requested
    if args.search:
        matching_lines = [line for line in content if args.search in line]
        match_count = len(matching_lines)
        results.append(f"Found '{args.search}' in {match_count} lines:")
        results.extend(matching_lines)

## Output the results
output_text = '\n'.join(results)

if args.output:
    ## Write to output file
    with open(args.output, 'w') as output_file:
        output_file.write(output_text)
    if args.verbose:
        print(f"Results written to {args.output}")
else:
    ## Print to console
    print(output_text)

3. Enregistrez le fichier.

4. Créons maintenant un fichier texte d'exemple à traiter :

echo -e "This is line 1\nThis is line 2\nThis is line 3\nPython is awesome\nArgparse makes CLI easy" > /home/labex/project/sample.txt

5. Exécutez le programme en spécifiant seulement le nom de fichier (argument positionnel) :

python /home/labex/project/file_processor.py /home/labex/project/sample.txt

Étant donné que nous n'avons pas spécifié d'actions avec des arguments optionnels, vous ne verrez aucune sortie.

6. Comptons maintenant le nombre de lignes dans le fichier :

python /home/labex/project/file_processor.py /home/labex/project/sample.txt --count

7. Vous devriez voir la sortie suivante :

Line count: 5

8. Recherchons une chaîne de caractères dans le fichier :

python /home/labex/project/file_processor.py /home/labex/project/sample.txt --search "line"

9. Vous devriez voir la sortie suivante :

Found 'line' in 3 lines:
This is line 1
This is line 2
This is line 3

10. Combinons maintenant plusieurs arguments optionnels :

python /home/labex/project/file_processor.py /home/labex/project/sample.txt --count --search "Python" --verbose

11. Vous devriez voir une sortie détaillée :

Processing file: /home/labex/project/sample.txt
File size: 96 bytes
Line count: 5
Found 'Python' in 1 lines:
Python is awesome

12. Enfin, écrivons les résultats dans un fichier de sortie :

python /home/labex/project/file_processor.py /home/labex/project/sample.txt --count --search "is" --output /home/labex/project/results.txt --verbose

13. Vous devriez voir :

Processing file: /home/labex/project/sample.txt
File size: 96 bytes
Results written to /home/labex/project/results.txt

14. Vous pouvez vérifier le contenu du fichier de sortie :

cat /home/labex/project/results.txt

15. Vous devriez voir :

Line count: 5
Found 'is' in 5 lines:
This is line 1
This is line 2
This is line 3
Python is awesome
Argparse makes CLI easy

Bonnes pratiques pour la combinaison d'arguments

Lorsque vous combinez des arguments positionnels et optionnels, gardez ces directives à l'esprit :

1. Utilisez les arguments positionnels pour les entrées essentielles sans lesquelles votre programme ne peut pas fonctionner.
2. Utilisez les arguments optionnels pour les options de configuration et les fonctionnalités qui peuvent avoir des valeurs par défaut sensées.
3. Définissez les arguments positionnels avant les arguments optionnels dans votre code.
4. Fournissez des messages d'aide clairs pour tous les arguments.
5. Regroupez les arguments optionnels liés.

En combinant efficacement les arguments positionnels et optionnels, vous pouvez créer des interfaces en ligne de commande à la fois puissantes et conviviales.

Résumé

Dans ce laboratoire, vous avez appris les différences fondamentales entre les arguments positionnels et les arguments optionnels dans le module argparse de Python :

• Les arguments positionnels sont des entrées obligatoires définies par leur position dans la ligne de commande. Ils sont idéaux pour les informations essentielles dont votre programme a besoin pour fonctionner.

• Les arguments optionnels sont préfixés par des tirets et peuvent être omis. Ils offrent de la flexibilité et des options de configuration pour votre programme.

Vous avez créé plusieurs programmes Python qui démontrent comment utiliser argparse pour construire des interfaces en ligne de commande conviviales. Vous avez appris à :

• Définir et accéder aux arguments positionnels
• Créer des arguments optionnels avec des formes courtes et longues
• Définir des valeurs par défaut pour les arguments optionnels
• Utiliser des arguments indicateurs (flag arguments) qui ne nécessitent pas de valeurs
• Combiner les deux types d'arguments dans des applications plus complexes

Ces compétences vous aideront à créer des applications Python plus flexibles et conviviales qui peuvent être exécutées depuis la ligne de commande. Que vous construisiez de simples utilitaires ou des applications complexes, argparse fournit un cadre puissant pour gérer les arguments de la ligne de commande.