Command Line Arguments in Python: Examples & Guidelines!

The right way to Cross Command Line Arguments?

Command-line arguments are handed to a Python script when achieved from the command-line interface (CLI). Those arguments can be utilized to keep watch over the script’s conduct, comparable to specifying enter recordsdata, atmosphere configuration choices, or defining parameters for the script to make use of.

Syntax

The overall syntax for operating a Python script with command line arguments is:

python script.py arg1 arg2 arg3

Right here, script.py is the identify of the Python script, and arg1, arg2, and arg3 are the command line arguments handed to the script.

Python sys Module

The sys module supplies get admission to to a few variables used or maintained by way of the Python interpreter, together with sys.argv, an inventory of command-line arguments handed to the script. The primary part, sys.argv[0], is the script identify, and the following components are the arguments.

Instance with sys Module

import sys

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

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

Script identify: script.py
Collection of arguments: 3
Arguments: ['script.py', 'arg1', 'arg2']

Python getopt Module

The getopt module supplies a solution to parse command line arguments and choices. It’s very similar to the C getopt() serve as.

Instance with getopt Module

import getopt
import sys

def primary(argv):
    inputfile = ''
    outputfile = ''
    check out:
        opts, args = getopt.getopt(argv, "hello:o:", ["ifile=", "ofile="])
    except for getopt.GetoptError:
        print('script.py -i <inputfile> -o <outputfile>')
        sys.go out(2)
    for decide, arg in opts:
        if decide == '-h':
            print('script.py -i <inputfile> -o <outputfile>')
            sys.go out()
        elif decide in ("-i", "--ifile"):
            inputfile = arg
        elif decide in ("-o", "--ofile"):
            outputfile = arg
    print('Enter report is "', inputfile)
    print('Output report is "', outputfile)

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

Working python script.py -i enter.txt -o output.txt will yield:

Enter report is "enter.txt"
Output report is "output.txt"

Python argparse Module

The argparse module is extra robust and versatile than getopt. It routinely generates assist and utilization messages and problems mistakes when customers argue invalid.

Instance with argparse Module

import argparse

parser = argparse.ArgumentParser(description='Procedure some integers.')
parser.add_argument('integers', metavar='N', kind=int, nargs='+', assist='an integer for the accumulator')
parser.add_argument('--sum', dest='acquire', motion='store_const', const=sum, default=max, assist='sum the integers (default: in finding the max)')
args = parser.parse_args()

print(args.acquire(args.integers))

Working the Python script.py 1 2 3 4 –sum will output the sum of the integers equipped (1, 2, 3, 4), which is 10.

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

Instance with docopt

"""Utilization: script.py [options]
Choices:
  -h --help     Display this display screen.
  -o FILE       Specify output report.
"""

from docopt import docopt

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

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

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

Conclusion

Command line arguments strengthen the capability and versatility of Python scripts, permitting them to engage seamlessly with customers and different techniques. Python supplies a number of modules to deal with command line arguments, each and every with its strengths. The sys module provides elementary capability, getopt is appropriate for easy use instances, argparse supplies complete choices for complicated situations, and docopt lets in for simple introduction of command-line interfaces from docstrings. Via mastering those gear, you’ll make your Python scripts extra flexible and robust.

FAQs

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

You’ll parse command-line arguments in Python the use of the argparse module, which supplies a strong and versatile solution to deal with arguments. Then again, you’ll use the sys.argv listing for easy wishes or the getopt and docopt modules for extra complex parsing.

2. Can I get admission to command-line arguments immediately in Python?

You’ll get admission to command-line arguments immediately the use of the sys.argv listing. sys.argv comprises all of the arguments handed to the script, with sys.argv[0] being the script identify and next components representing the handed arguments.

3. How do I deal with non-compulsory arguments in Python? 

You’ll use the argparse module to deal with non-compulsory arguments in Python. Outline non-compulsory arguments the use of the add_argument approach, specifying the — prefix. For instance, parser.add_argument(‘–output’, assist=’ Output report’) handles an non-compulsory output report argument.

4. Can I go flags (boolean choices) as command-line arguments?

Sure, you’ll go flags or boolean choices the use of the argparse module. Outline a flag with the motion parameter set to ‘store_true’. For instance, parser.add_argument(‘–verbose’, motion=’store_true’, assist=’Permit verbose output’) creates a flag that may be set by way of together with –verbose within the command.

5. How do I deal with positional arguments in Python?

Positional arguments in Python will also be treated the use of the argparse module. Outline them with out the — prefix within the add_argument approach. For instance, parser.add_argument(‘filename’, assist=’Title of the report’) calls for the person to give you the filename as a positional argument.