Comment puis-je traiter les arguments de la ligne de commande en Python?

Question

Ce qui serait une expression facile à traiter les arguments de ligne de commande si j'attends quelque chose comme 001 ou 999 (limitons les attentes à 001 ... 999 plage pour ce temps), et peu d'autres arguments passés, et aimerait ignorer inattendu?

Je comprends par exemple si je dois savoir si « debug » a été passé entre les paramètres, ce sera quelque chose comme ça:

if 'debug' in argv[1:]: 
    print 'Will be running in debug mode.' 

Comment savoir si 009 ou 575 a été adopté?

Tous ceux-ci sont attendues des appels:

python script.py 
python script.py 011 
python script.py 256 debug 
python script.py 391 xls 
python script.py 999 debug pdf 

À ce stade, je ne se soucient pas des appels comme ça:

python script.py 001 002 245 568 
python script.py some unexpected argument 
python script.py 0001 
python script.py 02 

... premier - en raison de plus d'un « numérique " argument; deuxième - à cause de ... bien, des arguments inattendus; troisième et quatrième - en raison d'arguments non-3 chiffres.

Answer 1

Comme d'autres ont répondu, optparse est la meilleure option, mais si vous voulez juste code rapide essayer quelque chose comme ceci:

import sys, re 

first_re = re.compile(r'^\d{3}$') 

if len(sys.argv) > 1: 

    if first_re.match(sys.argv[1]): 
     print "Primary argument is : ", sys.argv[1] 
    else: 
     raise ValueError("First argument should be ...") 

    args = sys.argv[2:] 

else: 

    args =() 

# ... anywhere in code ... 

if 'debug' in args: 
    print 'debug flag' 

if 'xls' in args: 
    print 'xls flag' 

EDIT: Voici un exemple optparse parce que beaucoup de gens répondent optparse sans vraiment expliquer pourquoi, ou expliquer ce que vous devez changer pour le faire fonctionner.

La principale raison d'utiliser optparse est qu'elle vous donne plus de flexibilité pour l'expansion ultérieure, et vous donne plus de flexibilité sur la ligne de commande. En d'autres termes, vos options peuvent apparaître dans n'importe quel ordre et les messages d'utilisation sont générés automatiquement. Cependant, pour que cela fonctionne avec optparse, vous devez modifier vos spécifications en mettant '-' ou '-' devant les arguments optionnels et vous devez autoriser tous les arguments dans n'importe quel ordre.

Alors, voici un exemple d'utilisation optparse:

import sys, re, optparse 

first_re = re.compile(r'^\d{3}$') 

parser = optparse.OptionParser() 
parser.set_defaults(debug=False,xls=False) 
parser.add_option('--debug', action='store_true', dest='debug') 
parser.add_option('--xls', action='store_true', dest='xls') 
(options, args) = parser.parse_args() 

if len(args) == 1: 
    if first_re.match(args[0]): 
     print "Primary argument is : ", args[0] 
    else: 
     raise ValueError("First argument should be ...") 
elif len(args) > 1: 
    raise ValueError("Too many command line arguments") 

if options.debug: 
    print 'debug flag' 

if options.xls: 
    print 'xls flag' 

Les différences ici avec optparse et votre spec est que vous pouvez maintenant avoir des lignes de commande comme:

python script.py --debug --xls 001 

et vous pouvez facilement ajouter de nouvelles options en appelant parser.add_option()

Answer 2

Regardez le module optparse. Traiter avec sys.argv est très bien pour des choses vraiment simples, mais ça devient rapidement hors de contrôle. Notez que vous pouvez trouver optparse plus facile à utiliser si vous pouvez changer un peu votre format d'argument; par exemple. remplacer debug par --debug et xls par --xls ou --output=xls.

Answer 3

optparse est votre meilleur ami pour l'analyse de la ligne de commande. Regardez également dans argparse; Ce n'est pas dans la bibliothèque standard, cependant.

Answer 4

Si vous voulez implémenter des commutateurs de ligne de commande, donnez getopt un aspect. C'est incroyablement simple à utiliser aussi.

Answer 5

Van Gale a largement raison d'utiliser l'expression régulière par rapport à l'argument. Cependant, il n'est PAS absolument nécessaire de tout faire une option lors de l'utilisation d'optparse, qui sépare sys.argv en options et arguments, selon si un "-" ou "-" est en face ou non. Certains exemples de code pour passer par quelques arguments:

import sys 
import optparse 

claParser = optparse.OptionParser() 
claParser.add_option(
(opts, args) = claParser.parse_args() 
if (len(args) >= 1): 
    print "Arguments:" 
    for arg in args: 
    print " " + arg 
else: 
    print "No arguments" 
sys.exit(0) 

Oui, le tableau args est analysé de la même manière que sys.argv serait, mais la possibilité d'ajouter facilement des options si nécessaire a été ajouté. Pour en savoir plus sur optparse, consultez le relevant Python doc.