In this blog, we will learn what are the command line arguments, why do we use them and how to use them. We will also discuss argparse, the recommended command-line parsing module in the Python standard library.
Let’s start with a very simple example that calculates the area of a rectangle. Let’s name it rect.py.
|
1 2 3 4 5 6 |
def rectangle_area(length, width): area = length*width return area if __name__ == '__main__': print(rectangle_area(2,2)) |
Running the above script we get
|
1 2 |
$ python rect.py 4 |
Problem:
Now, if we were to calculate the area of a rectangle for different length and width, we have to change the function arguments. The above code is small so one might not bother changing 2 numbers. But the problem arises when the code is large and one need to change values at multiple locations.
Solution:
This problem can be solved if we provide the arguments at the runtime. For example, what we want is something as shown below
|
1 2 |
$ python rect.py 2 2 4 |
We want the 2’s should somehow be assigned to the length and width variable through the command line so that we don’t need to change the script every time. This can be done easily using the Python argparse module.
Before discussing the argparse module, I hope now you are able to answer the 2 questions, what are the command line arguments and why do we use them?
So, the parameters/arguments given to a program at runtime (For example, the 2’s from the command line shown above) are known as the command-line arguments.
Using command line arguments we can give our program different inputs or additional information without changing the code.
Now let’s see how to parse and access the command line argument. For this, we will use the argparse module.
Let’s again take the above rect.py and add few lines (Line 3 to Line 6)to it as shown below
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
import argparse ap = argparse.ArgumentParser(description='Calculate the area of rectangle') ap.add_argument('-l', '--length', type=int, required=True, help='Length of rectangle', dest='Length') ap.add_argument('-w', '--width', type=int, required=True, help='Width of rectangle', dest='Width') args = ap.parse_args() def rectangle_area(length, width): area = length*width return area if __name__ == '__main__': print(rectangle_area(args.Length, args.Width)) |
Before running any program from the command line, the best practice is to know about the program. And this can be done using the -h or –help flag as shown below
|
1 2 3 4 5 6 7 8 9 |
$ python rect.py -h usage: rect.py [-h] -l LENGTH -w WIDTH Calculate the area of a rectangle optional arguments: -h, --help show this help message and exit -l LENGTH, --length LENGTH Length of rectangle -w WIDTH, --width WIDTH Width of rectangle |
So, using the -h or –help flag, we got a overview about the program without even looking into the program.
So, let’s discuss what the code lines we added above actually mean. And how to parse and assign the command-line arguments to length and width.
On Line 3, we instantiate the ArgumentParser object as ap. We can think of it as a container to hold the arguments. The description tells the main purpose of the program(It is optional).
Then on Line 4 and 5, we add the optional arguments length and width. We specify both the shorthand (-l) and longhand versions (–length). To run a program from the command line, specify the flag(either shorthand or longhand or mix) followed by the value as shown below.
|
1 2 3 4 |
$ python rect.py -l 2 -w 3 6 $ python rect.py --length 2 --width 3 6 |
The required=True make the optional argument compulsory. For example, if we run rect.py without the width argument it will throw an error as shown below
|
1 2 |
$ python rect.py --length 2 rect.py: error: the following arguments are required: -w/--width |
If we omit writing required=True, None value will be assigned to that flag. For example, omit required=True from the width(Line 5) and re-run rect.py without the width argument, None will be assigned to the width flag.
|
1 2 3 4 5 6 7 |
$ python rect.py --length 2 Traceback (most recent call last): File "D:/kang.py", line 15, in <module> print(rectangle_area(args.length, args.width)) File "D:/kang.py", line 10, in rectangle_area area = length*width TypeError: unsupported operand type(s) for *: 'int' and 'NoneType' |
By default, the arguments are treated as a string so we explicitly defined the type as int for our problem. The help string gives additional information about the argument.
On Line 6, we parse the command line arguments using parse_args() method. This returns an object with the attributes specified in the add_argument() method. The name of the attribute is specified by the
To access the value of the command line arguments, we can simply use args.attribute_name, where attribute_name is the name specified in the dest argument. For example, args.Length and args.Width in rect.py example as shown above.
So, this is how you can use the argparse module for parsing command line arguments. I hope you now will feel comfortable when dealing with the command line arguments.
This blog contains only a gentle introduction to the argparse module. If you want to explore more, Python documentation is the way to go.
Hope you enjoy reading.
If you have any doubt/suggestion please feel free to ask and I will do my best to help or improve myself. Good-bye until next time.