Wie lassen sich Befehlszeilenargumente am besten auswerten?

Question

Was ist das am einfachsten , am knappsten und die meisten flexibel Methode oder Bibliothek zum Parsen von Python-Befehlszeilenargumenten?

Answer 1

argparse ist der richtige Weg. Hier ist eine kurze Zusammenfassung, wie man es benutzt:

1) Initialisieren

import argparse

# Instantiate the parser
parser = argparse.ArgumentParser(description='Optional app description')

2) Argumente hinzufügen

# Required positional argument
parser.add_argument('pos_arg', type=int,
                    help='A required integer positional argument')

# Optional positional argument
parser.add_argument('opt_pos_arg', type=int, nargs='?',
                    help='An optional integer positional argument')

# Optional argument
parser.add_argument('--opt_arg', type=int,
                    help='An optional integer argument')

# Switch
parser.add_argument('--switch', action='store_true',
                    help='A boolean switch')

3) Parsen

args = parser.parse_args()

4) Zugang

print("Argument values:")
print(args.pos_arg)
print(args.opt_pos_arg)
print(args.opt_arg)
print(args.switch)

5) Werte prüfen

if args.pos_arg > 10:
    parser.error("pos_arg cannot be larger than 10")

Verwendung

Richtige Verwendung:

$ ./app 1 2 --opt_arg 3 --switch

Argument values:
1
2
3
True

Falsche Argumente:

$ ./app foo 2 --opt_arg 3 --switch
usage: convert [-h] [--opt_arg OPT_ARG] [--switch] pos_arg [opt_pos_arg]
app: error: argument pos_arg: invalid int value: 'foo'

$ ./app 11 2 --opt_arg 3
Argument values:
11
2
3
False
usage: app [-h] [--opt_arg OPT_ARG] [--switch] pos_arg [opt_pos_arg]
convert: error: pos_arg cannot be larger than 10

Volle Hilfe:

$ ./app -h

usage: app [-h] [--opt_arg OPT_ARG] [--switch] pos_arg [opt_pos_arg]

Optional app description

positional arguments:
  pos_arg            A required integer positional argument
  opt_pos_arg        An optional integer positional argument

optional arguments:
  -h, --help         show this help message and exit
  --opt_arg OPT_ARG  An optional integer argument
  --switch           A boolean switch

Answer 2

Diese Antwort legt nahe optparse was für ältere Python-Versionen geeignet ist. Für Python 2.7 und höher, argparse Ersetzt optparse . Siehe diese Antwort für weitere Informationen.

Wie bereits von anderen Leuten erwähnt, ist es besser, optparse statt getopt zu verwenden. getopt ist so ziemlich eine Eins-zu-Eins-Abbildung der Standardfunktionen der C-Bibliothek getopt(3) und nicht sehr einfach zu benutzen.

optparse ist zwar etwas ausführlicher, aber viel besser strukturiert und später einfacher zu erweitern.

Hier ist eine typische Zeile, um eine Option zu Ihrem Parser hinzuzufügen:

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

Es spricht so ziemlich für sich selbst; zur Verarbeitungszeit akzeptiert es -q oder --query als Optionen, speichert das Argument in einem Attribut namens query und hat einen Standardwert, wenn Sie es nicht angeben. Es ist auch selbstdokumentierend, da Sie das Argument help (das verwendet wird, wenn es mit -h/--help ausgeführt wird) direkt mit der Option deklarieren.

Normalerweise analysieren Sie Ihre Argumente mit:

options, args = parser.parse_args()

Dies analysiert standardmäßig die dem Skript übergebenen Standardargumente (sys.argv[1:])

options.query wird dann auf den Wert gesetzt, den Sie an das Skript übergeben haben.

Sie erstellen einen Parser einfach mit dem Befehl

parser = optparse.OptionParser()

Das sind alle Grundlagen, die Sie brauchen. Hier ist ein vollständiges Python-Skript, das dies zeigt:

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 Zeilen Python, die Ihnen die Grundlagen zeigen.

Speichern Sie es in sample.py, und führen Sie es einmal mit

python sample.py

und einmal mit

python sample.py --query myquery

Darüber hinaus werden Sie feststellen, dass optparse sehr einfach zu erweitern ist. In einem meiner Projekte habe ich eine Command-Klasse erstellt, mit der sich Unterbefehle in einem Befehlsbaum einfach verschachteln lassen. Sie nutzt optparse stark, um Befehle miteinander zu verketten. Das kann ich nicht in ein paar Zeilen erklären, aber Sie können es gerne tun in meinem Repository herumstöbern für die Hauptklasse, sowie eine Klasse, die sie verwendet, und den Optionsparser

Answer 3

Verwendung von docopt

Seit 2012 gibt es eine sehr einfache, leistungsstarke und wirklich cool Modul für das Parsen von Argumenten namens docopt . Hier ist ein Beispiel aus der Dokumentation:

"""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)

Das war's also: 2 Codezeilen plus Ihr Doc-String, der ist wesentlich und Sie erhalten Ihre Argumente geparst und in Ihrem Argumente-Objekt verfügbar.

python-fire verwenden

Seit 2017 gibt es ein weiteres cooles Modul namens python-fire . Es kann eine CLI-Schnittstelle für Ihren Code generieren, indem Sie Null Argumenten-Parsing. Hier ist ein einfaches Beispiel aus der Dokumentation (dieses kleine Programm stellt die Funktion double in der Befehlszeile):

import fire

class Calculator(object):

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

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

In der Befehlszeile können Sie Folgendes ausführen:

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

Answer 4

Ich bevorzuge Klicken Sie auf . Es abstrahiert die Verwaltung von Optionen und ermöglicht "(...) die Erstellung schöner Kommandozeilenschnittstellen auf kompatible Weise mit so wenig Code wie nötig".

Hier ein Beispiel für die Verwendung:

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()

Außerdem erzeugt es automatisch schön formatierte Hilfeseiten:

$ 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.

Answer 5

Der neue hippe Weg ist argparse para diese Gründe. argparse > optparse > getopt

aktualisieren: Ab py2.7 argparse ist Teil der Standardbibliothek und optparse ist veraltet.