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


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?.

Asked By: edgerA



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.
Answered By: Ayman Hourieh
import sys


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.


import sys
Answered By: John Slavick

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
Answered By: JPCosta

I like getopt from stdlib, eg:

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

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

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).

Answered By: Peter Ericson

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

import argparse

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

    args = parser.parse_args()


$ 1 2 3 4

$ --sum 1 2 3 4
Answered By: jfs

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:

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

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

  • 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
    proper argument checking
Answered By: Silfheed

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

Answered By: Mufasa

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

Answered By: tverrbjelke

My solution is entrypoint2. Example:

from entrypoint2 import 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: [-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
Answered By: ponty
#set default args as -h , if no args:
if len(sys.argv) == 1: sys.argv[1:] = ["-h"]
Answered By: whi

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

  -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')
Answered By: ralbatross

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.

Answered By: David C. Bishop

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.

Answered By: Ryne Everett

If you need something fast and not very flexible

import sys

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

Then run python James Smith

to produce the following output:

Hello James Smith

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__':

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

Answered By: circular-ruin
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()

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

Answered By: JON

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

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

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 "", line 3, in <module>
    _, arg1, arg2, arg3, *_ = sys.argv + [None] * 2
ValueError: not enough values to unpack (expected at least 4, got 3)
Answered By: Volodymyr Boiko
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])
for i in sys.argv[1:]:

Let’s name this file and let’s run it:

C:Userssimone> python arg1 arg2 arg3 ecc
File name:

Now let’s write a simple program,

import sys

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


C:Userssimone> python 10 4 6 3
Answered By: SimCop07

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

# file name:
# 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 "/Users/lawrence/data" "20220518" "XYZ123" "/Users/lawrence/logs"
# Windows usage: 
#   python "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","%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","%Y%m%d %H:%M"))

# call main() to begin processing...

if __name__ == '__main__':


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 file):

$ python3 "/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 file):

D:scripts>python "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.

Answered By: Lawrence Rich

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]
                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")
Answered By: O Wigley

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):

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: [-h] conf_file 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.

Answered By: Gibbs