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

¿Cuál es la mejor manera de llamar a una función dada una cadena con el nombre de la función en un programa de Python? Por ejemplo, supongamos que tengo un módulo fooy tengo una cadena cuyo contenido es "bar". ¿Cuál es la mejor forma de llamar foo.bar()?

Necesito obtener el valor de retorno de la función, por eso no solo uso eval. Descubrí cómo hacerlo utilizando evalpara definir una función temporal que devuelve el resultado de esa llamada de función, pero espero que haya una forma más elegante de hacerlo.

Asumiendo módulo foocon método bar:

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

Puede acortar las líneas 2 y 3 para:

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

si eso tiene más sentido para su caso de uso.

Puede usar getattrde esta manera en métodos vinculados a instancias de clase, métodos a nivel de módulo, métodos de clase ... la lista continúa.

locals()["myfunction"]()

o

globals()["myfunction"]()

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

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

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

Solo una simple contribución. Si la clase que necesitamos instanciar 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 mejor respuesta según las preguntas frecuentes de programación de Python 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

La respuesta (espero) que nadie haya querido

Evaluar como comportamiento

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, queremos verificar

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

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

Para lo que vale, si necesita pasar el nombre de la función (o clase) y el nombre de la aplicación como una cadena, puede hacer esto:

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

Prueba esto. Si bien esto todavía usa eval, solo lo usa para invocar la función desde el contexto actual . Entonces, tiene la función real de usar como desee.

El principal beneficio para mí de esto es que obtendrá errores relacionados con la evaluación al momento 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)

nada de lo sugerido me ayudó. Aunque descubrí esto.

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

Estoy usando python 2.66

Espero que esto ayude

Como esta pregunta Cómo llamar dinámicamente métodos dentro de una clase usando la asignación de nombre de método a una variable [duplicado] marcada como duplicada como esta, estoy publicando una respuesta relacionada aquí:

El escenario es que un método en una clase quiere llamar a otro método en la misma clase dinámicamente. He agregado algunos detalles al ejemplo original que ofrece un escenario y claridad más amplios:

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

Salida (Python 3.7.x)

función1: 12

función2: 12

Esta es una respuesta simple, esto le permitirá borrar la pantalla, por ejemplo. Hay dos ejemplos a continuación, con eval y exec, que imprimirán 0 en la parte superior después de la limpieza (si está utilizando Windows, cambie cleara cls, los usuarios de Linux y Mac se van como están, por ejemplo) o simplemente ejecútelo, respectivamente.

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