- À propos de sys.argv
- Afficher les arguments avec sys.argv
- Accéder aux arguments individuellement
- Connaître le nombre d'arguments
- Parcourir les arguments de la ligne de commande
- Convertir les arguments en nombres
- Utiliser plusieurs arguments dans un programme
- Gérer les arguments manquants et les erreurs
- Créer un petit programme avec sys.argv
- À retenir
1. À propos de sys.argv
Le module sys de Python fournit différentes fonctions et variables permettant d'interagir avec l'environnement d'exécution de l'interpréteur. Parmi elles, sys.argv permet de récupérer les arguments transmis à un programme Python depuis la ligne de commande.
sys.argv est une liste Python. Son premier élément, sys.argv[0], correspond généralement au nom ou au chemin du script exécuté. Les éléments suivants correspondent aux arguments fournis par l'utilisateur.
Le programme suivant affiche simplement le contenu de sys.argv. Supposons que ce programme soit enregistré dans un fichier nommé programme.py.
1 2 3 | import sys print(sys.argv) |
Si nous exécutons le programme avec la commande suivante :
1 | python programme.py Python 25 |
Sortie :
1 | ['programme.py', 'Python', '25'] |
Nous constatons que programme.py occupe l'indice 0, tandis que Python et 25 correspondent aux arguments fournis dans la ligne de commande.
2. Afficher les arguments avec sys.argv
La variable sys.argv peut être affichée comme n'importe quelle autre liste Python. Chaque argument fourni dans la ligne de commande devient un élément de cette liste.
Le programme suivant affiche tous les arguments reçus par le script.
1 2 3 | import sys print("Arguments :", sys.argv) |
Exécutons le programme avec :
1 | python programme.py Python Java HTML |
Sortie :
1 | Arguments : ['programme.py', 'Python', 'Java', 'HTML'] |
Les arguments sont séparés par des espaces dans la commande. Lorsqu'un argument doit contenir des espaces, il faut généralement le placer entre guillemets dans le terminal.
Le programme précédent peut par exemple être exécuté avec la commande suivante :
1 | python programme.py "Python pour débutants" |
Sortie :
1 | Arguments : ['programme.py', 'Python pour débutants'] |
3. Accéder aux arguments individuellement
Comme sys.argv est une liste, nous pouvons accéder à chaque argument à l'aide de son indice. L'élément sys.argv[0] représente le script, sys.argv[1] le premier argument utilisateur, sys.argv[2] le deuxième, et ainsi de suite.
Le programme suivant récupère deux arguments individuellement.
1 2 3 4 5 | import sys print("Script :", sys.argv[0]) print("Premier argument :", sys.argv[1]) print("Deuxième argument :", sys.argv[2]) |
Exécutons le programme avec :
1 | python programme.py Python Django |
Sortie :
1 2 3 | Script : programme.py Premier argument : Python Deuxième argument : Django |
Nous pouvons également récupérer uniquement les arguments fournis par l'utilisateur grâce au slicing sys.argv[1:].
1 2 3 4 | import sys arguments = sys.argv[1:] print(arguments) |
Exécutons le programme avec :
1 | python programme.py Python Django Flask |
Sortie :
1 | ['Python', 'Django', 'Flask'] |
4. Connaître le nombre d'arguments
La fonction len() permet de connaître le nombre d'éléments contenus dans sys.argv. Il faut cependant tenir compte du fait que le premier élément correspond au script lui-même.
Le programme suivant affiche le nombre total d'éléments de sys.argv ainsi que le nombre d'arguments réellement fournis par l'utilisateur.
1 2 3 4 | import sys print("Nombre total :", len(sys.argv)) print("Nombre d'arguments :", len(sys.argv) - 1) |
Exécutons le programme avec :
1 | python programme.py Python Java PHP |
Sortie :
1 2 | Nombre total : 4 Nombre d'arguments : 3 |
Une autre solution consiste à utiliser sys.argv[1:] afin d'exclure directement le nom du script.
1 2 3 4 | import sys arguments = sys.argv[1:] print("Nombre d'arguments :", len(arguments)) |
Exécutons le programme avec :
1 | python programme.py Python Java PHP |
Sortie :
1 | Nombre d'arguments : 3 |
5. Parcourir les arguments de la ligne de commande
Comme sys.argv est une liste, nous pouvons la parcourir avec une boucle for. Pour afficher uniquement les arguments saisis par l'utilisateur, nous pouvons parcourir sys.argv[1:].
Le programme suivant affiche chaque argument sur une ligne différente.
1 2 3 4 | import sys for argument in sys.argv[1:]: print(argument) |
Exécutons le programme avec :
1 | python programme.py Python Java Django |
Sortie :
1 2 3 | Python Java Django |
La fonction enumerate() permet également de numéroter les arguments pendant leur parcours.
1 2 3 4 | import sys for numero, argument in enumerate(sys.argv[1:], start=1): print(numero, ":", argument) |
Exécutons le programme avec :
1 | python programme.py Python Java Django |
Sortie :
1 2 3 | 1 : Python 2 : Java 3 : Django |
6. Convertir les arguments en nombres
Les éléments récupérés avec sys.argv sont des chaînes de caractères. Lorsqu'un argument représente un nombre destiné à un calcul, il faut donc le convertir avec int() ou float().
Le programme suivant récupère deux nombres entiers depuis la ligne de commande et calcule leur somme.
1 2 3 4 5 6 | import sys a = int(sys.argv[1]) b = int(sys.argv[2]) print("Somme :", a + b) |
Exécutons le programme avec :
1 | python programme.py 15 27 |
Sortie :
1 | Somme : 42 |
Pour travailler avec des nombres décimaux, nous pouvons utiliser float().
1 2 3 4 5 6 7 | import sys prix = float(sys.argv[1]) quantite = int(sys.argv[2]) total = prix * quantite print("Total :", total) |
Exécutons le programme avec :
1 | python programme.py 12.5 4 |
Sortie :
1 | Total : 50.0 |
7. Utiliser plusieurs arguments dans un programme
Les arguments de la ligne de commande permettent de rendre un programme plus flexible. L'utilisateur peut fournir les données nécessaires au moment de l'exécution sans modifier le code source.
Le programme suivant reçoit un nom et un âge depuis la ligne de commande.
1 2 3 4 5 6 7 | import sys nom = sys.argv[1] age = int(sys.argv[2]) print("Nom :", nom) print("Âge :", age, "ans") |
Exécutons le programme avec :
1 | python programme.py Younes 30 |
Sortie :
1 2 | Nom : Younes Âge : 30 ans |
Nous pouvons également récupérer un nombre variable d'arguments. Le programme suivant calcule la somme de tous les nombres fournis après le nom du script.
1 2 3 4 5 6 7 8 | import sys somme = 0 for valeur in sys.argv[1:]: somme = somme + int(valeur) print("Somme :", somme) |
Exécutons le programme avec :
1 | python programme.py 10 20 30 40 |
Sortie :
1 | Somme : 100 |
8. Gérer les arguments manquants et les erreurs
Accéder directement à sys.argv[1] ou sys.argv[2] peut provoquer une exception IndexError lorsque l'utilisateur ne fournit pas suffisamment d'arguments. Il est donc préférable de vérifier leur nombre avant de les utiliser.
Le programme suivant exige exactement deux arguments utilisateur.
1 2 3 4 5 6 7 8 | import sys if len(sys.argv) != 3: print("Utilisation : python programme.py nombre1 nombre2") else: a = int(sys.argv[1]) b = int(sys.argv[2]) print("Somme :", a + b) |
Si nous exécutons le programme sans argument :
1 | python programme.py |
Sortie :
1 | Utilisation : python programme.py nombre1 nombre2 |
Une autre erreur fréquente apparaît lorsque l'utilisateur fournit une valeur qui ne peut pas être convertie en nombre. Une structure try...except permet de gérer l'exception ValueError.
1 2 3 4 5 6 7 8 9 10 11 | import sys if len(sys.argv) != 3: print("Utilisation : python programme.py nombre1 nombre2") else: try: a = float(sys.argv[1]) b = float(sys.argv[2]) print("Somme :", a + b) except ValueError: print("Erreur : les arguments doivent être des nombres.") |
Exécutons le programme avec un argument incorrect :
1 | python programme.py 12 Python |
Sortie :
1 | Erreur : les arguments doivent être des nombres. |
9. Créer un petit programme avec sys.argv
Un cas pratique consiste à créer une petite calculatrice en ligne de commande. Le premier argument représente l'opération et les deux arguments suivants représentent les nombres à utiliser.
Le programme suivant accepte les opérations addition, soustraction, multiplication et division.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | import sys if len(sys.argv) != 4: print("Utilisation : python calcul.py operation a b") else: operation = sys.argv[1] try: a = float(sys.argv[2]) b = float(sys.argv[3]) if operation == "addition": print("Résultat :", a + b) elif operation == "soustraction": print("Résultat :", a - b) elif operation == "multiplication": print("Résultat :", a * b) elif operation == "division": if b != 0: print("Résultat :", a / b) else: print("Erreur : division par zéro.") else: print("Opération inconnue.") except ValueError: print("Erreur : a et b doivent être des nombres.") |
Exécutons le programme avec la commande suivante :
1 | python calcul.py multiplication 6 7 |
Sortie :
1 | Résultat : 42.0 |
Ce principe permet de créer des programmes utilisables directement depuis un terminal, un script système ou un autre programme.
10. À retenir
La variable sys.argv du module sys permet de récupérer les arguments transmis à un programme Python depuis la ligne de commande.
- sys.argv est une liste.
- sys.argv[0] correspond généralement au nom ou au chemin du script exécuté.
- sys.argv[1] représente le premier argument utilisateur.
- sys.argv[2] représente le deuxième argument, et ainsi de suite.
- sys.argv[1:] permet de récupérer uniquement les arguments utilisateur.
- len(sys.argv) - 1 donne le nombre d'arguments utilisateur.
- Les arguments récupérés sont des chaînes de caractères.
- int() et float() permettent de convertir les arguments numériques.
- Il est conseillé de vérifier le nombre d'arguments avant d'accéder à leurs indices.
- try...except permet de gérer les erreurs de conversion et de rendre le programme plus robuste.
Le programme suivant rassemble les opérations essentielles : récupération des arguments, vérification de leur nombre, conversion en nombres et utilisation des valeurs.
1 2 3 4 5 6 7 8 9 10 11 12 13 | import sys if len(sys.argv) != 3: print("Utilisation : python programme.py a b") else: try: a = float(sys.argv[1]) b = float(sys.argv[2]) print("Premier nombre :", a) print("Deuxième nombre :", b) print("Somme :", a + b) except ValueError: print("Erreur : veuillez fournir deux nombres.") |
Exécutons le programme avec :
1 | python programme.py 15 25 |
Sortie :
1 2 3 | Premier nombre : 15.0 Deuxième nombre : 25.0 Somme : 40.0 |
Auteur : Younes Derfoufi
Lieu de travail : CRMEF OUJDA
Site Web : www.tresfacile.net
Chaine YouTube : https://www.youtube.com/user/InformatiquesFacile
Me contacter : https://www.tresfacile.net/me-contacter/
