Quelle est la meilleure façon d'analyser les arguments de ligne de commande?

Cette réponse suggère optparse qui est approprié pour les anciennes versions de Python. Pour Python 2.7 et au-dessus, argparse remplace optparse. Voir cette réponse pour plus d'informations.

Que d'autres personnes nous ont fait remarquer, vous êtes mieux d'aller avec optparse plus de getopt. getopt est à peu près un one-to-one mapping de la norme getopt(3) fonctions de la bibliothèque C, et pas très facile à utiliser.

optparse, tout en étant un peu plus verbeux, est beaucoup mieux structuré et le plus simple pour étendre plus tard.

Voici un typique de la ligne pour ajouter des options à votre parser:

parser.add_option('-q', '--query',
            action="store", dest="query",
            help="query string", default="spam")

Il parle de lui-même; au temps de traitement, il acceptera -q ou --requête comme des options, des magasin de l'argument dans un attribut appelé requête et a une valeur par défaut si vous ne spécifiez pas d'elle. Il est également l'auto-documentation dans la déclaration de l'aide de l'argument (qui sera utilisé lors de l'exécution avec -h/--help) juste ici avec l'option.

Habituellement, vous analysez vos arguments avec:

options, args = parser.parse_args()

Ce sera, par défaut, l'analyse de la norme arguments passés au script (sys.argv[1:])

options.la requête sera ensuite mis à la valeur que vous avez passés au script.

Vous créer un analyseur simplement en faisant

parser = optparse.OptionParser()

Ce sont toutes les bases dont vous avez besoin. Voici un script Python qui le montre:

import optparse

parser = optparse.OptionParser()

parser.add_option('-q', '--query',
    action="store", dest="query",
    help="query string", default="spam")

options, args = parser.parse_args()

print 'Query string:', options.query

5 lignes de python que vous montrer les bases.

L'enregistrer dans sample.py et le lancer une fois avec

python sample.py

et une fois avec

python sample.py --query myquery

Au-delà de cela, vous trouverez que optparse est très facile à étendre.
Dans un de mes projets, j'ai créé une classe de Commande qui vous permet de nid sous-commandes dans un arbre de commande facilement. Il utilise optparse fortement à la chaîne de commandes. Ce n'est pas quelque chose que je peux facilement expliquer en quelques lignes, mais n'hésitez pas à parcourir autour de mon référentiel pour la classe principale, ainsi que une classe qui l'utilise et l'option analyseur

À l'aide de docopt

Depuis 2012 Python est très simple, puissant et vraiment cool module pour l'argument d'analyse appelé docopt. Il fonctionne avec Python 2.6 3.5 et ne nécessite aucune installation (il suffit de le copier). Voici un exemple tiré de la documentation:

"""Naval Fate.

Usage:
  naval_fate.py ship new <name>...
  naval_fate.py ship <name> move <x> <y> [--speed=<kn>]
  naval_fate.py ship shoot <x> <y>
  naval_fate.py mine (set|remove) <x> <y> [--moored | --drifting]
  naval_fate.py (-h | --help)
  naval_fate.py --version

Options:
  -h --help     Show this screen.
  --version     Show version.
  --speed=<kn>  Speed in knots [default: 10].
  --moored      Moored (anchored) mine.
  --drifting    Drifting mine.

"""
from docopt import docopt


if __name__ == '__main__':
    arguments = docopt(__doc__, version='Naval Fate 2.0')
    print(arguments)

Donc ce que c'est: 2 lignes de code en plus de votre doc chaîne qui est essentiel et vous obtenez vos arguments analysées et disponibles dans votre objet arguments. Je vous l'ai dit c'est cool, n'ai-je pas 😉

À l'aide de python-le-feu

Depuis 2017 python-le-feu a un autre cool module qui peut donner à une interface CLI de votre code en vous faisant zéro argument de l'analyse. Voici un exemple simple de la documentation (ce petit programme expose fonction double à la ligne de commande):

import fire

class Calculator(object):

  def double(self, number):
    return 2 * number

if __name__ == '__main__':
  fire.Fire(Calculator)

À partir de la ligne de commande, vous pouvez exécuter:

> calculator.py double 10
20
> calculator.py double --number=15
30

Génial n'est-ce pas?

Je préfère Cliquez sur. Il les résumés gestion d'options et permet de "(...) la création de belle ligne de commande interfaces dans une composable façon avec aussi peu de code que nécessaire".

Voici un exemple d'usage:

import click

@click.command()
@click.option('--count', default=1, help='Number of greetings.')
@click.option('--name', prompt='Your name',
              help='The person to greet.')
def hello(count, name):
    """Simple program that greets NAME for a total of COUNT times."""
    for x in range(count):
        click.echo('Hello %s!' % name)

if __name__ == '__main__':
    hello()

Il génère également automatiquement formatés que les pages d'aide:

$ python hello.py --help
Usage: hello.py [OPTIONS]

  Simple program that greets NAME for a total of COUNT times.

Options:
  --count INTEGER  Number of greetings.
  --name TEXT      The person to greet.
  --help           Show this message and exit.

Utilisation optparse qui vient avec la bibliothèque standard. Par exemple:

#!/usr/bin/env python
import optparse

def main():
  p = optparse.OptionParser()
  p.add_option('--person', '-p', default="world")
  options, arguments = p.parse_args()
  print 'Hello %s' % options.person

if __name__ == '__main__':
  main()

Source: À l'aide de Python pour créer des outils de ligne de commande UNIX

Cependant que de Python 2.7 optparse est obsolète, voir: Pourquoi utiliser argparse plutôt que optparse?

Léger argument de ligne de commande par défaut

Bien que argparse est grand et c'est la bonne réponse pour entièrement documenté commutateurs de ligne de commande et de fonctions avancées, vous pouvez utiliser la fonction argument par défaut pour les poignées de simples arguments de position très simplement.

import sys

def get_args(name='default', first='a', second=2):
    return first, int(second)

first, second = get_args(*sys.argv)
print first, second

Le nom de l'argument saisit le nom du script et n'est pas utilisé. Test de sortie ressemble à ceci:

> ./test.py
a 2
> ./test.py A
A 2
> ./test.py A 20
A 20

Pour de simples scripts où je veux juste quelques valeurs par défaut, je trouve cela tout à fait suffisant. Vous pouvez également inclure un certain type de coercition dans les valeurs de retour de la ligne de commande ou des valeurs pourront être des chaînes de caractères.

Je préfère optparse de getopt. Il est très déclarative: vous dire les noms des options et les effets qu'ils auraient dû l'être (par exemple, la fixation d'un champ booléen), et il vous tend de retour d'un dictionnaire renseignée selon votre cahier des charges.

http://docs.python.org/lib/module-optparse.html

Argparse code peut être plus long que la réelle mise en œuvre du code!

C'est un problème que j'ai trouver avec plus populaire argument options d'analyse, c'est que si vos paramètres ne sont modestes, le code du document devient disproportionnée des avantages qu'ils offrent.

Un relatif à la nouvelle-comer à l'argument de l'analyse de la scène (je pense) est plac.

C'est un peu reconnu de compromis avec argparse, mais utilise inline documentation et enroule simplement autour de main() fonction du type de fonction:

def main(excel_file_path: "Path to input training file.",
     excel_sheet_name:"Name of the excel sheet containing training data including columns 'Label' and 'Description'.",
     existing_model_path: "Path to an existing model to refine."=None,
     batch_size_start: "The smallest size of any minibatch."=10.,
     batch_size_stop:  "The largest size of any minibatch."=250.,
     batch_size_step:  "The step for increase in minibatch size."=1.002,
     batch_test_steps: "Flag.  If True, show minibatch steps."=False):
"Train a Spacy (http://spacy.io/) text classification model with gold document and label data until the model nears convergence (LOSS < 0.5)."

    pass # Implementation code goes here!

if __name__ == '__main__':
    import plac; plac.call(main)

J'ai prolongé d'Erco approche pour permettre tenu des arguments de position et des arguments optionnels. Ceux-ci devraient précéder l'-d-v etc. les arguments.

De position et les arguments optionnels peuvent être récupérées avec PosArg(i) et OptArg(j'ai, par défaut), respectivement.
Lorsqu'un argument optionnel est trouvé à la position de départ de la recherche d'options (ex -i) est déplacé 1 à l'avance pour éviter de créer un "inattendue" fatale.

import os,sys
def HelpAndExit():
print("<<your help output goes here>>")
sys.exit(1)
def Fatal(msg):
sys.stderr.write("%s: %s\n" % (os.path.basename(sys.argv[0]), msg))
sys.exit(1)
def NextArg(i):
'''Return the next command line argument (if there is one)'''
if ((i+1) >= len(sys.argv)):
Fatal("'%s' expected an argument" % sys.argv[i])
return(1, sys.argv[i+1])
def PosArg(i):
'''Return positional argument'''
if i >= len(sys.argv):
Fatal("'%s' expected an argument" % sys.argv[i])
return sys.argv[i]
def OptArg(i, default):
'''Return optional argument (if there is one)'''
if i >= len(sys.argv):
Fatal("'%s' expected an argument" % sys.argv[i])
if sys.argv[i][:1] != '-':
return True, sys.argv[i]
else:
return False, default
### MAIN
if __name__=='__main__':
verbose = 0
debug   = 0
infile  = "infile"
outfile = "outfile"
options_start = 3
# --- Parse two positional parameters ---
n1 = int(PosArg(1))
n2 = int(PosArg(2))
# --- Parse an optional parameters ---
present, a3 = OptArg(3,50)
n3 = int(a3)
options_start += int(present)
# --- Parse rest of command line ---
skip = 0
for i in range(options_start, len(sys.argv)):
if not skip:
if   sys.argv[i][:2] == "-d": debug ^= 1
elif sys.argv[i][:2] == "-v": verbose ^= 1
elif sys.argv[i][:2] == "-i": (skip,infile)  = NextArg(i)
elif sys.argv[i][:2] == "-o": (skip,outfile) = NextArg(i)
elif sys.argv[i][:2] == "-h": HelpAndExit()
elif sys.argv[i][:1] == "-":  Fatal("'%s' unknown argument" % sys.argv[i])
else:                         Fatal("'%s' unexpected" % sys.argv[i])
else: skip = 0
print("Number 1 = %d" % n1)
print("Number 2 = %d" % n2)
print("Number 3 = %d" % n3)
print("Debug    = %d" % debug)
print("verbose  = %d" % verbose)
print("infile   = %s" % infile)
print("outfile  = %s" % outfile)