Llamar a una función de un módulo usando su nombre (una cadena)

locals()["myfunction"]()

O

globals()["myfunction"]()

Locals devuelve un diccionario con una tabla de símbolos local actual. globals devuelve un diccionario con una tabla de símbolos global.

La solución de Patrick es probablemente la más limpia. Si también necesita recoger dinámicamente el módulo, puede importarlo como:

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

Solo una simple contribución. Si la clase que necesitamos como instancia está en el mismo archivo, podemos usar algo como esto:

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

Por ejemplo:

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

Y, si no es una clase:

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

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

Dada una cadena, con una ruta completa de python a una función, así es como obtuve el resultado de dicha función:

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 respuesta (espero) que nadie ha querido

Comportamiento similar a la evaluación

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

¿Por qué no agregar la importación automática

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

En caso de que tengamos diccionarios adicionales que queremos comprobar

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

Tenemos que ir más profundo

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

La mejor respuesta de acuerdo con el Python programming FAQ sería:

functions = {'myfoo': foo.bar}

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

La principal ventaja de esta técnica es que las cadenas no necesitan coincidir con los nombres de las funciones. Esta es también la técnica principal utilizada para emular una construcción de caso

Por si sirve de algo, si necesita pasar el nombre de la función (o clase) y el nombre de la aplicación como una cadena, entonces podría hacer esto:

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

Nada de lo que se sugirió me ayudó. Sin embargo, descubrí esto.

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

Estoy usando python 2.66

Espero que esto ayude

Prueba esto. Mientras que esto todavía usa eval, solo lo usa para invocar la función desde el contexto actual. Después de eso, usted tiene la función real de utilizar como desee.

El principal beneficio para mí de esto es que obtendrá cualquier error relacionado con la evaluación en el punto de invocar la función. Entonces obtendrá solo los errores relacionados con la función cuando llame.

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)