Arguments de ligne de commande Python

Python est une langue de haut niveau conçue pour faire des codes généraux et non pour un problème spécifique. Nous pouvons l'utiliser à des fins générales, comme la création de sites Web à l'aide de Python ou l'analyse des données à l'aide de ce langage Python. La programmation «Python» fournit également les arguments Command_line. Les arguments de ligne de commande sont les arguments que nous avons présentés sur la console ou le terminal de tout système d'exploitation après avoir mentionné le nom du fichier de code avec l'extension de fichier. Nous pouvons également le définir comme, dans n'importe quel programme, la valeur qui est passé par l'invite de commande qui serait des arguments de ligne de commande. Dans ce guide, nous discuterons de l'argument de la ligne de commande dans la programmation «Python».

Méthodes pour les arguments de ligne de commande dans Python

• En utilisant «sys.argv "
• En utilisant le module «argparse»
• En utilisant le module «getopt»

Nous expliquerons toutes les méthodes en détail dans ce guide et montrerons également la démonstration pratique de toutes ces méthodes.

Exemple # 01: par Sys.Méthode Argv

Nous faisons ces codes python dans l'application «Spyder». Nous pouvons accéder aux variables et fonctions de ligne de commande en importation du système. Ainsi, nous importons «sys», puis nous déclarons et initialisons la variable «num» avec le «len (sys.argv) ". «Argv» sera la liste des valeurs de chaîne qui sont les arguments que notre ligne de commande deviendra. «Len» représente la durée des arguments qui sont passés. Ainsi, dans la variable «num», le nombre des valeurs transmises sur le terminal lorsque la ligne de commande est stockée.

Nous affichons également ces numéros d'argument qui sont passés en utilisant «l'impression». En dessous, nous avons mis le «sys.argv [0] ”dans la déclaration d'impression. Le «Argv» détient toujours le nom du programme ou le nom du fichier de code. Ainsi, le nom du fichier que nous avons créé sera rendu sur le terminal. Après cela, nous imprimons ces arguments qui sont transmis sur le terminal. Il imprimera tous les numéros que nous avons passés comme arguments de ligne de commande sur l'écran de la console.

En dessous, nous avons défini une boucle pour la boucle et déclaré une variable «A» là-bas dont la portée est entre «1» à la longueur de l'Argv qui est stockée dans «num». Imprimez tous les arguments sur la console. "Argv [a]" détient tous les arguments de commande_line. Il les affiche également sur la console. Maintenant, nous initialisons la «somme» parce que nous voulons calculer la somme de toutes les valeurs que nous passerons au moment de l'exécution sur le terminal.

Nous utilisons à nouveau la boucle «pour» et passons la gamme. Mais cette fois, nous calculons la somme de toutes ces valeurs que nous avons transmises sur le terminal. Cette somme sera stockée dans la variable «SUM». Ensuite, nous imprimons également la somme de toutes les valeurs que nous passerons au moment de l'exécution sur le terminal.

importer sys
num = len (sys.argv)
Print ("Total Arguments passés ici:", NUM)
print ("\ nname du fichier python:", sys.argv [0])
print ("\ narguments que nous avons passé:", end = "")
pour une plage (1, num):
imprimer (sys.argv [a], end = "")
Sum = 0
pour i à portée (1, num):
Sum + = int (sys.argv [i])
Print ("\ n \ nLe somme des arguments passés:", sum)

Sur le terminal, nous avons d'abord mis le mot clé «Run». Ensuite, placez le nom du fichier avec l'extension appropriée et transmettez les arguments de la ligne de commande ici. Donc, il affiche toutes les lignes comme nous l'avons défini dans le code ci-dessus. Il rend d'abord la longueur des arguments de ligne de commande puis le nom du fichier. Après cela, il rend tous les arguments de ligne de commande et rend également la somme de tous.

Exemple # 02: par la méthode Argparse

Maintenant, nous utilisons la méthode «Argparse» dans cet exemple. Nous importons d'abord le «argparse». Nous allons donc accéder aux variables et à la fonction de ce. Nous initialisons une variable «données» et stockons une ligne que nous utiliserons dans notre code. Après cela, nous initialisons un «analyseur» et dans la «description», nous passons la variable «données» dans laquelle nous avons stocké le message que nous voulons afficher et nous mettons tout cela dans la variable «my_parser». Nous avons également mis la «Parse.args () ”à la fin.

Importer Argparse
data = "Nous utilisons la méthode ArgParse ici"
my_parser = argparse.ArgumentParser (Description = Data)
my_parser.parse_args ()

Regardez le résultat ci-dessous. Lorsque nous passons «-h» comme argument de ligne de commande, il rend d'abord le message que nous avons stocké dans la variable «données» et affiche également «l'argument facultatif» car ce «H» montre le message d'aide. Lorsque nous mettons «-o» comme argument de ligne de commande, cela rend un message d'erreur qu'il s'agit d'un argument non reconnu.

Exemple # 03: par méthode getopt

Voici la dernière méthode que nous utilisons dans ce code. Nous importons «sys» ainsi que «getopt» dans ce code. Ce «getopt» est l'analyseur que nous avons utilisé pour les arguments de la ligne de commande. Ensuite, dans la variable «ArgumentList», nous avons passé le «sys.argv [1:] ”pour supprimer le premier argument que nous passons dans la ligne de commande. Nous initialisons le «my_option» avec le «HMO:».

Après cela, nous initialisons la variable «my_long_option». Nous utilisons le «essayez» ici qui vérifiera l'erreur. Après cela, nous analysons les arguments. Le «Getopt» offre à la fois des options courtes et longues, ainsi que la possibilité de désigner une valeur. Après cela, nous vérifions tous les arguments que nous passerons comme arguments de ligne de commande. Si l'argument de la ligne de commande est «-H» ou «-Help», il imprimera le message qui est donné en dessous. Si l'argument de la ligne de commande est «-m» ou «-my_file», il affichera le message qui est écrit après cela.

De plus, si l'argument de la ligne de commande est «-o» ou «-output», il affiche également le message que nous avons écrit ici après cela. Si l'argument de la ligne de commande n'est pas de tout ce qui précède, il affichera le message d'erreur car nous avons placé le «getOPT. Erreur »dans le code.

importer getopt, sys
ArgumentList = sys.Argv [1:]
my_options = "hmo:"
new_long_options = ["help", "my_file", "output ="
essayer:
arguments, valeurs = getopt.getOPT (ArgumentList, my_options, new_long_options)
pour my_argument, my_value en arguments:
Si my_argument dans ("-h", "- help"):
Imprimer ("Affichage de l'aide")
elif my_argument dans ("-m", "--my_file"):
print ("Affichage de fichier_name:", sys.argv [0])
elif my_argument dans ("-o", "--output"):
Imprimer (("Activation du mode de sortie spécial (% s)")% (my_value))
sauf getopt.Erreur comme err:
print (str (err))

Ici, vous voyez que lorsque nous mettons «-h» comme ligne de commande, il affiche le même message que nous avons écrit dans le code. Lorsque nous mettons deux arguments de ligne de commande comme «-help» et aussi «-m», il affiche deux messages ci-dessous. Dans l'argument de la ligne de commande «-o», nous avons également passé la chaîne qui est également affichée dans le message.

Conclusion

Nous avons fourni ce guide pour vous aider à apprendre le concept des «arguments de ligne de commande» dans «Python». Nous avons exploré «l'argument de la ligne de commande» et avons également expliqué trois méthodes ici. Nous avons expliqué l'argument de la ligne de commande selon laquelle le processus de transmission des valeurs au programme avec le nom du programme au moment de l'exécution via l'invite de commande.