Wie man Argumente zur Befehlszeile in Python analysiert

Die Befehlszeilenargumente werden verwendet, um Daten zum Zeitpunkt der Programmausführung im Programm zu übergeben. Diese Funktion ist in den meisten beliebten Programmiersprachen verfügbar. Die Verarbeitung von Befehlszeilenargumenten ist jedoch für verschiedene Sprachen unterschiedlich. Die Argumentewerte werden zum Zeitpunkt der Ausführung des Programms mit dem Programmnamen angegeben. Die Python -Sprache unterstützt diese Funktion. Wie Befehlszeilenargumente im Python-Skript analysiert werden, wird in diesem Artikel gezeigt.

Analyse des Befehlszeilenarguments mit Verwendung sys Modul

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

Beispiel 1: Lesen Sie die Anzahl der Argumente und Argumentenwerte

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

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

Ausgang:

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

Beispiel 2: Lesen von Argumentwerten unter Verwendung der Schleife

Im vorherigen Beispiel werden Argumentwerte als Array gedruckt. Erstellen Sie eine Datei mit dem folgenden Skript, um die Art der Argumentvariablen zu drucken und jeden Argumentwert in jeder Zeile zu drucken.

# SYS -Modul importieren
Importsystem
# Drucken Sie den Typ der Variablen, sys.argv
drucken (Typ (SYS.argv))
# Drucken Sie jedes Befehlszeilenargument in jeder Zeile aus
print ('Die Befehlszeilenargumente sind:')
denn ich in sys.argv:
drucken (i)

Ausgang:

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

Analyse des Befehlszeilenarguments mit GetOpt-Modul

Getopt Das Modul wird verwendet, um Befehlszeilenargumente mit den Optionen zu analysieren. getopt () Die 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 Verwendungen dieser Argumente sind unten angegeben.

Args: Es enthält das Argument aus dem Kommandozeilenargument.

Short_option: Es kann jeder Brief sein, der mit dem Argument passt.

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

Syntax: Getopt.getopt (args, Short_option, [long_option])

Beispiel 3: Lesen von Argumentwerten mit kurzen GetOpt -Optionen

Getopt Das 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, indem der Skriptname weggelassen wird. 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
# Argument Variable speichern und den Skriptnamen weglassen
argv = sys.Argv [1:]
versuchen:
# Definieren Sie GetOpt -kurze Optionen
Optionen, args = getopt.getopt (argv, 'x: y:')
# Die Optionen und das Argument drucken
Druck (Optionen)
drucken (args)
außer Getopt.Getopterror:
# Drucken Sie die Fehlermeldung, wenn die falsche Option bereitgestellt wird
drucken ('Die falsche Option ist bereitgestellt')
# Beenden Sie das Skript
sys.Ausgang (2)

Ausgang:

Führen Sie das Skript ohne Argument, Argumente mit korrekten Optionen und Argumenten mit der falschen Option aus.

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 wird zwei Zahlen hinzufügen, wenn '-A' oder '-hinzufügen' wird als Option verwendet und zwei Zahlen subtrahieren, wenn '-S' oder '-sub ' wird zur Laufzeit als Option verwendet.

# GetOpt -Modul importieren
Getopt importieren
# SYS -Modul importieren
Importsystem
# Argument Variable speichern und den Skriptnamen weglassen
argv = sys.Argv [1:]
# Die Ergebnisvariable initialisieren
Ergebnis = 0
versuchen:
# Definieren Sie GetOpt Short- und Long -Optionen
Optionen, args = getopt.Getopt (sys.argv [1:], 'a: s', ['add =', 'sub ='])
# Lesen Sie jede Option für die Schleife mit
Für OPT, ARG in Optionen:
# Berechnen Sie die Summe, wenn die Option -a oder --add ist
Wenn Sie sich ('-a', '--add') anschließen:
result = int (argv [1]) + int (argv [2])
# Berechnen Sie die Sonnenstruktur, wenn die Option -s oder -Subs ist
Elif Opt in ('-s', '-Sub'):
result = int (argv [1]) - int (argv [2])
print ('result =', result)
außer Getopt.Getopterror:
# Drucken Sie die Fehlermeldung, wenn die falsche Option bereitgestellt wird
drucken ('Die falsche Option ist bereitgestellt')
# Beenden Sie das Skript
sys.Ausgang (2)

Ausgang:

Führen Sie das Skript ohne Argumente und Optionen aus.

Parsing-Befehlszeilenargument mit Argparse-Modul analysieren

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

Beispiel 5: Lesen Befehlszeilenargumente mit ArgParse

Das folgende Beispiel zeigt die Verwendung von Argparse Modul zum Lesen des Befehlszeilenarguments. Hier werden zwei Optionen für das Lesen von Befehlszeilenargumenten definiert. Diese sind '-n' oder '-name' Und '-e' oder '-email'. Wenn der Benutzer ein falsches Argument angibt, wird ein Fehler mit einer Nutzungsnachricht angezeigt. Wenn der Benutzer mit den Argumenten korrekte Optionen bereitstellt, werden die Argumentwerte angezeigt. Wenn der Benutzer das Skript mit der Option "-Help" ausführt, wird die erforderliche Nachricht zum Ausführen des Skripts angezeigt.

# Argparse -Modul importieren
Argparse importieren
# SYS -Modul importieren
Importsystem
# Die Funktion deklarieren, um Befehlszeilenargumente zu definieren
Def Reseptions (args = sys.Argv [1:]):
Parser = argParse.ArgumentParser (Beschreibung = "Die Parsen -Befehle listen."))
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)
Return Opts
# Rufen Sie die Funktion auf, um die Argumentwerte zu lesen
Optionen = Readoptions (SYS.argv [1:])
Druck (Optionen.Name)
Druck (Optionen.Email)

Ausgang:

Führen Sie das Skript mit falscher Option, Option korrigieren und Option aus.

Abschluss:

In diesem Tutorial werden verschiedene Argumente für Befehlszeilen mit drei Python-Modulen untersucht. Ich hoffe, dieses Tutorial hilft dem Kodierer, der Daten mit den Befehlszeilenargumenten in Python lesen möchte.

Sehen Sie sich das Video des Autors an: Hier