Python ist eine Hochsprache, die für allgemeine Codes und nicht für bestimmte Probleme entwickelt wurde. Wir können es für allgemeine Zwecke verwenden, z. B. zum Erstellen von Websites mit Python oder zum Analysieren der Daten mit dieser Python-Sprache. Die „Python“-Programmierung liefert auch die command_line-Argumente. 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 in jedem Programm als den Wert definieren, der über die Eingabeaufforderung übergeben wird, die als Befehlszeilenargumente bezeichnet wird. In diesem Handbuch werden wir das Befehlszeilenargument in der „Python“-Programmierung besprechen.
Methoden für Befehlszeilenargumente in Python
- Durch die Verwendung von „sys.argv“
- Durch die Verwendung des Moduls „argparse“.
- Durch Nutzung des „getopt“-Moduls
Wir werden alle Methoden in diesem Leitfaden ausführlich erklären und auch die praktische Demonstration all dieser Methoden zeigen.
Beispiel Nr. 01: Durch die 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. Wir importieren also „sys“ und deklarieren und initialisieren dann die Variable „num“ mit „len(sys.argv)“. Das „argv“ wird die Liste der Zeichenfolgenwerte sein, die die Argumente sind, zu denen unsere Befehlszeile wird. „len“ steht für die Länge der übergebenen Argumente. In der Variable „num“ wird also die Anzahl der Werte gespeichert, die auf dem Terminal als Kommandozeile übergeben werden.
Wir zeigen auch die Argumentnummern an, die mit „print“ übergeben werden. Darunter setzen wir „sys.argv[0]“ in die Druckanweisung. Das „argv“ enthält immer den Programmnamen oder Codedateinamen. Der Name der von uns erstellten Datei wird also auf dem Terminal gerendert. Danach drucken wir die Argumente, die auf dem Terminal übergeben werden. Es werden alle Zahlen ausgegeben, die wir als Befehlszeilenargumente auf dem Konsolenbildschirm übergeben haben.
Darunter haben wir eine for-Schleife definiert und dort eine Variable „a“ deklariert, deren Wertebereich zwischen „1“ und der Länge des in „num“ abgelegten argv liegt. Geben Sie alle Argumente auf der Konsole aus. „argv[a]“ enthält alle command_line-Argumente. Es zeigt sie auch auf der Konsole an. Jetzt initialisieren wir „sum“, weil wir die Summe aller Werte berechnen wollen, die wir zum Zeitpunkt der Ausführung auf dem Terminal übergeben.
Wir verwenden wieder die „for“-Schleife und übergeben den Bereich. Aber dieses Mal berechnen wir die Summe all jener Werte, die wir an das Terminal weitergegeben haben. Diese Summe wird in der Variable „Summe“ gespeichert. Dann drucken wir auch die Summe aller Werte, die wir zum Zeitpunkt der Ausführung auf dem Terminal übergeben.
importieren sysAuf eins = nur ( sys . argv )
drucken ( 'Gesamtzahl der hier übergebenen Argumente:' , Auf eins )
drucken ( ' \n Name der Python-Datei:' , sys . argv [ 0 ] )
drucken ( ' \n Argumente, die wir weitergegeben haben:' , Ende = ' ' )
zum a in Angebot ( 1 , Auf eins ) :
drucken ( sys . argv [ a ] , Ende = ' ' )
Summe = 0
zum ich in Angebot ( 1 , Auf eins ) :
Summe + = int ( sys . argv [ ich ] )
drucken ( ' \n \n Die Summe der übergebenen Argumente: ' , Summe )
Auf dem Terminal geben wir zuerst das Schlüsselwort „run“ ein. Platzieren Sie dann den Dateinamen zusammen mit der richtigen Erweiterung und übergeben Sie hier die Befehlszeilenargumente. Es zeigt also alle Zeilen an, wie wir sie im obigen Code definiert haben. Es rendert zuerst die Länge der Befehlszeilenargumente und dann den Namen der Datei. Danach rendert es alle Befehlszeilenargumente und auch die Summe von allen.
Beispiel # 02: Durch die argparse-Methode
Nun verwenden wir in diesem Beispiel die Methode „argparse“. Wir importieren zuerst den „argparse“. Also werden wir auf die Variablen und Funktionen 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 „description“ die „data“-Variable, in der wir die Nachricht gespeichert haben, die wir anzeigen möchten, und wir stecken all diese in die „my_parser“-Variable. Wir setzen auch die „parse.args()“ an das Ende.
importieren argparseDaten = 'Wir verwenden hier die argparse-Methode'
mein_parser = argparse. ArgumentParser ( Bezeichnung = Daten )
mein_parser. parse_args ( )
Sehen Sie sich das Ergebnis unten an. Wenn wir „-h“ als Kommandozeilenargument übergeben, rendert es zuerst die Nachricht, die wir in der „data“-Variable gespeichert haben, und zeigt auch das „optionale Argument“, da dieses „h“ die Hilfemeldung anzeigt. Wenn wir „-o“ als Befehlszeilenargument eingeben, wird eine Fehlermeldung ausgegeben, dass es sich um ein nicht erkanntes Argument handelt.
Beispiel Nr. 03: Durch die getopt-Methode
Hier ist die letzte Methode, die wir in diesem Code verwenden. Wir importieren „sys“ sowie „getopt“ in diesen Code. Dieses „getopt“ ist der Parser, den wir für die Kommandozeilenargumente verwendet haben. Dann haben wir in der Variablen „argumentList“ „sys.argv[1:]“ übergeben, 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 hier den „Versuch“, der den Fehler überprüft. Danach analysieren wir die Argumente. Der „getopt“ bietet sowohl kurze als auch lange Optionen, zusammen mit der Option, einen Wert zu benennen. Danach überprüfen wir alle Argumente, die wir als Befehlszeilenargumente übergeben. Wenn das Befehlszeilenargument „-h“ oder „–Help“ ist, wird die darunter angegebene Nachricht ausgegeben. Wenn das Befehlszeilenargument „-m“ oder „—My_file“ ist, wird die Nachricht angezeigt, die danach geschrieben wird.
Wenn das Befehlszeilenargument „-o“ oder „–Output“ ist, wird auch die Nachricht angezeigt, die wir hier danach geschrieben haben. Wenn das Befehlszeilenargument nicht aus allen oben genannten stammt, wird die Fehlermeldung angezeigt, da wir die Datei „getopt. Fehler“ im Code.
importieren gekrönt , sysArgumentliste = sys . argv [ 1 : ]
meine_optionen = 'Nacht:'
neue_lange_optionen = [ 'Hilfe' , 'Meine Datei' , 'Ausgabe='
Versuchen :
Argumente , Werte = gekrönt . gekrönt ( Argumentliste , meine_optionen , neue_lange_optionen )
zum mein_Argument , mein_Wert in Argumente:
wenn mein_Argument in ( '-h' , '--Hilfe' ) :
drucken ( 'Hilfe anzeigen' )
elf mein_Argument in ( '-m' , '--Meine Datei' ) :
drucken ( 'Dateiname wird angezeigt:' , sys . argv [ 0 ] )
elf mein_Argument in ( '-Ö' , '--Ausgabe' ) :
drucken ( ( 'Spezialausgabemodus aktivieren (% s)' ) % ( mein_Wert ) )
außer gekrönt . Error wie irren:
drucken ( Str ( irren ) )
Hier sehen Sie, dass, wenn wir „-h“ als Befehlszeile eingeben, dieselbe Nachricht angezeigt wird, die wir in den Code geschrieben haben. Wenn wir zwei Befehlszeilenargumente als „–Help“ und auch „-m“ eingeben, werden unten zwei Meldungen angezeigt. Im Kommandozeilenargument „-o“ haben wir auch den String übergeben, der auch in der Meldung angezeigt wird.
Fazit
Wir haben diesen Leitfaden bereitgestellt, um Ihnen beim Erlernen des Konzepts der „Befehlszeilenargumente“ in „Python“ zu helfen. Wir haben das „Befehlszeilenargument“ untersucht und auch hier drei Methoden erklärt. Wir haben das Befehlszeilenargument erklärt, bei dem die Werte zusammen mit dem Programmnamen zum Zeitpunkt der Ausführung über die Eingabeaufforderung an das Programm übergeben werden.