How can I read and process (parse) command line arguments?

Question

In Python, how can we find out the command line arguments that were provided for a script, and process them?

---

_{Related background reading: What does "sys.argv[1]" mean? (What is sys.argv, and where does it come from?). For some more specific examples, see Implementing a "[command] [action] [parameter]" style command-line interfaces? and How do I format positional argument help using Python's optparse?.}

Detent

Use docopt (see @ralbatross's answer at https://mcmap.net/q/53790/-how-can-i-read-and-process-parse-command-line-arguments). I've tried every other way and, really, docopt is the only one I will use going forward. – Slippery

I don't think there's one single best way. argparse is standard and featureful. docopt is very elegant but not in the standard library. For very easy lightweight use you can make function default values handle comand line argument defaults for you. – Miscue

Answer 1

The canonical solution in the standard library is argparse (docs):

Here is an example:

from argparse import ArgumentParser

parser = ArgumentParser()
parser.add_argument("-f", "--file", dest="filename",
                    help="write report to FILE", metavar="FILE")
parser.add_argument("-q", "--quiet",
                    action="store_false", dest="verbose", default=True,
                    help="don't print status messages to stdout")

args = parser.parse_args()

argparse supports (among other things):

• Multiple options in any order.
• Short and long options.
• Default values.
• Generation of a usage help message.

Boatload

Are these built in modules the best? Or can you think of a better custom way? – Detent

Yes, these are the best. Since they're part of the standard library, you can be sure they'll be available and they're easy to use. optparse in particular is powerful and easy. – James

@edgerA: What does "better custom way" mean? – Allfired

optparse is one of the best; getopt is old and really ought to be considered deprecated. – Cheep

at this point (12/2011), argparse is now considered a better option than optparse, correct? – Scandinavia

Python Documentation suggests the use of argparse instead of optparse. – Frimaire

Since optparse is deprecated, the asker of the question is no longer a member on stack overflow, and this is the accepted answer on a highly visible question - please consider completely rewriting your example code to use stdlib argparse instead. – Rosenzweig

@AymanHourieh you did not show how to get those arguments. The documentation of this module is a mess. – Lanitalank

Has this changed over the past 14 years? And with the transition to Python 3? – Fisticuffs

Answer 2

import sys

print("\n".join(sys.argv))

sys.argv is a list that contains all the arguments passed to the script on the command line. sys.argv[0] is the script name.

Basically,

import sys

print(sys.argv[1:])

Cecum

For really simple stuff, this is the way to go, although you probably only want to use sys.argv[1:] (avoids the script name). – Promotive

Answer 3

Just going around evangelizing for argparse which is better for these reasons.. essentially:

(copied from the link)

• argparse module can handle positional and optional arguments, while optparse can handle only optional arguments

• argparse isn’t dogmatic about what your command line interface should look like - options like -file or /file are supported, as are required options. Optparse refuses to support these features, preferring purity over practicality

• argparse produces more informative usage messages, including command-line usage determined from your arguments, and help messages for both positional and optional arguments. The optparse module requires you to write your own usage string, and has no way to display help for positional arguments.

• argparse supports action that consume a variable number of command-line args, while optparse requires that the exact number of arguments (e.g. 1, 2, or 3) be known in advance

• argparse supports parsers that dispatch to sub-commands, while optparse requires setting allow_interspersed_args and doing the parser dispatch manually

And my personal favorite:

• argparse allows the type and action parameters to add_argument() to be specified with simple callables, while optparse requires hacking class attributes like STORE_ACTIONS or CHECK_METHODS to get proper argument checking

Shiny

This is now part of standard Python as of 2.7 and 3.2 :) – Marcum

What are "optional arguments"? You say they're in optparse. I thought that they were arguments that may or may not be provided, but you said they're in optparse while going on to say that "optparse requires that the exact number of arguments be known in advance". So either your definition of "optional argument" differs from what I thought, or your answer is inconsistent with itself. – Titer

Just a gripe: argparse documentation is also insanely, insanely complicated. You can't get a simple answer for "how do I make a command line argument take in a single value, and how do I access that value." </gripe> – Rivalee

@Rivalee This gentle tutorial on argparse might help... – Yale

@Titer "optional arguments" in this context presumably means arguments specified with option-like arguments such as -f or --foo, while "exact number of arguments be known in advance" presumably means positional arguments given without any preceding option flags. – Nicobarese

Answer 4

There is also argparse stdlib module (an "impovement" on stdlib's optparse module). Example from the introduction to argparse:

# script.py
import argparse

if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument(
        'integers', metavar='int', type=int, choices=range(10),
         nargs='+', help='an integer in the range 0..9')
    parser.add_argument(
        '--sum', dest='accumulate', action='store_const', const=sum,
        default=max, help='sum the integers (default: find the max)')

    args = parser.parse_args()
    print(args.accumulate(args.integers))

Usage:

$ script.py 1 2 3 4
4

$ script.py --sum 1 2 3 4
10

Posthumous

its just a copy and paste – Parian

@Parian at the time of the publication of my answer there were no other answers that mention argparse in any way. The module itself was not in stdlib¶ What do you have against code examples from the documentation? Why do you think it is necessary to come up with your own examples instead of examples provided by the author of the module? And I don't like link-only answers (I'm not alone). – Posthumous

Peoples coming here already had an idea whats in the documentation and will be here only for further clearance about the topic.Same was my case but what i really found here is a copy and paste from the original docs.Peace! – Parian

"Peoples coming here already had an idea whats in the documentation" - i highly doubt that assumtion. somehow. – Emplacement

I found it difficult to figure out how to actually use the results of the parsing. In this answer, this is addressed in the last line of code (so +1). But to be honest, this example is very compact and probably far beyond the capabilities of people asking about processing command line arguments. – Timm

Answer 5

If you need something fast and not very flexible

main.py:

import sys

first_name = sys.argv[1]
last_name = sys.argv[2]
print("Hello " + first_name + " " + last_name)

Then run python main.py James Smith

to produce the following output:

Hello James Smith

Gordie

A more realistic usage would be python main.py "James Smith" which puts James Smith in sys.argv[1] and produces an IndexError when you try to use the nonexistent sys.argv[2]. Quoting behavior will somewhat depend on which platform and shell you run Python from. – Disharoon

I don't agree that my usage is less realistic. Pretend your program needs to know the exact first and last name of a person to run the script in a business where people can have multiple first and last names? If James Smith has Joseph as an extra first or last name, how would distinguish between whether Joseph is an extra first or last name if you only do python main.py "James Joseph Smith"? If you are concerned with index out of bounds, you can add a check for the number of provided arguments. Less realistic or not, my example shows how to handle multiple arguments. – Gordie

All the other answers are for plotting a lunar landing mission. I'm just simply using gmail-trash-msg.py MessageID. This answer is straight forward to test MessageID parameter has been passed in sys.argv[1]. – Likker

Answer 6

One way to do it is using sys.argv. This will print the script name as the first argument and all the other parameters that you pass to it.

import sys

for arg in sys.argv:
    print arg

Unbearable

Answer 7

The docopt library is really slick. It builds an argument dict from the usage string for your app.

Eg from the docopt readme:

"""Naval Fate.

Usage:
  naval_fate.py ship new <name>...
  naval_fate.py ship <name> move <x> <y> [--speed=<kn>]
  naval_fate.py ship shoot <x> <y>
  naval_fate.py mine (set|remove) <x> <y> [--moored | --drifting]
  naval_fate.py (-h | --help)
  naval_fate.py --version

Options:
  -h --help     Show this screen.
  --version     Show version.
  --speed=<kn>  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)

Admittance

This has rapidly become my favorite way to go. It's string parsing so it's kind of brittle, but it's brittle all in one place and you can preview your logic at try.docopt.org . Optional and mutually-exclusive arguments are done in a really elegant way. – Riley

Answer 8

#set default args as -h , if no args:
if len(sys.argv) == 1: sys.argv[1:] = ["-h"]

Brunette

Answer 9

I use optparse myself, but really like the direction Simon Willison is taking with his recently introduced optfunc library. It works by:

"introspecting a function definition (including its arguments and their default values) and using that to construct a command line argument parser."

So, for example, this function definition:

def geocode(s, api_key='', geocoder='google', list_geocoders=False):

is turned into this optparse help text:

    Options:
      -h, --help            show this help message and exit
      -l, --list-geocoders
      -a API_KEY, --api-key=API_KEY
      -g GEOCODER, --geocoder=GEOCODER

Catania

Answer 10

I like getopt from stdlib, eg:

try:
    opts, args = getopt.getopt(sys.argv[1:], 'h', ['help'])
except getopt.GetoptError, err: 
    usage(err)

for opt, arg in opts:
    if opt in ('-h', '--help'): 
        usage()

if len(args) != 1:
    usage("specify thing...")

Lately I have been wrapping something similiar to this to make things less verbose (eg; making "-h" implicit).

Bloodstain

Answer 11

Pocoo's click is more intuitive, requires less boilerplate, and is at least as powerful as argparse.

The only weakness I've encountered so far is that you can't do much customization to help pages, but that usually isn't a requirement and docopt seems like the clear choice when it is.

Okeefe

Answer 12

As you can see optparse "The optparse module is deprecated with and will not be developed further; development will continue with the argparse module."

Monkfish

Answer 13

import argparse

parser = argparse.ArgumentParser(description='Process some integers.')
parser.add_argument('integers', metavar='N', type=int, nargs='+',
                   help='an integer for the accumulator')
parser.add_argument('--sum', dest='accumulate', action='store_const',
                   const=sum, default=max,
                   help='sum the integers (default: find the max)')

args = parser.parse_args()
print(args.accumulate(args.integers))

Assuming the Python code above is saved into a file called prog.py
$ python prog.py -h

Ref-link: https://docs.python.org/3.3/library/argparse.html

Glutton

Answer 14

You may be interested in a little Python module I wrote to make handling of command line arguments even easier (open source and free to use) - Commando

External

There is already another command-line parsing module named Commando: github.com/lakshmivyas/commando. It wraps argparse by using decorators. – Duplication

python and wheel re-invention – Philbrook

Answer 15

Yet another option is argh. It builds on argparse, and lets you write things like:

import argh

# declaring:

def echo(text):
    "Returns given word as is."
    return text

def greet(name, greeting='Hello'):
    "Greets the user with given name. The greeting is customizable."
    return greeting + ', ' + name

# assembling:

parser = argh.ArghParser()
parser.add_commands([echo, greet])

# dispatching:

if __name__ == '__main__':
    parser.dispatch()

It will automatically generate help and so on, and you can use decorators to provide extra guidance on how the arg-parsing should work.

Brimstone

This is the best solution. Using argh is easier than another libs or using sys. – Tiffinytiffy

I wanted to like argh but it's not particularly suitable for scenarios where your utmost desire is not to have a command with subcommands. – Disharoon

@Disharoon YMMV, but I found that this was more of a defect in the documentation than in the library itself. It seems perfectly feasible to have def frobnicate_spleches(...) defining a function that does whatever your script does, then doing if __name__ == '__main__': argh.dispatch_command(frobnicate_spleches) at the end of the file. – Brimstone

Answer 16

I recommend looking at docopt as a simple alternative to these others.

docopt is a new project that works by parsing your --help usage message rather than requiring you to implement everything yourself. You just have to put your usage message in the POSIX format.

Barreto

Answer 17

Also with python3 you might find convenient to use Extended Iterable Unpacking to handle optional positional arguments without additional dependencies:

try:
   _, arg1, arg2, arg3, *_ = sys.argv + [None] * 2
except ValueError:
   print("Not enough arguments", file=sys.stderr) # unhandled exception traceback is meaningful enough also
   exit(-1)

The above argv unpack makes arg2 and arg3 "optional" - if they are not specified in argv, they will be None, while if the first is not specified, ValueError will be thouwn:

Traceback (most recent call last):
  File "test.py", line 3, in <module>
    _, arg1, arg2, arg3, *_ = sys.argv + [None] * 2
ValueError: not enough values to unpack (expected at least 4, got 3)

Interdigitate

Answer 18

Reason for the new answer:

1. Existing answers specify multiple options.
2. Standard option is to use argparse, a few answers provided examples from the documentation, and one answer suggested the advantage of it. But all fail to explain the answer adequately/clearly to the actual question by OP, at least for newbies.

An example of argparse:

import argparse


def load_config(conf_file):
    pass


if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    //Specifies one argument from the command line
    //You can have any number of arguments like this
    parser.add_argument("conf_file", help="configuration file for the application") 
    args = parser.parse_args()
    config = load_config(args.conf_file)

Above program expects a config file as an argument. If you provide it, it will execute happily. If not, it will print the following

usage: test.py [-h] conf_file
test.py: error: the following arguments are required: conf_file

• You can have the option to specify if the argument is optional.

• You can specify the expected type for the argument using type key

  parser.add_argument("age", type=int, help="age of the person")

• You can specify default value for the arguments by specifying default key

This document will help you to understand it to an extent.

Tenacious

Answer 19

import sys

# Command line arguments are stored into sys.argv
# print(sys.argv[1:])

# I used the slice [1:] to print all the elements except the first
# This because the first element of sys.argv is the program name
# So the first argument is sys.argv[1], the second is sys.argv[2] ecc

print("File name: " + sys.argv[0])
print("Arguments:")
for i in sys.argv[1:]:
    print(i)

Let's name this file command_line.py and let's run it:

C:\Users\simone> python command_line.py arg1 arg2 arg3 ecc
File name: command_line.py
Arguments:
arg1
arg2
arg3
ecc

Now let's write a simple program, sum.py:

import sys

try:
    print(sum(map(float, sys.argv[1:])))
except:
    print("An error has occurred")

Result:

C:\Users\simone> python sum.py 10 4 6 3
23

Inly

Answer 20

My solution is entrypoint2. Example:

from entrypoint2 import entrypoint
@entrypoint
def add(file, quiet=True): 
    ''' This function writes report.

    :param file: write report to FILE
    :param quiet: don't print status messages to stdout
    '''
    print file,quiet

help text:

usage: report.py [-h] [-q] [--debug] file

This function writes report.

positional arguments:
  file         write report to FILE

optional arguments:
  -h, --help   show this help message and exit
  -q, --quiet  don't print status messages to stdout
  --debug      set logging level to DEBUG

Delk

Answer 21

Several of our biotechnology clients have posed these two questions recently:

• How can we execute a Python script as a command?
• How can we pass input values to a Python script when it is executed as a command?

I have included a Python script below which I believe answers both questions. Let's assume the following Python script is saved in the file test.py:

#
#----------------------------------------------------------------------
#
# file name: test.py
#
# input values: data  - location of data to be processed
#               date  - date data were delivered for processing
#               study - name of the study where data originated
#               logs  - location where log files should be written 
#
# macOS usage: 
#
#   python3 test.py "/Users/lawrence/data" "20220518" "XYZ123" "/Users/lawrence/logs"
#
# Windows usage: 
#
#   python test.py "D:\data" "20220518" "XYZ123" "D:\logs"
#
#----------------------------------------------------------------------
#
# import needed modules...
#
import sys
import datetime

def main(argv):

   #
   # print message that process is starting...
   #
   print("test process starting at", datetime.datetime.now().strftime("%Y%m%d %H:%M"))

   #
   # set local values from input values...
   #
   data = sys.argv[1]
   date = sys.argv[2]
   study = sys.argv[3]
   logs = sys.argv[4]

   #
   # print input arguments...
   #
   print("data value is", data)
   print("date value is", date)
   print("study value is", study)
   print("logs value is", logs)

   #
   # print message that process is ending...
   #
   print("test process ending at", datetime.datetime.now().strftime("%Y%m%d %H:%M"))

#
# call main() to begin processing...
#

if __name__ == '__main__':

   main(sys.argv)

The script can be executed on a macOS computer in a Terminal shell as shown below and the results will be printed to standard output (be sure the current directory includes the test.py file):

$ python3 test.py "/Users/lawrence/data" "20220518" "XYZ123" "/Users/lawrence/logs"
test process starting at 20220518 16:51
data value is /Users/lawrence/data
date value is 20220518
study value is XYZ123
logs value is /Users/lawrence/logs
test process ending at 20220518 16:51

The script can also be executed on a Windows computer in a Command Prompt as shown below and the results will be printed to standard output (be sure the current directory includes the test.py file):

D:\scripts>python test.py "D:\data" "20220518" "XYZ123" "D:\logs"
test process starting at 20220518 17:20
data value is D:\data
date value is 20220518
study value is XYZ123
logs value is D:\logs
test process ending at 20220518 17:20

This script answers both questions posed above and is a good starting point for developing scripts that will be executed as commands with input values.

Dupleix

Answer 22

This handles simple switches, value switches with optional alternative flags.

import sys

# [IN] argv - array of args
# [IN] switch - switch to seek
# [IN] val - expecting value
# [IN] alt - switch alternative
# returns value or True if val not expected
def parse_cmd(argv,switch,val=None,alt=None):
    for idx, x in enumerate(argv):
        if x == switch or x == alt:
            if val:
                if len(argv) > (idx+1):            
                    if not argv[idx+1].startswith('-'):
                        return argv[idx+1]
            else:
                return True

//expecting a value for -i
i = parse_cmd(sys.argv[1:],"-i", True, "--input")

//no value needed for -p
p = parse_cmd(sys.argv[1:],"-p")

Eatables