Simple argparse example wanted: 1 argument, 3 results

Posted on

Question :

Simple argparse example wanted: 1 argument, 3 results

The documentation for the argparse python module, while excellent I’m sure, is too much for my tiny beginner brain to grasp right now. I don’t need to do math on the command line or meddle with formatting lines on the screen or change option characters. All I want to do is “If arg is A, do this, if B do that, if none of the above show help and quit”.

Answer #1:

My understanding of the original question is two-fold. First, in terms of the simplest possible argparse example, I’m surprised that I haven’t seen it here. Of course, to be dead-simple, it’s also all overhead with little power, but it might get you started.

import argparse

parser = argparse.ArgumentParser()
args = parser.parse_args()

if args.a == '':
    print 'You nailed it!'

But this positional argument is now required. If you leave it out when invoking this program, you’ll get an error about missing arguments. This leads me to the second part of the original question. Matt Wilkie seems to want a single optional argument without a named label (the –option labels). My suggestion would be to modify the code above as follows:

parser.add_argument("a", nargs='?', default="check_string_for_empty")
if args.a == 'check_string_for_empty':
    print 'I can tell that no argument was given and I can deal with that here.'
elif args.a == '':
    print 'You nailed it!'
    print args.a

There may well be a more elegant solution, but this works and is minimalist.

Answered By: mightypile

Answer #2:

Here’s the way I do it with argparse (with multiple args):

parser = argparse.ArgumentParser(description='Description of your program')
parser.add_argument('-f','--foo', help='Description for foo argument', required=True)
parser.add_argument('-b','--bar', help='Description for bar argument', required=True)
args = vars(parser.parse_args())

args will be a dictionary containing the arguments:

if args['foo'] == 'Hello':
    # code here

if args['bar'] == 'World':
    # code here

In your case simply add only one argument.

Answered By: Diego Navarro

Answer #3:

The argparse documentation is reasonably good but leaves out a few useful details which might not be obvious. (@Diego Navarro already mentioned some of this but I’ll try to expand on his answer slightly.) Basic usage is as follows:

parser = argparse.ArgumentParser()
parser.add_argument('-f', '--my-foo', default='foobar')
parser.add_argument('-b', '--bar-value', default=3.14)
args = parser.parse_args()

The object you get back from parse_args() is a ‘Namespace’ object: An object whose member variables are named after your command-line arguments. The Namespace object is how you access your arguments and the values associated with them:

args = parser.parse_args()
print args.my_foo
print args.bar_value

(Note that argparse replaces ‘-‘ in your argument names with underscores when naming the variables.)

In many situations you may wish to use arguments simply as flags which take no value. You can add those in argparse like this:

parser.add_argument('--foo', action='store_true')
parser.add_argument('--no-foo', action='store_false')

The above will create variables named ‘foo’ with value True, and ‘no_foo’ with value False, respectively:

if (
    print "foo is true"

if (args.no_foo is False):
    print "nofoo is false"

Note also that you can use the “required” option when adding an argument:

parser.add_argument('-o', '--output', required=True)

That way if you omit this argument at the command line argparse will tell you it’s missing and stop execution of your script.

Finally, note that it’s possible to create a dict structure of your arguments using the vars function, if that makes life easier for you.

args = parser.parse_args()
argsdict = vars(args)
print argsdict['my_foo']
print argsdict['bar_value']

As you can see, vars returns a dict with your argument names as keys and their values as, er, values.

There are lots of other options and things you can do, but this should cover the most essential, common usage scenarios.

Answered By: DMH

Answer #4:

Matt is asking about positional parameters in argparse, and I agree that the Python documentation is lacking on this aspect. There’s not a single, complete example in the ~20 odd pages that shows both parsing and using positional parameters.

None of the other answers here show a complete example of positional parameters, either, so here’s a complete example:

# tested with python 2.7.1
import argparse

parser = argparse.ArgumentParser(description="An argparse example")

parser.add_argument('action', help='The action to take (e.g. install, remove, etc.)')
parser.add_argument('foo-bar', help='Hyphens are cumbersome in positional arguments')

args = parser.parse_args()

if args.action == "install":
    print("You asked for installation")
    print("You asked for something other than installation")

# The following do not work:
# print(
# print(args.foo_bar)

# But this works:
print(getattr(args, 'foo-bar'))

The thing that threw me off is that argparse will convert the named argument “–foo-bar” into “foo_bar”, but a positional parameter named “foo-bar” stays as “foo-bar”, making it less obvious how to use it in your program.

Notice the two lines near the end of my example — neither of those will work to get the value of the foo-bar positional param. The first one is obviously wrong (it’s an arithmetic expression minus bar), but the second one doesn’t work either:

AttributeError: 'Namespace' object has no attribute 'foo_bar'

If you want to use the foo-bar attribute, you must use getattr, as seen in the last line of my example. What’s crazy is that if you tried to use dest=foo_bar to change the property name to something that’s easier to access, you’d get a really bizarre error message:

ValueError: dest supplied twice for positional argument

Here’s how the example above runs:

$ python
usage: [-h] action foo-bar error: too few arguments

$ python -h
usage: [-h] action foo-bar

An argparse example

positional arguments:
  action      The action to take (e.g. install, remove, etc.)
  foo-bar     Hyphens are cumbersome in positional arguments

optional arguments:
  -h, --help  show this help message and exit

$ python install foo
You asked for installation
Answered By: Mark E. Haase

Answer #5:

Yet another summary introduction, inspired by this post.

import argparse

# define functions, classes, etc.

# executes when your script is called from the command-line
if __name__ == "__main__":

    parser = argparse.ArgumentParser()
    # define each option with: parser.add_argument
    args = parser.parse_args() # automatically looks at sys.argv
    # access results with: args.argumentName

Arguments are defined with combinations of the following:

parser.add_argument( 'name', options... )              # positional argument
parser.add_argument( '-x', options... )                # single-char flag
parser.add_argument( '-x', '--long-name', options... ) # flag with long name

Common options are:

  • help: description for this arg when --help is used.
  • default: default value if the arg is omitted.
  • type: if you expect a float or int (otherwise is str).
  • dest: give a different name to a flag (e.g. '-x', '--long-name', dest='longName').
    Note: by default --long-name is accessed with args.long_name
  • action: for special handling of certain arguments
    • store_true, store_false: for boolean args
      '--foo', action='store_true' => == True
    • store_const: to be used with option const
      '--foo', action='store_const', const=42 => == 42
    • count: for repeated options, as in ./ -vv
      '-v', action='count' => args.v == 2
    • append: for repeated options, as in ./ --foo 1 --foo 2
      '--foo', action='append' => == ['1', '2']
  • required: if a flag is required, or a positional argument is not.
  • nargs: for a flag to capture N args
    ./ --foo a b => = ['a', 'b']
  • choices: to restrict possible inputs (specify as list of strings, or ints if type=int).
Answered By: Jonathan H

Answer #6:

Note the Argparse Tutorial in Python HOWTOs. It starts from most basic examples, like this one:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("square", type=int,
                    help="display a square of a given number")
args = parser.parse_args()

and progresses to less basic ones.

There is an example with predefined choice for an option, like what is asked:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("square", type=int,
                    help="display a square of a given number")
parser.add_argument("-v", "--verbosity", type=int, choices=[0, 1, 2],
                    help="increase output verbosity")
args = parser.parse_args()
answer = args.square**2
if args.verbosity == 2:
    print("the square of {} equals {}".format(args.square, answer))
elif args.verbosity == 1:
    print("{}^2 == {}".format(args.square, answer))
Answered By: Alexey

Answer #7:

Here’s what I came up with in my learning project thanks mainly to @DMH…

Demo code:

import argparse

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('-f', '--flag', action='store_true', default=False)  # can 'store_false' for no-xxx flags
    parser.add_argument('-r', '--reqd', required=True)
    parser.add_argument('-o', '--opt', default='fallback')
    parser.add_argument('arg', nargs='*') # use '+' for 1 or more args (instead of 0 or more)
    parsed = parser.parse_args()
    # NOTE: args with '-' have it replaced with '_'
    print('Result:',  vars(parsed))
    print('parsed.reqd:', parsed.reqd)

if __name__ == "__main__":

This may have evolved and is available online:

Script to give this code a workout:

Answered By: Peter L

Answer #8:

You could also use plac (a wrapper around argparse).

As a bonus it generates neat help instructions – see below.

Example script:

#!/usr/bin/env python3
def main(
    arg: ('Argument with two possible values', 'positional', None, None, ['A', 'B'])
    """General help for application"""
    if arg == 'A':
        print("Argument has value A")
    elif arg == 'B':
        print("Argument has value B")

if __name__ == '__main__':
    import plac

Example output:

No arguments supplied –

usage: [-h] {A,B} error: the following arguments are required: arg

Unexpected argument supplied – C:

usage: [-h] {A,B} error: argument arg: invalid choice: 'C' (choose from 'A', 'B')

Correct argument supplied – A :

Argument has value A

Full help menu (generated automatically) – -h:

usage: [-h] {A,B}

General help for application

positional arguments:
  {A,B}       Argument with two possible values

optional arguments:
  -h, --help  show this help message and exit

Short explanation:

The name of the argument usually equals the parameter name (arg).

The tuple annotation after arg parameter has the following meaning:

  • Description (Argument with two possible values)
  • Type of argument – one of ‘flag’, ‘option’ or ‘positional’ (positional)
  • Abbreviation (None)
  • Type of argument value – eg. float, string (None)
  • Restricted set of choices (['A', 'B'])


To learn more about using plac check out its great documentation:

Plac: Parsing the Command Line the Easy Way

Answered By: quasoft

Leave a Reply

Your email address will not be published. Required fields are marked *