How Can I Call a Module Function in Python When the Function Name is Dynamic?

Invoking Module Functions with Dynamic Function Naming

Imagine a scenario where you have a requirement to call a function of a module, but the function name is dynamically generated, stored as a string. This prompts the question: how can this be achieved programmatically?

Dynamic Function Invocation using Module and Function Name as Strings

The solution to this challenge lies in Python's getattr function. getattr takes an object and a string representing an attribute (or method) name, and returns the attribute's value. By applying this concept to modules, you can invoke their functions by passing the module reference and function name as strings.

Consider the following example:

import foo
func_name = "bar"
bar = getattr(foo, func_name)
result = bar()

In this example, the module foo contains a function bar. Using getattr, we retrieve the bar function by passing the foo module and the string "bar". Finally, we invoke bar and store its return value in result.

Beyond Functions: Dynamic Invocation of Class Methods

getattr's versatility extends beyond the invocation of module-level functions. It can also be employed to access class instance-bound methods, module-level methods, class methods, and so on.

Example of Class Method Invocation:

class MyClass:
    @classmethod
    def classmethod_foo(cls, arg):
        pass

my_class_instance = MyClass()
classmethod_foo = getattr(my_class_instance, "classmethod_foo")
classmethod_foo(arg)

This example demonstrates the dynamic invocation of the class method classmethod_foo on an instance of MyClass.

Note:
Python versions 3.10 and later introduce the new getattr alias getattrs, which provides additional flexibility and convenience for accessing attributes dynamically.

The above is the detailed content of How Can I Call a Module Function in Python When the Function Name is Dynamic?. For more information, please follow other related articles on the PHP Chinese website!