Home Calling a function of a module by using its name (a string)

# Calling a function of a module by using its name (a string)

ricree
1#
ricree Published in 2008-08-06 03:36:08Z
 What is the best way to go about calling a function given a string with the function's name in a Python program. For example, let's say that I have a module foo, and I have a string whose contents are "bar". What is the best way to go about calling foo.bar()? I need to get the return value of the function, which is why I don't just use eval. I figured out how to do it by using eval to define a temp function that returns the result of that function call, but I'm hoping that there is a more elegant way to do this.
Ben Hoyt
2#
Ben Hoyt Reply to 2017-02-22 18:10:17Z
 Assuming module foo with method bar: import foo method_to_call = getattr(foo, 'bar') result = method_to_call()  As far as that goes, lines 2 and 3 can be compressed to: result = getattr(foo, 'bar')()  if that makes more sense for your use case. You can use getattr in this fashion on class instance bound methods, module-level methods, class methods... the list goes on.
Ben Hoyt
3#
Ben Hoyt Reply to 2017-02-22 18:08:23Z
 Patrick's solution is probably the cleanest. If you need to dynamically pick up the module as well, you can import it like: module = __import__('foo') func = getattr(module, 'bar') func() 
sastanin
4#
 locals()["myfunction"]()  or globals()["myfunction"]()  locals returns a dictionary with a current local symbol table. globals returns a dictionary with global symbol table.
trubliphone
5#
 For what it's worth, if you needed to pass the function (or class) name and app name as a string, then you could do this: myFnName = "MyFn" myAppName = "MyApp" app = sys.modules[myAppName] fn = getattr(app,myFnName) 
tbc0
6#
 Just a simple contribution. If the class that we need to instance is in the same file, we can use something like this: # 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()  For example: 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')  And, if not a class: def sampleFunc(arg): print('you called sampleFunc({})'.format(arg)) globals()['sampleFunc']('sample arg') 
Natdrip
7#
 none of what was suggested helped me. I did discover this though. 
ferrouswheel
8#
 Given a string, with a complete python path to a function, this is how I went about getting the result of said function: 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() 
 The answer (I hope) no one ever wanted Eval like behavior getattr(locals().get("foo") or globals().get("foo"), "bar")()  Why not add auto-importing getattr( locals().get("foo") or globals().get("foo") or __import__("foo"), "bar")()  In case we have extra dictionaries we want to check getattr(next((x for x in (f("foo") for f in [locals().get, globals().get, self.__dict__.get, __import__]) if x)), "bar")()  We need to go deeper 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")() 
 The best answer according to the Python programming FAQ would be: 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