In Python 3, you can get the Command Line Interface (CLI) parameters using the sys module. Consider the following example:
import sys
print("Program name:", sys.argv[0])
print("CLI arguments:", sys.argv[1:])
sys.argv is a list containing the command-line arguments passed to the script. The first element of sys.argv is always the name of the script itself, and the rest of the elements are the actual arguments passed to the script.
You can access individual arguments using their index in the sys.argv list, starting from index 1. For example, sys.argv[1] will give you the first command-line argument, sys.argv[2] will give you the second argument, and so on. Under index 0 you can find the script name. Alternatively, you can splice this out.
Splicing the arguments #
Splicing the arguments using sys.argv[1:] will get you only the parameters without the script name. When you use the slice notation sys.argv[1:], it creates a new list that contains all the elements of the original sys.argv list, except for the first element (the script name).
In the context of command-line arguments, the first element of sys.argv is always the name of the program itself, and the rest of the elements are the actual arguments passed to the program.
For example, if you run the program myprogram.py with the command python myprogram.py arg1 arg2 arg3, then the sys.argv list would be:
['myprogram.py', 'arg1', 'arg2', 'arg3']
If you use the slice notation sys.argv[1:], then it creates a new list that contains all the elements of the sys.argv list, except for the first element ('myprogram.py'). The resulting list would be:
['arg1', 'arg2', 'arg3']
In other words, sys.argv[1:] is a way to extract only the command-line arguments from the sys.argv list, without including the name of the program itself. This can be useful when you want to process only the command-line arguments and not the name of the program.
If you still wonder how splicing works, you can check this answer on Stackoverflow.
Flags and Options #
Note that sys.argv includes all command-line arguments, including any flags or options that start with a hyphen (-) or double hyphen (--). If you want to parse these options in a more structured way, you can use a library like argparse.
Using argparse #
argparse is a powerful Python module for parsing command-line arguments and options. Here's a simple example:
import argparse
parser = argparse.ArgumentParser(description='Example script to demonstrate argparse usage')
parser.add_argument('input_file', help='Input file name')
parser.add_argument('--output', '-o', help='Output file name')
args = parser.parse_args()
print('Input file:', args.input_file)
print('Output file:', args.output)
Here we've created an ArgumentParser object and added two arguments to it: input_file and output. The input_file argument is required, while the output argument is optional.
The help argument of the add_argument method is used to provide a brief description of the argument. The --output and -o arguments are equivalent. The -o option is the shorthand for the longer --output option.
Once the arguments have been defined, we call the parse_args method of the ArgumentParser object to parse the command-line arguments. The resulting args object contains the values of the parsed arguments.
We can access the values of the arguments using the attribute names that correspond to the argument names. For example, args.input_file gives the value of the input_file argument and args.output gives the value of the output argument.
Note that argparse automatically generates help messages based on the argument definitions, which can be accessed by running the script with the --help option.
🙏🙏🙏
Since you've made it this far, sharing this article on your favorite social media network would be highly appreciated 💖! For feedback, please ping me on Twitter.
Published