Comment analyser les arguments sur la ligne de commande en Python

Les arguments en ligne de commande sont utilisés pour transmettre des données dans le programme au moment de l'exécution du programme. Cette fonctionnalité est disponible sur la plupart des langages de programmation populaires. Mais le traitement des arguments en ligne de commande est différent pour différentes langues. Les valeurs des arguments sont données avec le nom du programme au moment de l'exécution du programme. Python Language prend en charge cette fonctionnalité. Comment les arguments en ligne de commande sont analysés dans le script Python est montré dans cet article.

Argument de la ligne de commande d'analyse en utilisant système module

Les arguments en ligne de commande sont stockés dans une liste en utilisant système module. système.argv est utilisé pour lire les valeurs des arguments en ligne de commande. Le nombre total d'arguments en ligne de commande peut être compté en utilisant Len () fonction. L'utilisation de ce module est décrite dans la partie de l'article.

Exemple 1: Lire le nombre d'arguments et de valeurs d'argument

Créer un fichier avec le script Python suivant. Ici, les valeurs d'argument de ligne de commande sont stockées dans la variable, argv Comme les autres langues. Len () La méthode compte le nombre total d'arguments passés au moment de l'exécution du script. Les valeurs d'argument sont imprimées comme un tableau à la fin du script.

# Importer le module sys
importer sys
# Imprimer le nombre total d'arguments
Print ('Total Arguments:', Len (Sys.argv))
imprimer ('Les valeurs de l'argument sont:', str (sys.argv))

Sortir:

Le script ci-dessus est exécuté ici en utilisant quatre arguments en ligne de commande. Le premier argument est le nom du script et d'autres sont des valeurs numériques. La sortie suivante apparaîtra après l'exécution du script.

Exemple 2: Valeurs d'argument de lecture en utilisant la boucle

Dans l'exemple précédent, les valeurs d'argument sont imprimées comme un tableau. Créez un fichier avec le script suivant pour imprimer le type de variable d'argument et imprimer chaque valeur d'argument dans chaque ligne en utilisant pour Loop.

# Importer le module sys
importer sys
# Imprimez le type de la variable, sys.argv
Imprimer (Type (sys.argv))
# Imprimez chaque argument de ligne de commande dans chaque ligne
Print ('Les arguments de la ligne de commande sont:')
pour je dans sys.Argv:
Imprimer (i)

Sortir:

Le script ci-dessus est exécuté en fournissant trois arguments avec le nom du script. La sortie suivante apparaîtra après l'exécution du script.

Argument de la ligne de commande d'analyse utilisant le module getOPT

Getopt Le module est utilisé pour analyser les arguments en ligne de commande avec les options. getOPT () La méthode de ce module est utilisée pour lire les arguments. Cette méthode a trois arguments. Les deux premiers arguments sont obligatoires et le dernier argument est facultatif. Les utilisations de ces arguments sont données ci-dessous.

Args: Il contient l'argument tiré de l'argument en ligne de commande.

short_option: Ce peut être n'importe quelle lettre qui passe avec l'argument.

long_option: Il est utilisé pour définir de longues options avec deux parties. Ce sont le nom d'option et la valeur de l'option.

Syntaxe: getopt.getOPT (args, short_option, [long_option])

Exemple 3: Valeurs d'arguments de lecture à l'aide de courtes options de getOPT

getopt Le module contient plus de fonctionnalités que système module. L'exemple suivant montre comment des options courtes peuvent être utilisées dans getOPT () méthode. argv La variable stockera les arguments en ligne de commande en omettant le nom du script. Ensuite, deux options sont définies dans le getOPT () Méthode qui peut être utilisée avec l'argument au moment de l'exécution. Si une erreur se produit, un message d'erreur s'affichera.

# Importer le module GetOPT
importer getopt
# Importer le module sys
importer sys
# Store Argument Variable Omet le nom du script
argv = sys.Argv [1:]
essayer:
# Définir les options courtes de GetOpt
Options, args = getopt.getopt (argv, 'x: y:')
# Imprimez les options et l'argument
Imprimer (options)
imprimer (args)
sauf getopt.GetOpterror:
# Imprimez le message d'erreur si la mauvaise option est fournie
imprimer («la mauvaise option est fournie»)
# Terminer le script
système.sortie (2)

Sortir:

Exécutez le script sans aucun argument, arguments avec des options et des arguments corrects avec la mauvaise option.

Exemple 4: Valeurs d'arguments de lecture à l'aide d'options de GetOPT courtes et longues

Cet exemple montre comment les options courtes et longues peuvent être utilisées avec les valeurs d'argument. Il ajoutera deux nombres lorsque '-un' ou '-ajouter' sera utilisé comme une option et soustrayra deux nombres lorsque '-s ' ou '-sous' sera utilisé comme une option au moment de l'exécution.

# Importer le module GetOPT
importer getopt
# Importer le module sys
importer sys
# Store Argument Variable Omet le nom du script
argv = sys.Argv [1:]
# Initialiser la variable de résultat
résultat = 0
essayer:
# Définir les options courtes et longues GetOPt
Options, args = getopt.getopt (sys.argv [1:], 'a: s', ['add =', 'sub ='])
# Lisez chaque option en utilisant pour Loop
pour Opt, Arg dans les options:
# Calculez la somme si l'option est -a ou --add
Si opt dans ('-a', '--add'):
result = int (argv [1]) + int (argv [2])
# Calculez la soleil si l'option est -s ou -
elif opt dans ('-s', '--sub'):
result = int (argv [1]) - int (argv [2])
print ('result =', résultat)
sauf getopt.GetOpterror:
# Imprimez le message d'erreur si la mauvaise option est fournie
imprimer («la mauvaise option est fournie»)
# Terminer le script
système.sortie (2)

Sortir:

Exécutez le script sans arguments et options, arguments avec l'option «-a», arguments avec l'option «-s» et les arguments avec la mauvaise option.

Argument de la ligne de commande d'analyse utilisant le module ArgParse

Le module Argparse contient de nombreuses options pour lire les arguments en ligne de commande. Valeurs d'argument par défaut, l'argument avec le type de données, les arguments de position, le message d'aide, etc. peut être fourni par ce module.

Exemple 5: Lire des arguments en ligne de commandement à l'aide d'Argparse

L'exemple suivant montre l'utilisation de argparse module pour lire l'argument de la ligne de commande. Ici, deux options sont définies pour lire les arguments en ligne de commande. Ceux-ci sont '-n' ou '-name' et '-e' ou '-email'. Si l'utilisateur fournit un mauvais argument, il affichera une erreur avec un message d'utilisation. Si l'utilisateur fournit des options correctes avec les arguments, il affichera les valeurs d'argument. Si l'utilisateur exécute le script avec l'option «-Help», il fournira le message nécessaire pour exécuter le script.

# Importer le module Argparse
Importer Argparse
# Importer le module sys
importer sys
# Déclarer la fonction pour définir les arguments en ligne de commande
def readoptions (args = sys.Argv [1:]):
Parser = Argparse.ArgumentPaSer (Description = "Les commandes d'analyse.")
analyseur.add_argument ("- n", "--name", help = "Tapez votre nom.")
analyseur.add_argument ("- e", "--email", help = "Tapez votre e-mail.")
opts = analyseur.parse_args (args)
Return Opts
# Appelez la fonction pour lire les valeurs de l'argument
Options = ReadOptions (sys.Argv [1:])
imprimer (options.nom)
imprimer (options.e-mail)

Sortir:

Exécutez le script avec une mauvaise option, l'option correcte et l'option d'aide.

Conclusion:

Diverses façons de lire des arguments en ligne de commande sont expliquées dans ce tutoriel en utilisant trois modules Python. J'espère que ce tutoriel aidera le codeur qui veut lire des données à l'aide d'arguments en ligne de commande dans Python.

Regardez la vidéo de l'auteur: ici