Exécution de scripts Python en ligne de commande et explication détaillée des options

Python est utilisé dans une large gamme d’applications en raison de sa flexibilité et de sa facilité d’utilisation. Parmi ces fonctionnalités, l’exécution de scripts depuis la ligne de commande est particulièrement utile dans de nombreux contextes. Par exemple, il est possible d’exécuter des scripts de traitement de données avec des arguments, ou de les intégrer dans des tâches automatisées. De plus, l’utilisation des arguments de ligne de commande permet de modifier le comportement d’un script, offrant ainsi une grande flexibilité pour créer des scripts polyvalents. Cet article vous expliquera en détail comment gérer les arguments de ligne de commande avec Python, en couvrant les méthodes de base ainsi que des techniques avancées.

Sommaire

Les bases des arguments de ligne de commande

Lorsque vous exécutez un script Python à partir de la ligne de commande, vous pouvez passer des arguments pour contrôler son comportement. La méthode de base pour cela consiste à utiliser sys.argv.

Qu’est-ce que sys.argv ?

sys.argv fait partie du module sys de la bibliothèque standard Python, et fournit les arguments de ligne de commande sous forme de liste. Le premier élément de cette liste (sys.argv[0]) est le nom du script, et les éléments suivants sont les arguments qui lui sont passés.

Exemple d’utilisation de base

Le script suivant affiche simplement les arguments qui lui sont passés :

import sys

if __name__ == "__main__":
    print("Nom du script:", sys.argv[0])
    print("Arguments:", sys.argv[1:])

Lorsque ce script est exécuté avec la commande python script.py arg1 arg2, la sortie sera la suivante :

Nom du script: script.py
Arguments: ['arg1', 'arg2']

Les défis de l’analyse des arguments

Utiliser sys.argv permet de récupérer facilement les arguments, mais cela présente certains défis :

La vérification du nombre et du type des arguments doit être effectuée manuellement.
L’analyse des options (ex. : --help) devient complexe.
Le code devient encombré lors du traitement de longues listes d’arguments.

Pour résoudre ces problèmes, Python propose des modules spécialisés comme argparse. Dans la section suivante, nous verrons comment utiliser ce module pour analyser les arguments de manière plus simple et plus robuste.

Présentation du module argparse

Le module argparse fait partie de la bibliothèque standard de Python et fournit un outil puissant pour analyser les arguments de ligne de commande. Il permet de définir facilement les options et les arguments, et de les analyser lors de l’exécution du script.

Structure de base de argparse

Voici les étapes de base pour utiliser argparse :

Création d’un objet ArgumentParser
Il s’agit de l’objet de base utilisé pour analyser les arguments.
Définition des arguments
Vous spécifiez les arguments ou options que le script doit accepter.
Analyse des arguments
Les arguments passés à la ligne de commande sont analysés et utilisés pour contrôler le programme.

Exemple d’utilisation de base

Voici un exemple simple où argparse est utilisé pour analyser les arguments :

import argparse

if __name__ == "__main__":
    # Création de l'objet ArgumentParser
    parser = argparse.ArgumentParser(description="Exemple d'analyse des arguments")

    # Ajout des arguments
    parser.add_argument("name", help="Veuillez spécifier le nom d'utilisateur")
    parser.add_argument("--age", type=int, help="Veuillez spécifier l'âge")

    # Analyse des arguments
    args = parser.parse_args()

    # Affichage des résultats
    print(f"Bonjour, {args.name}!")
    if args.age:
        print(f"Vous avez {args.age} ans.")

Lorsque ce script est exécuté avec la commande :

python script.py Alice --age 30

La sortie sera la suivante :

Bonjour, Alice!
Vous avez 30 ans.

Les principaux avantages de argparse

Vérification automatique des types des arguments : Il est possible de valider automatiquement les types de valeurs comme les nombres ou les chaînes de caractères.
Aide intégrée : Le module ajoute automatiquement une option --help, qui génère un message d’aide expliquant comment utiliser les arguments.
Prise en charge des structures d’arguments complexes : Vous pouvez définir des arguments obligatoires, facultatifs, des indicateurs ou même des sous-commandes.

La section suivante expliquera comment configurer les arguments d’options à l’aide de argparse.

Configuration des arguments d’options

Le module argparse vous permet de configurer des arguments de ligne de commande flexibles, y compris des options qui modifient le comportement du script. Les arguments d’options sont généralement précédés de -- ou -.

Configuration de base des arguments d’options

Les arguments d’options sont ajoutés à l’aide de la méthode add_argument, où vous spécifiez le nom de l’option en utilisant -- ou -.

Voici un exemple simple d’options d’arguments :

import argparse

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Exemple d'options d'arguments")

    # Ajout des options
    parser.add_argument("--verbose", action="store_true", help="Affiche des informations détaillées")
    parser.add_argument("--output", type=str, help="Spécifie le fichier de sortie")

    args = parser.parse_args()

    if args.verbose:
        print("Mode verbeux activé")
    if args.output:
        print(f"Fichier de sortie : {args.output}")

Vous pouvez exécuter ce script comme suit :

python script.py --verbose --output result.txt

La sortie sera la suivante :

Mode verbeux activé
Fichier de sortie : result.txt

Principaux paramètres de configuration

Voici quelques paramètres courants pour personnaliser les options d’arguments :

1. Spécification du type

Vous pouvez utiliser le paramètre type pour spécifier le type des valeurs attendues.

parser.add_argument("--count", type=int, help="Spécifie le nombre de traitements")

2. Valeur par défaut

Vous pouvez spécifier une valeur par défaut pour un argument à l’aide du paramètre default.

parser.add_argument("--level", type=int, default=1, help="Spécifie le niveau de traitement (par défaut : 1)")

3. Option obligatoire

Vous pouvez rendre un argument obligatoire en définissant required=True.

parser.add_argument("--config", required=True, help="Spécifie le fichier de configuration")

Gestion des arguments de type flag

Certains arguments optionnels ne prennent pas de valeur et basculent simplement un booléen lorsque spécifiés. Dans ce cas, vous pouvez utiliser action="store_true".

parser.add_argument("--debug", action="store_true", help="Active le mode débogage")

Lorsque vous exécutez ce script avec l’option --debug, args.debug sera égal à True.

Conclusion

En utilisant argparse, vous pouvez facilement configurer des arguments d’options flexibles et conviviaux. La prochaine section traitera de la génération automatique des messages d’aide dans argparse.

Génération automatique des messages d’aide

Le module argparse génère automatiquement des messages d’aide pour les arguments de ligne de commande, ce qui permet de fournir facilement des informations sur l’utilisation du script à l’utilisateur.

Message d’aide de base

Lorsque vous créez un objet ArgumentParser, les options --help ou -h sont automatiquement ajoutées, et vous pouvez afficher une description des arguments du script.

Exemple : message d’aide généré automatiquement

Exécutez le script suivant :

import argparse

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Exemple de message d'aide")
    parser.add_argument("--input", help="Spécifie le fichier d'entrée")
    parser.add_argument("--output", help="Spécifie le fichier de sortie")
    parser.add_argument("--verbose", action="store_true", help="Active le mode détaillé")

    args = parser.parse_args()

Si vous exécutez ce script avec l’option --help, le message suivant sera affiché :

python script.py --help

usage: script.py [-h] [--input INPUT] [--output OUTPUT] [--verbose]

Exemple de message d'aide

options:
  -h, --help       Affiche ce message d'aide et termine
  --input INPUT    Spécifie le fichier d'entrée
  --output OUTPUT  Spécifie le fichier de sortie
  --verbose        Active le mode détaillé

Ce message d’aide inclut une description des arguments et des options. Vous pouvez utiliser -h ou --help pour obtenir ce résultat.

Personnalisation des messages d’aide

Avec argparse, vous pouvez personnaliser les descriptions et les messages d’aide pour les arguments.

1. Description du script

Utilisez le paramètre description de ArgumentParser pour ajouter une description du script.

parser = argparse.ArgumentParser(description="Ce script traite des fichiers")

2. Description pour chaque argument

Ajoutez des descriptions pour chaque argument à l’aide du paramètre help de add_argument.

parser.add_argument("--input", help="Spécifie le fichier d'entrée")

3. Ajout d’exemples d’utilisation personnalisés

Utilisez le paramètre epilog pour ajouter des exemples ou des informations supplémentaires à la fin de l’aide.

parser = argparse.ArgumentParser(
    description="Exemple de message d'aide",
    epilog="Exemple : python script.py --input file.txt --output result.txt"
)

Exemple : message d’aide personnalisé

import argparse

if __name__ == "__main__":
    parser = argparse.ArgumentParser(
        description="Ce script traite des fichiers",
        epilog="Exemple : python script.py --input in.txt --output out.txt"
    )
    parser.add_argument("--input", required=True, help="Spécifie le fichier d'entrée")
    parser.add_argument("--output", required=True, help="Spécifie le fichier de sortie")
    parser.add_argument("--verbose", action="store_true", help="Affiche des informations détaillées")

    args = parser.parse_args()

Lorsque vous exécutez python script.py --help, le message d’aide suivant sera affiché :

usage: script.py [-h] --input INPUT --output OUTPUT [--verbose]

Ce script traite des fichiers

options:
  -h, --help       Affiche ce message d'aide et termine
  --input INPUT    Spécifie le fichier d'entrée
  --output OUTPUT  Spécifie le fichier de sortie
  --verbose        Affiche des informations détaillées

Exemple : python script.py --input in.txt --output out.txt

Avantages des messages d’aide

Facilité d’utilisation : L’utilisateur peut rapidement comprendre comment utiliser le script.
Consistance : La description de tous les arguments peut être présentée dans un format cohérent.
Maintenance : Les messages d’aide sont automatiquement mis à jour lors des modifications du code.

Dans la section suivante, nous allons aborder la mise en place de « sous-commandes » pour permettre à un script d’avoir plusieurs actions différentes.

Introduction des sous-commandes

Un script avec plusieurs fonctionnalités peut bénéficier d’une organisation claire où chaque fonction est séparée en sous-commandes. Cela peut être réalisé avec la fonctionnalité de sous-commandes du module argparse, ce qui permet d’organiser efficacement les tâches et de rendre le script plus facile à utiliser.

Structure de base des sous-commandes

Pour définir des sous-commandes, vous devez utiliser la méthode add_subparsers. Cette méthode vous permet de définir des sous-commandes, chacune avec ses propres arguments et options.

Exemple : sous-commandes de base

Voici un exemple où deux sous-commandes, add et delete, sont définies :

import argparse

if __name__ == "__main__":
    # Création de l'objet ArgumentParser principal
    parser = argparse.ArgumentParser(description="Exemple de sous-commandes")

    # Création du gestionnaire de sous-commandes
    subparsers = parser.add_subparsers(dest="command", help="Commandes disponibles")

    # Sous-commande 'add'
    parser_add = subparsers.add_parser("add", help="Ajoute un élément")
    parser_add.add_argument("item", help="Nom de l'élément à ajouter")

    # Sous-commande 'delete'
    parser_delete = subparsers.add_parser("delete", help="Supprime un élément")
    parser_delete.add_argument("item", help="Nom de l'élément à supprimer")

    # Analyse des arguments
    args = parser.parse_args()

    # Traitement en fonction de la sous-commande
    if args.command == "add":
        print(f"Élément '{args.item}' ajouté")
    elif args.command == "delete":
        print(f"Élément '{args.item}' supprimé")
    else:
        parser.print_help()

Vous pouvez exécuter ce script comme suit :

python script.py add "Tâche 1"

Sortie :

Élément 'Tâche 1' ajouté

python script.py delete "Tâche 1"

Sortie :

Élément 'Tâche 1' supprimé

Arguments et options des sous-commandes

Chaque sous-commande peut avoir ses propres arguments et options. Par exemple, vous pouvez ajouter une option de description pour la sous-commande add et une option de confirmation pour la sous-commande delete.

Exemple d’extension des sous-commandes

# Ajouter une option de description pour la sous-commande 'add'
parser_add.add_argument("--description", help="Décrit l'élément à ajouter")

# Ajouter un flag de confirmation pour la sous-commande 'delete'
parser_delete.add_argument("--force", action="store_true", help="Supprime sans confirmation")

Voici comment exécuter ce script avec les options :

python script.py add "Tâche 2" --description "Nouvelle tâche"

python script.py delete "Tâche 2" --force

Précautions lors de l’utilisation des sous-commandes

Paramètre dest
Le résultat des sous-commandes est stocké dans l’argument dest (par exemple, args.command).
Oublier de spécifier une sous-commande
Il est important d’appeler print_help() si aucune sous-commande n’est spécifiée pour afficher un message d’aide.
Conception cohérente
Lorsque les sous-commandes augmentent, il est essentiel de maintenir une cohérence dans les noms des commandes et des arguments.

Conclusion

Les sous-commandes offrent une manière claire de gérer plusieurs actions dans un seul script. Elles sont particulièrement utiles pour créer des outils de gestion de tâches ou des clients API avec plusieurs fonctionnalités. La section suivante expliquera comment utiliser la bibliothèque click pour une analyse encore plus flexible des arguments.

Analyse des options avec la bibliothèque click

Bien que argparse soit puissant, la bibliothèque click est plus adaptée pour créer des outils de ligne de commande simples et intuitifs. click permet de définir les arguments et de générer des messages d’aide automatiquement, avec moins de code.

Bases de click

click utilise des décorateurs de fonction pour définir les arguments et options, ce qui rend le code plus lisible et permet de séparer les fonctionnalités naturellement.

Installation de click

Commencez par installer la bibliothèque :

pip install click

Exemple de base

Voici un exemple simple d’utilisation de click pour analyser les arguments de la ligne de commande :

import click

@click.command()
@click.option("--name", prompt="Votre nom", help="Spécifiez le nom d'utilisateur")
@click.option("--age", default=25, help="Spécifiez l'âge (par défaut : 25)")
def greet(name, age):
    """Affiche un message de salutation"""
    click.echo(f"Bonjour, {name}! Vous avez {age} ans.")

if __name__ == "__main__":
    greet()

Exécutez ce script comme suit :

python script.py --name Alice --age 30

Sortie :

Bonjour, Alice! Vous avez 30 ans.

Si --name ou --age ne sont pas spécifiés, le programme demandera une saisie utilisateur.

Outils multi-commandes

click facilite également la définition de plusieurs commandes. Vous pouvez utiliser @click.group() pour regrouper plusieurs commandes dans un seul script.

Exemple : plusieurs commandes

import click

@click.group()
def cli():
    """Gère plusieurs commandes"""
    pass

@click.command()
@click.argument("item")
def add(item):
    """Ajoute un élément"""
    click.echo(f"Élément '{item}' ajouté")

@click.command()
@click.argument("item")
def delete(item):
    """Supprime un élément"""
    click.echo(f"Élément '{item}' supprimé")

cli.add_command(add)
cli.add_command(delete)

if __name__ == "__main__":
    cli()

Exécutez ce script comme suit :

python script.py add "Tâche 1"
python script.py delete "Tâche 1"

Sortie :

Élément 'Tâche 1' ajouté  
Élément 'Tâche 1' supprimé

Les avantages de click

Code concis : La définition des arguments et options avec des décorateurs est intuitive.
Génération automatique de l’aide : L’option --help est générée automatiquement.
Invitation à entrer des données : Avec l’option prompt, le script peut demander des saisies utilisateur lorsque les arguments sont manquants.
Couleurs et décorations : Vous pouvez facilement ajouter des couleurs et des décorations à la sortie avec click.echo().

Exemple de message d’erreur personnalisé

click facilite également la gestion des erreurs. Voici un exemple où vous pouvez personnaliser un message d’erreur :

@click.command()
@click.argument("number", type=int)
def square(number):
    """Calcule le carré du nombre spécifié"""
    if number < 0:
        raise click.BadParameter("Veuillez spécifier un nombre positif")
    click.echo(f"{number} au carré est {number**2}")

if __name__ == "__main__":
    square()

Conclusion

click est une bibliothèque flexible qui permet de créer facilement des outils de ligne de commande, qu’ils soient simples ou complexes avec plusieurs sous-commandes. La prochaine section abordera les meilleures pratiques pour le développement d’outils en ligne de commande.

Meilleures pratiques pour le développement d’outils en ligne de commande

Lors de la création d’outils en ligne de commande en Python, il est essentiel de concevoir une interface intuitive et extensible. Cette section explique les meilleures pratiques pour concevoir des outils en ligne de commande efficaces.

1. Interface intuitive et cohérente

Pour garantir que l’utilisateur ne se perde pas, il est crucial de concevoir une interface simple et cohérente.

Points recommandés

Les noms de commandes et d’options doivent être clairs et pas trop courts (par exemple : --verbose).
Attribuez des abréviations aux noms d’options longs (par exemple : --help et -h).
Organisez les sous-commandes et options de manière hiérarchique pour maintenir une structure logique.

Exemple

tool.py add "nom de tâche" --priority high
tool.py delete "nom de tâche" --force

2. Exploitation de l’aide générée automatiquement

Enrichir la description des arguments et des options permet de générer un message d’aide détaillé, facilitant la compréhension des commandes par les utilisateurs.

Approche recommandée

Ajoutez des chaînes help appropriées pour chaque argument et option.
Complétez la description du script et les exemples d’utilisation à l’aide des paramètres description et epilog.

Exemple : configuration avec argparse

parser = argparse.ArgumentParser(
    description="Outil de gestion des tâches",
    epilog="Exemple d'utilisation : python tool.py add 'tâche' --priority high"
)

3. Implémentation de la gestion des erreurs

Si l’utilisateur spécifie des arguments ou options incorrects, renvoyer un message d’erreur clair augmente la fiabilité du script.

Exemple de gestion des erreurs

@click.command()
@click.argument("number", type=int)
def square(number):
    if number < 0:
        raise click.BadParameter("Les nombres négatifs ne sont pas supportés")
    click.echo(f"{number} au carré est {number**2}")

4. Modularisation de la structure de l’outil

Si votre script devient complexe, divisez-le en plusieurs modules pour faciliter sa gestion.

Exemple de structure

project/
├── cli.py        # Interface en ligne de commande
├── commands/
│   ├── add.py    # Commande 'add'
│   ├── delete.py # Commande 'delete'
│   └── __init__.py
├── utils.py      # Fonctions utilitaires
└── main.py       # Point d'entrée

5. Implémentation des tests unitaires

Ajoutez des tests pour assurer la qualité de votre outil en ligne de commande.

Exemple de test

Testez votre script avec pytest :

from click.testing import CliRunner
from my_tool import cli

def test_add_command():
    runner = CliRunner()
    result = runner.invoke(cli, ["add", "Task 1"])
    assert result.exit_code == 0
    assert "Tâche 1 ajoutée" in result.output

6. Prise en charge multiplateforme

Assurez-vous que votre outil fonctionne sur Windows, macOS et Linux.

Points à considérer

Utilisez os.path ou pathlib pour gérer les chemins de fichiers.
Utilisez subprocess pour appeler des commandes shell ou des programmes externes.

7. Simplification de la distribution et de l’installation

Pour rendre votre outil facilement utilisable dans d’autres environnements, mettez en place un mécanisme de packaging et d’installation.

Méthode recommandée

Utilisez setuptools pour créer un package Python.
Configurez entry_points pour rendre votre outil installable en tant que commande en ligne.

from setuptools import setup

setup(
    name="my_tool",
    version="1.0",
    py_modules=["tool"],
    install_requires=["click"],
    entry_points={
        "console_scripts": [
            "tool=tool:cli",
        ],
    },
)

Conclusion

Le développement d’outils en ligne de commande nécessite une attention particulière à l’ergonomie, à l’extensibilité et à la maintenabilité. En intégrant les bonnes pratiques, vous pouvez créer des outils à la fois conviviaux et faciles à gérer pour les développeurs. Avec Python, vous avez la flexibilité nécessaire pour relever ce défi.