Call Python Function by String Name

• Introduction
• Step-by-Step Guide
• Code Example
• Additional Notes
• Summary
• Conclusion
• References

In Python, functions are first-class objects, meaning they can be manipulated like any other data type. This includes the ability to call functions dynamically using their names stored as strings. This technique is particularly useful when you don't know which specific function you need to execute until runtime.

Let's explore how to call Python functions dynamically using their names stored as strings.

Understanding the Goal

Imagine you have a situation where you don't know the exact function to call until your program is running. You might have the function's name stored in a variable, read from a file, or received as user input. This is where calling functions by their string names becomes essential.

Methods

1. Using getattr()

   • Ideal for: Functions within modules and classes.
   • Obtain a reference to a function using its name:

   import my_module
   
   function_name = "my_function"
   my_function = getattr(my_module, function_name)

   • Call the retrieved function:

   result = my_function() 

2. Using globals() or locals()

   • Ideal for: Functions defined in the same scope where you're calling from.

   • Retrieve the function from the global or local symbol table:

     def greet(name):
         return f"Hello, {name}!"
     
     function_name = "greet"
     my_function = globals()[function_name] 
     # Or: my_function = locals()[function_name] 

   • Call the function:

     result = my_function("Alice")  

Important Considerations

• Security: Be extremely cautious when using eval() to call functions from strings. If the string content comes from an untrusted source (like user input), it could lead to serious security vulnerabilities.
• Alternatives: Often, there are more structured and secure ways to achieve your goal without directly calling functions from strings. Consider using dictionaries to map strings to functions or employing design patterns like the strategy pattern.

Example

def add(x, y):
    return x + y

def subtract(x, y):
    return x - y

operation = input("Enter operation ('add' or 'subtract'): ")
num1 = float(input("Enter first number: "))
num2 = float(input("Enter second number: "))

if operation in ["add", "subtract"]:
    selected_function = globals()[operation]
    result = selected_function(num1, num2)
    print(f"Result: {result}")
else:
    print("Invalid operation!")

In this example, the user's input determines which function (add or subtract) is called.

This Python code defines three functions: add, subtract, and greet. It then prompts the user to choose one of these functions by name. Based on the user's input, the code dynamically calls the chosen function with user-provided arguments and displays the result. The code includes input validation to ensure the user enters a valid function name and, for the arithmetic functions, numeric input.

def add(x, y):
    """Adds two numbers."""
    return x + y

def subtract(x, y):
    """Subtracts two numbers."""
    return x - y

def greet(name):
    """Greets the person passed in as a parameter."""
    return f"Hello, {name}!"

# Store function names in a list
functions = ["add", "subtract", "greet"]

# Get user input for function name
while True:
    function_name = input(f"Enter a function name ({', '.join(functions)}): ")
    if function_name in functions:
        break
    else:
        print("Invalid function name. Please try again.")

# Call the function dynamically
if function_name == "greet":
    name = input("Enter a name: ")
    result = globals()[function_name](name)
else:
    try:
        num1 = float(input("Enter the first number: "))
        num2 = float(input("Enter the second number: "))
        result = globals()[function_name](num1, num2)
    except ValueError:
        print("Invalid input. Please enter numbers only.")
        result = None

# Print the result
if result is not None:
    print(f"Result: {result}")

Explanation:

1. Define Functions: We define three functions: add, subtract, and greet.
2. Function List: A list functions stores the valid function names for user selection.
3. User Input: The code prompts the user to enter a function name from the list. Input validation ensures the entered name is valid.
4. Dynamic Function Call:
   • The globals()[function_name] expression retrieves the function object from the global namespace using the string stored in function_name.
   • Depending on the chosen function, the code prompts for appropriate arguments (numbers for add/subtract, a name for greet).
   • It then calls the retrieved function with the provided arguments.
5. Error Handling: A try-except block handles potential ValueError exceptions if the user enters non-numeric input for add or subtract.
6. Result Display: Finally, the code prints the result of the function call, if available.

Key Points:

• User Choice: This example demonstrates how a user's input can determine the program's flow by dynamically selecting which function to execute.
• Input Validation: Validating user input is crucial to prevent errors and enhance the robustness of the code.
• Flexibility: Dynamic function calling provides flexibility, allowing your program to adapt its behavior based on runtime conditions.

On getattr():

• Flexibility: getattr() isn't limited to functions. You can use it to retrieve any attribute of an object (methods, variables) by its name.
• Nested Attributes: You can chain getattr() calls to access attributes within nested objects. For example: getattr(getattr(my_object, 'nested_object'), 'attribute_name')

On globals() and locals():

• Scope Awareness: Be mindful of the scope when using these. globals() accesses global variables, while locals() accesses variables in the current local scope.
• Dynamic Environments: These functions are particularly useful in dynamic environments like web servers where function names might be determined based on request parameters.

Security and Best Practices:

• Sanitize Input: Always sanitize user input rigorously before using it to call functions dynamically. This helps prevent code injection attacks.
• Whitelisting: Consider creating a whitelist of allowed function names to restrict what users can execute.
• Design Patterns: Explore design patterns like the Command pattern or Factory pattern. They offer more structured and maintainable ways to handle dynamic function execution.

Additional Techniques:

• eval() (Use with Extreme Caution): While powerful, eval() is generally discouraged for dynamic function calling due to its security risks. If you must use it, ensure the input is completely trusted and sanitized.
• inspect Module: The inspect module provides advanced tools for introspection, including ways to get information about functions and call them dynamically.

When to Use Dynamic Function Calling:

• Configuration-driven Logic: When the behavior of your program needs to change based on configuration files or user settings.
• Plugins and Extensions: Allowing users to extend functionality by registering functions that can be called dynamically.
• Frameworks and Libraries: Frameworks often use dynamic function calling to provide flexibility and extensibility.

Remember: Dynamic function calling can make your code more concise and adaptable, but it also introduces complexity and potential security risks. Use it judiciously and prioritize security and maintainability.

This table summarizes how to call Python functions dynamically using their names stored as strings:

Key Points:

• Dynamic function calling is useful when the function to execute is determined at runtime.
• Prioritize security: Be extremely cautious with user input and avoid eval().
• Consider alternatives like dictionaries or design patterns for safer and more structured solutions.

Dynamic function calling in Python, where functions are called using their names stored as strings, offers flexibility in scenarios where the specific function to execute is unknown until runtime. Techniques like using getattr(), globals(), and locals() enable this capability. However, it's crucial to prioritize security, especially when handling user input, as misuse can lead to vulnerabilities. While eval() exists, it's strongly discouraged due to its high security risks. Alternatives like dictionaries or design patterns offer safer and more structured approaches. Choosing the appropriate method depends on factors like the function's location (module, class, or scope) and the source of the function name. Always sanitize user input rigorously and consider whitelisting allowed function names to mitigate risks. By understanding the methods, security implications, and best practices, developers can leverage dynamic function calling effectively while maintaining a secure and robust codebase.

• Call a function by a String name - Python - GeeksforGeeks | A Computer Science portal for geeks. It contains well written, well thought and well explained computer science and programming articles, quizzes and practice/competitive programming/company interview Questions.
• Python: call a function from string name - Stack Overflow | Oct 29, 2011 ... If it's in a class, you can use getattr: class MyClass(object): def install(self): print "In install" method_name = 'install' # set by the ...
• Here is how to call a function of a module by using its name in Python | To call a function of a module by using its name in Python, you can use the getattr function. Alternatively, you can also use the globals() function to retrieve ...
• Calling a class function using strings in Python - Stack Overflow | Mar 30, 2020 ... I want to create a function where you can put in a string and that it scans through all the different classes and gives back te names of all the matching ...
• Python: How to dynamically call a method/function given a string of ... | Python: How to dynamically call a method/function given a string of its name - python-call-method-from-string.py
• Use a string to call function in Python - Stack Overflow | Nov 9, 2010 ... This does not exactly answer your question, but maybe it helps nevertheless: As mentioned, eval should be avoided if possible.
• inspect — Inspect live objects — Python 3.12.7 documentation | Source code: Lib/inspect.py The inspect module provides several useful functions to help get information about live objects such as modules, classes, methods, functions, tracebacks, frame objects, ...
• Call a Function by a String name in Python | by Glasshost | Medium | Sometimes, we may need to call a function in Python whose name is only known during runtime or whose name is stored in a string. In such cases, we can use the getattr() function to call the…
• ctypes — A foreign function library for Python — Python 3.12.7 ... | Source code: Lib/ctypes ctypes is a foreign function library for Python. It provides C compatible data types, and allows calling functions in DLLs or shared libraries. It can be used to wrap these ...