it-swarm.com.de

Wie kann ich Befehlszeilenargumente lesen / verarbeiten?

572
edgerA

Die kanonische Lösung in der Standardbibliothek lautet argparse ( docs ):

Hier ist ein Beispiel:

from argparse import ArgumentParser

parser = ArgumentParser()
parser.add_argument("-f", "--file", dest="filename",
                    help="write report to FILE", metavar="FILE")
parser.add_argument("-q", "--quiet",
                    action="store_false", dest="verbose", default=True,
                    help="don't print status messages to stdout")

args = parser.parse_args()

argparse unterstützt unter anderem:

  • Mehrere Optionen in beliebiger Reihenfolge.
  • Kurze und lange Optionen.
  • Standardwerte.
  • Generierung einer Nutzungshilfe.
410
Ayman Hourieh
_import sys

print("\n".join(sys.argv))
_

sys.argv ist eine Liste, die alle Argumente enthält, die an das Skript in der Befehlszeile übergeben wurden.

Grundsätzlich gilt,

_import sys
print(sys.argv[1:])
_
511
John Slavick

Ich gehe einfach herum und evangelisiere aus argumentativ , was aus diesen Gründen besser ist .. im Wesentlichen:

(aus dem Link kopiert)

  • das argparse-Modul kann positionelle und optionale Argumente verarbeiten, während optparse nur optionale Argumente verarbeiten kann

  • argparse ist nicht dogmatisch, wie Ihre Befehlszeilenschnittstelle aussehen soll - Optionen wie -file oder/file werden unterstützt, ebenso wie erforderliche Optionen. Optparse weigert sich, diese Funktionen zu unterstützen, und zieht die Reinheit der Praktikabilität vor

  • argparse erzeugt informativere Verwendungsnachrichten, einschließlich der Befehlszeilenverwendung, die anhand Ihrer Argumente ermittelt wurde, und Hilfemeldungen für positionelle und optionale Argumente. Für das optparse-Modul müssen Sie eine eigene Verwendungszeichenfolge schreiben, und es kann keine Hilfe für Positionsargumente angezeigt werden.

  • argparse unterstützt Aktionen, die eine variable Anzahl von Befehlszeilenargumenten verbrauchen, während optparse voraussetzt, dass die genaue Anzahl der Argumente (z. B. 1, 2 oder 3) im Voraus bekannt ist

  • argparse unterstützt Parser, die an Unterbefehle gesendet werden, während für optparse allow_interspersed_args festgelegt und der Parser manuell gesendet werden muss

Und mein persönlicher Favorit:

  • mit argparse können die Typ- und Aktionsparameter add_argument() mit einfachen Callables angegeben werden, während für optparse Hacking-Klassenattribute wie STORE_ACTIONS oder CHECK_METHODS erforderlich sind, um eine ordnungsgemäße Argumentprüfung zu erhalten
125
Silfheed

Es gibt auch argparse stdlib-Modul (eine "Verbesserung" des Moduls stdlib optparse). Beispiel aus die Einleitung zu argparse :

# script.py
import argparse

if __== '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument(
        'integers', metavar='int', type=int, choices=range(10),
         nargs='+', help='an integer in the range 0..9')
    parser.add_argument(
        '--sum', dest='accumulate', action='store_const', const=sum,
        default=max, help='sum the integers (default: find the max)')

    args = parser.parse_args()
    print(args.accumulate(args.integers))

Verwendungszweck:

$ script.py 1 2 3 4
4

$ script.py --sum 1 2 3 4
10
67
jfs

Eine Möglichkeit ist die Verwendung von sys.argv. Dadurch werden der Skriptname als erstes Argument und alle anderen Parameter ausgegeben, die Sie an das Skript übergeben.

import sys

for arg in sys.argv:
    print arg
49
JPCosta

Die docopt Bibliothek ist wirklich schlau. Es wird ein Argument dikt aus der Verwendungszeichenfolge für Ihre App erstellt.

ZB aus der docopt-Readme:

"""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 __== '__main__':
    arguments = docopt(__doc__, version='Naval Fate 2.0')
    print(arguments)
48
ralbatross

Wenn Sie etwas brauchen, schnell und nicht sehr flexibel

main.py:

import sys

first_name = sys.argv[1]
last_name = sys.argv[2]
print("Hello " + first_name + " " + last_name)

Führen Sie dann python main.py James Smith aus.

um die folgende Ausgabe zu erzeugen:

Hallo James Smith

41
#set default args as -h , if no args:
if len(sys.argv) == 1: sys.argv[1:] = ["-h"]
26
whi

Ich benutze optparse selbst, aber ich mag die Richtung, die Simon Willison mit seiner kürzlich eingeführten optfunc Bibliothek einschlägt. Es funktioniert durch:

msgstr "Eine Funktionsdefinition (einschließlich ihrer Argumente und ihrer Standardwerte) untersuchen und diese verwenden, um einen Parser für Befehlszeilenargumente zu erstellen."

So zum Beispiel diese Funktionsdefinition:

def geocode(s, api_key='', geocoder='google', list_geocoders=False):

wird in diesen optparse Hilfetext umgewandelt:

    Options:
      -h, --help            show this help message and exit
      -l, --list-geocoders
      -a API_KEY, --api-key=API_KEY
      -g GEOCODER, --geocoder=GEOCODER
19
Van Gale

Ich mag getopt von stdlib, zB:

try:
    opts, args = getopt.getopt(sys.argv[1:], 'h', ['help'])
except getopt.GetoptError, err: 
    usage(err)

for opt, arg in opts:
    if opt in ('-h', '--help'): 
        usage()

if len(args) != 1:
    usage("specify thing...")

In letzter Zeit habe ich etwas Ähnliches verpackt, um die Worte weniger wortreich zu machen (z. B. "-h" implizit zu machen).

8
Peter Ericson

Wie Sie sehen können optparse "Das Modul optparse ist veraltet und wird nicht weiterentwickelt; die Entwicklung wird mit dem Modul argparse fortgesetzt."

7
tverrbjelke

Pocoos Klicken ist intuitiver, benötigt weniger Boilerplate und ist mindestens so leistungsfähig wie argparse.

Die einzige Schwäche, auf die ich bisher gestoßen bin, ist, dass Sie nicht viele Anpassungen an Hilfeseiten vornehmen können, aber dies ist normalerweise keine Voraussetzung, und docopt scheint die klare Wahl zu sein, wenn dies der Fall ist.

7
Ryne Everett
import argparse

parser = argparse.ArgumentParser(description='Process some integers.')
parser.add_argument('integers', metavar='N', type=int, nargs='+',
                   help='an integer for the accumulator')
parser.add_argument('--sum', dest='accumulate', action='store_const',
                   const=sum, default=max,
                   help='sum the integers (default: find the max)')

args = parser.parse_args()
print(args.accumulate(args.integers))

Assuming the Python code above is saved into a file called prog.py
$ python prog.py -h

Ref-link: https://docs.python.org/3.3/library/argparse.html
5
JON

Möglicherweise interessiert Sie ein kleines Python Modul, das ich geschrieben habe, um die Handhabung von Befehlszeilenargumenten noch einfacher zu machen (Open Source und frei verwendbar) - Commando

4
Mufasa

Ich empfehle docopt als einfache Alternative zu diesen anderen.

docopt ist ein neues Projekt, bei dem Sie Ihre --help-Verwendungsmeldung analysieren müssen, anstatt alles selbst implementieren zu müssen. Sie müssen nur Ihre Nutzungsnachricht in das POSIX-Format einfügen.

4
David C. Bishop

Eine weitere Option ist argh . Es baut auf argparse auf und ermöglicht das Schreiben von Dingen wie:

import argh

# declaring:

def echo(text):
    "Returns given Word as is."
    return text

def greet(name, greeting='Hello'):
    "Greets the user with given name. The greeting is customizable."
    return greeting + ', ' + name

# assembling:

parser = argh.ArghParser()
parser.add_commands([echo, greet])

# dispatching:

if __== '__main__':
    parser.dispatch()

Es wird automatisch Hilfe und so weiter generiert, und Sie können Dekoratoren verwenden, um zusätzliche Anleitungen zu geben, wie das Parsen von Argumenten funktionieren soll.

3
circular-ruin

Meine Lösung ist Entypoint2 . Beispiel:

from entrypoint2 import entrypoint
@entrypoint
def add(file, quiet=True): 
    ''' This function writes report.

    :param file: write report to FILE
    :param quiet: don't print status messages to stdout
    '''
    print file,quiet

hilfstext:

usage: report.py [-h] [-q] [--debug] file

This function writes report.

positional arguments:
  file         write report to FILE

optional arguments:
  -h, --help   show this help message and exit
  -q, --quiet  don't print status messages to stdout
  --debug      set logging level to DEBUG
0
ponty