Chiamare una funzione di un modulo usando il suo nome (una stringa)

Qual è il modo migliore per chiamare una funzione assegnata a una stringa con il nome della funzione in un programma Python. Ad esempio, diciamo che ho un modulo fooe ho una stringa il cui contenuto è "bar". Qual è il modo migliore per chiamare foo.bar()?

Devo ottenere il valore di ritorno della funzione, motivo per cui non mi limito a utilizzare eval. Ho capito come farlo usando evalper definire una funzione temporanea che restituisce il risultato di quella chiamata di funzione, ma spero che ci sia un modo più elegante per farlo.

Supponendo il modulo foocon il metodo bar:

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

È possibile abbreviare le righe 2 e 3 per:

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

se questo ha più senso per il tuo caso d'uso.

È possibile utilizzare getattrin questo modo metodi associati a istanze di classe, metodi a livello di modulo, metodi di classe ... l'elenco potrebbe continuare.

locals()["myfunction"]()

o

globals()["myfunction"]()

la gente del posto restituisce un dizionario con una tabella dei simboli locale corrente. globals restituisce un dizionario con tabella dei simboli globale.

La soluzione di Patrick è probabilmente la più pulita. Se devi ritirare dinamicamente anche il modulo, puoi importarlo come:

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

Solo un semplice contributo. Se la classe che dobbiamo istanziare è nello stesso file, possiamo usare qualcosa del genere:

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

Per esempio:

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

E, se non una classe:

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

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

Data una stringa, con un percorso python completo per una funzione, ecco come ho ottenuto il risultato di detta funzione:

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

La migliore risposta secondo le FAQ sulla programmazione di Python sarebbe:

functions = {'myfoo': foo.bar}

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

Il vantaggio principale di questa tecnica è che le stringhe non devono necessariamente corrispondere ai nomi delle funzioni. Questa è anche la tecnica principale utilizzata per emulare un costrutto case

La risposta (spero) che nessuno abbia mai voluto

Comportamento simile al male

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

Perché non aggiungere l'importazione automatica

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

Nel caso in cui abbiamo dizionari extra che vogliamo controllare

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

Dobbiamo andare più a fondo

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

Per quello che vale, se hai bisogno di passare il nome della funzione (o della classe) e il nome dell'app come stringa, puoi farlo:

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

Prova questo. Mentre questo usa ancora eval, lo usa solo per evocare la funzione dal contesto corrente . Quindi, hai la vera funzione da usare come desideri.

Il vantaggio principale per me da questo è che otterrai errori relativi ad eval al momento di convocare la funzione. Quindi riceverai solo gli errori relativi alla funzione quando chiami.

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)

niente di ciò che mi è stato suggerito mi ha aiutato. L'ho scoperto però.

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

Sto usando Python 2.66

Spero che sia di aiuto

Come questa domanda Come chiamare dinamicamente i metodi all'interno di una classe usando l'assegnazione nome metodo a una variabile [duplicato] contrassegnata come duplicata come questa, sto pubblicando una risposta correlata qui:

Lo scenario è che un metodo in una classe vuole chiamare un altro metodo sulla stessa classe in modo dinamico, ho aggiunto alcuni dettagli all'esempio originale che offre uno scenario più ampio e chiarezza:

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

Output (Python 3.7.x)

funzione1: 12

funzione2: 12

Questa è una risposta semplice, ad esempio ti permetterà di cancellare lo schermo. Di seguito sono riportati due esempi, con eval ed exec, che stamperanno 0 in alto dopo la pulizia (se si utilizza Windows, si clearpassa a cls, gli utenti Linux e Mac se ne vanno come è per esempio) o semplicemente si eseguono, rispettivamente.

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