Aufruffunktion basierend auf argparse

Ich bin neu in python und derzeit mit ihm zu spielen.
Ich habe ein script, das einige API-Aufrufe an ein Gerät. Ich würde gerne die Funktionalität erweitern und verschiedene Funktionen aufrufen auf der Grundlage der Argumente beim Aufruf des Skripts.

Derzeit habe ich die folgenden:

parser = argparse.ArgumentParser()
parser.add_argument("--showtop20", help="list top 20 by app",
                    action="store_true")
parser.add_argument("--listapps", help="list all available apps",
                    action="store_true")
args = parser.parse_args()

Ich habe auch ein

def showtop20():
    .....

und

def listapps():
....

Wie kann ich die Funktion aufrufen (und nur diese) basiert auf dem argument gegeben?
Ich will nicht zu laufen

if args.showtop20:
   #code here

if args.listapps:
   #code here

als ich mich bewegen will, die unterschiedlichen Funktionen zu einem Modul später halten die zentrale ausführbare Datei sauber und ordentlich.

InformationsquelleAutor der Frage f0rd42 | 2014-12-17

argparse python

16

Da es scheint, wie Sie wollen, um eine und nur eine Funktion in Abhängigkeit der gegebenen Argumente, ich schlage vor, Sie verwenden eine obligatorische positionelle argument ./prog command anstelle von optionalen Argumenten (./prog --command1 oder ./prog --command2).

so, so etwas sollte es tun:
```
FUNCTION_MAP = {'top20' : my_top20_func,
                'listapps' : my_listapps_func }

parser.add_argument('command', choices=FUNCTION_MAP.keys())

args = parser.parse_args()

func = FUNCTION_MAP[args.command]
func()
```
InformationsquelleAutor der Antwort Hannes Ovrén
9

Gibt es viele Möglichkeiten, skinning-diese Katze. Hier ist einer, der mit action='store_const' (inspiriert durch die dokumentierten subparser Beispiel):
```
p=argparse.ArgumentParser()
p.add_argument('--cmd1', action='store_const', const=lambda:'cmd1', dest='cmd')
p.add_argument('--cmd2', action='store_const', const=lambda:'cmd2', dest='cmd')

args = p.parse_args(['--cmd1'])
# Out[21]: Namespace(cmd=<function <lambda> at 0x9abf994>)

p.parse_args(['--cmd2']).cmd()
# Out[19]: 'cmd2'
p.parse_args(['--cmd1']).cmd()
# Out[20]: 'cmd1'
```
Mit einem gemeinsamen dest jeder Aktion legt seine Funktion (const) im gleichen Namensraum-Attribut. Die Funktion wird aufgerufen durch args.cmd().

Und wie in der dokumentiert subparsers Beispiel, diese Funktionen geschrieben werden kann, so wie andere Werte verwenden aus dem Namespace.
```
args = parse_args()
args.cmd(args)
```
Besseren Vergleich, hier das äquivalent subparsers Fall:
```
p = argparse.ArgumentParser()
sp = p.add_subparsers(dest='cmdstr')
sp1 = sp.add_parser('cmd1')
sp1.set_defaults(cmd=lambda:'cmd1')
sp2 = sp.add_parser('cmd2')
sp2.set_defaults(cmd=lambda:'cmd2')

p.parse_args(['cmd1']).cmd()
# Out[25]: 'cmd1'
```
Wie dargestellt in der Dokumentation, subparsers können Sie definieren verschiedene parameter für jeden der Befehle.

Und natürlich sind alle diese add argument oder parser-Anweisungen erstellt werden könnte in einer Schleife über eine Liste oder ein dictionary, das Paare eine Taste mit einer Funktion.

Ein weiterer wichtiger Aspekt - welche Art der Nutzung und helfen wollen Sie? Die verschiedenen Ansätze generieren sehr unterschiedliche Hilfe-Nachrichten.

InformationsquelleAutor der Antwort hpaulj

Wenn Ihre Funktionen sind "einfach genug" nehmen Sie Vorteil von type parameter https://docs.python.org/2.7/library/argparse.html#type

Typ= alle aufrufbar, übernimmt ein einziges string-argument und
gibt den konvertierten Wert:

In deinem Beispiel (auch wenn Sie nicht benötigen, einen umgewandelten Wert):

parser.add_argument("--listapps", help="list all available apps",
                    type=showtop20,
                    action="store")

Dieses einfache Skript:

import argparse

def showtop20(dummy):
    print "{0}\n".format(dummy) * 5

parser = argparse.ArgumentParser()
parser.add_argument("--listapps", help="list all available apps",
                    type=showtop20,
                    action="store")
args = parser.parse_args()

Geben:

# ./test.py --listapps test
test
test
test
test
test
test

InformationsquelleAutor der Antwort klashxx

Zumindest von dem, was Sie beschrieben haben, --showtop20 und --listapps Klang mehr wie sub-Befehle als Optionen. Wenn dies der Fall ist, können wir subparsers für die Erreichung Ihrer gewünschten Ergebnis. Hier ist ein proof-of-concept:

import argparse
import sys

def showtop20():
    print('running showtop20')

def listapps():
    print('running listapps')

parser = argparse.ArgumentParser()
subparsers = parser.add_subparsers()

# Create a showtop20 subcommand    
parser_showtop20 = subparsers.add_parser('showtop20', help='list top 20 by app')
parser_showtop20.set_defaults(func=showtop20)

# Create a listapps subcommand       
parser_listapps = subparsers.add_parser('listapps', help='list all available apps')
parser_listapps.set_defaults(func=listapps)

# Print usage message if no args are supplied.

# NOTE: Python 2 will error 'too few arguments' if no subcommand is supplied.
#       No such error occurs in Python 3, which makes it feasible to check
#       whether a subcommand was provided (displaying a help message if not).
#       argparse internals vary significantly over the major versions, so it's
#       much easier to just override the args passed to it.

if len(sys.argv) <= 1:
    sys.argv.append('--help')

options = parser.parse_args()

# Run the appropriate function (in this case showtop20 or listapps)
options.func()

# If you add command-line options, consider passing them to the function,
# e.g. `options.func(options)`

InformationsquelleAutor der Antwort Six

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.