Call a Function by Name in a Python Module

By the end of this page, you will understand how Python can look up functions dynamically by name, how to use getattr() to access a function from a module or object, how to call it safely, and when a dictionary-based dispatch pattern is a better choice.

In Python, functions inside a module are attributes of that module. That means if a module contains a function like bar, Python stores it similarly to how it stores variables and constants on that module.

When you write:

import foo
foo.bar()

Python is accessing the bar attribute from the foo module and then calling it.

If the function name is stored as a string, you cannot write foo.func_name() because that looks for a function literally named func_name. Instead, you need a way to ask Python:

• "Get the attribute whose name is this string"
• Then call it if it is a function

The built-in function getattr() is the standard tool for this.

function = getattr(foo, "bar")
function()

This matters because dynamic lookup is common in real programs:

• command handlers
• plugin systems
• configuration-based behavior
• API routing
• event processing

However, dynamic function calls should be used carefully. If the string comes from a user or external input, blindly calling whatever name is provided can be unsafe or lead to hard-to-debug code. In many real projects, developers use a controlled dispatch table instead of unrestricted dynamic lookup.

Think of a Python module like a toolbox with labeled compartments.

• The module is the toolbox
• Each function is a tool inside it
• The function name is the label on the compartment
• getattr(module, name) means: "Open the compartment with this label"

If the label exists, you get the tool. If not, Python raises an error.

Then calling the function is like taking the tool out and using it.

So this:

foo.bar()

is the direct version, while this:

name = "bar"
getattr(foo, name)()

is the version where you first look up the label dynamically.

The core syntax is:

getattr(object_or_module, attribute_name)

To call a function by name from a module:

import foo

func_name = "bar"
func = getattr(foo, func_name)
func()

You can also do it in one line:

getattr(foo, func_name)()

Example 1: Simple dynamic function call

Suppose foo.py contains:

# foo.py

def bar():
    print("Hello from bar")

Then another file can do:

import foo

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

Output:

Hello from bar

Example 2: Calling a function with arguments

Consider this code:

# foo.py

def add(a, b):
    return a + b

import foo

func_name = "add"
func = getattr(foo, func_name)
result = func(2, 3)
print(result)

Here is what happens step by step:

1. import foo

   • Python loads the foo module.
   • The function add becomes available as foo.add.

2. func_name = "add"

   • A string is stored in func_name.
   • This is only text, not a function yet.

3. func = getattr(foo, func_name)

   • Python reads the value of func_name, which is "add".

Dynamic function lookup is useful when the function to run is not known until runtime.

Command-line tools

A command name can map to a function:

command = "build"
getattr(commands_module, command)()

Plugin systems

A config file may specify which processor to run:

processor_name = config["processor"]
processor = getattr(processors, processor_name)
processor(data)

Event handlers

Different event names can trigger different functions:

event_name = "on_login"
handler = getattr(handlers, event_name)
handler(user)

Data processing scripts

A script may apply a transformation chosen by name:

transform_name = "normalize"
transform = getattr(transforms, transform_name)
clean_data = transform(raw_data)

Testing utilities

Test frameworks and helper scripts sometimes discover functions dynamically by naming rules.

In real projects, developers often use dynamic lookup in controlled ways rather than calling any arbitrary string.

1. Guard clauses before calling

func = getattr(foo, func_name, None)
if func is None:
    raise ValueError(f"Unknown function: {func_name}")

return func()

This avoids crashing with an unclear error.

2. Check that the attribute is callable

Not every attribute on a module is a function.

value = getattr(foo, func_name, None)
if value is None:
    raise ValueError("Not found")
if not callable(value):
    raise TypeError(f"{func_name} exists but is not callable")

value()

3. Use a dispatch table for safety

This is often better when only a few functions are allowed.

import foo

DISPATCH = {
    "bar": foo.bar,
    "baz": foo.baz,
}

func = DISPATCH.get(func_name)
 func  :
     ValueError()

func()

Mistake 1: Using dot notation with the variable name

Broken code:

import foo

func_name = "bar"
foo.func_name()

Why it is wrong:

• Python looks for an attribute literally named func_name
• It does not use the string value stored in the variable

Correct version:

getattr(foo, func_name)()

Mistake 2: Forgetting to call the function

Broken code:

func = getattr(foo, "bar")
print(func)

This prints the function object instead of running it.

Correct version:

func = getattr(foo, "bar")
func()

Mistake 3: Not handling missing names

Broken code:

func = getattr(foo, "does_not_exist")
func()

This raises AttributeError.

getattr() vs dispatch dictionary

Core pattern

func = getattr(module, "function_name")
func()

One-line call

getattr(module, name)()

With arguments

getattr(module, name)(arg1, arg2)

Safe lookup with default

func = getattr(module, name, None)
if func is not None:
    func()

Check callability

value = getattr(module, name, None)
if callable(value):
    value()

Safer controlled alternative

DISPATCH = {
    "bar": foo.bar,
    "baz": foo.baz,
}

func = DISPATCH.get(name)
if func:
    func()

Rules to remember

How do I call a function by string name in Python?

Use getattr():

func = getattr(foo, "bar")
func()

Can I call foo.func_name() if func_name = "bar"?

No. That looks for an attribute literally named func_name. To use the string value, use getattr(foo, func_name).

What happens if the function name does not exist?

getattr() raises AttributeError unless you provide a default value:

getattr(foo, func_name, None)

Can getattr() return something other than a function?

Yes. It returns any attribute with that name, such as strings, numbers, classes, or variables. Use callable() if you need to verify that it can be called.

Is getattr() safe to use with user input?

Not by itself. If the name comes from a user, it is better to validate it or use a dispatch dictionary with only allowed functions.

• getattr() — the built-in function used to retrieve an attribute by string name.
• attributes and objects — functions in modules and methods on objects are accessed as attributes.
• modules in Python — a module acts like a namespace containing functions, variables, and classes.
• callable objects — not every attribute is callable, so this concept helps when validating what you retrieved.
• dictionaries — a common alternative for mapping strings to functions explicitly.
• error handling with try/except — useful when dynamic lookup may fail.
• functions as first-class objects — Python lets you store functions in variables and pass them around.
• dynamic dispatch — the broader idea of choosing what code to run at runtime.