Aufruf einer Funktion eines Moduls mit Hilfe seines Namens (einer Zeichenkette)

Question

Was ist der beste Weg, um eine Funktion aufzurufen, wenn man eine Zeichenkette mit dem Namen der Funktion in einem Python-Programm hat. Nehmen wir zum Beispiel an, dass ich ein Modul habe foo und ich habe eine Zeichenkette mit folgendem Inhalt "bar" . Wie kann ich am besten anrufen? foo.bar() ?

Ich muss den Rückgabewert der Funktion erhalten, weshalb ich nicht einfach eval . Ich habe herausgefunden, wie man das macht, indem man eval um eine temporäre Funktion zu definieren, die das Ergebnis dieses Funktionsaufrufs zurückgibt, aber ich hoffe, dass es einen eleganteren Weg gibt, dies zu tun.

Answer 1

Die beste Antwort ist nach Ansicht der Python-Programmierung FAQ wäre:

functions = {'myfoo': foo.bar}

mystring = 'myfoo'
if mystring in functions:
    functions[mystring]()

Der Hauptvorteil dieser Technik ist, dass die Zeichenketten nicht mit den Namen der Funktionen übereinstimmen müssen. Dies ist auch die primäre Technik, um ein Case-Konstrukt zu emulieren

Answer 2

Die Antwort, die (hoffentlich) niemand wollte

Verhalten wie bei Eval

getattr(locals().get("foo") or globals().get("foo"), "bar")()

Warum nicht automatisch importieren

getattr(
    locals().get("foo") or 
    globals().get("foo") or
    __import__("foo"), 
"bar")()

Falls wir zusätzliche Wörterbücher haben, die wir prüfen wollen

getattr(next((x for x in (f("foo") for f in 
                          [locals().get, globals().get, 
                           self.__dict__.get, __import__]) 
              if x)),
"bar")()

Wir müssen tiefer gehen

getattr(next((x for x in (f("foo") for f in 
              ([locals().get, globals().get, self.__dict__.get] +
               [d.get for d in (list(dd.values()) for dd in 
                                [locals(),globals(),self.__dict__]
                                if isinstance(dd,dict))
                if isinstance(d,dict)] + 
               [__import__])) 
        if x)),
"bar")()

Answer 3

Versuchen Sie dies. Dies verwendet zwar immer noch eval, aber nur, um die Funktion aus dem aktuellen Kontext aufzurufen . Dann haben Sie die eigentliche Funktion, die Sie nach Belieben nutzen können.

Der Hauptvorteil besteht für mich darin, dass Sie alle eval-bezogenen Fehler bereits beim Aufruf der Funktion erhalten. Dann erhalten Sie nur die funktionsbezogenen Fehler beim Aufruf.

def say_hello(name):
    print 'Hello {}!'.format(name)

# get the function by name
method_name = 'say_hello'
method = eval(method_name)

# call it like a regular function later
args = ['friend']
kwargs = {}
method(*args, **kwargs)

Answer 4

Wenn Sie den Namen der Funktion (oder Klasse) und den Namen der Anwendung als Zeichenkette übergeben müssten, könnten Sie dies tun:

myFnName  = "MyFn"
myAppName = "MyApp"
app = sys.modules[myAppName]
fn  = getattr(app,myFnName)

Answer 5

Da diese Frage Dynamischer Aufruf von Methoden innerhalb einer Klasse durch Zuweisung eines Methodennamens an eine Variable [duplizieren] als Duplikat markiert, poste ich hier eine verwandte Antwort:

Das Szenario ist, eine Methode in einer Klasse wollen eine andere Methode auf der gleichen Klasse dynamisch aufrufen, habe ich einige Details zu ursprünglichen Beispiel, das einige weitere Szenario und Klarheit bietet hinzugefügt:

class MyClass:
    def __init__(self, i):
        self.i = i

    def get(self):
        func = getattr(MyClass, 'function{}'.format(self.i))
        func(self, 12)   # This one will work
        # self.func(12)    # But this does NOT work.

    def function1(self, p1):
        print('function1: {}'.format(p1))
        # do other stuff

    def function2(self, p1):
        print('function2: {}'.format(p1))
        # do other stuff

if __name__ == "__main__":
    class1 = MyClass(1)
    class1.get()
    class2 = MyClass(2)
    class2.get()

Ausgabe (Python 3.7.x)

Funktion1: 12

Funktion2: 12