Comment analyser les arguments de la ligne de commande en Python

Vous souhaitez exécuter des scripts Python avec des arguments de ligne de commande ? Apprenez à analyser les arguments de la ligne de commande à l'aide des modules sys, getopt et argparse de Python.

En Python, lorsque vous souhaitez lire les données de l'utilisateur, vous utilisez la fonction input(). Cependant, pour certaines applications, vous pouvez vouloir passer certains arguments lors de l'exécution du script sur la ligne de commande.

Dans ce tutoriel, nous allons apprendre à exécuter un script Python avec des options et des arguments en ligne de commande. Nous apprendrons ensuite à utiliser les modules intégrés de Python pour analyser ces options et arguments.

Commençons !

Comprendre sys.argv en Python

Si vous avez programmé en C, vous savez que l'une des façons les plus simples de transmettre des arguments au programme est de le faire via la ligne de commande. Pour ce faire, vous pouvez structurer la fonction principale comme suit :

#include<stdio.h>

int main(int argc, char **argv){
 //argc : nombre d'arguments
 //argv : vecteur d'arguments
    
 //fait quelque chose sur les arguments

 return 0 ;
}

Ici, argc représente le nombre d'arguments et argv représente le vecteur d'arguments.

Exécution de scripts Python avec des arguments de ligne de commande

En Python, vous pouvez exécuter le script Python à la ligne de commande en utilisant python3 filename.py. Ce faisant, vous pouvez également passer un nombre arbitraire d'arguments de ligne de commande :

$ python3 filename.py arg1 arg2 ... argn

Le module sys fournit un support prêt à l'emploi pour accéder à ces arguments de ligne de commande et les traiter. sys.argv est la liste de tous les arguments de ligne de commande que nous passons lorsque nous exécutons le script Python.

Voici un exemple dans lequel nous exécutons main.py avec des arguments de ligne de commande :

$ python3 main.py hello world python script

Nous pouvons parcourir le vecteur d'arguments à l'aide d'une simple boucle pour et d'une fonction d'énumération:

# main.py

import sys

for idx, arg in enumerate(sys.argv) :
 print(f "arg{idx} : {arg}")

# Sortie
arg0:main.py
arg1:hello
arg2:world
arg3:python
arg4:script

Nous voyons que le premier argument (à l'index 0) est le nom du fichier Python. Les arguments suivants commencent à l'index 1.

Il s'agit d'un programme de travail minimal qui accepte et traite les arguments de la ligne de commande. Cependant, nous constatons certains problèmes :

• Comment les utilisateurs du programme savent-ils quels arguments transmettre ?
• Et que signifient ces arguments ?

Ce n'est pas très clair. Pour y remédier, vous pouvez utiliser les modules getopt ou argparse. C'est ce que nous allons apprendre dans les sections suivantes

Analyse des arguments en ligne de commande à l'aide de getopt de Python

Nous allons apprendre à analyser les arguments de la ligne de commande à l'aide du module intégré getopt.

Après avoir importé getopt du module getoptVous pouvez spécifier les arguments à analyser ainsi que les options courtes et les options longues avec lesquelles exécuter le script. Nous devons analyser tous les arguments à partir de l'index 1 du fichier sys.argv. La tranche à analyser est donc sys.argv[1 :].

Ici, nous aurons besoin d'une chaîne de message et d'un nom de fichier. Utilisations m et f comme options courtes et message et file comme options longues.

Mais comment s'assurer qu'une option spécifique nécessite un argument ?

• Dans les options courtes, vous pouvez faire en sorte qu'une option nécessite un argument en ajoutant deux points ( 🙂 après le nom de l'option courte.
• De même, dans les options longues, vous pouvez ajouter le signe = après le nom de l'option longue. Nous pouvons capturer ces options et leurs arguments respectifs.

En ajoutant ces éléments, nous aurons le code suivant dans main.py :

# main.py

import sys
from getopt import getopt

opts, args = getopt(sys.argv[1 :],'m:f:',['message=','file='])

print(opts)
print(args)

Ici, la variable opts contient les options et les arguments sous la forme d'une liste de tuples. Tout autre argument positionnel que nous passons sera collecté dans la variable args.

Nous pouvons passer le message et le nom de fichier pour exécuter le script, et nous pouvons utiliser les options courtes ou les options longues.

Si vous exécutez main.py en utilisant les options longues, vous obtiendrez le résultat suivant :

$ python3 main.py --message hello --file somefile.txt

Nous avons les options et les arguments sous forme de tuples dans la variable opts. Comme nous n'avons passé aucun argument de position, args est une liste vide.

# Sortie
[('--message', 'hello'), ('--file', 'somefile.txt')]
[]

De manière équivalente, nous pouvons également utiliser les options courtes comme indiqué :

$ python3 main.py -m hello -f somefile.txt

# Sortie
[('-m', 'hello'), ('-f', 'somefile.txt')]
[]

⚠️ L'option courte -m de cet exemple ne doit pas être confondue avec l'indicateur de ligne de commande -m qui est utilisé pour exécuter un module en tant que module principal lors de l'exécution d'un script Python.

Par exemple, vous utilisez python3 -m unittest main.py pour exécuter unittest en tant que module principal lors de l'exécution de main.py.

Nous avons mentionné que tous les autres arguments positionnels que nous passons seront collectés dans la variable args. Voici un exemple :

$ python3 main.py -m hello -f somefile.txt another_argument

La liste args contient l'argument positionnel another_argument.

# Sortie
[('-m', 'hello'), ('-f', 'somefile.txt')]
['another_argument']

Ici, opts est une liste de tuples. Nous pouvons donc la parcourir en boucle, décompresser le n-uplet et en extraire les arguments correspondant aux options spécifiques.

Mais que faisons-nous du nom de fichier et du message après avoir traité ces arguments ? Nous allons ouvrir le fichier en mode écriture et écrire la chaîne de message convertie en majuscules dans le fichier.

# main.py
import sys
from getopt import getopt

opts, args = getopt(sys.argv[1 :],'m:f:',['message=','file='])

print(opts)
print(args)

for option, argument in opts :
 if option == '-m' :
 message = argument
 if option == '-f' :
 file = argument

with open(file,'w') as f :
 f.write(message.upper())

Exécutons main.py avec les options courtes et les arguments de la ligne de commande.

$ python main.py -m hello -f thisfile.txt
[('-m', 'hello'), ('-f', 'thisfile.txt')]
[]

Après avoir exécuté main.py, nous pouvons voir 'thisfile.txt' dans notre répertoire de travail. Il contient la chaîne 'hello' convertie en majuscules ('HELLO').

$ ls
main.py thisfile.txt

$ cat thisfile.txt
HELLO

Comment analyser les arguments de la ligne de commande avec Argparse

Le module argparse, également intégré à la bibliothèque standard de Python, fournit des fonctionnalités permettant d'analyser les arguments de la ligne de commande et de construire des interfaces de ligne de commande.

Pour analyser les arguments de la ligne de commande, importons la classe ArgumentParser du module argparse. Ici, nous avons instancié arg_parser, un objet ArgumentParser:

from argparse import ArgumentParser

arg_parser = ArgumentParser()

Ensuite, nous aimerions ajouter deux arguments de ligne de commande :

• message: la chaîne du message, et
• file: le nom du fichier avec lequel nous voulons travailler.

Nous appelons maintenant la méthode add_argument() sur arg_parser pour ajouter ces deux arguments. Dans l'appel de la méthode add_argument(), vous pouvez définir l'aide comme une chaîne de caractères (une description de l'argument).

arg_parser.add_argument('message',help='message string')
arg_parser.add_argument('file',help='filename')

Jusqu'à présent, nous avons instancié arg_parser et ajouté les arguments de la ligne de commande. Lorsque le programme est exécuté en ligne de commande, vous pouvez utiliser la méthode parse_args() de arg_parser pour obtenir les valeurs des arguments.

Ici, nous capturons l'espace de noms des arguments dans la variable args. Vous pouvez donc utiliser args.argument_name pour obtenir les valeurs des arguments.

Après avoir obtenu les valeurs des arguments, nous écrivons la chaîne de message avec la permutation des majuscules et des minuscules (à l'aide de la méthode swapcase() string) dans le fichier.

args = arg_parser.parse_args()

message = args.message
file = args.file

with open(file,'w') as f :
 f.write(message.swapcase())

En mettant tout cela ensemble, voici notre fichier main.py :

# main.py

from argparse import ArgumentParser

arg_parser = ArgumentParser()
arg_parser.add_argument('message',help='message string')
arg_parser.add_argument('file',help='filename')

args = arg_parser.parse_args()
print(args)

message = args.message
file = args.file

with open(file,'w') as f :
 f.write(message.swapcase())

Comprendre l'utilisation des arguments de la ligne de commande

Pour comprendre l'utilisation des arguments lors de l'exécution de main.py, vous pouvez utiliser l'option --help long comme indiqué :

$ python3 main.py --help
utilisation : main.py [-h] message file

positional arguments :
 message message string
 file filename

optional arguments :
 -h, --help afficher ce message d'aide et quitter

Il n' y a pas d'arguments optionnels et message et fichier sont des arguments de position obligatoires. Vous pouvez également utiliser l'option courte -h :

$ python3 main.py -h
utilisation : main.py [-h] message file

arguments positionnels :
 message message string
 file filename

arguments optionnels :
 -h, --help afficher ce message d'aide et quitter

Comme vous l'avez vu, les deux arguments sont des arguments de position par défaut. Donc si vous ne passez pas un ou plusieurs de ces arguments, vous rencontrerez des erreurs.

Ici, nous avons passé un argument de position (Hello) pour la chaîne de message, mais nous n'avons pas fourni de valeur pour l'argument file.

Nous obtenons donc une erreur indiquant que l'argument file est requis.

$ python3 main.py Hello
utilisation : main.py [-h] message file
main.py : error : the following arguments are required : file

Lorsque nous exécutons main.py avec les deux arguments positionnels, nous constatons que l'espace de noms args contient les valeurs des arguments.

python3 main.py Hello file1.txt

# Sortie
Namespace(file='file1.txt', message='Hello')

Si nous examinons le contenu du répertoire de travail actuel, nous constatons que le script crée le fichier 'file1.txt' :

$ ls
file1.txt main.py

La chaîne de message originale est 'Hello' ; après avoir échangé la casse, la chaîne de message dans le fichier 'file1.txt' est 'hELLO'.

$ cat file1.txt
hELLO

Comment rendre les arguments de la ligne de commande facultatifs ?

Pour rendre ces arguments de ligne de commande optionnels, vous pouvez préfixer le nom de l'argument par --.

Modifions main.py pour rendre les arguments message et fichier optionnels.

# main.py

from argparse import ArgumentParser

arg_parser = ArgumentParser()
arg_parser.add_argument('--message',help='message string')
arg_parser.add_argument('--file',help='filename')

Comme les arguments de la ligne de commande sont tous deux optionnels, nous pouvons définir des valeurs par défaut pour ces arguments.

if args.message and args.file :
 message = args.message
 file = args.file
else :
 message = 'Python3'
 file = 'monfichier.txt'

A ce stade, le fichier main.py contient le code suivant :

# main.py

from argparse import ArgumentParser

arg_parser = ArgumentParser()
arg_parser.add_argument('--message',help='message string')
arg_parser.add_argument('--file',help='filename')

args = arg_parser.parse_args()
print(args)

if args.message and args.file :
 message = args.message
 file = args.file
else :
 message = 'Python3'
 file = 'myfile.txt'

with open(file,'w') as f :
 f.write(message.swapcase())

Si nous vérifions l'utilisation, nous voyons que message et file sont des arguments optionnels. Cela signifie que vous pouvez maintenant exécuter main.py sans ces deux arguments.

$ python3 main.py --help
utilisation : main.py [-h] [--message MESSAGE] [--file FILE]

arguments optionnels :
 -h, --help afficher ce message d'aide et quitter
 --message MESSAGE chaîne de message
 --file FILE nom de fichier

$ python3 main.py

Dans l'argument namespace, file et message sont tous deux None.

# Sortie
Namespace(file=None, message=None)

Nous constatons que le nom de fichier et le message par défaut 'monfichier.txt' et 'Python3' sont utilisés. Le fichier 'monfichier.txt' se trouve maintenant dans le répertoire de travail :

$ ls
file1.txt main.py myfile.txt

Il contient la chaîne de caractères 'Python3' avec la casse des lettres intervertie :

$ cat myfile.txt
pYTHON3

Vous pouvez également utiliser les arguments --message et --file pour rendre la commande plus lisible.

$ python3 main.py --message Codage --file file2.txt

# Sortie
Namespace(file='file2.txt', message='Coding')

Nous voyons le fichier 'file2.txt' dans le répertoire de travail :

$ ls
file1.txt file2.txt main.py myfile.txt

Et il contient la chaîne 'cODING' comme prévu.

$ cat file2.txt
cODING

Conclusion

Voici un résumé de ce que nous avons appris dans ce tutoriel :

• Comme dans le langage de programmation C, en Python, vous pouvez accéder aux arguments de la ligne de commande en parcourant en boucle le vecteur d'arguments sys.argv. sys.argv[0] est le nom du script Python. Nous sommes donc intéressés par l'analyse des arguments sys.argv[1 :].
• Cependant, pour améliorer la lisibilité et pouvoir ajouter des options, vous pouvez utiliser les modules getopt et argparse.
• Vous pouvez utiliser le module getopt pour analyser la liste des arguments de la ligne de commande en commençant par l'index 1 jusqu'à la fin de la liste. Vous pouvez spécifier des options courtes et des options longues.
• Lorsqu'une option prend un argument, vous pouvez spécifier deux points ( 🙂 et = après l'option courte et l'option longue, respectivement.
• Avec le module argparse de Python, vous pouvez instancier un objet ArgumentParser et utiliser la méthode add_argument() pour ajouter un argument positionnel requis. Utilisez -- devant le nom de l'argument pour le rendre facultatif.
• Pour récupérer les valeurs des arguments de la ligne de commande, appelez la méthode parse_args() de l'objet ArgumentParser.

Découvrez ensuite comment effectuer un hachage sécurisé en Python.