Understanding argument parsing with argparse in Python

Question

I am now starting exploring Python, and was testing how arguments can be passed to a script with "argparse". The way I wrote a sample script was as following, where arguments passed through flags -i and -o are compulsory and flag -u is optional:

#!/usr/bin/python

import sys
import argparse

## set usage options and define arguments
usage = "usage: %prog [options]"
parser = argparse.ArgumentParser(usage)

parser.add_argument("-i",  action="store", dest="input", help="input file")
parser.add_argument("-o",  action="store", dest="output", help="output file")
parser.add_argument("-u", action="store_true", dest="isunfolded", default=False, help="optional flag")

args = parser.parse_args()

print len(sys.argv)  
if len(sys.argv) < 2:
#        parser.print_help()   
        print 'Incorrect number of params'
        exit()
else:
        print "Correct number of params: ", len(sys.argv)

Running this script:

> ./test-args.py -i a -o b

prints:

5
Correct number of params:  5

I understand the printing statement in the if conditional (5 is higher than 2), however, after reading the argparse documentation (https://docs.python.org/3/library/argparse.html) I still don't quite understand why -i and -o flags are counted as arguments. This behaviour seems to be quite different from e.g. perl Getopt::Std, which I'm more used to.

So, the question is what is the best way of parsing arguments in Python and to evaluate the presence of mandatory arguments (without using required=True)

Why don't you want to use required=True? Also, sys.argv contains the unparsed list of arguments, namely ["./test-args.py", "-i", "a", "-o", "-b"]. If you want the parsed arguments, you should inspect args.input, args.output, and args.isunfolded. After the arguments are parsed, they are no longer in the form of a list (except for positional arguments), so it makes no sense to ask for "number of arguments". — Rufflewind
– Rufflewind, Commented Jan 6, 2015 at 20:12
@Rufflewind yes I know that inspect args.input, args.output, and args.isunfolded is the best way to do it, but since I'm still learning Python I want to understand these simple forms. — PedroA
– PedroA, Commented Jan 6, 2015 at 21:09
@Ashalynd "print len(args)" produces the following error: "TypeError: object of type 'Namespace' has no len()" — PedroA
– PedroA, Commented Jan 6, 2015 at 21:16

ButterDog · Accepted Answer · 2015-01-06 20:14:32Z

2

It gives you 5 because sys.argv contains the raw input passed to python as arguments (the script name and 4 arguments).

You can see argparse as an abstraction for this, so once you use it, you can forget about sys.argv. In most cases it is better not to mix these two methods.

argparse its a nice way to handle arguments, I don't quite get why you don't want to use the required option when that's exactly the way to go. Another alternative is to parse the sys.argv yourself (regex maybe?) and drop argparse altogether.

answered Jan 6, 2015 at 20:14

ButterDog

5,2536 gold badges47 silver badges62 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

hpaulj · Accepted Answer · 2015-01-06 23:42:37Z

There's a Python getopt which probably is similar to the Perl one (assuming both are modelled after the C/Unix version).

https://docs.python.org/2/library/getopt.html

In your code, sys.argv is a list of strings from the command line (as interpreted by the shell and interpreter). It is the raw input for any of the parsers ('getopt', 'optparse', 'argparse'). And it is available for your parsing as well. When learning it is a good idea to include a

print sys.argv

line. parser.parse_args() uses this list. sys.argv[0] is used as prog attribute (in the default usage), while sys.argv[1:] (the rest) is parsed according to the rules you define with add_argument. For testing I often like to use parse_args with a custom list of strings, e.g.

print parser.parse_args(['-i', 'input', '-o', 'output', '-u'])

With your definition I'd expect to see something like:

Namespace(input='input', output='output', isunfolded=True)

The parser returns an object (type argparse.Namespace), which has attributes defined by your arguments. Values are usually accessed with expressions like args.input, args.isunfolded. The docs also show how you easily express this as a dictionary.

By long standing UNIX conventions, arguments flagged by strings like '-i' are options, that is they are optional. argparse generalizes this concept by letting you specify a required=True parameter.

Other arguments are positionals. They are interpreted according to their order. And as such they are normally required. What argparse adds is the ability to define those positionals, such as type, nargs, etc. With nargs='?' they are optional. Many of the nargs values are similar to regular expression characters (e.g. +?*). In fact argparse uses a form a regular expression parsing to allocate strings among arguments.

I'd refine your arguments thus (taking advantage of various defaults)

a1 = parser.add_argument("-i", "--input", help="input file")  # 'store' is the default
a2 = parser.add_argument("-o", "--output",help="output file") # use the --output as dest
a3 = parser.add_argument("-u", "--isunfolded",  action="store_true", help="optional flag")

If input and output were required, I could change them to:

parser.add_argument("input", help="input file")  # 'store' is the default
parser.add_argument("output",help="output file") # use the --output as dest
parser.add_argument("-u", "--isunfolded",  action="store_true", help="optional flag")

Now input and output are positional arguments, as in test.py -u inputfile outputfile

By using a1 = parser... I can look at the object produced by this statement.

print a1

produces

_StoreAction(option_strings=['-i', '--input'], dest='input', nargs=None, const=None,
    default=None, type=None, choices=None, help='input file', metavar=None)

This tells me that a1 is a _StoreAction object (a subclass of argparse.Action). It also displays a number (not all) of its attributes, ones that define its action. A positional, on the other hand, has values like these:

a2 = p.add_argument("output", help="output file")
_StoreAction(option_strings=[], dest='output', nargs=None, const=None, 
    default=None, type=None, choices=None, help='output file', metavar=None)

It may also be instructive to look at a1.required and a2.required, which are respectively False and True. required is an Action attribute that is not routinely displayed, but is, never the less accessible.

I've pulled all these test values from a parser defined in an interactive shell (Ipython). It's a great way to explore Python and modules like argparse.

PedroA · Accepted Answer · 2015-01-06 21:53:08Z

0

After reading other related posts it seems that the best way to do this is as was suggested by @Rufflewind and inspect the args itself:

if not args.input or not args.output:
        print 'Incorrect number of params'
        exit()
else:
        print "Correct number of params"

answered Jan 6, 2015 at 21:53

PedroA

1,9254 gold badges31 silver badges53 bronze badges

Collectives™ on Stack Overflow

Understanding argument parsing with argparse in Python

3 Answers 3

Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related