Calling Functions by Their Names in Python: A Guide to Dynamic Function Invocation

Discover how to dynamically call functions in Python using string variables. This guide simplifies accessing functions based on names stored in lists, eliminating cumbersome if statements.
---
This video is based on the question https://stackoverflow.com/q/65607170/ asked by the user 'TFC' ( https://stackoverflow.com/u/12757690/ ) and on the answer https://stackoverflow.com/a/65607254/ provided by the user 'Chayim Friedman' ( https://stackoverflow.com/u/7884305/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Python: Would it be possible to call a function specifying by string variable?

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Calling Functions by Their Names in Python: A Guide to Dynamic Function Invocation

When programming in Python, you may encounter situations where you want to dynamically invoke functions based on their names stored as strings. This problem arises particularly when you have multiple functions and you want to avoid lengthy and complex if statements. Instead, what if you could directly call a function by its name? This guide will guide you through this process, showing you how to efficiently execute functions using a string variable as the function name.

The Challenge

Suppose you have several functions, and their names are stored in a list. You want to select one of these functions randomly at runtime and invoke it without using multiple if or elif statements to check which function should be called. While it's common to hard-code function calls using conditional statements, this approach can become cumbersome and error-prone, especially as your list of functions grows.

To illustrate, consider the following initial setup using Python:

[[See Video to Reveal this Text or Code Snippet]]

You can see how this approach can quickly become unmanageable. Let’s explore a more efficient solution.

The Solution: Using globals()

The good news is that Python's globals() function allows you to access the global namespace, which includes all globally defined functions. By leveraging this feature, you can call a function directly using its name as a string.

Here’s how you can implement this:

Define your functions: Start by defining all the functions you want to include.

Store function names in a list: Keep a list of the function names as strings.

Select a function randomly: Use the random.choice() method to select a function name from the list.

Call the function using globals(): Use the globals() dictionary to access the function and call it.

Here’s the updated code implementing this solution:

[[See Video to Reveal this Text or Code Snippet]]

How This Works:

Accessing the Function: The globals() function returns a dictionary representing the current global symbol table. By using the string name of your chosen function as a key, you can access the function object itself.

Invoking the Function: After retrieving the function, simply add parentheses () along with any required arguments to invoke it.

Conclusion

Using globals() for dynamic function invocation allows you to streamline your code and make it more flexible. This method is particularly useful when you want to add more functions without altering your control structures.

Takeaways:

You can call functions by their names stored in strings.

The globals() function can fetch the function object using its name.

This approach reduces complexity and enhances maintainability.

Implementing this strategy in your projects can save you time and reduce code clutter. Happy coding!