5 Best Ways to Add Command Line Arguments in Python

Rate this post

๐Ÿ’ก Problem Formulation: When developing Python applications, there may be scenarios where the program needs to process parameters provided by the user at runtime. For example, you might want to pass a filename, a logging level, or other configuration options when invoking your Python script from the command line. How does one parse and utilize these command line arguments in the Python environment?

Method 1: Using sys.argv

The sys.argv list in Python provides a straightforward approach to handle command line arguments. The sys module that comes with the Python standard library contains argv, which is a list of command line arguments passed to a Python script. argv[0] is always the script name, and the subsequent items are the arguments passed.

Here’s an example:

import sys

# Example of sys.argv to access command line arguments
def main():
    for arg in sys.argv[1:]:

if __name__ == "__main__":

Output: Each argument on the command line will be printed on a separate line.

This example demonstrates the simplest way to iterate through each command line argument using a for loop, excluding the first element which is the script name itself.

Method 2: Using getopt module

The getopt module is a parser for command line options based on the C library function getopt(). It allows scripts to support both short and long option formats, parsing the options and respective values provided by the user.

Here’s an example:

import getopt, sys

# Example of getopt to parse command line arguments
def main():
    opts, args = getopt.getopt(sys.argv[1:], 'hf:v', ['help', 'verbosity='])
    for opt, arg in opts:
        if opt in ['-h', '--help']:
            print('Displaying help')
        elif opt in ['-v', '--verbosity']:
            print(f'Verbosity set to {arg}')

if __name__ == "__main__":

Output: Displays help or sets the verbosity level based on the options passed.

By utilizing the getopt module functions, you can effectively parse short options like ‘-h’ and long options like ‘–help’, handling them within a program with appropriate logic.

Method 3: Using argparse module

argparse is a powerful module for parsing command line arguments and sub-commands in Python. It offers a simple interface to define required arguments, defaults, and help messages, and produces user-friendly command line interfaces.

Here’s an example:

import argparse

# Example of argparse to handle command line arguments
def main():
    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()

if __name__ == "__main__":

Output: Outputs the sum or the max of the argument integers based on the provided flags.

This snippet showcases the creation of a command-line interface with an optional argument to sum integers, using the argparse module to parse the said arguments and apply the appropriate action.

Method 4: Using click library

The click library is a Python package for creating beautiful command line interfaces in a composable way with as little code as necessary. It provides decorators to define command line options and arguments, making it an attractive tool for more complex CLIs.

Here’s an example:

import click

# Example of using click to create command line interface
@click.option('--count', default=1, help='Number of greetings.')
@click.option('--name', prompt='Your name', help='The person to greet.')
def greet(count, name):
    for _ in range(count):
        click.echo(f'Hello, {name}!')

if __name__ == '__main__':

Output: Greets the user by name for the specified count.

This code employs the click library to define a simple CLI that asks for the user’s name and the number of times to greet the user, demonstrating how command line arguments and options can be elegantly handled with decorators.

Bonus One-Liner Method 5: Using os.environ for Environment Variables

Sometimes, instead of command line arguments, one might prefer to use environment variables for configuration. The os.environ dictionary provides access to the environment variables of the operating system, which can be used as an alternative for command line parameters.

Here’s an example:

import os

# A one-liner to get an environment variable
database_uri = os.environ.get('DATABASE_URI', 'default_db_uri')


Output: Prints the value of the `DATABASE_URI` environment variable, or `default_db_uri` if it’s not set.

This one-liner demonstrates accessing an environment variable within a Python script, providing a fallback value if the environment variable is not set, thus allowing configuration without resorting to command line arguments.


  • Method 1: Using sys.argv. Strengths: Inbuilt, no dependencies, straightforward. Weaknesses: Basic, manual parsing required, lack of advanced features.
  • Method 2: Using getopt module. Strengths: Borrows from C-style command line argument parsing. Weaknesses: Slightly complex, less Pythonic than other options.
  • Method 3: Using argparse module. Strengths: Robust, flexible, and built into Python. Weaknesses: Can be verbose for simple use cases.
  • Method 4: Using click library. Strengths: User-friendly, decorator-based syntax, great for complex CLIs. Weaknesses: Requires installation of an external package.
  • Bonus Method 5: Using os.environ. Strengths: Ideal for Dockerized or continuous integration workflows. Weaknesses: Not suitable for interactive argument input.