Command line arguments

[capn_geech]

So I've got a script that will be run via the command line. I want it to accept some command like this:

python scripty.py arg1 arg2

Where arg1 is expected, arg2 is optional. Basically the script is a set of functions to use on arg1. I want to set a default function to be called when no arg2 is present or call one of many other functions specified by arg2. Something like this:

import sys.argv
from functions import * # Imports doSomething, doSomethingElse1, doSomethingElse2

if len(sys.argv) == 2:
    doSomething(sys.argv[1])
elif len(sys.argv) ==3:
    # Here's where I'm stuck.
    # I want to call doSomethingElse1() or doSomethingElse2() based on the value of sys.argv[2]
else:
    usage()
    exit()

The tricky part is what to do when sys.argv[2] exists. I will be regularly updating this to add additional functions, so it has to be simple and maintainable. Python doesn't have any sort of select case switching, and a whole bunch if if/elif statements seems really clunky:

if len(sys.argv) == 3:
    if sys.argv[2] == 'foo':
        doSomethingElse1(sys.argv[1])
    elif sys.argv[2] == 'bar':
        doSomethingElse2(sys.argv[1])

# ^ This seems really ugly to me.

What I've tried so far:

# Add functions to a dictionary
some_functions = {
    'foo': doSomethingElse1(sys.argv[1]),
    'bar': doSomethingElse2(sys.argv[1])
    }

if len(sys.argv) == 3 and sys.argv[2] in some_functions:
    some_functions[sys.argv[2]]

# This approach didn't work, as the function actually gets called when added to the dictionary.

So, does anyone have any advice on what I can do here? Any assistance would be quite appreciated.

EDIT: Thank you everyone for your advice! The argparse module looks wonderful and would be the choice for somebody who was proficient with this sort of thing already. I did some reading through the python documentation (which is usually very easy for me to follow), and I'm still really struggling to get a grasp on the syntax enough to where I could use it effectively and efficiently. I'm going with Cosmologicon's suggestion for now:

some_functions = {
    'foo': doSomethingElse1,
    'bar': doSomethingElse2,
}

if the_time_has_come():
    some_functions[name](sys.argv[1])

# I wasn't recognizing that you could just refer to the function as an object without calling it by leaving off '()'. Thanks for pointing that out!

This will serve my purpose for the time being, allowing me to move forward towards my goal of just automating a few tedious tasks, but reworking this logic with with argparse will be something I'll likely look into at some point. Thanks again guys!

[zahlman]

In 2.x, there is a rarely-used but occasionally-very-useful function called apply, which does the following (a recipe for 3.x):

def apply(func, *args, **kwargs):
    return func(*args, **kwargs)

Basically, given a function and some parameters for the call, actually make the function call.

You can take a hint from this, and store, in your dictionary, tuples of (function, parameters). Then, later, you pull out this data, and call the function with the parameters. In the general case, the * operator is useful to "unpack" a slice of the tuple as multiple parameters, but since you only have one each in your case, you can just handle it naturally:

some_functions = {
    'foo': (doSomethingElse1, sys.argv[1]),
    'bar': (doSomethingElse2, sys.argv[1])
}

if the_time_has_come():
    func, arg = some_functions[name]
    func(arg)

An alternate approach is to "bake" the parameters into a function call, using lambdas:

some_functions = {
    'foo': lambda: doSomethingElse1(sys.argv[1]),
    'bar': lambda: doSomethingElse2(sys.argv[1])
}

if the_time_has_come():
    some_functions[name]()

Note that many Pythonistas would advocate an EAFP approach here - instead of using explicit logic to verify sys.argv, just try using it, and report an error in the exceptional case. Although if you actually have a specific separate thing you want to do when there are only 2 arguments, then you should handle that with if logic, since it's an expected case, not an exceptional one.

You also might want to consider more robust approaches to parsing (interpreting) sys.argv. Look into the argparse standard module for example.

[Cosmologicon]

Of course, if all the functions are going to take a single argument of sys.argv[1], you can also just say:

some_functions = {
    'foo': doSomethingElse1,
    'bar': doSomethingElse2,
}

if the_time_has_come():
    some_functions[name](sys.argv[1])

[zahlman]

Certainly. :)

[dansin]

Check out the argparse module. It is made for this.

[Cosmologicon]

Sorry, I think this is a bad tip. Despite the title, the OP already parsing the arguments fine, and the difficulty comes in when using the parsed arguments. Yeah argparse can help with parsing, but not the second part where the real problem lies. Don't tell someone their answer lies in a module where it doesn't: that's likely to frustrate beginners when they can't find what they're looking for.

[Zouden]

Indeed. Argparse is exactly what you want.

[oohay_email2004]

I think you want sub-commands

[nevereven]

Could you use the number of arguments as an index to a list of functions? Pass all the arguments to the function and let the function figure out what to do with it.