Wie lese / verarbeite ich Befehlszeilenargumente?

Ich bin ursprünglich ein C-Programmierer. Ich habe zahlreiche Tricks und "Hacks" gesehen, um viele verschiedene Argumente zu lesen.

Wie können Python-Programmierer dies tun?

verbunden

• Wie lassen sich Befehlszeilenargumente, die an ein Python-Skript übergeben werden, am besten erfassen / analysieren?
• Implementieren von Befehlszeilenschnittstellen im Stil "[Befehl] [Aktion] [Parameter]"?
• Wie kann ich Befehlszeilenargumente in Python verarbeiten?
• Wie formatiere ich Positionsargumente mithilfe von Pythons Optparse?

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

import sys

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

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

Grundsätzlich,

import sys
print(sys.argv[1:])

Ich gehe einfach herum und evangelisiere für Argparse, was aus diesen Gründen besser ist . Im Wesentlichen:

(vom Link kopiert)

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

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

• argparse erzeugt informativere Verwendungsnachrichten, einschließlich der aus Ihren Argumenten ermittelten Befehlszeilenverwendung, und Hilfemeldungen für Positions- und optionale Argumente. Das optparse-Modul erfordert das Schreiben einer eigenen Verwendungszeichenfolge und kann keine Hilfe für Positionsargumente anzeigen.

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

• argparse unterstützt Parser, die an Unterbefehle senden, während optparse allow_interspersed_argsdas manuelle Festlegen und Ausführen des Parser-Versands erfordert

Und mein persönlicher Favorit:

• Mit argparse können die Typ- und Aktionsparameter add_argument() mit einfachen aufrufbaren Elementen angegeben werden, während für optparse das Hacken von Klassenattributen wie STORE_ACTIONSoder CHECK_METHODSeine ordnungsgemäße Argumentprüfung erforderlich ist

Es gibt auch ein argparsestdlib-Modul (eine "Verbesserung" des stdlib- optparseModuls). Beispiel aus der Einführung zu argparse :

# script.py
import argparse

if __name__ == '__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

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

import sys

for arg in sys.argv:
    print arg

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

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

Wenn Sie etwas schnelles und nicht sehr flexibles brauchen

main.py:

import sys

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

Dann renne python main.py James Smith

um die folgende Ausgabe zu erzeugen:

Hallo James Smith

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

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

"Introspektion einer Funktionsdefinition (einschließlich ihrer Argumente und ihrer Standardwerte) und Verwendung dieser, um einen Befehlszeilenargument-Parser 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

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 Dinge weniger ausführlich zu machen (z. B. "-h" implizit zu machen).

Pocoos Klick ist intuitiver, erfordert 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 viel anpassen können, um Seiten zu helfen, aber das ist normalerweise keine Voraussetzung, und docopt scheint die klare Wahl zu sein, wenn dies der Fall ist.

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

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

Vielleicht interessiert Sie ein kleines Python-Modul, das ich geschrieben habe, um die Handhabung von Befehlszeilenargumenten noch einfacher zu machen (Open Source und kostenlos) - Commando

Ich empfehle einen Blick auf docopt als einfache Alternative zu diesen anderen zu betrachten.

docopt ist ein neues Projekt, bei dem Ihre --help-Verwendungsnachricht analysiert wird, anstatt dass Sie alles selbst implementieren müssen. Sie müssen nur Ihre Nutzungsnachricht in das POSIX-Format stellen.

Eine weitere Option ist Argh . Es baut auf Argparse auf und lässt Sie Dinge schreiben 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 __name__ == '__main__':
    parser.dispatch()

Es wird automatisch Hilfe usw. generiert, und Sie können Dekorateure verwenden, um zusätzliche Anleitungen zur Funktionsweise des Arg-Parsing zu geben.

Meine Lösung ist entrypoint2 . 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