Wie lesen / Prozessbefehlszeilenargumente?
-
06-07-2019 - |
Frage
Ich bin ursprünglich ein C-Programmierer. Ich habe zahlreiche Tricks und „Hacks“ gesehen viele verschiedene Argumente zu lesen.
Was sind einige der Möglichkeiten, Python-Programmierer dies tun können?
Related
Lösung
Die kanonische Lösung in der Standardbibliothek ist 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
Träger (unter anderem):
- Mehr Optionen in beliebiger Reihenfolge.
- Kurz und lange Optionen.
- Standardwerte.
- Die Erzeugung einer Nutzung Hilfemeldung an.
Andere Tipps
import sys
print("\n".join(sys.argv))
sys.argv
ist eine Liste, die alle Argumente enthält bestanden um das Skript auf der Kommandozeile.
Grundsätzlich
import sys
print(sys.argv[1:])
Gehen Sie einfach um für evangelisieren argparse die diese Gründe .. im wesentlichen:
(über den Link kopiert)
-
argparse Modul kann behandeln Positions und optionale Argumente, während optparse kann nur optional Griff Argumente
-
argparse ist nicht dogmatisch was Ihre Befehlszeilenschnittstelle aussehen sollte - Optionen wie -datei oder / Datei unterstützt, ebenso wie erforderliche Optionen. Optparse weigert sich, unterstützt diese Funktionen, lieber Reinheit über Praktikabilität
-
argparse produziert mehr informative Nutzung Nachrichten, einschließlich Kommandozeilennutzung bestimmt aus Ihre Argumente und Hilfemeldungen für beide Lage- und optional Argumente. Das Modul optparse erfordert, dass Sie Ihre eigene Nutzung zu schreiben String und hat keine Möglichkeit, anzuzeigen Hilfe für Positionsargumente.
-
argparse unterstützt Aktion, verbrauchen eine variable Anzahl von Befehlszeilen-args, während optparse setzt voraus, dass die genaue Zahl der Argumente (beispielsweise 1, 2 oder 3) bezeichnet werden im Voraus
-
argparse unterstützt Parser, dass Versand an Unterbefehle, während optparse erfordert Einstellung
allow_interspersed_args
und dabei die Parser Versand manuell
Und mein persönlicher Favorit:
- argparse erlaubt die Art und
Aktionsparameter
add_argument()
werden mit einfachen angegeben Callables, während optparse erfordert Hacker-Klasse Attribute wieSTORE_ACTIONS
oderCHECK_METHODS
zu erhalten richtiges Argument Überprüfung
Es gibt auch argparse
stdlib Modul (ein "impovement" auf stdlib des optparse
Modul) . Beispiel von die Einführung in 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))
Verbrauch:
$ script.py 1 2 3 4
4
$ script.py --sum 1 2 3 4
10
Eine Möglichkeit, es zu tun sys.argv
verwendet. Dadurch wird der Skriptnamen als erstes Argument und alle anderen Parameter drucken, die Sie ihm übergeben.
import sys
for arg in sys.argv:
print arg
Die docopt Bibliothek ist wirklich glatt. Es baut ein Argument dict aus der Nutzung Zeichenfolge für Ihre Anwendung.
Zum Beispiel von 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 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)
Dann laufen python main.py James Smith
die folgende Ausgabe erzeugen:
Hallo James Smith
#set default args as -h , if no args:
if len(sys.argv) == 1: sys.argv[1:] = ["-h"]
Ich benutze optparse mich, aber wirklich, wie die Richtung Simon Willison nimmt mit seinem kürzlich eingeführten optfunc Bibliothek. Es funktioniert durch:
"eine Funktion introspecting Definition (einschließlich seiner Argumente und die Standardwerte) und mit die zu einer Befehlszeile zu konstruieren Argument-Parser. "
So zum Beispiel dieser Funktionsdefinition:
def geocode(s, api_key='', geocoder='google', list_geocoders=False):
wird in diesem optparse Hilfetext eingeschaltet:
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, zum Beispiel:
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 worden Umwickeln um diese Similiar Dinge weniger ausführlich zu machen. (Eg; machen „-h“ implizite)
Pocoo klicken intuitiver ist, erfordert weniger vorformulierten, und ist mindestens so mächtig wie argparse.
Die einzige Schwäche, die ich bisher erlebt habe ist, dass man nicht viel Anpassung Seiten zu helfen, tun können, aber das ist in der Regel nicht erforderlich, und docopt wie die klare Wahl scheint, als es ist.
Sie können in einem kleinen Python-Modul interessiert sein I Umgang mit Kommandozeilenargumenten noch einfacher (Open Source und kostenlos zu benutzen) machen geschrieben - Commando
ich empfehlen, sich unter docopt als einfache Alternative zu diesen anderen.
docopt ist ein neues Projekt, das durch Analysieren Ihrer --help Usage-Meldung arbeitet anstatt dass man alles selbst implementieren. Sie müssen nur Ihre Nutzungsmeldung im POSIX-Format setzen.
Eine weitere Option ist argh . Es baut auf argparse, und lassen Sie schreiben Dinge 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 generieren und so weiter, und Sie können Dekorateure zusätzliche Anleitung geben verwenden, wie der arg-Parsing funktionieren soll.
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
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
Hilfetext:
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