What s the best way to parse command line arguments

Question

What s the easiest  tersest  and most flexible method or library for parsing Python command line arguments

User · Answer

Argparse code can be longer than actual implementation code!

That's a problem I find with most popular argument parsing options is that if your parameters are only modest, the code to document them becomes disproportionately large to the benefit they provide.

A relative new-comer to the argument parsing scene (I think) is plac.

It makes some acknowledged trade-offs with argparse, but uses inline documentation and wraps simply around main() type function function:

def main(excel_file_path: "Path to input training file.",
     excel_sheet_name:"Name of the excel sheet containing training data including columns 'Label' and 'Description'.",
     existing_model_path: "Path to an existing model to refine."=None,
     batch_size_start: "The smallest size of any minibatch."=10.,
     batch_size_stop:  "The largest size of any minibatch."=250.,
     batch_size_step:  "The step for increase in minibatch size."=1.002,
     batch_test_steps: "Flag.  If True, show minibatch steps."=False):
"Train a Spacy (http://spacy.io/) text classification model with gold document and label data until the model nears convergence (LOSS < 0.5)."

    pass # Implementation code goes here!

if __name__ == '__main__':
    import plac; plac.call(main)

User · Answer

I prefer Click  It abstracts managing options and allows        creating beautiful command line interfaces in a composable way with as little code as necessary    Here s example usage   import click   click command    click option  --count   default 1  help  Number of greetings     click option  --name   prompt  Your name                 help  The person to greet    def hello count  name          Simple program that greets NAME for a total of COUNT times         for x in range count           click echo  Hello  s     name   if   name         main         hello     It also automatically generates nicely formatted help pages     python hello py --help Usage  hello py  OPTIONS     Simple program that greets NAME for a total of COUNT times   Options    --count INTEGER  Number of greetings    --name TEXT      The person to greet    --help           Show this message and exit

User · Answer

I prefer optparse to getopt  It s very declarative  you tell it the names of the options and the effects they should have  e g   setting a boolean field   and it hands you back a dictionary populated according to your specifications   http   docs python org lib module-optparse html

User · Answer

Here s a method  not a library  which seems to work for me   The goals here are to be terse  each argument parsed by a single line  the args line up for readability  the code is simple and doesn t depend on any special modules  only os   sys   warns about missing or unknown arguments gracefully  use a simple for range   loop  and works across python 2 x and 3 x  Shown are two toggle flags  -d  -v   and two values controlled by arguments  -i xxx and -o xxx    import os sys  def HelpAndExit        print   lt  lt your help output goes here gt  gt        sys exit 1   def Fatal msg       sys stderr write   s   s n     os path basename sys argv 0    msg       sys exit 1   def NextArg i          Return the next command line argument  if there is one         if   i 1   gt   len sys argv            Fatal    s  expected an argument    sys argv i       return 1  sys argv i 1        MAIN if   name       main          verbose   0     debug     0     infile     infile      outfile    outfile         Parse command line     skip   0     for i in range 1  len sys argv            if not skip              if   sys argv i   2      -d   debug    1             elif sys argv i   2      -v   verbose    1             elif sys argv i   2      -i    skip infile     NextArg i              elif sys argv i   2      -o    skip outfile    NextArg i              elif sys argv i   2      -h   HelpAndExit               elif sys argv i   1      -    Fatal    s  unknown argument    sys argv i               else                          Fatal    s  unexpected    sys argv i           else  skip   0      print   d  d  s  s     debug verbose infile outfile     The goal of NextArg   is to return the next argument while checking for missing data  and  skip  skips the loop when NextArg   is used  keeping the flag parsing down to one liners

User · Answer

consoleargs deserves to be mentioned here  It is very easy to use  Check it out   from consoleargs import command   command def main url  name None            param url  Remote URL     param name  File name         print    Downloading url   r  into file   r        url  name   if   name         main       main     Now in console     python demo py --help Usage  demo py URL  OPTIONS   URL     Remote URL   Options      --name -n   File name    python demo py http   www google com  Downloading url   http   www google com    into file  None     python demo py http   www google com  --name index html Downloading url   http   www google com    into file   index html

User · Answer

Using docopt  Since 2012 there is a very easy  powerful and really cool module for argument parsing called docopt  Here is an example taken from its documentation       Naval Fate   Usage    naval fate py ship new  lt name gt       naval fate py ship  lt name gt  move  lt x gt   lt y gt   --speed  lt kn gt     naval fate py ship shoot  lt x gt   lt y gt    naval fate py mine  set remove   lt x gt   lt y gt   --moored   --drifting    naval fate py  -h   --help    naval fate py --version  Options    -h --help     Show this screen    --version     Show version    --speed  lt kn gt   Speed in knots  default  10     --moored      Moored  anchored  mine    --drifting    Drifting mine       from docopt import docopt   if   name         main         arguments   docopt   doc    version  Naval Fate 2 0       print arguments    So this is it  2 lines of code plus your doc string which is essential and you get your arguments parsed and available in your arguments object   Using python-fire  Since 2017 there s another cool module called python-fire  It can generate a CLI interface for your code with you doing zero argument parsing  Here s a simple example from the documentation  this small program exposes the function double to the command line    import fire  class Calculator object      def double self  number       return 2   number  if   name         main       fire Fire Calculator    From the command line  you can run    gt  calculator py double 10 20  gt  calculator py double --number 15 30

User · Answer

This answer suggests optparse which is appropriate for older Python versions  For Python 2 7 and above  argparse replaces optparse  See this answer for more information   As other people pointed out  you are better off going with optparse over getopt   getopt is pretty much a one-to-one mapping of the standard getopt 3  C library functions  and not very easy to use   optparse  while being a bit more verbose  is much better structured and simpler to extend later on   Here s a typical line to add an option to your parser   parser add option  -q    --query               action  store   dest  query               help  query string   default  spam     It pretty much speaks for itself  at processing time  it will accept -q or --query as options  store the argument in an attribute called query and has a default value if you don t specify it   It is also self-documenting in that you declare the help argument  which will be used when run with -h --help  right there with the option   Usually you parse your arguments with   options  args   parser parse args     This will  by default  parse the standard arguments passed to the script  sys argv 1     options query will then be set to the value you passed to the script   You create a parser simply by doing  parser   optparse OptionParser     These are all the basics you need   Here s a complete Python script that shows this   import optparse  parser   optparse OptionParser    parser add option  -q    --query       action  store   dest  query       help  query string   default  spam    options  args   parser parse args    print  Query string    options query   5 lines of python that show you the basics   Save it in sample py  and run it once with  python sample py   and once with  python sample py --query myquery   Beyond that  you will find that optparse is very easy to extend  In one of my projects  I created a Command class which allows you to nest subcommands in a command tree easily   It uses optparse heavily to chain commands together   It s not something I can easily explain in a few lines  but feel free to browse around in my repository for the main class  as well as a class that uses it and the option parser

User · Answer

Use optparse which comes with the standard library  For example      usr bin env python import optparse  def main      p   optparse OptionParser     p add option  --person    -p   default  world     options  arguments   p parse args     print  Hello  s    options person  if   name         main       main     Source  Using Python to create UNIX command line tools  However as of Python 2 7 optparse is deprecated  see  Why use argparse rather than optparse

User · Answer

Lightweight command line argument defaults  Although argparse is great and is the right answer for fully documented command line switches and advanced features  you can use function argument defaults to handles straightforward positional arguments very simply   import sys  def get args name  default   first  a   second 2       return first  int second   first  second   get args  sys argv  print first  second   The  name  argument captures the script name and is not used  Test output looks like this    gt    test py a 2  gt    test py A A 2  gt    test py A 20 A 20   For simple scripts where I just want some default values  I find this quite sufficient  You might also want to include some type coercion in the return values or command line values will all be strings

User · Answer

argparse is the way to go  Here is a short summary of how to use it   1  Initialize  import argparse    Instantiate the parser parser   argparse ArgumentParser description  Optional app description     2  Add Arguments    Required positional argument parser add argument  pos arg   type int                      help  A required integer positional argument      Optional positional argument parser add argument  opt pos arg   type int  nargs                          help  An optional integer positional argument      Optional argument parser add argument  --opt arg   type int                      help  An optional integer argument      Switch parser add argument  --switch   action  store true                       help  A boolean switch     3  Parse  args   parser parse args     4  Access  print  Argument values    print args pos arg  print args opt pos arg  print args opt arg  print args switch    5  Check Values  if args pos arg  gt  10      parser error  pos arg cannot be larger than 10     Usage  Correct use       app 1 2 --opt arg 3 --switch  Argument values  1 2 3 True   Incorrect arguments       app foo 2 --opt arg 3 --switch usage  convert  -h   --opt arg OPT ARG   --switch  pos arg  opt pos arg  app  error  argument pos arg  invalid int value   foo       app 11 2 --opt arg 3 Argument values  11 2 3 False usage  app  -h   --opt arg OPT ARG   --switch  pos arg  opt pos arg  convert  error  pos arg cannot be larger than 10   Full help       app -h  usage  app  -h   --opt arg OPT ARG   --switch  pos arg  opt pos arg   Optional app description  positional arguments    pos arg            A required integer positional argument   opt pos arg        An optional integer positional argument  optional arguments    -h  --help         show this help message and exit   --opt arg OPT ARG  An optional integer argument   --switch           A boolean switch

User · Answer

Just in case you might need to  this may help if you need to grab unicode arguments on Win32  2K  XP etc     from ctypes import    def wmain argc  argv       print argc     for i in argv          print i     return 0  def startup        size   c int       ptr   windll shell32 CommandLineToArgvW windll kernel32 GetCommandLineW    byref size       ref   c wchar p   size value     raw   ref from address ptr      args    arg for arg in raw      windll kernel32 LocalFree ptr      exit wmain len args   args   startup

User · Answer

I think the best way for larger projects is optparse  but if you are looking for an easy way  maybe http   werkzeug pocoo org documentation script is something for you   from werkzeug import script    actions go here def action foo name             action foo does foo        pass  def action bar id 0  title  default title           action bar does bar        pass  if   name         main         script run     So basically every function action   is exposed to the command line and a nice help message is generated for free    python foo py  usage  foo py  lt action gt    lt options gt          foo py --help  actions    bar      action bar does bar      --id                          integer   0     --title                       string    default title    foo      action foo does foo      --name                        string

User · Answer

Pretty much everybody is using getopt  Here is the example code for the doc    import getopt  sys  def main        try          opts  args   getopt getopt sys argv 1     ho v     help    output         except getopt GetoptError            print help information and exit          usage           sys exit 2      output   None     verbose   False     for o  a in opts          if o     -v               verbose   True         if o in   -h    --help                usage               sys exit           if o in   -o    --output                output   a   So in a word  here is how it works   You ve got two types of options  Those who are receiving arguments  and those who are just like switches   sys argv is pretty much your char   argv in C  Like in C you skip the first element which is the name of your program and parse only the arguments   sys argv 1    Getopt getopt will parse it according to the rule you give in argument    ho v  here describes the short arguments   -ONELETTER  The   means that -o accepts one argument   Finally   help    output    describes long arguments   --MORETHANONELETTER    The   after output once again means that output accepts one arguments   The result is a list of couple  option argument   If an option doesn t accept any argument  like --help here  the arg part is an empty string  You then usually want to loop on this list and test the option name as in the example   I hope this helped you

User · Answer

The new hip way is argparse for these reasons   argparse   optparse   getopt  update  As of py2 7 argparse is part of the standard library and optparse is deprecated

User · Answer

I extended Erco s approach to allow for required positional arguments and for optional arguments  These should precede the -d  -v etc  arguments   Positional and optional arguments can be retrieved with PosArg i  and OptArg i  default  respectively  When an optional argument is found the start position of searching for options  e g  -i  is moved 1 ahead to avoid causing an  unexpected  fatal   import os sys   def HelpAndExit        print   lt  lt your help output goes here gt  gt        sys exit 1   def Fatal msg       sys stderr write   s   s n     os path basename sys argv 0    msg       sys exit 1   def NextArg i          Return the next command line argument  if there is one         if   i 1   gt   len sys argv            Fatal    s  expected an argument    sys argv i       return 1  sys argv i 1    def PosArg i          Return positional argument        if i  gt   len sys argv           Fatal    s  expected an argument    sys argv i       return sys argv i   def OptArg i  default          Return optional argument  if there is one         if i  gt   len sys argv           Fatal    s  expected an argument    sys argv i       if sys argv i   1      -           return True  sys argv i      else          return False  default       MAIN if   name       main          verbose   0     debug     0     infile     infile      outfile    outfile      options start   3        --- Parse two positional parameters ---     n1   int PosArg 1       n2   int PosArg 2          --- Parse an optional parameters ---     present  a3   OptArg 3 50      n3   int a3      options start    int present         --- Parse rest of command line ---     skip   0     for i in range options start  len sys argv            if not skip              if   sys argv i   2      -d   debug    1             elif sys argv i   2      -v   verbose    1             elif sys argv i   2      -i    skip infile     NextArg i              elif sys argv i   2      -o    skip outfile    NextArg i              elif sys argv i   2      -h   HelpAndExit               elif sys argv i   1      -    Fatal    s  unknown argument    sys argv i               else                          Fatal    s  unexpected    sys argv i           else  skip   0      print  Number 1    d    n1      print  Number 2    d    n2      print  Number 3    d    n3      print  Debug       d    debug      print  verbose     d    verbose      print  infile      s    infile      print  outfile     s    outfile

[python] What's the best way to parse command line arguments?

Examples related to python

Examples related to command-line

Examples related to command-line-arguments