Python Command Line Parsing Tutorial

Das Parsing for Command Line Argumente wurde früher in der Standard -Python -Bibliothek „ArgParse“ aufgenommen. Durch die Ermöglichung der Benutzereingabetupferwerte, die irgendwie analysiert und anschließend verwendet werden, „argParse“. Es bietet Flexibilität und wiederverwendet Ihren Code anstelle der manuellen Einstellung von Variablen als Teil des Codes.

Beispiel 1

Wir werden den nachfolgenden Code implementieren, um die Struktur und Verwendung einer Argparse -Bibliothek anzuzeigen.

Argparse importieren
Parser = argParse.ArgumentParser ()
Parser.add_argument ('-name', type = str, fordert = true)
args = parser.Parse_args ()
print ('hi,', args.Name)

Die "ArgParse" -Bibliothek würde zu Beginn des Code importiert. Der Parser wird von argumentParser () initialisiert, sodass wir mit dem Hinzufügen von benutzerdefinierten Parametern beginnen können. Verwenden Sie Parser.add_argument () Funktion zum Hinzufügen der gewünschten Argumente. Der "Name", "Typ" und "Erforderlich" werden als Argumente dieser Methode angegeben. Das "Erforderliche" Attribut ist ein Boolescher. Wir setzen den Wert des Arguments "Typ" als "Str" und "erforderlich" als "wahr". Die Funktion parse_args () wird aufgerufen. Die „Argumente.Name ”Attribut“ scheint der Name eines solchen Arguments zu sein, das mit der Funktion add_argument () identifiziert wurde.

Der vorherige Code erzeugt diese Art von Ergebnis wie gezeigt:

Wie wir sehen können, wird dies einen Fehler aufwerfen, da das Argument „Name“ erforderlich ist, aber es fehlt, fehlt jedoch. Wenn wir den Namen hinzufügen, erhalten wir die folgende Ausgabe:

Beispiel 2

Es gibt bestimmte Situationen, in denen wir nicht über den Namen argumentieren möchten, der für die Flagge verwendet werden könnte. Man kann einen Positionsparameter verwenden, um zu vermeiden.

Hier werden wir die Positionsargumente multiplizieren, indem wir die Parameter angeben.

Argparse importieren
Parser = argParse.ArgumentParser ()
Parser.add_argument ('-i', type = int, fordert = true)
Parser.add_argument ('-j', type = int, fordert = true)
args = parser.Parse_args ()
Produkt = args.i * args.J
print ('Produkt:', Produkt)

Der Parser wurde erstmals nach dem Importieren des Argparse -Moduls erzeugt. Die Variablen "I" und "J", zwei Argumente vom Typ Ganzzahl, die dann wahr sein müssen, wurden dann hinzugefügt. Danach werden Produktformeln nach Analyse der Parameter angewendet. Wir verwenden die Print () -Funktion, um das Produkt anzuzeigen.

Beispiel 3

In diesem Fall machen wir Multiplikation, ohne die Positionsparameter anzugeben.

Argparse importieren
Parser = argParse.ArgumentParser ()
Parser.add_argument ('k', type = int)
Parser.add_argument ('l', type = int)
args = parser.Parse_args ()
Produkt = args.k * args.l
print ('Produkt:', Produkt)

Erstens wurde der Parser das Integrieren des „ArgParse“ -Pakets anfänglich mit der ArgumentParser () -Methode konstruiert. Das "K" und "L" sind die beiden Argumente, die mit dem Ganzzahltyp angegeben sind. Obwohl Positionsargumente eine Befehlszeile klarer halten, geben wir hier nicht das „Erforderliche“ Attribut an. Danach wurden die angegebenen Parameter mit Hilfe der Parse_args () -Methode analysiert. Wir werden eine Produktfunktion unter Verwendung der Variablen „K“ und „L“ definieren. Um das Ergebnis zu zeigen, werden wir die Druckanweisung verwenden.

Beispiel 4

Optionale Argumente sind möglicherweise hilfreich, wenn wir einem Benutzer eine gewählte Wahl zur Verfügung stellen möchten, um Funktionen zu verwenden. Wir geben einfach den optionalen Parameter mit der Funktion add_argument () an, um ein optionales Argument hinzuzufügen.

Argparse importieren
Parser = argParse.ArgumentParser ()
Parser.add_argument ('-name', type = str, fordert = true)
Parser.add_argument ('-class', type = int)
args = parser.Parse_args ()
Wenn args.Klasse:
drucken (args.Name 'in', Args.Klasse, 'Klasse.'))
anders:
print ('Hey,', Args.Name + '!'))

Wir starten das Programm, indem wir die "ArgParse" -Bibliothek einbeziehen. Wir haben zuerst einen Parser anhand der ArgumentParser () -Methode eingerichtet, um zwei Parser -Argumente auszuführen. Jetzt werden wir die Funktion add_argument () aufrufen, um verschiedene Parameter hinzuzufügen. Diese Argumente enthalten zwei Variablen, Name und Klasse, bei denen das Argument „Name“ vom Typ "String" enthält und es wahr sein muss. Der Parameter „Klasse“ enthält den Typ "Ganzzahl".

Darüber hinaus verwenden wir nach der Parsen der Parameter den Zustand „If-ELSE“. Im Inneren haben wir die Print () -Funktion zweimal angewendet, einmal nach der Anweisung "if" und erneut nach der Anweisung "else", um die Ausgabe darzustellen. Die Argumente in Print () -Methoden variieren in beiden Fällen. Die Argumente in der ersten Print () -Funktion enthalten Name und Klasse. Gleichzeitig umfassen die Argumente, die in der Methode der zweiten Print () vorgestellt wurden.Name.

Nach dem Ausführen des Code erhalten wir die beiden unten angegebenen Ausgänge. Wir erhalten die erste Ausgabe, nachdem wir die optionalen Argumente und die zweite ohne die optionalen Argumente verwendet haben.

Aus den beiden vorherigen Ausgängen können wir feststellen, dass es einen Unterschied zwischen beiden Ausgaben gibt, da die optionalen Argumente in einem und nicht in den anderen verwendet werden.

Beispiel 5

Stellen wir uns vor, wir wenden den Benutzer anstatt den Benutzer aufzu fordern. Da wir nicht vorhersagen können, wie viele Werte ein Benutzer eingeben wird, ist es nicht erforderlich, ein neues Argument für jeden neuen Wert zu erstellen. Die Nummer (oder Eingaben), das das Argument akzeptieren kann.

Wir werden mehrere Eingabeargumente bereitstellen und das Ergebnis in diesem Fall drucken.

Argparse importieren
Parser = argParse.ArgumentParser ()
Parser.add_argument ('-values', type = int, nargs = 5)
args = parser.Parse_args ()
sum = sum (args.Werte)
print ('sum:', sum)

Wir haben initiiert, indem wir die "ArgParse" -Bibliothek importieren, die für die Ausführung des vorherigen Codes erforderlich ist. Wir werden einen Parser erstellen, indem wir die ArgumentParser () -Methode aufrufen. Diese Funktion enthält kein Argument. Als nächstes wird die Methode add_argument () aufgerufen. Diese Methode hat drei Parameter. Bei mehreren Eingabeargumenten haben wir das Attribut „Nargs“ in der Methode add_argument () verwendet. Jetzt werden wir die Funktion parse_args () zum Parsen nennen. Wir wenden die Summe () -Methode an, um die Summe der Werte zu finden. Um die Ausgabe darzustellen, haben wir die Druckanweisung verwendet.

Beispiel 6

Was ist, wenn wir die Summe von mehr Eingängen als fünf Werte wollen?? Wir können dazu führen, dass das Argument eine beliebige Anzahl von Werten akzeptiert, indem wir Nargs = "+" einstellen.

Argparse importieren
Parser = argParse.ArgumentParser ()
Parser.add_argument ('-values', type = int, nargs = '+')
args = parser.Parse_args ()
sum = sum (args.Werte)
print ('sum:', sum)

Wir können das Skript mit fast einer beliebigen Anzahl von Eingabetwerten ausführen. Hier verwenden wir den gleichen Code wie früher, aber in diesem Code werden wir 'nargs' = 5 in 'nargs' = '+' ändern.

Abschluss

Dieser Artikel umfasste eine Vielzahl von Python-Befehlszeilen-Parsing-Techniken wie einfache Argumente, Positionsargumente, optionale Argumente und mehrere Eingabebereiche. Es lieferte auch Beispiele, um festzustellen, wie sich der Ausgang ändert, je nachdem, ob ein Argument verwendet wird oder nicht. Wir können Beispiele verwenden, um zu untersuchen und zu verstehen, ob ein Argument unter bestimmten Umständen angemessen ist.