Python >> Tutoriel Python >  >> Python

Arguments de ligne de commande – module getopt

Salut les gens ! Dans cet article, nous allons comprendre le module getopt qui prend en charge les arguments de ligne de commande. Alors, commençons.

Qu'est-ce que le module getopt ?

Le getopt module est un analyseur d'arguments de ligne de commande qui prend en charge les mêmes fonctionnalités que le getopt() Unix fonction. Son API est conçue de manière similaire à la fonction C getopt().

Dans les démonstrations qui suivent, nous utiliserons le module sys pour lire les arguments passés au programme en utilisant le sys.argv fonction, puis utilisez le module getopt pour analyser les arguments.

  • sys.argv :Liste des arguments de la ligne de commande
  • len(sys.argv)  :nombre d'arguments de ligne de commande.
import sys
number=len(sys.argv)
arguments=str(sys.argv)
print ('The Number of arguments:', number, 'arguments.')
print ('Argument List:', arguments)

Sortie :

C:\Users\Tanushree Thapliyal\Desktop>py yess.py A1 B2 C3 D4
The Number of arguments: 5 arguments.
Argument List: ['yess.py', 'A1', 'B2', 'C3', 'D4']

Le 0ème index est le nom du script et est compté dans le nombre d'arguments.

Démonstration des fonctions du module getopt

Passons en revue quelques-uns des exemples du module getopt ici. Nous allons démontrer quelques-unes des deux fonctions courantes.

1. Analyse des options de ligne de commande et de la liste des paramètres avec getopt.getopt()

Le getopt() La fonction analyse les options de ligne de commande et la liste des paramètres. Cette fonction accepte trois arguments :

  • arguments est la liste d'arguments à passer.
  • shortops est la chaîne de lettres d'options que le script veut reconnaître.
  • options longues est la liste des chaînes avec les noms des options longues qui doivent être prises en charge.

Il renvoie la liste des paires (option, valeur) et la liste des arguments de programme restants après la suppression de la liste d'options.

import sys
import getopt

args=sys.argv[1:]
inputfile = ''
outputfile = ''

try:
   opts, args = getopt.getopt(args,"hi:o:",["infile=","outfile="])
except getopt.GetoptError:
   print ('test.py -i <inputfile> -o <outputfile>')
   sys.exit(2)

for opt, arg in opts:
   if opt == '-h':
      print ('args.py -i <inputfile> -o <outputfile>')
      sys.exit()
   elif opt in ("-i", "--infile"):
      inputfile = arg
   elif opt in ("-o", "--outfile"):
      outputfile = arg

print ('Input file is "', inputfile)
print ('Output file is "', outputfile)

En plus d'accepter les arguments complets en tant que --infile et --outfile , nous acceptons également les arguments en tant que -i et -o .

REMARQUE : La démonstration ci-dessus ne traite en aucun cas les arguments. Le but de la démonstration est de montrer que le module getopt analyse les arguments et nous permet de travailler facilement avec des arguments en ligne.

Ici, sys.argv[1:] signifie que l'index de départ est 1 car sys.argv[0] est le nom du script auquel nous n'avons pas besoin d'accéder.

CAS 1  :Utilisation d'un tiret simple (‘ - ') et formes courtes -i et -o.

Sortie :

py python.py -i=abc.txt -o=xyz.txt
Input file is " abc.txt
Output file is " xyz.txt

CAS 2 : Utilisation d'un double tiret (' - ') et de formes longues des arguments

py python.py --infile=abc.txt --outfile=xyz.txt
Input file is " abc.txt
Output file is " xyz.txt

2. Analyse de style GNU avec la fonction gnu_getopt()

Le getopt.gnu_getopt() La fonction est utilisée pour l'analyse de style GNU. Son fonctionnement est similaire au getopt() sauf que, dans ce cas, l'analyse de style GNU est utilisée par défaut, ce qui signifie que les arguments d'option et de non-option peuvent être mélangés.

import getopt
import sys

category = '1.0'
fix = False
output_file = 'abc.txt'

print ('ARGV      :', sys.argv[1:])

options, remainder = getopt.gnu_getopt(sys.argv[1:], 'o:f', ['output=','fix', 'category='])

print ('OPTIONS   :', options)

for opt, arg in options:
    if opt in ('-o', '--output'):
        output_filename = arg
    elif opt in ('-f', '--fix'):
        fix = True
    elif opt == '--category':
    	category = arg
        
print ('category   :', category)
print ('fix        :',fix)
print ('output    :', output_file)
print ('remaining :', remainder)

Sortie :

py yess.py -f not_an_option --output foo

ARGV      : ['-f', 'not_an_option', '--output', 'foo']
OPTIONS   : [('-f', ''), ('--output', 'foo')]
category   : 1.0
fix        : True
output    : abc.txt
remaining : ['not_an_option']

Nous pouvons également exécuter ce code sans passer d'arguments-

ARGV      : []
OPTIONS   : []
category   : 1.0
fix        : False
output    : abc.txt
remaining : []

Si ‘ — ‘ est passé dans l'argument, getopt arrête de traiter les arguments restants comme des options.

py yess.py -f -- --output foo
ARGV      : ['-f', '--', '--output', 'foo']
OPTIONS   : [('-f', '')]
category   : 1.0
fix        : True
output    : abc.txt
remaining : ['--output', 'foo']

Gérer les exceptions avec getopt.GetoptError

Lorsqu'une option reconnue n'est pas trouvée dans la liste des arguments ou lorsque l'option qui nécessite un argument n'en reçoit aucun, une erreur d'exception est déclenchée.

Le module argparse de Python est une alternative qui fournit une interface de ligne de commande avec moins de code et plus d'aide et de messages d'erreur informatifs. Vous pouvez en savoir plus sur la gestion des exceptions.

Conclusion

Dans ce tutoriel, nous avons découvert le module opt et sa fonction importante et comment nous pouvons passer des arguments de ligne de commande via ce module.

Référence

Documents officiels