Python - Arguments de Ligne de Commande

Bonjour, aspirants programmeurs !aujourd'hui, nous allons entamer un voyage passionnant dans le monde des arguments de ligne de commande en Python. Ne vous inquiétez pas si vous êtes nouveau dans la programmation ; je vais vous guider à travers chaque étape avec la diligence et la patience d'un enseignant chevronné. Plongeons-y !

Qu'est-ce qu'un Argument de Ligne de Commande ?

Imaginez que vous êtes un chef, et au lieu de toujours cuisiner le même plat, vous voulez être capable de changer les ingrédients en fonction de ce que vos clients demandent. En programmation, les arguments de ligne de commande sont comme ces demandes spéciales de clients. Ils nous permettent de donner à nos programmes Python des entrées différentes lors de leur exécution, rendant notre code plus flexible et puissant.

Arguments de Ligne de Commande en Python

En Python, nous pouvons facilement accéder aux arguments de ligne de commande en utilisant le module sys. Commençons par un exemple simple :

import sys

print("Bonjour, je suis votre premier programme Python !")
print("Nombre d'arguments :", len(sys.argv))
print("Arguments :", str(sys.argv))

Enregistrez ceci sous hello_args.py et exécutez-le à partir de la ligne de commande comme ceci :

python hello_args.py arg1 arg2 arg3

Vous verrez une sortie similaire à :

Bonjour, je suis votre premier programme Python !
Nombre d'arguments : 4
Arguments : ['hello_args.py', 'arg1', 'arg2', 'arg3']

Analysons cela :

• sys.argv est une liste contenant les arguments de ligne de commande.
• Le premier élément (sys.argv[0]) est toujours le nom du script lui-même.
• Le reste des éléments sont les arguments que nous avons passés.

Accès aux Arguments Spécifiques

Maintenant, créons un programme qui utilise ces arguments :

import sys

if len(sys.argv) < 2:
print("Veuillez fournir votre nom en tant qu'argument !")
else:
name = sys.argv[1]
print(f"Bonjour, {name} ! Bienvenue dans le monde des arguments de ligne de commande !")

Enregistrez ceci sous greet.py et exécutez-le :

python greet.py Alice

Sortie :

Bonjour, Alice ! Bienvenue dans le monde des arguments de ligne de commande !

Si vous l'exécutez sans argument :

python greet.py

Sortie :

Veuillez fournir votre nom en tant qu'argument !

Cet exemple montre comment nous pouvons rendre nos programmes interactifs et conviviaux !

Passage d'Arguments au Moment de l'Exécution

Créons un exemple plus pratique. Nous allons faire une simple calculatrice :

import sys

def calculator(operation, num1, num2):
if operation == 'add':
return num1 + num2
elif operation == 'subtract':
return num1 - num2
elif operation == 'multiply':
return num1 * num2
elif operation == 'divide':
return num1 / num2 if num2 != 0 else "Erreur : Division par zéro"
else:
return "Opération invalide"

if len(sys.argv) != 4:
print("Utilisation : python calculator.py <operation> <num1> <num2>")
else:
operation = sys.argv[1]
try:
num1 = float(sys.argv[2])
num2 = float(sys.argv[3])
result = calculator(operation, num1, num2)
print(f"Résultat : {result}")
except ValueError:
print("Erreur : Veuillez fournir des nombres valides")

Enregistrez ceci sous calculator.py et utilisez-le comme ceci :

python calculator.py add 5 3

Sortie :

Résultat : 8.0

Ce exemple de calculatrice montre comment nous pouvons créer des outils puissants qui prennent différentes entrées et effectuent diverses opérations.

Module getopt de Python

Pour des interfaces de ligne de commande plus complexes, Python fournit le module getopt. C'est comme avoir un assistant habile pour aider à trier toutes les différentes options et arguments que vos utilisateurs pourraient fournir.

Voici un exemple :

import sys
import getopt

def main(argv):
inputfile = ''
outputfile = ''
try:
opts, args = getopt.getopt(argv,"hi:o:",["ifile=","ofile="])
except getopt.GetoptError:
print('test.py -i <inputfile> -o <outputfile>')
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
print('test.py -i <inputfile> -o <outputfile>')
sys.exit()
elif opt in ("-i", "--ifile"):
inputfile = arg
elif opt in ("-o", "--ofile"):
outputfile = arg
print('Fichier d\'entrée est :", inputfile)
print('Fichier de sortie est :", outputfile)

if __name__ == "__main__":
main(sys.argv[1:])

Enregistrez ceci sous file_processor.py et exécutez-le :

python file_processor.py -i input.txt -o output.txt

Sortie :

Fichier d'entrée est : input.txt
Fichier de sortie est : output.txt

Le module getopt nous aide à gérer à la fois les options courtes (-i, -o) et les options longues (--ifile, --ofile), rendant notre programme plus convivial.

Module argparse de Python

Pour des interfaces de ligne de commande encore plus sophistiquées, Python offre le module argparse. C'est comme avoir un restaurant à service complet pour vos besoins de ligne de commande !

Voici un exemple :

import argparse

parser = argparse.ArgumentParser(description='Traiter quelques entiers.')
parser.add_argument('integers', metavar='N', type=int, nargs='+',
help='un entier pour l\'accumulateur')
parser.add_argument('--sum', dest='accumulate', action='store_const',
const=sum, default=max,
help='additionner les entiers (par défaut : trouver le max)')

args = parser.parse_args()
print(args.accumulate(args.integers))

Enregistrez ceci sous integer_processor.py et utilisez-le comme ceci :

python integer_processor.py 1 2 3 4

Sortie :

4

Ou avec l'option --sum :

python integer_processor.py 1 2 3 4 --sum

Sortie :

10

Le module argparse génère automatiquement des messages d'aide, gère les erreurs et permet des structures d'arguments plus complexes.

Comparaison des Méthodes

Voici une comparaison rapide des méthodes que nous avons discutées :

Méthode	Complexité	Cas d'Utilisation
sys.argv	Simple	Gestion basique des arguments
getopt	Modéré	Options courtes et longues
argparse	Avancé	CLIs complexes avec aide automatique

N'oubliez pas, la meilleure méthode dépend de vos besoins spécifiques. Commencez simplement avec sys.argv, et à mesure que vos programmes deviennent plus complexes, envisagez de passer à getopt ou argparse.

En conclusion, les arguments de ligne de commande sont un outil puissant dans votre boîte à outils Python. Ils vous permettent de créer des programmes flexibles et interactifs qui peuvent s'adapter à différentes entrées et besoins des utilisateurs. Au fil de votre parcours en Python, vous trouverez innombrables façons d'utiliser ces techniques pour construire des logiciels incroyables. Bon codage, et que vos aventures en ligne de commande soient toujours passionnantes !

Credits: Image by storyset