Tutoriel d'analyse de ligne de commande Python

L'analyse des arguments de ligne de commande était auparavant incluse dans la bibliothèque Python par défaut «Argparse». En permettant aux valeurs d'entrée de l'utilisateur d'être en quelque sorte analysées puis utilisées, «ArgParse». Il offre une flexibilité et réutilise votre code à la place de la définition manuelle des variables dans le cadre du code.

Exemple 1

Nous implémenterons le code suivant pour montrer la structure et l'utilisation d'une bibliothèque Argparse.

Importer Argparse
Parser = Argparse.ArgumentParser ()
analyseur.add_argument ('- name', type = str, requis = true)
args = analyseur.parse_args ()
imprimer ('salut', args.nom)

La bibliothèque «Argparse» serait importée au début du code. L'analyseur est initialisé par argumentParser (), nous pourrons donc commencer à ajouter des paramètres personnalisés. Utiliser l'analyseur.Fonction add_argument () pour ajouter les arguments souhaités. Le «nom», «type» et «requis» seront donnés comme les arguments de cette méthode. L'attribut «requis» est un booléen indiquant si le champ de ligne de commande suivant est exécuté, et l'argument «type» montre le type de variable spécifié comme une entrée. Nous définissons la valeur de l'argument «Type» comme «Str» et «Obligatoire» comme «vrai». La fonction parse_args () sera appelée. Les «args.Nom ”L'attribut semble être le nom d'un tel argument identifié avec la fonction add_argument ().

Le code précédent produit ce type de résultat comme indiqué:

Comme nous pouvons le voir, cela augmentera une erreur car l'argument «nom» est nécessaire mais fait défaut. Lorsque nous ajoutons -nom, nous obtenons la sortie suivante:

Exemple 2

Il y a certaines situations où nous ne voulons pas discuter du nom qui pourrait être utilisé pour le drapeau. On peut utiliser un paramètre positionnel pour éviter d'avoir à fournir l'indicateur -name avant d'entrer la valeur réelle.

Ici, nous multiplierons les arguments de position en spécifiant les paramètres.

Importer Argparse
Parser = Argparse.ArgumentParser ()
analyseur.add_argument ('- i', type = int, requis = true)
analyseur.add_argument ('- j', type = int, requis = true)
args = analyseur.parse_args ()
produit = args.I * args.J
Imprimer ('Produit:', produit)

L'analyseur a été généré pour la première fois après l'importation du module «Argparse». Les variables «I» et «J», deux arguments de type entier qui doivent être vraies, ont ensuite été ajoutés. Après cela, des formules de produit seront appliquées après l'analyse des paramètres. Nous utilisons la fonction print () pour afficher le produit.

Exemple 3

Dans ce cas, nous faisons une multiplication sans spécifier les paramètres de position.

Importer Argparse
Parser = Argparse.ArgumentParser ()
analyseur.add_argument ('k', type = int)
analyseur.add_argument ('l', type = int)
args = analyseur.parse_args ()
produit = args.k * args.l
Imprimer ('Produit:', produit)

Premièrement, intégrant le package «ArgParse», l'analyseur a été initialement construit à l'aide de la méthode ArgumentParser (). Les «K» et «L» sont les deux arguments spécifiés avec le type entier. Bien que les arguments positionnels gardent une ligne de commande plus claire, nous ne fournissons pas l'attribut «requis» ici. Par la suite, les paramètres donnés ont été analysés à l'aide de la méthode PARSE_ARGS (). Nous définirons une fonction de produit en utilisant les variables «K» et «L». Pour montrer le résultat, nous utiliserons la déclaration d'impression.

Exemple 4

Les arguments facultatifs peuvent être utiles chaque fois que nous voulons fournir à un utilisateur un certain choix pour utiliser les fonctionnalités. Nous spécifions simplement le paramètre facultatif à l'aide de la fonction add_argument () pour ajouter un argument facultatif.

Importer Argparse
Parser = Argparse.ArgumentParser ()
analyseur.add_argument ('- name', type = str, requis = true)
analyseur.add_argument ('- class', type = int)
args = analyseur.parse_args ()
Si args.Classe:
imprimer (args.nom, 'in', args.Classe, 'classe.')
autre:
print ('hey', args.nom + '!')

Nous commençons le programme en incorporant la bibliothèque «Argparse». Nous avons d'abord établi un analyseur en utilisant la méthode ArgumentParser () pour exécuter deux arguments d'analyseur. Maintenant, nous appellerons la fonction add_argument () pour ajouter différents paramètres. Ces arguments incluent deux variables, le nom et la classe, où l'argument «nom» est du type «String», et il doit être vrai. Le paramètre «classe» a le type «entier».

De plus, après l'analyse des paramètres, nous utilisons la condition «if-else». À l'intérieur, nous avons appliqué la fonction print () deux fois, une fois par l'instruction «if» et à nouveau par l'instruction «else», pour représenter la sortie. Les arguments en méthodes imprimés () varient dans ces deux cas. Les arguments donnés dans la fonction première imprime () incluent le nom et la classe. En même temps, les arguments présentés dans la deuxième méthode print () incluent les args.nom.

Après avoir exécuté le code, nous obtenons les deux sorties comme indiqué ci-dessous. Nous obtenons la première sortie après avoir utilisé les arguments facultatifs et le second sans les arguments facultatifs.

À partir des deux sorties différentes précédentes, nous pouvons observer qu'il existe une différence entre les deux sorties en raison de l'utilisation des arguments facultatifs en un et non dans l'autre.

Exemple 5

Imaginons que plutôt que de demander à l'utilisateur de fournir des entrées «x» et «y», nous voulons que l'utilisateur entre dans une plage de nombres et le script, qui renverrait ensuite le total de tous ces chiffres. Comme nous ne pouvons pas prédire le nombre de valeurs qu'un utilisateur entrera, il n'est pas nécessaire de créer un nouvel argument pour chaque nouvelle valeur. Le nombre (ou les entrées) que l'argument peut accepter peut être spécifié à l'aide de l'option «Nargs» dans la fonction add_argument ().

Nous fournirons plusieurs arguments d'entrée et imprimerons le résultat dans ce cas.

Importer Argparse
Parser = Argparse.ArgumentParser ()
analyseur.add_argument ('- valeurs', type = int, nargs = 5)
args = analyseur.parse_args ()
sum = sum (args.valeurs)
Imprimer ('Sum:', somme)

Nous entrons en importation en importation de la bibliothèque «ArgParse», qui est requise pour exécuter le code précédent. Nous allons créer un analyseur en appelant la méthode ArgumentParser (). Cette fonction ne contient aucun argument. Ensuite, la méthode add_argument () sera invoquée. Cette méthode a trois paramètres. Dans le cas de plusieurs arguments d'entrée, nous avons utilisé l'attribut «Nargs» dans la méthode add_argument (). Maintenant, nous appellerons la fonction parse_args () pour l'analyse. Nous appliquons la méthode sum () pour trouver la somme des valeurs. Pour représenter la sortie, nous avons utilisé l'instruction PRINT.

Exemple 6

Et si nous voulons la somme de plus d'entrées que cinq valeurs? Nous pouvons faire en sorte que l'argument accepte n'importe quel nombre de valeurs en définissant nargs = "+".

Importer Argparse
Parser = Argparse.ArgumentParser ()
analyseur.add_argument ('- valeurs', type = int, nargs = '+')
args = analyseur.parse_args ()
sum = sum (args.valeurs)
Imprimer ('Sum:', somme)

Nous pouvons exécuter le script avec à peu près n'importe quel nombre de valeurs d'entrée. Ici, nous utilisons le même code que plus tôt, mais, dans ce code, nous modifierons 'nargs' = 5 à 'nargs' = '+'.

Conclusion

Cet article a couvert une variété de techniques d'analyse de ligne de commande Python, telles que des arguments simples, des arguments de position, des arguments facultatifs et plusieurs arguments d'entrée. Il a également fourni des exemples pour voir comment la sortie change selon un argument utilisé ou non. Nous pouvons utiliser des exemples pour examiner et comprendre si un argument est approprié dans une certaine circonstance.