Einfaches argparse-Beispiel gesucht: 1 Argument, 3 Ergebnisse

Question

Le site Dokumentation für die argparse python modul Das ist zwar ausgezeichnet, aber für mein kleines Anfängerhirn im Moment noch zu viel. Ich muss nicht in der Befehlszeile rechnen oder mich mit der Formatierung von Zeilen auf dem Bildschirm befassen oder Optionszeichen ändern. Alles, was ich tun möchte, ist "Wenn Arg A ist, tue dies, wenn B ist, tue das, wenn nichts davon zutrifft, zeige Hilfe und kündige" .

Answer 1

Um das zu ergänzen, was andere gesagt haben:

Normalerweise verwende ich den Parameter "dest", um einen Variablennamen anzugeben, und verwende dann "globals().update()", um diese Variablen in den globalen Namensraum zu stellen.

Verwendung:

$ python script.py -i "Hello, World!"

Code:

...
parser.add_argument('-i', '--input', ..., dest='inputted_variable',...)
globals().update(vars(parser.parse_args()))
...
print(inputted_variable) # Prints "Hello, World!"

Answer 2

Ich bin alle Beispiele und Antworten durchgegangen, und auf die eine oder andere Weise entsprachen sie nicht meinem Bedarf. Also werde ich ihr ein Szenario auflisten, bei dem ich mehr Hilfe brauche, und ich hoffe, dass dies die Idee besser erklären kann.

Ursprüngliches Problem

Ich muss ein Tool entwickeln, das eine Datei erhält, um sie zu verarbeiten, und es benötigt eine optionale Konfigurationsdatei, die zur Konfiguration des Tools verwendet werden kann.

Ich brauche also etwas wie das Folgende

mytool.py file.text -config config-file.json

Die Lösung

Hier ist der Lösungscode

import argparse

def main():
    parser = argparse.ArgumentParser(description='This example for a tool to process a file and configure the tool using a config file.')
    parser.add_argument('filename', help="Input file either text, image or video")
    # parser.add_argument('config_file', help="a JSON file to load the initial configuration ")
    # parser.add_argument('-c', '--config_file', help="a JSON file to load the initial configuration ", default='configFile.json', required=False)
    parser.add_argument('-c', '--config', default='configFile.json', dest='config_file', help="a JSON file to load the initial configuration " )
    parser.add_argument('-d', '--debug', action="store_true", help="Enable the debug mode for logging debug statements." )

    args = parser.parse_args()

    filename = args.filename
    configfile = args.config_file

    print("The file to be processed is", filename)
    print("The config file is", configfile)

    if args.debug:
        print("Debug mode enabled")
    else:
        print("Debug mode disabled")

    print("and all arguments are: ", args)

if __name__ == '__main__':
    main()

Ich werde die Lösung in mehreren Erweiterungen zeigen, um die Idee zu verdeutlichen

Erste Runde: Liste der Argumente

Alle Eingaben als Pflichteingaben auflisten, so dass das zweite Argument lautet

parser.add_argument('config_file', help="a JSON file to load the initial configuration ")

Wenn wir den Hilfebefehl für dieses Tool aufrufen, erhalten wir folgendes Ergebnis

(base) > python .\argparser_example.py -h
usage: argparser_example.py [-h] filename config_file

This example for a tool to process a file and configure the tool using a config file.

positional arguments:
  filename     Input file either text, image or video
  config_file  a JSON file to load the initial configuration

optional arguments:
  -h, --help   show this help message and exit

und wenn ich es wie folgt ausführe

(base) > python .\argparser_example.py filename.txt configfile.json

das Ergebnis wird sein

The file to be processed is filename.txt
The config file is configfile.json
and all arguments are:  Namespace(config_file='configfile.json', filename='filename.txt')

Aber die Konfigurationsdatei sollte optional sein, ich habe sie aus den Argumenten entfernt

(base) > python .\argparser_example.py filename.txt

Das Ergebnis wird sein:

usage: argparser_example.py [-h] filename config_file
argparser_example.py: error: the following arguments are required: c

Das bedeutet, dass wir ein Problem mit dem Werkzeug haben

Zweite Runde: Optimal gestalten

Um dies optional zu machen, habe ich das Programm wie folgt geändert

    parser.add_argument('-c', '--config', help="a JSON file to load the initial configuration ", default='configFile.json', required=False)

Das Ergebnis der Hilfe sollte sein

usage: argparser_example.py [-h] [-c CONFIG] filename

This example for a tool to process a file and configure the tool using a config file.

positional arguments:
  filename              Input file either text, image or video

optional arguments:
  -h, --help            show this help message and exit
  -c CONFIG, --config CONFIG
                        a JSON file to load the initial configuration

Wenn ich also das Programm ausführe

(base) > python .\argparser_example.py filename.txt

das Ergebnis wird sein

The file to be processed is filename.txt
The config file is configFile.json
and all arguments are:  Namespace(config_file='configFile.json', filename='filename.txt')

mit Argumenten wie

(base) > python .\argparser_example.py filename.txt --config_file anotherConfig.json

Das Ergebnis wird sein

The file to be processed is filename.txt
The config file is anotherConfig.json
and all arguments are:  Namespace(config_file='anotherConfig.json', filename='filename.txt')

Runde 3: Erweiterungen

um den Namen der Flagge zu ändern von --config_file zu --config Während wir den Variablennamen beibehalten, ändern wir den Code so, dass er Folgendes enthält dest='config_file' wie die folgenden:

parser.add_argument('-c', '--config', help="a JSON file to load the initial configuration ", default='configFile.json', dest='config_file')

und der Befehl lautet

(base) > python .\argparser_example.py filename.txt --config anotherConfig.json

Um die Unterstützung für ein Debug-Modus-Flag hinzuzufügen, müssen wir ein Flag in den Argumenten hinzufügen, um ein boolesches Debug-Flag zu unterstützen. Um dies zu implementieren, habe ich das Folgende hinzugefügt:

    parser.add_argument('-d', '--debug', action="store_true", help="Enable the debug mode for logging debug statements." )

wird der Werkzeugbefehl sein:

(carnd-term1-38) > python .\argparser_example.py image.jpg -c imageConfig,json --debug

das Ergebnis wird sein

The file to be processed is image.jpg
The config file is imageConfig,json
Debug mode enabled
and all arguments are:  Namespace(config_file='imageConfig,json', debug=True, filename='image.jpg')

Answer 3

Ein wirklich einfacher Weg, argparse zu benutzen und die '-h'/'--help'-Schalter zu ändern, um Ihre eigenen persönlichen Code-Hilfe-Anweisungen anzuzeigen, ist, die Standard-Hilfe auf False zu setzen, Sie können auch so viele zusätzliche .add_arguments hinzufügen, wie Sie möchten:

import argparse

parser = argparse.ArgumentParser(add_help=False)

parser.add_argument('-h', '--help', action='help',
                help='To run this script please provide two arguments')
parser.parse_args()

Ausführen: python test.py -h

Ausgabe:

usage: test.py [-h]

optional arguments:
  -h, --help  To run this script please provide two arguments

Answer 4

Wenn Sie faul genug sind, können Sie zusätzlich zu den vorhandenen Antworten ein Tool zur Codegenerierung namens protoargs . Es erzeugt Argumente Parser aus der Konfiguration. Für Python verwendet es argparse .

Konfiguration mit optionalem A und B :

syntax = "proto2";
message protoargs
{
    optional string A     = 1; // A param description
    optional string B     = 2; // B param description
}//protoargs

Konfiguration mit erforderlichem A und B :

syntax = "proto2";
message protoargs
{
    required string A     = 1; // A param description
    required string B     = 2; // B param description
}//protoargs

Konfiguration mit den Positionen A und B :

syntax = "proto2";
message protoargs
{
    required string A     = 1; // A param description
    required string B     = 2; // B param description
}//protoargs
message protoargs_links
{
}//protoargs_links

Jetzt sollten Sie nur noch laufen:

python ./protoargs.py -i test.proto -o . --py

Und verwenden Sie es (es ist möglich, hier andere Beispiele zu nehmen):

import sys
import test_pa

class ArgsParser:
    program = "test"
    description = "Simple A and B parser test."

    def parse(self, argv):
        self.config = test_pa.parse(self.program, self.description, argv)

    def usage(self):
        return test_pa.usage(self.program, self.description)

if __name__ == "__main__":
    parser = ArgsParser()

    if len(sys.argv) == 1:
        print(parser.usage())
    else:
        parser.parse(sys.argv[1:])

        if parser.config.A:
            print(parser.config.A)

        if parser.config.B:
            print(parser.config.B)

Wenn Sie mehr wollen - ändern Sie die Konfiguration, generieren Sie den Parser neu, verwenden Sie eine aktualisierte parser.config.

UPD: Wie in den Regeln erwähnt, muss ich angeben, dass dies mein eigenes Projekt ist.

Answer 5

Da Sie nicht klargestellt haben, ob die Argumente "A" und "B" positional oder optional sind, werde ich eine Mischung aus beidem machen.

Positionale Argumente sind standardmäßig erforderlich. Wird keines angegeben, wird die Meldung 'Few arguments given' ausgegeben, was bei den optionalen Argumenten nicht der Fall ist, wenn man ihren Namen kennt. Dieses Programm nimmt eine Zahl und gibt standardmäßig ihr Quadrat zurück, wenn die Option cube verwendet wird, soll es ihren Würfel zurückgeben.

import argparse
parser = argparse.ArgumentParser('number-game')
parser.add_argument(
    "number",
    type=int,
    help="enter a number"
   )
parser.add_argument(
   "-c", "--choice",
   choices=['square','cube'],
   help="choose what you need to do with the number"
)

# all the results will be parsed by the parser and stored in args
args = parser.parse_args()

# if square is selected return the square, same for cube 
if args.c == 'square':
    print("{} is the result".format(args.number**2))
elif args.c == 'cube':
    print("{} is the result".format(args.number**3))
else:
    print("{} is not changed".format(args.number))

Verwendung

$python3 script.py 4 -c square
16

Hier nehmen die optionalen Argumente einen Wert an, wenn Sie sie nur wie eine Flagge verwenden wollen, können Sie das auch. Durch die Verwendung von -s für Quadrat und -c für Würfel ändern wir das Verhalten, indem wir action = "store_true" hinzufügen. Es wird nur dann auf true geändert, wenn es verwendet wird.

parser.add_argument(
    "-s", "--square",
    help="returns the square of number",
    action="store_true"
    )
parser.add_argument(
    "-c", "--cube",
    help="returns the cube of number",
    action="store_true"
    )

so dass der bedingte Block in geändert werden kann,

if args.s:
    print("{} is the result".format(args.number**2))
elif args.c:
    print("{} is the result".format(args.number**3))
else:
    print("{} is not changed".format(args.number))

Verwendung

$python3 script.py 4 -c
64