Wywoływanie funkcji modułu przy użyciu jego nazwy (ciągu)

Jaki jest najlepszy sposób na wywołanie funkcji o podanym ciągu znaków z nazwą funkcji w programie Python. Na przykład, powiedzmy, że mam moduł fooi mam ciąg znaków, którego treść jest "bar". Jak najlepiej zadzwonić foo.bar()?

Potrzebuję uzyskać wartość zwracaną przez funkcję, dlatego po prostu jej nie używam eval. Zrozumiałem, jak to zrobić, używając evalfunkcji temp, która zwraca wynik tego wywołania funkcji, ale mam nadzieję, że istnieje bardziej elegancki sposób na zrobienie tego.

Zakładając moduł fooz metodą bar:

import foo
method_to_call = getattr(foo, 'bar')
result = method_to_call()

Możesz skrócić linie 2 i 3, aby:

result = getattr(foo, 'bar')()

jeśli ma to większy sens w twoim przypadku użycia.

Możesz używać getattrw ten sposób metod związanych z instancjami klas, metod na poziomie modułów, metod klas ... lista jest długa.

locals()["myfunction"]()

lub

globals()["myfunction"]()

locals zwraca słownik z bieżącą lokalną tablicą symboli. globals zwraca słownik z globalną tablicą symboli.

Rozwiązanie Patricka jest prawdopodobnie najczystsze. Jeśli chcesz również dynamicznie podnieść moduł, możesz go zaimportować w następujący sposób:

module = __import__('foo')
func = getattr(module, 'bar')
func()

Tylko prosty wkład. Jeśli klasa, którą musimy wprowadzić, znajduje się w tym samym pliku, możemy użyć czegoś takiego:

# Get class from globals and create an instance
m = globals()['our_class']()

# Get the function (from the instance) that we need to call
func = getattr(m, 'function_name')

# Call it
func()

Na przykład:

class A:
    def __init__(self):
        pass

    def sampleFunc(self, arg):
        print('you called sampleFunc({})'.format(arg))

m = globals()['A']()
func = getattr(m, 'sampleFunc')
func('sample arg')

# Sample, all on one line
getattr(globals()['A'](), 'sampleFunc')('sample arg')

A jeśli nie klasa:

def sampleFunc(arg):
    print('you called sampleFunc({})'.format(arg))

globals()['sampleFunc']('sample arg')

Biorąc pod uwagę ciąg znaków wraz z pełną ścieżką do funkcji w języku Python, w ten sposób zacząłem uzyskiwać wynik tej funkcji:

import importlib
function_string = 'mypackage.mymodule.myfunc'
mod_name, func_name = function_string.rsplit('.',1)
mod = importlib.import_module(mod_name)
func = getattr(mod, func_name)
result = func()

Najlepsza odpowiedź zgodnie z najczęściej zadawanymi pytaniami dotyczącymi programowania w języku Python :

functions = {'myfoo': foo.bar}

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

Podstawową zaletą tej techniki jest to, że ciągi nie muszą pasować do nazw funkcji. Jest to również podstawowa technika stosowana do emulacji konstrukcji przypadku

Odpowiedź (mam nadzieję) nikt nigdy nie chciał

Zachowanie przypominające ewolucję

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

Dlaczego nie dodać automatycznego importowania

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

Jeśli mamy dodatkowe słowniki, które chcemy sprawdzić

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

Musimy zejść głębiej

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")()

Jeśli chodzi o wartość, jeśli chcesz przekazać nazwę funkcji (lub klasy) i nazwę aplikacji jako ciąg, możesz to zrobić:

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

Spróbuj tego. Chociaż nadal używa eval, używa go tylko do przywołania funkcji z bieżącego kontekstu . Następnie masz prawdziwą funkcję do użycia, jak chcesz.

Główną korzyścią z tego jest to, że w momencie przywołania funkcji otrzymasz błędy związane z ewaluacją. Wtedy podczas połączenia otrzymasz tylko błędy związane z funkcją.

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)

nic z tego, co sugerowano, nie pomogło mi. Odkryłem to jednak.

<object>.__getattribute__(<string name>)(<params>)

Używam Pythona 2.66

Mam nadzieję że to pomoże

Jako pytanie: Jak dynamicznie wywoływać metody w klasie za pomocą przypisania nazwy metody do zmiennej [duplikat] oznaczonej jako duplikat tak jak tutaj, zamieszczam pokrewną odpowiedź tutaj:

Scenariusz jest taki, że metoda w klasie chce dynamicznie wywoływać inną metodę w tej samej klasie. Dodałem kilka szczegółów do oryginalnego przykładu, który oferuje szerszy scenariusz i przejrzystość:

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()

Dane wyjściowe (Python 3.7.x)

funkcja1: 12

funkcja2: 12

To prosta odpowiedź, która pozwoli na przykład wyczyścić ekran. Poniżej znajdują się dwa przykłady, z eval i exec, które wypisują 0 na górze po czyszczeniu (jeśli używasz Windowsa, zmień clearna cls, użytkownicy Linuksa i Maca wychodzą tak jak na przykład) lub po prostu uruchom je odpowiednio.

eval("os.system(\"clear\")")
exec("os.system(\"clear\")")