Some advantages of using argparse to handle arguments as well as options
I started using Python long enough ago that there was only the getopt module, which was okay because that's what I was used to from C and other Unix languages (shell, Perl, etc), and then evolved for a bit through optparse; I only started using argparse relatively recently. As a result of all of this background, I'm used to thinking of 'argument handling' as only processing command line switches and their arguments for you, and giving you back basically a list of the remaining arguments, which is your responsibility to check how many there are, parse, and so on.
Despite being very accustomed to working this way, I'm starting to abandon it when using argparse. Part of this is what I discovered the first time I used argparse, namely that it's the lazy way. But I've now used argparse a second time and I'm feeling that there are real advantages to letting it handle as many positional arguments as possible in as specific a way as possible.
For instance, suppose that you're writing a Python program that takes exactly five positional arguments. The lazy way to handle this is simply:
parser.add_argument("args", metavar="ARGS", nargs=5)
If you take exactly five arguments, they probably mean different things. So the better way is to add them separately:
parser.add_argument("eximid", metavar="EXIMID") parser.add_argument("ctype", metavar="CONTENT-TYPE") parser.add_argument("cdisp", metavar="CONTENT-DISPOSITION") parser.add_argument("mname", metavar="MIMENAME") parser.add_argument("file", metavar="FILE")
Obviously this gives you easy separate access to each argument in
your program, but the really nice thing this does is that it adds
some useful descriptive context to your program's usage message.
If you choose the
metavar values well, your usage message will
strongly hint to what needs to be supplied as each argument. But
we can do better, because argparse is perfectly happy to let you
attach help to positional arguments as well as to switches (and it
will then print it out again in the usage message, all nicely
formatted and so on).
You can do the same thing by hand, of course; there's nothing preventing you from writing the same documentation with manual argument parsing and printing it out appropriately (although argparse does do a good job of formatting it). But it feels easier with argparse and it feels more natural, because argparse lets me put everything to do with a positional argument in one spot; I can name the internal variable, specify its visible short name, and then add help, all at once. If nothing else, this is likely to keep all of these things in sync with each other.
(And I'm not going to underestimate the importance of automatic good formatting, because that removes a point of friction in writing the help message for a given positional argument.)
The result of all of this is that using argparse for positional arguments in my latest program has effortlessly given me not just a check for having the right number of positional arguments but a bunch of useful help text as well. Since I frequently don't touch programs for a year or two, I foresee this being a useful memory jog for future me.
In summary, if I can get argparse to handle my positional arguments in future Python programs, I'm going to let it. I've become convinced that it's not just the lazy way, it's the better way.
(This is where some Python people may laugh at me for having taken so long to start using argparse. In my vague defense, we still have some machines without Python 2.7.)