TypeError: 'str' object is not callable in python script

Your error specifically is because you're trying to call a method with the signature string(db, usr). The line sys.argv[1] refers to the string located in the list argv in your program sys. Strings are not callable; your code is the equivalent of:

"add"(db, usr)  # add is not a variable name.

The answer to the other question used a dictionary whose lookup-keys were associated with the specific methods of the same name, so they didn't call the string so much as lookup the method from the dictionary using the string.

In order to call the function named by sys.argv[1] it needs to be fetched first. For example:

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

def mul(x,y):
    return x * y

def perform(action, x, y):
    # action is a string containing a function name ("add" or "mul").
    # globals() contains the accessible members, along with the functions.
    return globals()[action](x, y)

In the context of the original code:

actions = ['add','rem','rmusr']
if sys.argv[1] in actions:
    func = globals()[sys.argv[1]]
    sys.exit(func(db, usr))

sys.argv[1] is of type str (a string), and a string is not a function. So when you try to execute sys.argv[1](db, usr), you are literally trying to execute a string as if it were a function, which is not allowed.

What you can do, however, is lookup the function by using the value inside sys.argv[1]. You can do this multiple ways. One way would be to lookup the function by using globals(), which returns a dictionary of the names of the functions mapped to the actual function itself.

For example:

Lets say you execute your program with this command: python myScript.py argument1. That would mean that sys.argv[1] would have the value "argument1". Then you would take this value and lookup the function in the dictionary returned by globals() (or you could use locals() if you are in the same scope as the function you are calling):

sys.exit(globals()[sys.argv[1]](db, usr))

The other way would be to create this dictionary yourself:

actions = {'add': add, 'rem': rem, 'rmusr': rmusr}
if sys.argv[1] in actions:
    sys.exit(actions[sys.argv[1]](db, usr))

You could use something like this:

# specify the function to call for each command:
# (note: the lookup key is a string, but the value is a function reference)
actions = {'add': add, 'rem': rem, 'rmusr': rmusr}
cmd = sys.argv[1]
# check if it's in the dictionary's keys
if cmd in actions:
    # lookup the function to call
    func = actions[cmd]
    # call the function
    sys.exit(func(db, usr))

Or this is less verbose, but also less specific. It uses the fact that all defined functions are listed by name in the globals() dictionary.

# list of all allowed commands:
actions = ['add', 'rem', 'rmusr']
cmd = sys.argv[1]
# check if it's allowed
if cmd in actions:
    # lookup the function by name in the globals() dictionary
    func = globals()[cmd]
    # call the function
    sys.exit(func(db, usr))

I prefer using: https://docs.python.org/3.3/library/argparse.html Using the argparse you have morze flexability using the command lines args. You can easily use the if statement if an arg is used im the command lines.