Python

So analysieren Sie Argumente in der Befehlszeile in Python in

So analysieren Sie Argumente in der Befehlszeile in Python in
Die Befehlszeilenargumente werden verwendet, um Daten im Programm zum Zeitpunkt der Programmausführung zu übergeben. Diese Funktion ist in den meisten gängigen Programmiersprachen verfügbar. Aber die Verarbeitung von Befehlszeilenargumenten ist für verschiedene Sprachen unterschiedlich. Die Argumentwerte werden mit dem Programmnamen zum Zeitpunkt der Ausführung des Programms angegeben. Python-Sprache unterstützt diese Funktion. Wie Befehlszeilenargumente in Python-Skripten geparst werden, wird in diesem Artikel gezeigt.

Analysieren von Befehlszeilenargumenten mit sys Modul

Befehlszeilenargumente werden mit in einer Liste gespeichert sys Modul.  sys.argv wird verwendet, um die Werte der Kommandozeilenargumente zu lesen. Die Gesamtzahl der Befehlszeilenargumente kann mit gezählt werden len() Funktion. Die Verwendung dieses Moduls ist im Teil des Artikels beschrieben.

Beispiel 1: Anzahl der Argumente und Argumentwerte lesen

Erstellen Sie eine Datei mit dem folgenden Python-Skript.  Hier werden die Kommandozeilenargumentwerte in der Variablen gespeichert, argv wie andere Sprachen. len() -Methode zählt die Gesamtzahl der übergebenen Argumente zum Zeitpunkt der Ausführung des Skripts passed. Argumentwerte werden als Array am Ende des Skripts ausgegeben.

# sys-Modul importieren
Importsystem
# Gesamtzahl der Argumente drucken
print('Gesamtargumente:', len(sys.argv))
print('Die Argumentwerte sind:', str(sys.argv))

Ausgabe:

Das obige Skript wird hier mit vier Befehlszeilenargumenten ausgeführt. Das erste Argument ist der Skriptname und andere sind numerische Werte. Die folgende Ausgabe erscheint nach dem Ausführen des Skripts.

Beispiel 2: Argumentwerte mit der Schleife lesen

Im vorherigen Beispiel werden Argumentwerte als Array ausgegeben. Erstellen Sie eine Datei mit dem folgenden Skript, um den Typ der Argumentvariablen zu drucken und jeden Argumentwert in jeder Zeile zu drucken, indem Sie die for-Schleife verwenden.

# sys-Modul importieren
Importsystem
# Geben Sie den Typ der Variablen aus, sys.argv
print(type(sys.argv))
# Jedes Befehlszeilenargument in jeder Zeile ausgeben
print('Die Befehlszeilenargumente sind:')
für ich im sys.Argument:
drucken(i)

Ausgabe:

Das obige Skript wird ausgeführt, indem drei Argumente mit dem Skriptnamen bereitgestellt werden. Die folgende Ausgabe erscheint nach dem Ausführen des Skripts.

Analysieren von Befehlszeilenargumenten mit dem getopt-Modul

Getopt -Modul wird verwendet, um Befehlszeilenargumente mit den Optionen zu analysieren. getopt() Methode dieses Moduls wird zum Lesen der Argumente verwendet. Diese Methode hat drei Argumente. Die ersten beiden Argumente sind obligatorisch und das letzte Argument ist optional. Die Verwendung dieser Argumente ist unten angegeben.

Argumente: Es enthält das Argument aus dem Befehlszeilenargument.

kurze_option: Es kann ein beliebiger Buchstabe sein, der mit dem Argument übergeben wird.

lange_option: Es wird verwendet, um lange Optionen mit zwei Teilen zu definieren. Dies sind der Optionsname und der Optionswert.

Syntax: getopt.getopt(args, kurze_option, [lange_option])

Beispiel 3: Lesen von Argumentwerten mit kurzen getopt-Optionen

getopt Modul enthält mehr Funktionen als sys Modul. Das folgende Beispiel zeigt, wie kurze Optionen in . verwendet werden können getopt() Methode. argv Variable speichert die Befehlszeilenargumente durch Weglassen des Skriptnamens. Als nächstes werden zwei Optionen in der . definiert getopt() Methode, die mit dem Argument zur Laufzeit verwendet werden kann. Wenn ein Fehler auftritt, wird eine Fehlermeldung angezeigt.

# Getopt-Modul importieren
getopt importieren
# sys-Modul importieren
Importsystem
# Argumentvariable ohne Skriptnamen speichern script
argv = sys.argv[1:]
 
Versuchen:
# Definiere getopt short-Optionen
Optionen, Argumente = getopt.getopt(argv, 'x:y:')
# drucke die Optionen und das Argument
Drucken (Optionen)
drucken (Argumente)
 
außer getopt.GetoptError:
# Drucken Sie die Fehlermeldung, wenn die falsche Option angegeben ist
print('Die falsche Option ist angegeben')
# Beende das Skript
sys.Ausgang(2)

Ausgabe:

Führen Sie das Skript ohne Argumente aus, Argumente mit korrekten Optionen und Argumente mit falscher Option.

Beispiel 4: Lesen von Argumentwerten mit kurzen und langen getopt-Optionen

Dieses Beispiel zeigt, wie sowohl kurze als auch lange Optionen mit den Argumentwerten verwendet werden können. Es fügt zwei Zahlen hinzu, wenn '-ein' oder '-hinzufügen' wird als Option verwendet und subtrahiert zwei Zahlen, wenn '-s' oder '-unter' wird als Option zur Laufzeit verwendet.

# Getopt-Modul importieren
getopt importieren
# sys-Modul importieren
Importsystem
# Argumentvariable ohne Skriptnamen speichern script
argv = sys.argv[1:]
# Ergebnisvariable initialisieren
Ergebnis=0
 
Versuchen:
 
# Definiere getopt Short- und Long-Optionen
Optionen, Argumente = getopt.getopt(sys.argv[1:], 'a:s', ['add=','sub='])
 
# Lesen Sie jede Option mit der for-Schleife
für opt, arg in Optionen:
# Berechnen Sie die Summe, wenn die Option -a oder --add . ist
wenn Opt-in ('-a', '--add'):
Ergebnis = int(argv[1]) + int(argv[2])
# Berechnen Sie die Sonnentraktion, wenn die Option -s oder --sub . ist
elif-Opt-in ('-s', '--sub'):
Ergebnis = int(argv[1]) - int(argv[2])
 
print('Ergebnis = ', Ergebnis)
außer getopt.GetoptError:
# Drucken Sie die Fehlermeldung, wenn die falsche Option angegeben ist
print('Die falsche Option ist angegeben')
# Beende das Skript
sys.Ausgang(2)

Ausgabe:

Führen Sie das Skript ohne Argumente und Optionen aus, Argumente mit Option '-a', Argumente mit Option '-s' und Argumente mit falscher Option.

Analysieren von Befehlszeilenargumenten mit dem argparse-Modul

Das Argparse-Modul enthält viele Optionen zum Lesen von Befehlszeilenargumenten. Standardargumentwerte, das Argument mit dem Datentyp, Positionsargumente, Hilfenachricht usw. kann von diesem Modul bereitgestellt werden.

Beispiel 5: Kommandozeilenargumente mit argparse lesen

Das folgende Beispiel zeigt die Verwendung von argparse Modul zum Lesen von Befehlszeilenargumenten. Hier sind zwei Optionen zum Lesen von Kommandozeilenargumenten definiert defined. Diese sind '-n' oder '-name' und '-e' oder '-e-Mail'. Wenn der Benutzer ein falsches Argument angibt, wird ein Fehler mit einer Verwendungsmeldung angezeigt. Wenn der Benutzer die richtigen Optionen mit den Argumenten angibt, werden die Argumentwerte angezeigt. Wenn der Benutzer das Skript mit der Option '-help' ausführt, wird die erforderliche Meldung zum Ausführen des Skripts angezeigt.

# Argparse-Modul importieren
Argparse importieren
# sys-Modul importieren
Importsystem
# Funktion deklarieren, um Befehlszeilenargumente zu definieren
def readOptions(args=sys.argv[1:]):
Parser = argparse.ArgumentParser(description="Die Listen der Parsing-Befehle.")
Parser.add_argument("-n", "--name", help="Geben Sie Ihren Namen ein.")
Parser.add_argument("-e", "--email", help="Geben Sie Ihre E-Mail ein.")
opts = Parser.parse_args(args)
Rückkehroptionen
# Rufen Sie die Funktion auf, um die Argumentwerte zu lesen
options = readOptions(sys.argv[1:])
drucken (Optionen.Name)
drucken (Optionen.Email)

Ausgabe:

Führen Sie das Skript mit der falschen Option, der richtigen Option und der Hilfeoption aus.

Fazit:

In diesem Tutorial werden verschiedene Möglichkeiten zum Lesen von Befehlszeilenargumenten anhand von drei Python-Modulen erläutert. Ich hoffe, dieses Tutorial wird dem Programmierer helfen, der Daten mit Befehlszeilenargumenten in Python lesen möchte.

Video des Autors ansehen: hier

Schlacht um Wesnoth 1.13.6 Entwicklung veröffentlicht
Schlacht um Wesnoth 1.13.6, das letzten Monat veröffentlicht wurde, ist die sechste Entwicklungsversion im 1.13.x-Serie und bietet eine Reihe von Verb...
So installieren Sie League of Legends auf Ubuntu 14.04
Wenn Sie ein Fan von League of Legends sind, dann ist dies eine Gelegenheit für Sie, League of Legends zu testen. Beachten Sie, dass LOL von PlayOnLin...
Installieren Sie das neueste OpenRA-Strategiespiel auf Ubuntu Linux
OpenRA ist eine Libre/Free Real Time Strategy Game Engine, die die frühen Westwood-Spiele wie den Klassiker Command & Conquer: Red Alert Red nachbilde...