Understanding Command Line Arguments in Python

How to Pass Command Line Arguments?

Command-line arguments are passed to a Python script when executed from the command-line interface (CLI). These arguments can be used to control the script's behavior, such as specifying input files, setting configuration options, or defining parameters for the script to use.

Syntax

The general syntax for running a Python script with command line arguments is:

python script.py arg1 arg2 arg3

Here, script.py is the name of the Python script, and arg1, arg2, and arg3 are the command line arguments passed to the script.

Learn Python programming from scratch in our comprehensive Python Tutorial for Beginners.

Python sys Module

The sys module provides access to some variables used or maintained by the Python interpreter, including sys.argv, a list of command-line arguments passed to the script. The first element, sys.argv[0], is the script name, and the subsequent elements are the arguments.

Example with sys Module

import sys

print("Script name:", sys.argv[0])
print("Number of arguments:", len(sys.argv) - 1)
print("Arguments:", sys.argv[1:])

If you run this script as python script.py arg1 arg2, the output will be:

Script name: script.py
Number of arguments: 3
Arguments: ['script.py', 'arg1', 'arg2']

Python getopt Module

The getopt module provides a way to parse command line arguments and options. It is similar to the C getopt() function.

Example with getopt Module

import getopt
import sys

def main(argv):
    inputfile = ''
    outputfile = ''
    try:
        opts, args = getopt.getopt(argv, "hi:o:", ["ifile=", "ofile="])
    except getopt.GetoptError:
        print('script.py -i <inputfile> -o <outputfile>')
        sys.exit(2)
    for opt, arg in opts:
        if opt == '-h':
            print('script.py -i <inputfile> -o <outputfile>')
            sys.exit()
        elif opt in ("-i", "--ifile"):
            inputfile = arg
        elif opt in ("-o", "--ofile"):
            outputfile = arg
    print('Input file is "', inputfile)
    print('Output file is "', outputfile)

if __name__ == "__main__":
    main(sys.argv[1:])

Running python script.py -i input.txt -o output.txt will yield:

Input file is "input.txt"
Output file is "output.txt"

Python argparse Module

The argparse module is more powerful and flexible than getopt. It automatically generates help and usage messages and issues errors when users argue invalid.

Example with argparse Module

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

Running the Python script.py 1 2 3 4 --sum will output the sum of the integers provided (1, 2, 3, 4), which is 10.

This is because the --sum argument instructs the script to calculate the sum of the integers (1 + 2 + 3 + 4).

Docopt

docopt is a module that creates command line interfaces from a program's docstring.

Example with docopt

"""Usage: script.py [options]
Options:
  -h --help     Show this screen.
  -o FILE       Specify output file.
"""

from docopt import docopt

if __name__ == '__main__':
    arguments = docopt(__doc__)
    print(arguments)

Running python script.py -o output.txt will output:

{'--help': False, '-o': 'output.txt'}

Conclusion

Command line arguments enhance the functionality and flexibility of Python scripts, allowing them to interact seamlessly with users and other programs. Python provides several modules to handle command line arguments, each with its strengths. The sys module offers basic functionality, getopt is suitable for simple use cases, argparse provides comprehensive options for complex scenarios, and docopt allows for easy creation of command-line interfaces from docstrings. By mastering these tools, you can make your Python scripts more versatile and powerful.

If you are interested in enhancing your Python programming skills further, we woul highly recommend you to check Simplilearn's Python Certification Course. This course can help you gain the right Python programming skills and and make you job-ready in no time.

FAQs

1. How do I parse command-line arguments in Python?

You can parse command-line arguments in Python using the argparse module, which provides a robust and flexible way to handle arguments. Alternatively, you can use the sys.argv list for simple needs or the getopt and docopt modules for more advanced parsing.

2. Can I access command-line arguments directly in Python?

You can access command-line arguments directly using the sys.argv list. sys.argv contains all the arguments passed to the script, with sys.argv[0] being the script name and subsequent elements representing the passed arguments.

3. How do I handle optional arguments in Python? 

You can use the argparse module to handle optional arguments in Python. Define optional arguments using the add_argument method, specifying the -- prefix. For example, parser.add_argument('--output', help=' Output file') handles an optional output file argument.

4. Can I pass flags (boolean options) as command-line arguments?

Yes, you can pass flags or boolean options using the argparse module. Define a flag with the action parameter set to 'store_true'. For example, parser.add_argument('--verbose', action='store_true', help='Enable verbose output') creates a flag that can be set by including --verbose in the command.

5. How do I handle positional arguments in Python?

Positional arguments in Python can be handled using the argparse module. Define them without the -- prefix in the add_argument method. For example, parser.add_argument('filename', help='Name of the file') requires the user to provide the filename as a positional argument.