Wywołanie funkcji modułu za pomocą jego nazwy (ciąg znaków)

locals()["myfunction"]()

Lub

globals()["myfunction"]()

Locals zwraca słownik z bieżącą tabelą symboli lokalnych. globals zwraca słownik z globalną tabelą symboli.

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

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

Zwykły wkład. Jeśli klasa, którą musimy instancjonować, 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')

I, 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, z pełną ścieżką Pythona do funkcji, oto jak zacząłem uzyskiwać wynik wspomnianej 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()

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

Eval like behavior

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

Dlaczego nie dodać auto-Import

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

W przypadku, gdy mamy dodatkowe słowniki 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 wejść 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")()

Najlepszą odpowiedzią według Python programming FAQ byłoby:

functions = {'myfoo': foo.bar}

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

Podstawową zaletą tej techniki jest to, że łańcuchy nie muszą pasować do nazw funkcji. Jest to również podstawowa technika używana do emulowania konstrukcji przypadku

Jeśli chcesz przekazać nazwę funkcji (lub klasy) i nazwę aplikacji jako łańcuch znaków, możesz to zrobić:

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

Nic z tego, co sugerowano, mi nie pomogło. Jednak odkryłem to.

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

Używam Pythona 2.66

Hope this helps

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ą dla mnie z tego jest to, że otrzymasz wszelkie błędy związane z eval w momencie wywołania funkcji. Wtedy otrzymasz tylko błędy związane z funkcją podczas wywoływania.

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)