Python est un langage de programmation puissant qui permet aux développeurs de créer une variété d’applications, des scripts de base aux grands systèmes logiciels. L’une des tâches de programmation les plus courantes est de créer des interfaces de ligne de commande (CLI), qui permettent aux utilisateurs d’interagir avec des programmes via un terminal ou une ligne de commande. Les CLI sont essentielles pour le scripting, l’automatisation et dans les cas où une interface graphique utilisateur est impraticable.
La gestion des paramètres de ligne de commande est une partie importante de la conception des CLI. Ces arguments permettent aux utilisateurs d’influencer le comportement d’un programme en fournissant des paramètres d’entrée lors de son exécution. Sans la capacité d’évaluer ces facteurs, les programmes seraient moins polyvalents et plus difficiles à adapter à des tâches spécifiques.
Python fournit plusieurs modules pour parsing des arguments de ligne de commande, mais le module argparse se distingue par sa simplicité et son exhaustivité. Le module argparse facilite le développement d’interfaces de ligne de commande fonctionnelles. Il gère automatiquement l’analyse des paramètres, affiche des instructions utiles et fournit des erreurs lorsque les utilisateurs fournissent des informations incorrectes.
Dans ce tutoriel, nous allons examiner comment utiliser le Python package argparse. Nous commencerons par un aperçu des interfaces de ligne de commande de Python et de l’importance de l’analyse des entrées de ligne de commande. Ensuite, nous discuterons du module argparse et de ses avantages.
Aperçu des Interfaces de Ligne de Commande en Python
Les interfaces en ligne de commande sont des programmes qui s’exécutent uniquement sur des commandes basées sur du texte. Les utilisateurs saisissent des commandes dans un terminal ou une ligne de commande, qui incluent généralement des arguments et des options qui modifient le comportement du programme. Les interfaces en ligne de commande sont utiles car elles sont facilement automatisées et intégrées avec d’autres technologies.
En Python, une interface en ligne de commande est créée en développant un script qui accepte une entrée en ligne de commande. Cette entrée est généralement présentée sous forme d’une liste d’arguments que le script peut accéder et interpréter. Pour des programmes basiques, gérer manuellement ces arguments via la liste sys.argv peut suffire. Cependant, lorsque la complexité du programme augmente, le traitement manuel des arguments devient inefficace et sujet aux erreurs.
Importance de l’analyse des arguments en ligne de commande
L’analyse des arguments en ligne de commande est nécessaire pour de nombreuses raisons:
- Flexibilité: En prenant des paramètres, un programme peut effectuer plusieurs tâches ou agir sur différents ensembles de données sans changer le code. Les utilisateurs peuvent spécifier des fichiers à traiter, configurer des paramètres et sélectionner des modes de fonctionnement.
- Convivialité: Une analyse correcte des arguments permet au programme d’afficher des messages utiles, d’instruire l’utilisateur sur l’utilisation du programme et de gérer élégamment les erreurs.
- Maintenabilité: L’utilisation d’un module de parsing dédié, tel que argparse, rend votre code plus clair et plus facile à entretenir. Il sépare la logique utilisée pour analyser les arguments de l’opération principale du programme.
Introduction au module argparse et ses avantages
Le argparse est une partie de la bibliothèque standard de Python. Par conséquent, il peut être utilisé sans installer de packages supplémentaires. Il offre une interface simple et cohérente pour analyser les entrées de ligne de commande. Certains des avantages d’utiliser argparse sont :
- Génération automatique d’aide: Il génère des messages d’aide et d’utilisation en fonction des arguments du code.
- Gestion des erreurs: Il affiche des messages d’erreur utiles lorsque les utilisateurs saisissent des arguments invalides.
- Conversion de type: Il peut automatiquement convertir les chaînes de paramètres au type de données approprié.
- Il prend en charge à la fois les arguments positionnels nécessaires et les arguments optionnels avec simplicité.
- Valeurs par défaut: Il vous permet de fournir des valeurs par défaut pour les paramètres que l’utilisateur ne fournit pas.
argparse permet aux développeurs de se concentrer sur la fonctionnalité principale de leur programme tout en dépendant d’une base solide pour gérer les entrées en ligne de commande.
Mise en place de argparse et utilisation de base
Maintenant que nous avons abordé l’importance de l’analyse des arguments en ligne de commande et les avantages d’utiliser argparse, regardons comment le configurer et l’utiliser dans un script Python.
Installation et importation de argparse
Il n’est pas nécessaire d’installer quoi que ce soit séparément car argparse fait partie de la bibliothèque standard de Python. Vous pouvez l’importer dès le début de votre script.
import argparse
Cette ligne charge le module argparse dans votre script, vous permettant d’utiliser sa fonctionnalité pour analyser les arguments en ligne de commande.
Création d’un simple analyseur d’arguments
La première étape pour utiliser argparse est de générer un objet analyseur. Cet objet stockera des informations sur les arguments que votre programme accepte et analysera les entrées en ligne de commande.
parser = argparse.ArgumentParser(description='Process some integers.')
Dans cet exemple, nous créons un objet ArgumentParser() et décrivons le programme. Lorsque l’utilisateur sélectionne l’option d’aide (-h ou --help), cette description sera affichée.
Ajout d’arguments positionnels et facultatifs
Maintenant que nous avons développé l’analyseur, nous pouvons spécifier les arguments que notre programme acceptera.
Ajout d’arguments positionnels
Les arguments positionnels sont essentiels et doivent être présentés dans un ordre précis. Par exemple, considérez un script qui ajoute deux nombres. Nous pouvons définir deux arguments positionnels pour les nombres:
parser.add_argument('num1', type=int, help='The first number to add.') parser.add_argument('num2', type=int, help='The second number to add.')
Dans ce code, num1 et num2 font référence aux paramètres positionnels.
type=int indique que les paramètres doivent être convertis en entiers. L’argument d’aide spécifie une description qui apparaîtra dans le message d’aide.
Ajouter des arguments optionnels
Les arguments optionnels ne sont pas nécessaires et fournissent généralement des options supplémentaires ou changent le comportement du programme. Ils sont généralement précédés d’un ou deux tirets. Nous allons ajouter un argument optionnel pour activer la sortie verbeuse :
parser.add_argument('-v', '--verbose', action='store_true', help='Increase output verbosity.')
Ici :
- L’option courte est
-v(par exemple,-v).--verboseest une option longue. action='store_true'indique que si l’option est sélectionnée, l’attribut verbeux sera défini surTrue; sinon, il seraFalse.- L’argument
helpspécifie une description pour le message d’aide.
Analyse des arguments et accès à leurs valeurs
Après avoir spécifié tous les arguments, nous devons analyser l’entrée de la ligne de commande. Utilisez la méthode .parse_args() pour y parvenir.
args = parser.parse_args()
Les paramètres analysés sont maintenant stockés dans la variable args en tant qu’attributs. Nous pouvons y accéder en utilisant la notation par points.
result = args.num1 + args.num2 print('The sum of {} and {} is {}'.format(args.num1, args.num2, result)) if args.verbose: print('Verbose mode is enabled.')
Pour rassembler le tout, voici un script complet qui additionne deux nombres et inclut un mode verbeux optionnel :
import argparse parser = argparse.ArgumentParser(description='Add two integers.') parser.add_argument('num1', type=int, help='The first number to add.') parser.add_argument('num2', type=int, help='The second number to add.') parser.add_argument('-v', '--verbose', action='store_true', help='Increase output verbosity.') args = parser.parse_args() result = args.num1 + args.num2 print('The sum of {} and {} is {}'.format(args.num1, args.num2, result)) if args.verbose: print('Calculation completed successfully.')
Vous pouvez exécuter ce script depuis la ligne de commande et fournir les arguments positionnels requis :
python add_numbers.py 3 5 The sum of 3 and 5 is 8
Si vous incluez l’option -v ou --verbose, le script affichera le message verbeux supplémentaire:
python add_numbers.py 3 5 --verbose The sum of 3 and 5 is 8 Calculation completed successfully.
Si l’utilisateur exécute le script avec l’option -h ou --help, argparse affichera un message d’aide généré automatiquement:
python add_numbers.py -h usage: add_numbers.py [-h] [-v] num1 num2 Add two integers. positional arguments: num1 The first number to add. num2 The second number to add. optional arguments: -h, --help show this help message and exit -v, --verbose Increase output verbosity.
Cette fonctionnalité rend votre programme plus convivial en fournissant des instructions claires sur la manière de l’utiliser.
Gestion avancée des arguments
Lors du développement de programmes en ligne de commande en Python, vous pouvez rencontrer des scénarios nécessitant une analyse d’arguments plus complexe. Le module argparse de Python comprend plusieurs fonctionnalités pour répondre à ces exigences complexes, vous permettant de développer des interfaces flexibles et conviviales.
Utilisation de nargs pour plusieurs arguments
Il y a des situations où votre application doit accepter de nombreuses valeurs pour le même argument. Par exemple, supposons que vous souhaitiez créer un script qui traite plusieurs fichiers en même temps. Le paramètre nargs dans argparse vous permet de spécifier combien d’arguments de ligne de commande doivent être lus.
Voici comment utiliser nargs pour accepter plusieurs noms de fichiers:
import argparse parser = argparse.ArgumentParser(description='Process multiple files.') parser.add_argument('filenames', nargs='+', help='List of files to process.') args = parser.parse_args() for filename in args.filenames: print(f'Processing file: {filename}') # Ajoutez votre code de traitement de fichier ici
Dans ce cas, nargs='+' indique au parseur de s’attendre à un ou plusieurs arguments dans les noms de fichiers. L’utilisateur peut fournir autant de noms de fichiers que nécessaire, et ils seront enregistrés dans une liste appelée args.filenames.
Si vous souhaitez accepter un certain nombre d’arguments, définissez nargs sur ce nombre. Par exemple, nargs=2 nécessite exactement deux paramètres.
Implémentation des choix pour limiter les valeurs des arguments
Parfois, vous souhaitez limiter un argument à une plage spécifiée de valeurs valides. Cela garantit que l’utilisateur propose une entrée valide, évitant ainsi les erreurs ou actions inattendues. Le paramètre des options vous permet de spécifier les valeurs autorisées pour un argument.
Considérez un script qui exécute plusieurs activités en fonction d’un mode sélectionné par l’utilisateur.
import argparse parser = argparse.ArgumentParser(description='Perform actions in different modes.') parser.add_argument('--mode', choices=['backup', 'restore', 'delete'], required=True, help='Mode of operation.') args = parser.parse_args() if args.mode == 'backup': print('Backing up data...') # Code de sauvegarde ici elif args.mode == 'restore': print('Restoring data...') # Code de restauration ici elif args.mode == 'delete': print('Deleting data...') # Code de suppression ici
Dans ce script, l’argument --mode doit être l’une des options. Si l’utilisateur entre une valeur qui n’est pas dans la liste, argparse renverra un message d’erreur.
Gestion des drapeaux booléens et des bascules
Les drapeaux booléens sont des choix qui activent ou désactivent des fonctionnalités spécifiques dans votre application. Ils sont généralement définis sans valeur, simplement en incluant le drapeau dans la commande. Vous pouvez gérer ces drapeaux dans argparse avec le paramètre action.
Par exemple, incluons un mode de débogage dans un script :
import argparse parser = argparse.ArgumentParser(description='A script with debug mode.') parser.add_argument('--debug', action='store_true', help='Enable debug output.') args = parser.parse_args() if args.debug: print('Debug mode is enabled.') # Informations de débogage supplémentaires ici else: print('Debug mode is disabled.')
En utilisant action='store_true', le drapeau --debug définira args.debug sur True lorsqu’il est présent et sur False sinon.
Définition des valeurs par défaut et des arguments requis
Les arguments facultatifs incluent fréquemment des valeurs par défaut sensées. Cela signifie que si l’utilisateur ne spécifie pas l’argument, l’application utilisera la valeur par défaut. L’argument default vous permet de spécifier une valeur par défaut.
Voici un exemple:
import argparse parser = argparse.ArgumentParser(description='Adjust program settings.') parser.add_argument('--timeout', type=int, default=30, help='Timeout in seconds.') args = parser.parse_args() print(f'Timeout is set to {args.timeout} seconds.')
Dans ce scénario, si l’utilisateur ne spécifie pas --timeout, la valeur par défaut est de 30 secondes.
Pour rendre un argument facultatif obligatoire, définissez required=True.
import argparse parser = argparse.ArgumentParser(description='Send a message.') parser.add_argument('--recipient', required=True, help='Recipient of the message.') args = parser.parse_args() print(f'Sending message to {args.recipient}.')
Le script exigera désormais l’argument --recipient.
Personnalisation des messages d’aide et d’erreur
Fournir des messages clairs et utiles aux utilisateurs est un élément essentiel du développement d’un programme en ligne de commande efficace. Le module argparse de Python crée automatiquement des messages d’aide, mais vous pouvez les modifier pour mieux correspondre à vos besoins.
Génération de messages d’aide automatiques
Par défaut, argparse génère un message d’aide, qui peut être consulté en utilisant les options -h ou --help. Ce message contient l’utilisation du programme, une description et des informations sur chaque argument.
Par exemple:
import argparse parser = argparse.ArgumentParser(description='Calculate factorial of a number.') parser.add_argument('number', type=int, help='The number to calculate the factorial for.') args = parser.parse_args()
Lorsqu’un utilisateur exécute le script avec -h, il verra:
usage: script.py [-h] number Calculate factorial of a number. positional arguments: number The number to calculate the factorial for. optional arguments: -h, --help show this help message and exit
Ce message d’aide automatique fournit des informations utiles sans nécessiter d’effort supplémentaire.
Personnalisation des descriptions d’aide et des messages d’utilisation
Bien que les messages d’aide par défaut soient utiles, vous pouvez les modifier pour fournir des informations supplémentaires ou pour s’adapter à une structure spécifique. Vous pouvez changer la description, l’épilogue et le texte d’utilisation dans l’ArgumentParser.
Par exemple, pour inclure un épilogue et personnaliser le message d’utilisation :
import argparse parser = argparse.ArgumentParser( description='Convert temperatures between Celsius and Fahrenheit.', epilog='Enjoy using the temperature converter!', usage='%(prog)s [options] temperature') parser.add_argument('temperature', type=float, help='Temperature value to convert.') parser.add_argument('--to-fahrenheit', action='store_true', help='Convert Celsius to Fahrenheit.') parser.add_argument('--to-celsius', action='store_true', help='Convert Fahrenheit to Celsius.') args = parser.parse_args()
Maintenant, lorsque l’utilisateur consulte le message d’aide, il inclura la description personnalisée, l’utilisation et l’épilogue :
python file.py --help usage: p.py [options] temperature Convert temperatures between Celsius and Fahrenheit. positional arguments: temperature Temperature value to convert. options: -h, --help show this help message and exit --to-fahrenheit Convert Celsius to Fahrenheit. --to-celsius Convert Fahrenheit to Celsius.
–to-fahrenheit Convertir Celsius en Fahrenheit.
–to-celsius Convertir Fahrenheit en Celsius.
Gestion de la gestion des erreurs et des retours utilisateurs
import argparse import sys class CustomArgumentParser(argparse.ArgumentParser): def error(self, message): print(f'Error: {message}') self.print_help() sys.exit(2) parser = CustomArgumentParser(description='Divide two numbers.') parser.add_argument('numerator', type=float, help='The numerator.') parser.add_argument('denominator', type=float, help='The denominator.') args = parser.parse_args() if args.denominator == 0: parser.error('Denominator cannot be zero.') result = args.numerator / args.denominator print(f'Result: {result}')
Si un utilisateur saisit des arguments invalides, argparse affichera un message d’erreur et quittera le programme. Vous pouvez modifier ce comportement pour fournir des retours plus utiles ou gérer les échecs différemment.
Python file.py 6 0 Error: Denominator cannot be zero. usage: file.py [-h] numerator denominator Divide two numbers. positional arguments: numerator The numerator. denominator The denominator. options: -h, --help show this help message and exit
Une approche consiste à remplacer la méthode d’erreur dans une sous-classe de ArgumentParser:
import argparse import os parser = argparse.ArgumentParser(description='Read a file and display its contents.') parser.add_argument('filepath', help='Path to the file.') args = parser.parse_args() if not os.path.exists(args.filepath): parser.error(f"The file {args.filepath} does not exist.") with open(args.filepath, 'r') as file: contents = file.read() print(contents)
Si l’utilisateur tente de diviser par zéro dans ce script, l’application affichera un avertissement d’erreur et un texte d’aide, dirigeant l’utilisateur à fournir des données valides.
python app..py file usage: p.py [-h] filepath app.py: error: The file file does not exist.
Vous pouvez également inclure une gestion d’erreurs personnalisée dans votre script. Par exemple, pour gérer les chemins de fichiers invalides :
Exécuter le script avec un chemin invalide affichera l’erreur ci-dessous :
Exemples concrets et cas d’utilisation
Comprendre comment utiliser le module argparse dans des situations réelles rendra sa fonctionnalité plus claire. Examinons quelques exemples de l’utilisation de argparse dans des applications concrètes.
Construire une calculatrice en ligne de commande
import argparse parser = argparse.ArgumentParser(description='Simple command-line calculator.') parser.add_argument('num1', type=float, help='First number.') parser.add_argument('operator', choices=['+', '-', '*', '/'], help='Operation to perform.') parser.add_argument('num2', type=float, help='Second number.') args = parser.parse_args() if args.operator == '+': result = args.num1 + args.num2 elif args.operator == '-': result = args.num1 - args.num2 elif args.operator == '*': result = args.num1 * args.num2 elif args.operator == '/': if args.num2 == 0: print('Error: Division by zero is not allowed.') exit(1) result = args.num1 / args.num2 print(f'The result is: {result}')
Supposons que vous deviez développer une calculatrice simple capable d’effectuer des opérations arithmétiques de base à partir de la ligne de commande. Cette calculatrice devrait accepter deux nombres et un opérateur pour exécuter le calcul demandé.
python calculator.py 10 + 5 The result is: 15.0
Voici comment aborder cette tâche :
Dans ce script, le module argparse est utilisé pour définir trois arguments positionnels : deux nombres et un opérateur. L’argument choices limite l’opérateur aux symboles arithmétiques valides. Lorsque l’utilisateur exécute le script, il peut réaliser ces calculs :
Cette calculatrice de base montre comment les options en ligne de commande peuvent améliorer la flexibilité et l’interactivité d’un programme.
Créer un script de traitement de fichiers avec plusieurs options
import argparse parser = argparse.ArgumentParser(description='Process text files.') parser.add_argument('input_file', help='Path to the input file.') parser.add_argument('-o', '--output', help='Path to the output file.') parser.add_argument('-m', '--mode', choices=['uppercase', 'lowercase'], default='uppercase', help='Processing mode.') parser.add_argument('-v', '--verbose', action='store_true', help='Enable verbose output.') args = parser.parse_args() Supposons que vous ayez besoin d'un script qui traite des fichiers texte et offre des choix tels que désigner un fichier de sortie, sélectionner un mode de traitement et activer une sortie détaillée. with open(args.input_file, 'r') as file: content = file.read() if args.verbose: print(f'Reading from {args.input_file}') Voici un exemple de la façon dont vous pourriez le configurer : if args.mode == 'uppercase': processed_content = content.upper() else: processed_content = content.lower() if args.verbose: print('Processing content') # Lire le fichier d'entrée if args.output: with open(args.output, 'w') as file: file.write(processed_content) if args.verbose: print(f'Writing output to {args.output}') else: print(processed_content)
# Traiter le contenu
python text_processor.py input.txt -o output.txt --mode lowercase -v Reading from input.txt Processing content Writing output to output.txt
# Écrire dans le fichier de sortie ou imprimer dans la console
Ce script accepte un fichier d’entrée et propose des options pour le fichier de sortie, le mode de traitement et la sortie détaillée. Les utilisateurs peuvent modifier le comportement du script sans altérer le code.
Développer un outil CLI avec des sous-commandes
import argparse parser = argparse.ArgumentParser(description='Manage tasks.') subparsers = parser.add_subparsers(dest='command', required=True) Dans des applications plus compliquées, des sous-commandes peuvent être nécessaires, similaire à la façon dont git fonctionne en utilisant des commandes telles que git commit et git push. Le moduleargparsefournit des sous-parsers à cet effet. parser_add = subparsers.add_parser('add', help='Add a new task.') parser_add.add_argument('name', help='Name of the task.') parser_add.add_argument('-p', '--priority', type=int, choices=range(1, 6), default=3, help='Priority of the task.') Voici comment créer un outil CLI avec des sous-commandes : parser_list = subparsers.add_parser('list', help='List all tasks.') parser_list.add_argument('-a', '--all', action='store_true', help='List all tasks, including completed ones.') # Sous-commande 'add' parser_complete = subparsers.add_parser('complete', help='Mark a task as completed.') parser_complete.add_argument('task_id', type=int, help='ID of the task to complete.') args = parser.parse_args() if args.command == 'add': print(f"Adding task '{args.name}' with priority {args.priority}") # Sous-commande 'list' elif args.command == 'list': print('Listing tasks') if args.all: print('Including completed tasks') # Sous-commande 'complete' elif args.command == 'complete': print(f'Marking task {args.task_id} as completed') # Code pour ajouter la tâche
# Code pour lister les tâches
# Code pour compléter la tâche
python task_manager.py add "Write report" -p 2 Adding task 'Write report' with priority 2
Dans cet exemple, le script a trois sous-commandes : add, list, et complete. Chaque sous-commande a ses propres arguments. Lorsque les utilisateurs exécutent le script, ils saisissent la sous-commande et tous les autres paramètres.
python task_manager.py list Listing tasks
Par exemple :
python task_manager.py complete 3 Marking task 3 as completed
Lister les tâches
Marquer les tâches comme complètes :
subparsers vous permet de créer des outils de ligne de commande complexes qui sont bien organisés et faciles à étendre, vous permettant de construire des applications pouvant faire plusieurs choses dans une seule interface.
Meilleures pratiques et conseils pour Python argparse
Le développement de programmes en ligne de commande implique plus que simplement écrire du code qui fonctionne. Cela implique également d’écrire un code propre, maintenable et convivial.
Voici quelques bonnes pratiques lors de l’utilisation du module argparse.
Organiser le code pour une meilleure lisibilité et maintenance
Lorsque vos scripts deviennent plus complexes, il est crucial de garder votre code organisé pour une meilleure compréhension et maintenance. Une approche pour y parvenir est d’utiliser des fonctions et des classes pour organiser les sections distinctes de votre code.
Découper votre programme en morceaux plus petits et réutilisables rend sa gestion plus facile et élimine la duplication de code.
Par exemple, dans un script de gestion des tâches, vous pourriez définir différentes fonctions pour ajouter des tâches, lister des tâches et compléter des tâches. Cette division vous permet de vous concentrer sur un aspect de la logique à la fois, rendant votre code plus clair.
Une autre technique efficace est de séparer la logique d’analyse des arguments du reste de votre code. Placer toutes les définitions d’arguments et l’analyse au début de votre script, ou dans une fonction dédiée, facilite la compréhension de la manière dont votre programme gère les entrées par d’autres personnes.
L’utilisation de noms de variables appropriés améliore également la lisibilité. Choisissez des noms de variables qui reflètent leur but, de sorte que toute personne consultant votre code puisse comprendre ce qui se passe. Inclure des commentaires et des docstrings pour expliquer ce que font vos fonctions et tout détail clé peut aider à augmenter la compréhension.
Tester et déboguer des applications en ligne de commande
Tester vos applications est crucial pour garantir leur bon fonctionnement et détecter les défauts dès le début. Écrire des tests unitaires avec des frameworks de test Python tels que unittest ou pytest est une excellente approche pour tester votre code. Ces tests vous permettent de simuler différentes entrées et de vous assurer que vos fonctions fonctionnent correctement.
Par exemple, vous pouvez tester plusieurs scénarios en simulant les entrées de la ligne de commande plutôt qu’en exécutant le script depuis la ligne de commande. Cette stratégie vous permet de vous assurer que votre analyse d’arguments fonctionne comme prévu et que votre application gère correctement divers scénarios.
Gérer les exceptions avec grâce est également essentiel. En utilisant des blocs try-except, vous pouvez attraper les erreurs et fournir des messages utiles à l’utilisateur. Cela rend votre application plus stable et conviviale.
Envisagez également d’inclure un drapeau de débogage dans votre script. Ce drapeau peut activer des sorties supplémentaires qui vous permettent de suivre l’exécution du programme lorsque quelque chose se passe mal. Avoir cette option facilite le diagnostic des problèmes tout au long du développement et de la maintenance.
Comparer argparse avec d’autres bibliothèques d’analyse d’arguments
Bien que argparse soit un utilitaire précieux dans la bibliothèque standard de Python, il existe d’autres bibliothèques qui offrent des méthodes alternatives pour analyser les arguments de ligne de commande. Comprendre ces options vous aidera à sélectionner le bon outil pour votre projet.
Une telle bibliothèque est Click. Click est un package tiers pour créer des interfaces en ligne de commande avec des décorateurs. Il a une syntaxe plus intuitive et est idéal pour les applications sophistiquées. Par exemple, vous pouvez utiliser des décorateurs Python pour créer des commandes et des options, rendant votre code plus compact et compréhensible.
Docopt est une autre option qui vous permet de définir votre interface en ligne de commande en utilisant la docstring du programme. Docopt analyse automatiquement le message d’aide et construit l’analyseur d’arguments lorsque les instructions d’utilisation sont incluses dans la docstring. Cette approche est élégante et convient aux scripts simples nécessitant une spécification plus lisible par l’homme.
En choisissant quelle bibliothèque utiliser, pensez aux exigences de votre projet. Si vous souhaitez éliminer les dépendances externes et souhaitez un outil capable de gérer la plupart des situations, argparse est une excellente solution. Si vous recherchez une syntaxe plus intuitive et travaillez sur une application complexe, Click pourrait être mieux adapté. Docopt est un bon choix pour les petits programmes avec des interfaces simples.
Conclusion
Tout au long de cet article, nous avons examiné comment utiliser le module Python argparse pour développer des programmes en ligne de commande en Python. En travaillant à travers des exemples du monde réel, nous avons appris à créer des scripts réalistes qui reçoivent des entrées utilisateur et accomplissent des tâches pertinentes.