Вызов функции модуля по его имени (строке)

Предполагая модуль foo с методом bar:

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

Вы можете сократить строки 2 и 3 до:

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

если это имеет больше смысла для вашего варианта использования.

Вы можете использовать getattr таким образом в методах, связанных с экземпляром класса, методах уровня модуля, методах класса ... список можно продолжить.

Решение Патрика, наверное, самое чистое. Если вам нужно также динамически подобрать модуль, вы можете импортировать его следующим образом:

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

locals()["myfunction"]()

или же

globals()["myfunction"]()

местные жители возвращает словарь с текущей локальной таблицей символов. глобалы возвращает словарь с глобальной таблицей символов.

Как бы то ни было, если вам нужно передать имя функции (или класса) и имя приложения в виде строки, вы можете сделать это:

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

Просто простой вклад. Если класс, который нам нужно создать, находится в том же файле, мы можем использовать что-то вроде этого:

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

Например:

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

И, если не класс:

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

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

ничего из предложенного мне не помогло. Я все же обнаружил это.

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

Я использую Python 2.66

Надеюсь это поможет

Учитывая строку с полным путем Python к функции, вот как я получил результат указанной функции:

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

Ответ (надеюсь) никто никогда не хотел

Eval like поведение

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

Почему бы не добавить автоимпорт

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

Если у нас есть лишние словари, мы хотим проверить

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

Нам нужно идти глубже

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

Лучшим ответом согласно FAQ по программированию на Python будет:

functions = {'myfoo': foo.bar}

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

The primary advantage of this technique is that the strings do not need to match the names of the functions. This is also the primary technique used to emulate a case construct

Попробуй это. Хотя он все еще использует eval, он использует его только для вызвать функцию из текущего контекста. Тогда у вас есть реальная функция, которую вы можете использовать по своему усмотрению.

Основное преимущество для меня в том, что вы получите любые ошибки, связанные с eval, в момент вызова функции. Тогда при вызове вы получите Только ошибок, связанных с функцией.

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)

Поскольку этот вопрос Как динамически вызывать методы внутри класса, используя присвоение имени метода переменной [дубликат] отмечен как дубликат, я отправляю связанный ответ здесь:

Сценарий заключается в том, что метод в классе хочет динамически вызывать другой метод в том же классе, я добавил некоторые детали в исходный пример, который предлагает более широкий сценарий и ясность:

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)

function1: 12

function2: 12

Это простой ответ, это позволит вам, например, очистить экран. Ниже приведены два примера с eval и exec, которые будут печатать 0 вверху после очистки (если вы используете Windows, измените clear на cls, пользователи Linux и Mac оставьте, например, как есть) или просто выполните его, соответственно.

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

getattr вызывает метод по имени из объекта. Но этот объект должен быть родительским для вызывающего класса. Родительский класс может быть получен super(self.__class__, self)

class Base:
    def call_base(func):
        """This does not work"""
        def new_func(self, *args, **kwargs):
            name = func.__name__
            getattr(super(self.__class__, self), name)(*args, **kwargs)
        return new_func

    def f(self, *args):
        print(f"BASE method invoked.")

    def g(self, *args):
        print(f"BASE method invoked.")

class Inherit(Base):
    @Base.call_base
    def f(self, *args):
        """function body will be ignored by the decorator."""
        pass

    @Base.call_base
    def g(self, *args):
        """function body will be ignored by the decorator."""
        pass

Inherit().f() # The goal is to print "BASE method invoked."

Хотя getattr () является элегантным (и примерно в 7 раз быстрее) методом, вы можете получить возвращаемое значение из функции (локальный, метод класса, модуль) с eval, столь же элегантным, как x = eval('foo.bar')(). И когда вы реализуете некоторую обработку ошибок, то достаточно безопасно (тот же принцип можно использовать для getattr). Пример с импортом модуля и классом:

# import module, call module function, pass parameters and print retured value with eval():
import random
bar = 'random.randint'
randint = eval(bar)(0,100)
print(randint) # will print random int from <0;100)

# also class method returning (or not) value(s) can be used with eval: 
class Say:
    def say(something='nothing'):
        return something

bar = 'Say.say'
print(eval(bar)('nice to meet you too')) # will print 'nice to meet you' 

Когда модуль или класс не существует (опечатка или что-то лучше), возникает ошибка NameError. Когда функция не существует, возникает AttributeError. Это можно использовать для обработки ошибок:

# try/except block can be used to catch both errors
try:
    eval('Say.talk')() # raises AttributeError because function does not exist
    eval('Says.say')() # raises NameError because the class does not exist
    # or the same with getattr:
    getattr(Say, 'talk')() # raises AttributeError
    getattr(Says, 'say')() # raises NameError
except AttributeError:
    # do domething or just...
    print('Function does not exist')
except NameError:
    # do domething or just...
    print('Module does not exist')