webentwicklung-frage-antwort-db.com.de

Verwenden eines Wörterbuchs zur Auswahl der auszuführenden Funktion

Ich versuche, mithilfe der funktionalen Programmierung ein Wörterbuch zu erstellen, das einen Schlüssel und eine auszuführende Funktion enthält: 

myDict={}
myItems=("P1","P2","P3",...."Pn")
def myMain(key):
    def ExecP1():
        pass
    def ExecP2():
        pass
    def ExecP3():
        pass
        ...
    def ExecPn():
        pass  

Nun habe ich einen Code gesehen, der zum Auffinden der definierten Funktionen in einem Modul verwendet wurde, und ich muss Folgendes tun:

    for myitem in myItems:
        myDict[myitem] = ??? #to dynamically find the corresponding function

Meine Frage lautet also: Wie erstelle ich eine Liste aller Exec-Funktionen und ordne sie dann mithilfe eines Wörterbuchs dem gewünschten Element zu. Am Ende werde ich myDict["P1"]() #this will call ExecP1() haben

Mein eigentliches Problem ist, dass ich Tonnen von diesen Elementen habe und eine Bibliothek erstellt, die sie behandelt, so dass der Endbenutzer nur noch myMain("P1") aufrufen muss.

Ich denke, ich benutze das Inspect-Modul, bin mir aber nicht so sicher, wie es geht.

Mein Grund zu vermeiden:

def ExecPn():
    pass
myDict["Pn"]=ExecPn

ist, dass ich Code schützen muss, während ich ihn verwende, um eine Skriptfunktion in meiner Anwendung bereitzustellen.

33
JohnnyDH

Nicht stolz darauf, aber:

def myMain(key):
    def ExecP1():
        pass
    def ExecP2():
        pass
    def ExecP3():
        pass
    def ExecPn():
        pass 
    locals()['Exec' + key]()

Ich empfehle jedoch, dass Sie diese in einem Modul/in einer Klasse ablegen.

18
Ohad

Vereinfachen, vereinfachen, vereinfachen Sie:

def p1(args):
    whatever

def p2(more args):
    whatever

myDict = {
    "P1": p1,
    "P2": p2,
    ...
    "Pn": pn
}

def myMain(name):
    myDict[name]()

Das ist alles was du brauchst.


Sie könnten die Verwendung von dict.get mit einem aufrufbaren Standardwert in Betracht ziehen, wenn name auf eine ungültige Funktion verweist.

def myMain(name):
    myDict.get(name, lambda: 'Invalid')()

(Hat diesen tollen Trick von Martijn Pieters abgeholt)

66
S.Lott

Vereinfachen, vereinfachen, vereinfachen + DRY:

tasks = {}
task = lambda f: tasks.setdefault(f.__name__, f)

@task
def p1():
    whatever

@task
def p2():
    whatever

def my_main(key):
    tasks[key]()
17
Joe
# index dictionary by list of key names

def fn1():
    print "One"

def fn2():
    print "Two"

def fn3():
    print "Three"

fndict = {"A": fn1, "B": fn2, "C": fn3}

keynames = ["A", "B", "C"]

fndict[keynames[1]]()

# keynames[1] = "B", so output of this code is

# Two
2
jwc3119
#!/usr/bin/python

def thing_a(arg=None):
    print 'thing_a', arg

def thing_b(arg=None):
    print 'thing_b', arg

ghetto_switch_statement = {
    'do_thing_a': thing_a,
    'do_thing_b': thing_b
}

ghetto_switch_statement['do_thing_a']("It's lovely being an A")
ghetto_switch_statement['do_thing_b']("Being a B isn't too shabby either")

print "Available methods are: ", ghetto_switch_statement.keys()
1
def p1( ):
    print("in p1")

def p2():
    print("in p2")

myDict={
    "P1": p1,
    "P2": p2

}

name=input("enter P1 or P2")

myDictname

1
Gokhale

Dies ruft Methoden aus dem Wörterbuch auf

Dies ist eine Python-Switch-Anweisung mit Funktionsaufruf

Erstellen Sie einige Module entsprechend Ihrer Anforderung . Wenn Sie Argumente übergeben möchten, übergeben Sie sie.

Erstellen Sie ein Wörterbuch, das diese Module je nach Anforderung aufruft.

    def function_1(arg):
        print("In function_1")

    def function_2(arg):
        print("In function_2")

    def function_3(fileName):
        print("In function_3")
        f_title,f_course1,f_course2 = fileName.split('_')
        return(f_title,f_course1,f_course2)


    def createDictionary():

        dict = {

            1 : function_1,
            2 : function_2,
            3 : function_3,

        }    
        return dict

    dictionary = createDictionary()
    dictionary[3](Argument)#pass any key value to call the method
0
akD

Du verschwendest deine Zeit:

  1. Sie sind dabei, eine Menge nutzlosen Code zu schreiben und neue Fehler einzuführen.
  2. Um die Funktion auszuführen, muss Ihr Benutzer den P1-Namen trotzdem kennen.
  3. Usw. usw. 

Fügen Sie einfach alle Ihre Funktionen in die .py-Datei ein:

# my_module.py

def f1():
    pass

def f2():
    pass

def f3():
    pass

Und benutze sie so:

import my_module

my_module.f1()
my_module.f2()
my_module.f3()

oder:

from my_module import f1
from my_module import f2
from my_module import f3

f1()
f2()
f3()

Dies sollte für den Anfang ausreichend sein.

0

Sie können einfach verwenden

myDict = {
    "P1": (lambda x: function1()),
    "P2": (lambda x: function2()),
    ...,
    "Pn": (lambda x: functionn())}
myItems = ["P1", "P2", ..., "Pn"]

for item in myItems:
    myDict[item]()
0