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

Das habe ich mir in meinem Lernprojekt ausgedacht, hauptsächlich dank @DMH...

Demo-Code:

import argparse

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('-f', '--flag', action='store_true', default=False)  # can 'store_false' for no-xxx flags
    parser.add_argument('-r', '--reqd', required=True)
    parser.add_argument('-o', '--opt', default='fallback')
    parser.add_argument('arg', nargs='*') # use '+' for 1 or more args (instead of 0 or more)
    parsed = parser.parse_args()
    # NOTE: args with '-' have it replaced with '_'
    print('Result:',  vars(parsed))
    print('parsed.reqd:', parsed.reqd)

if __name__ == "__main__":
    main()

Diese kann sich weiterentwickelt haben und ist online verfügbar: kommandozeile.py

Skript, um diesen Code auszuprobieren: kommandozeilen-demo.sh

Answer 2

Beachten Sie die Argparse Tutorial en Python-HOWTOs . Es beginnt mit den einfachsten Beispielen, wie diesem hier:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("square", type=int,
                    help="display a square of a given number")
args = parser.parse_args()
print(args.square**2)

und geht dann zu weniger grundlegenden über.

Es gibt ein Beispiel mit einer vordefinierten Auswahl für eine Option, wie die, um die gebeten wird:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("square", type=int,
                    help="display a square of a given number")
parser.add_argument("-v", "--verbosity", type=int, choices=[0, 1, 2],
                    help="increase output verbosity")
args = parser.parse_args()
answer = args.square**2
if args.verbosity == 2:
    print("the square of {} equals {}".format(args.square, answer))
elif args.verbosity == 1:
    print("{}^2 == {}".format(args.square, answer))
else:
    print(answer)

Answer 3

Code-Datei: argparseDemo.py

Einfach: gemeinsamer Fall

• name(abbr, full), mit Hilfe

  import argparse
  
  argParser = argparse.ArgumentParser()
  argParser.add_argument("-n", "--name", help="your name")
  
  args = argParser.parse_args()
  print("args=%s" % args)
  
  print("args.name=%s" % args.name)

  • aufrufen
    • python argparseDemo.py -n Crifan
    • python argparseDemo.py --name Crifan
  • Ausgabe: args=Namespace(name='Crifan') y args.name=Crifan

• Typ

  argParser.add_argument("-a", "--age", type=int, help="your current age")
  print("type(args.age)=%s" % type(args.age))

  • anrufen: python argparseDemo.py --age 30
  • Ausgabe: type(args.age)=<class 'int'> y args.age=30

• erforderlich

  argParser.add_argument("-a", "--age", required=True, type=int, help="your current age")

  • anrufen: python argparseDemo.py
  • Ausgabe: Fehler argparseDemo.py: error: the following arguments are required: -a/--age

• Standard

  argParser.add_argument("-a", "--age", type=int, default=20, help="your current age. Default is 20")

  • anrufen: python argparseDemo.py
  • Ausgabe: args.age=20

• Auswahlmöglichkeiten

  argParser.add_argument("-f", "--love-fruit", choices=['apple', 'orange', 'banana'], help="your love fruits")

  • anrufen: python argparseDemo.py -f apple
  • Ausgabe: args=Namespace(love_fruit='apple') y args.love_fruit=apple

• Multi-Argumente

  argParser.add_argument("-f", "--love-fruit", nargs=2, help="your love fruits")

  • anrufen: python argparseDemo.py -f apple orange
  • Ausgabe: args.love_fruit=['apple', 'orange']

Einzelheiten

am einfachsten: -x

• Code:

  import argparse
  
  argParser = argparse.ArgumentParser()
  argParser.add_argument("-a") # most simple -> got args.a, type is `str`
  args = argParser.parse_args()
  
  print("args.a=%s" % args.a)

• Verwendung = Ausführung in der Befehlszeile

  python argparseDemo.py -a 30

  • oder: ./argparseDemo.py -a 30
    • makeure argparseDemo.py ausführbar ist
      • wenn nicht, fügen Sie es hinzu: chmod +x argparseDemo.py

• Ausgabe

  args.a=30

• Hinweis

  • Standardtyp ist str
    • argParser.add_argument("-a") == argParser.add_argument("-a", type=str)
    • print("type(args.a)=%s" % type(args.a)) -> type(args.a)=<class 'str'>
  • args Typ ist Namespace
    • print("type(args)=%s" % type(args)) -> type(args)=<class 'argparse.Namespace'>
  • args Wert ist Namespace(a='30')
    • print("args=%s" % args) -> args=Namespace(a='30')
    • so können wir aufrufen/verwenden args.a

Parametername

vollständiger Parametername: --xxx

• Code

  argParser.add_argument("-a", "--age")

• Verwendung

  • python argparseDemo.py -a 30
    • oder: python argparseDemo.py --age 30

• geparsten Wert erhalten: args.age

  • Nota: NICHT args.a y NICHT existieren args.a

vollständiger Parametername mit mehreren Wörtern: --xxx-yyy

• Code

  argParser.add_argument("-a", "--current-age")

• geparsten Wert erhalten: args. aktuelles_Alter

Beschreibung der Hilfe hinzufügen: help

• Code

  argParser.add_argument("-a", help="your age") # with help

• Ausgabe

  • verwenden. --help kann Beschreibung sehen

     python argparseDemo.py --help
    usage: argparseDemo.py [-h] [-a A]
    
    optional arguments:
    -h, --help  show this help message and exit
    -a A        your age

den Parametertyp bestimmen: type

• Code

  argParser.add_argument("-a", type=int) # parsed arg is `int`, not default `str`

• Ausgabe

  • print("type(args.a)=%s" % type(args.a)) -> type(args.a)=<class 'int'>
  • print("args=%s" % args) -> args=Namespace(a=30)

Standardwert hinzufügen: default

• Code

  argParser.add_argument("-a", type=int, default=20) # if not pass a, a use default value: 20

• Wirkung

  • Verwendung: python argparseDemo.py
  • Ausgabe: print("args.age=%s" % args.age) -> args=Namespace(a=20)

Answer 4

Sie können auch Folgendes verwenden plac (ein Wrapper um argparse ).

Als Bonus generiert es nette Hilfeanweisungen - siehe unten.

Beispielskript:

#!/usr/bin/env python3
def main(
    arg: ('Argument with two possible values', 'positional', None, None, ['A', 'B'])
):
    """General help for application"""
    if arg == 'A':
        print("Argument has value A")
    elif arg == 'B':
        print("Argument has value B")

if __name__ == '__main__':
    import plac
    plac.call(main)

Beispielhafte Ausgabe:

Keine Argumente geliefert - example.py :

usage: example.py [-h] {A,B}
example.py: error: the following arguments are required: arg

Unerwartetes Argument geliefert - example.py C :

usage: example.py [-h] {A,B}
example.py: error: argument arg: invalid choice: 'C' (choose from 'A', 'B')

Richtiges Argument geliefert - example.py A :

Argument has value A

Vollständiges Hilfemenü (automatisch generiert) - example.py -h :

usage: example.py [-h] {A,B}

General help for application

positional arguments:
  {A,B}       Argument with two possible values

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

Kurze Erklärung:

Der Name des Arguments entspricht normalerweise dem Parameternamen ( arg ).

Die Tupel-Anmerkung nach arg Parameter hat die folgende Bedeutung:

• Beschreibung ( Argument with two possible values )
• Art des Arguments - eines von 'Flag', 'Option' oder 'positional' ( positional )
• Abkürzung ( None )
• Typ des Argumentwerts - z. B. Float, String ( None )
• Eingeschränkte Auswahlmöglichkeiten ( ['A', 'B'] )

Dokumentation:

Um mehr über die Verwendung von plac sehen Sie sich die großartige Dokumentation an:

Plac: Parsing der Kommandozeile auf die einfache Art

Answer 5

Ich bin neu in diesem Bereich, aber ich kombiniere Python mit Powershell und verwende diese Vorlage, inspiriert von einem ausführlichen und großartigen Python Kommandozeilenargumente - Real Python

Es gibt eine Menge, was Sie im Rahmen der init_argparse() und ich gehe hier nur auf das einfachste Szenario ein.

1. import argparse
2. verwenden. if __name__ == "__main__": main() Muster zur Ausführung vom Terminal aus
3. Parse-Argumente innerhalb der main() Funktion, die keine Parameter hat, da alle
4. ein definieren init_argparse() Funktion
   • ein Parser-Objekt erzeugen, indem Sie argparse.ArgumentParser()
   • deklarieren Sie ein oder mehrere Argumnten mit parser.add_argument("--<long_param_name>")
   • return parser
5. parsen Args durch Erstellen einer args Objekt durch Aufruf von parser.parse_args()
6. eine eigene Funktion definieren mit param1 , param2 , ...
7. aufrufen function_proper mit Parametern, die als Attribute einer args Objekt
   • z.B.. function_proper(param1=args.param1, param2=args.param2)

8. innerhalb einer Shell das Modul mit benannten Argumenten aufrufen:

   • z.B.. python foobar.py --param1="foo" --param2=="bar"

   file: foobar.py

   import argparse

   def function_proper(param1, param2):

   CODE...

   def init_argparse() -> argparse.ArgumentParser: parser = argparse.ArgumentParser() parser.add_argument("--param1") parser.add_argument("--param2") return parser

   def main() -> None: parser = init_argparse() args = parser.parse_args() function_proper(param1=args.param1, param2=args.param2)

   if name == "main": main()

   python .\foobar.py --param1="foo" --param2=="bar"