Python Command line Arguments
Python Command line Arguments
The command-line argument is used to the change functionality of the program. It's an extra command the programmer can use while launching a program. These commands have many uses such as adding more features and specialties into the program, specify a particular document to launch, and unlocking some special abilities of a computer or system that is disabled for normal use.
For example, if we talk about Python itself then to install the package or to use the pip command we have to write the command in the command line itself or in the PowerShell.
How to Pass Command-line Arguments in Python?
We suggest you, use the terminal to pass the argument into the file to make it reach the program. To pass the value through the terminal, we right the code:
$ python script.py arg1 arg2 ... argN
How to use the command line Arguments in python?
Python supports the command-line, which means the commands can be run on the command-line too as well as in any editor.
Just save the file with the extension ".py". To use the command-line argument in Python, we have numerous commands to pass the argument.
We have to use that command with the parameter or what we can say with the arguments. By using those files with all that package will help them in using the command line arguments. they all are given below:
- fire
- docopt
- argparse
- optparse
What is fire?
Fire is one of the preferred packages used in the command line argument because it automatically generates the command-line interfaces (CLIs). Other than this, the Fire package supports all the versions of Python. It is faster. you don't require to pass any argument in this. all are linked. But this package is not inbuilt you have to install it by using the code.
py -m pip install fire
Example:
#imported the fire package
import fire
#created a class named
#javatpoint
class javatpoint(object):
#created a method named print
#to print hello
def print(self):
print("Hello")
#created a method named open_file
#to print file name
def open_file(self, filename):
print("File Opened: ",filename)
#calling the javatpoint class using fire
if __name__ == '__main__':
fire.Fire(javatpoint)
Output:
python argument.py hello python argument.py File Opened: filename.txt
Explanation:
In this example, we first install the fire package use the above-given pip command (py -m pip install fire), after installation, we open the notepad or any editor and start writing the code.
First, we imported the fire package into the file using the import keyword. Then we created a class named javatpoint with the parameter object. In that class we created two methods the first method will print and other is open_file method prints the Hello. The open_file prints the file opened and the filename. In the next step, we check if the initial has the main function or not. if yes then it will call the javatpoint class.
What is docopt?
The docopt is one of the powerful packages of Python. It helps the programmer to define an interface for a common-line application and generate the parsing values and argument for the program. The docopt is a command-line interface description module. But this package is not inbuilt you have to install it by using the code.
py -m pip install docopt
Example:
use =''' Usage: argument.py [(<name1>|<name2>)] <name3>... argument.py mov <name1> <name2> argument.py (--h|--q) [<name1> -l] argument.py --version Options: -l, --all List all. -q, --quit exit. --version Version 3.9.4 -h --help Show this screen. --version Show version. --speed =<kn> Speed in knots [default: 10]. --moored Moored (anchored) mine. --drifting Drifting mine. ''' #importing the docopt package from docopt import docopt #passing the argument #using the docopt function arg = docopt(use) #printing the argument print(arg)
Output:
Usage: argument.py [(<name1>|<name2>)] <name3>... argument.py mov <name1> <name2> argument.py (--h|--q) [<name1> -l] argument.py --version Options: -l, --all List all. -q, --quit exit. --version Version 3.9.4 -h --help Show this screen. --version Show version. --speed =<kn> Speed in knots [default: 10]. --moored Moored (anchored) mine. --drifting Drifting mine.
Explanation:
In this example, we first install the docopt package use the above-given pip command (py -m pip install docopt), after installation, we open the notepad or any editor and start writing the code. First, we created a variable named use and declare its value as long text.
In this, we are parsing multiple lines in a single variable. Then, we imported the docopt method from the docopt package into the file using the import and from keyword. Then, we declare a variable named arg and declare it with the docopt function and pass the variable named use we created above. then, we simply print the arg variable.
What is argparse?
The argparse is a module used to work with the command line argument. That's why it is known as the command line parsing module.
The first module version was released in 2011. The argparse allows us to use the positional argument and customize the prefix characters. it also supports subcommands and the variable numbers of parameters for a single option. But this package is not inbuilt you have to install it by using the code.
py -m pip install argparse
To run file:
#code use to run the file in terminal \desktop\sachin\JavaTpoint\dictionary>python argument.py –h
Example:
#importing the argparse module
import argparse
#declaring the variable with
# the ArgumentParser method
# argparse module
par = argparse.ArgumentParser()
# creating the variables using the add_argument method
par.add_argument("first_name", help = "first name")
par.add_argument("last_name ", help = "last name")
par.add_argument("operation", help = "operation")
Output:
usage: code.py [-h] Java Tpoint operation positional arguments: Java first number Tpoint second number operation operation optional arguments: -h, --help show this help message and exit
Explanation:
In this example, we first install the argparse package use the above-given pip command (py -m pip install argparse), after installation, we open the notepad or any editor and start writing the code.
First, import the module argparse using the import keyword. After this, we declared a variable with the argument parser method of the argparse module. then we use the add argument method of the argument parser method and the argparse module to add the arguments. we have taken the 3 arguments to add.
What is optparse?
The optparse module is used to make code writing easy. that results in easy writing the command-line tool.
As we are talking about the command-line argument, it's of course that the optparse is the command-line argument parsing module.
The optparse is the favorable option of the programmers because it makes it easy to handle the command-line argument. It provides the options and allows the dynamic data to be taken from the users, and also, it is the inbuilt module of python. It is capable of working with the lesser than the 2.7 version of python and also with the higher version of python.
To run file:
#code use to run the file in terminal python argument.py -n 5
Example:
# import optparse module
import optparse
# created a function
#named table
def table(n, dest_cheak):
for i in range(1,11):
tab = i*n
print ("The " + str(i)+ "th value of "+str(n)+" table is " + str(tab))
return tab
# define a function for
# adding options
def Main():
# create OptionParser object
par = optparse.OptionParser()
# adding the options
par.add_option('-n', dest = 'num',
type = 'int',
help = 'specify the n''th table number to output')
par.add_option('-o', dest = 'out',
type = 'string',
help = 'specify an output file (Optional)')
par.add_option("-a", "--all",
action = "store_true",
dest = "prin",
default = False,
help = "print all numbers up to N")
(options, args) = par.parse_args()
if (options.num == None):
print (par.usage)
exit(0)
else:
number = options.num
# function calling
result = table(number, options.prin)
# Driver code
if __name__ == '__main__':
# function calling
Main()
Output:
python argument.py -n 5 The 1th value of 5 table is 5 The 2th value of 5 table is 10 The 3th value of 5 table is 15 The 4th value of 5 table is 20 The 5th value of 5 table is 25 The 6th value of 5 table is 30 The 7th value of 5 table is 35 The 8th value of 5 table is 40 The 9th value of 5 table is 45 The 10th value of 5 table is 50
Explanation:
Firstly we imported the optparse in the file by using the import keyword. Then we have created a function named table in that we are printing the table using for loop.
Then we created the function main and in that function, we created an object named par and declare it by the module optparse with its method OptionParser. Then we add the options for the number, string, and operations. This helps in allowing the dynamic data input. Then we check that the input that is an integer or not.
If it's an integer then we pass the value to the table function to print the table. and the output is attached above. This is the basic example of the optparse.