Python -Befehlszeilenargumente

Python ist eine hochrangige Sprache, die für allgemeine Codes und nicht für ein bestimmtes Problem ausgelegt ist. Wir können es für allgemeine Zwecke verwenden, wie Websites mithilfe von Python oder die Analyse der Daten mithilfe dieser Python -Sprache. Die Programmierung „Python“ enthält auch die Argumente command_line. Die Befehlszeilenargumente sind die Argumente, die wir auf der Konsole oder dem Terminal eines beliebigen Betriebssystems angegeben haben, nachdem wir den Namen der Codedatei zusammen mit der Dateierweiterung erwähnt haben. Wir können es auch als in jedem Programm definieren. In diesem Leitfaden werden wir das Argument der Befehlszeilen in der Programmierung „Python“ diskutieren.

Methoden für Befehlszeilenargumente in Python

• Durch die Verwendung von „sys.argv ”
• Durch die Verwendung des Argparse -Moduls
• Durch die Verwendung des "getopt" -Moduls

Wir werden alle Methoden in diesem Leitfaden ausführlich erläutern und auch die praktische Demonstration all dieser Methoden zeigen.

Beispiel # 01: nach sys.Argv -Methode

Wir machen diese Python -Codes in der "Spyder" -App. Wir können auf Befehlszeilenvariablen und -funktionen zugreifen, indem wir das System importieren. Also importieren wir "sys" und deklarieren und initialisieren die "Num" -Variable mit dem "len (sys sys".argv) ”. Das „Argv“ wird die Liste der Zeichenfolgenwerte sein, die die Argumente sind, die unsere Befehlszeile werden wird. "Len" repräsentiert die Länge der Argumente, die übergeben werden. In der Variablen „Num“ die Anzahl der an der Terminal übergebenen Werte, während die Befehlszeile gespeichert ist.

Wir zeigen auch diese Argumentnummern an, die mit dem „Druck“ übergeben werden,. Darunter setzen wir das „System.argv [0] “in der Print -Anweisung. Der „Argv“ enthält immer den Programmnamen oder den Code -Dateinamen. Der Name der von uns erstellten Datei wird also auf dem Terminal gerendert. Danach drucken wir diese Argumente, die am Terminal weitergegeben werden. Es wird alle Zahlen drucken, die wir als Befehlszeilenargumente auf dem Konsolenbildschirm übergeben haben.

Darunter haben wir A für Schleife definiert und eine Variable "A" dort deklariert, deren Bereich zwischen „1“ bis zur Länge des Argv ist, die in „Num“ gespeichert ist. Drucken Sie alle Argumente auf der Konsole aus. "Argv [a]" enthält alle Argumente command_line. Es zeigt sie auch auf der Konsole an. Jetzt initialisieren wir "Summe", weil wir die Summe aller Werte berechnen wollen, die wir zum Zeitpunkt der Ausführung am Terminal verabschieden werden.

Wir verwenden wieder die „für“ -Schloop und bestehen die Reichweite. Aber diesmal berechnen wir die Summe all dieser Werte, die wir am Terminal weitergegeben haben. Diese Summe wird in der Variablen „Sum“ gespeichert. Dann drucken wir auch die Summe aller Werte, die wir zum Zeitpunkt der Ausführung am Terminal verabschieden werden.

Importsystem
num = len (sys.argv)
print ("Gesamtargumente hier verabschiedet:", num)
print ("\ nname der Python -Datei:", sys.argv [0])
print ("\ nargumente, die wir bestanden haben:", End = "")
für eine Reichweite (1, num):
Druck (sys.argv [a], end = "")
Sum = 0
für i in Reichweite (1, num):
Sum += int (sys.argv [i])
print ("\ n \ n der Summe der Argumente übergeben:", Summe)

Auf dem Terminal setzen wir zuerst das Keyword "Run". Platzieren Sie dann den Dateinamen zusammen mit der richtigen Erweiterung und übergeben Sie die Befehlszeilenargumente hier. Es zeigt also alle Zeilen an, wie wir im obigen Code definiert haben. Es macht zuerst die Länge der Befehlszeilenargumente und dann den Namen der Datei. Danach rendert es alle Befehlszeilenargumente und macht auch die Summe von allen von ihnen.

Beispiel # 02: nach ArgParse -Methode

Jetzt verwenden wir in diesem Beispiel die „ArgParse“ -Methode. Wir importieren zuerst den "ArgParse". Wir werden also auf die Variablen und die Funktion davon zugreifen. Wir initialisieren eine "Daten" -Variable und speichern eine Zeile, die wir in unserem Code verwenden werden. Danach initialisieren wir einen „Parser“ und übergeben in „Beschreibung“ die Variable „Daten“, in der wir die Nachricht gespeichert haben, die wir anzeigen möchten. Wir setzen auch den „Parse“.args () “am Ende.

Argparse importieren
Data = "Wir verwenden die ArgParse -Methode hier"
my_parser = argParse.ArgumentParser (Beschreibung = Daten)
my_parser.Parse_args ()

Schauen Sie sich das Ergebnis unten an. Wenn wir als das Argument der Befehlszeilen „-h“ übergeben, wird zunächst die Nachricht, die wir in der Variablen „Daten“ gespeichert haben. Wenn wir "-o" als das Argument der Befehlszeilen einstellen, macht es eine Fehlermeldung, dass es sich um ein nicht erkanntes Argument handelt.

Beispiel # 03: Durch GetOpt -Methode

Hier ist die letzte Methode, die wir in diesem Code verwenden. Wir importieren "sys" sowie "getopt" in diesem Code. Dieser „Getopt“ ist der Parser, den wir für die Befehlszeilenargumente verwendet haben. Dann haben wir in der Variablen „Argumentlist“ das „SYS übergeben.Argv [1:] “Um das erste Argument zu entfernen, das wir in der Befehlszeile übergeben. Wir initialisieren die "my_option" mit dem "HMO:".

Danach initialisieren wir die Variable "my_long_option". Wir verwenden den „Versuch“ hier, um den Fehler zu überprüfen. Danach analysieren wir die Argumente. Das „Getopt“ bietet sowohl kurze als auch lange Optionen sowie die Option, einen Wert zu benennen. Danach überprüfen wir alle Argumente, die wir als Befehlszeilenargumente übergeben werden. Wenn das Argument der Befehlszeilen „-h“ oder „-Help“ lautet, wird die unten angegebene Nachricht gedruckt, die darunter angegeben ist. Wenn das Befehlszeilenargument "-m" oder "-my_file" ist, wird die danach geschriebene Nachricht angezeigt.

Wenn das Argument des Befehlszeilens "-o" oder "-output" lautet, wird auch die Nachricht angezeigt, die wir hier geschrieben haben. Wenn das Argument der Befehlszeilen nicht aus all den oben genannten stammt, wird die Fehlermeldung angezeigt, da wir das „getopt. Fehler ”im Code.

Import Getopt, sys
ArgumentList = sys.Argv [1:]
my_options = "hmo:"
new_long_options = ["help", "my_file", "output ="
versuchen:
Argumente, Werte = getopt.getopt (ArgumentList, my_options, new_long_options)
Für my_argument, my_Value in Argumenten:
Wenn my_argument in ("-h", "-help"):
print ("Hilfe anzeigen")
elif my_argument in ("-m", "--my_file"):
print ("Datei_Name anzeigen:", sys.argv [0])
elif my_argument in ("-o", "-output"):
print (("Spezialausgangsmodus aktivieren ( % s)") % (my_value))
außer Getopt.Fehler wie ERR:
print (str (arr))

Hier sehen Sie das, wenn wir „-h“ als Befehlszeile einfügen, zeigt dieselbe Nachricht, die wir im Code geschrieben haben. Wenn wir zwei Befehlszeilenargumente als "-Help" und "-m" einlegen, werden unten zwei Nachrichten angezeigt. Im Befehlszeilenargument "-O" haben wir auch die Zeichenfolge übergeben, die auch in der Nachricht angezeigt wird.

Abschluss

Wir haben diesen Leitfaden zur Verfügung gestellt, um das Konzept der „Befehlszeilenargumente“ in „Python“ zu erlernen. Wir haben das Argument „Befehlszeilen“ untersucht und hier auch drei Methoden erklärt. Wir haben das Argument der Befehlszeilen erläutert, dass der Prozess der Übergabe der Werte zusammen mit dem Programmnamen zum Zeitpunkt der Ausführung über die Eingabeaufforderung an das Programm weitergegeben wird.