Map Python Command Strings to Functions

Mapping command strings to existing functions lets you turn user input like "start" or "stop" into direct function calls without a long chain of if/elif statements. This makes your code cleaner, easier to extend, and perfect for building command-line tools, chat bots, or simple game engines. You only need a basic understanding of Python functions and dictionaries to follow along.

What You’ll Need

Python 3.6 or newer (for guaranteed dictionary order, though not strictly required).
A text editor or IDE.
Basic familiarity with defining and calling functions.

Step-by-Step

Define the functions you want to map. Start with the actual functions that will perform the work. For example:

def start():
    print("Starting...")

def stop():
    print("Stopping...")

def status():
    print("All systems nominal.")

Create a dictionary that maps command strings to those functions. The keys are the exact strings the user will type, and the values are the function objects themselves (without parentheses—you’re not calling them yet).
```
commands = {
    "start": start,
    "stop": stop,
    "status": status,
}
```
Get user input. Use input() for a simple command-line interface, or accept a string from any other source (like a web form or a socket). Strip whitespace and convert to lowercase if you want case-insensitive matching.
```
user_input = input("Enter command: ").strip().lower()
```
Look up the function in the dictionary. Use the get() method to safely retrieve the function. If the key exists, you get the function; if not, you get None (or a default you provide).
```
func = commands.get(user_input)
```
Call the function if it exists. Check if func is not None, then call it with parentheses. If it’s None, handle the unknown command gracefully.
```
if func:
    func()
else:
    print(f"Unknown command: {user_input}")
```
Handle functions that need arguments. If your functions take parameters, you can store them as lambda functions or use functools.partial. For example:
```
def greet(name):
    print(f"Hello, {name}!")

commands = {
    "greet": lambda: greet("World"),
    "greet_alice": lambda: greet("Alice"),
}
```
Or, for dynamic arguments, parse the input and pass them separately.

Use a loop to keep the program running. Wrap the input and dispatch in a while True loop, with an exit command like "quit" that breaks the loop.

while True:
    user_input = input("Enter command: ").strip().lower()
    if user_input == "quit":
        break
    func = commands.get(user_input)
    if func:
        func()
    else:
        print(f"Unknown command: {user_input}")

Common Mistakes

Calling the function when storing it in the dictionary. Writing "start": start() executes the function immediately and stores the return value (often None) instead of the function itself. Always store the function name without parentheses.
Forgetting to strip or lowercase the input. Users often type extra spaces or capital letters. If your dictionary keys are lowercase, a command like "Start" will fail. Normalize input before lookup.
Using commands[user_input] directly. This raises a KeyError if the command doesn’t exist. Use .get() to avoid crashing.
Not handling functions with different signatures. If some functions take arguments and others don’t, a simple dictionary lookup won’t work. You need to standardize the call signature (e.g., all functions accept *args) or use lambdas to adapt.

Tips

Use functools.partial for functions with fixed arguments. This avoids lambdas and can be more readable: commands = {"greet": partial(greet, "World")}.
Consider using a class to group related commands. You can map strings to bound methods, which automatically receive self.
Add aliases. You can map multiple keys to the same function: "start", "go", "begin" all point to start.
Use __doc__ for help. You can automatically generate a help message by iterating over the dictionary and printing each function’s docstring.
Keep the dictionary near the functions. This makes it easy to see what commands are available and what they do.

Troubleshooting

Command is found but nothing happens. Check that you actually called the function with parentheses. If you wrote func without (), nothing executes.
Getting TypeError: 'NoneType' object is not callable. This means .get() returned None, and you tried to call it. Make sure you check for None before calling.
Commands with arguments fail. If your function expects arguments but you’re calling it with none, you’ll get a TypeError. Use lambdas or partial to provide the arguments, or parse the input string and pass them dynamically.
Case sensitivity issues. If you want case-insensitive commands, ensure you convert both the input and the dictionary keys to lowercase. You can also build the dictionary with lowercase keys and use input().lower().
Dictionary order is not what you expect. In Python 3.7+, dictionaries preserve insertion order, but if you need a specific order for help text, sort the keys when displaying.

Frequently Asked Questions

Can I map a command to a function that takes arguments from the user?

Yes. You can split the input string into a command and arguments, then pass the arguments to the function. For example, "greet Alice" could be split into "greet" and ["Alice"], then call func(*args).

What if I have hundreds of commands?

Dictionaries scale well. You can even generate the dictionary programmatically by iterating over a list of function names or using decorators to register commands automatically.

Is this the same as using `eval()`?

No. eval() executes arbitrary code, which is dangerous. Mapping to known functions only runs code you’ve explicitly defined, making it safe for user input.

Can I map commands to methods of a class instance?

Yes. Store the bound method as the value: commands = {"start": obj.start}. When you call func(), it will call the method on that instance.

How do I add a new command later?

Simply define the function and add a new key-value pair to the dictionary. No other code changes are needed.

What if two commands should do the same thing?

Just point both keys to the same function: {"start": start, "go": start}. This is a clean way to create aliases.

Method: the standard formula for this calculation, rounded as each result states. See how the calculators work or report an error.

More cards in this drawer

The whole Numbers and Powers drawer →