Python start with args

Python — Command Line Arguments

Python Command Line Arguments provides a convenient way to accept some information at the command line while running the program. The arguments that are given after the name of the Python script are known as Command Line Arguments and they are used to pass some information to the program. For example —

$ python script.py arg1 arg2 arg3

Here Python script name is script.py and rest of the three arguments — arg1 arg2 arg3 are command line arguments for the program. There are following three Python modules which are helpful in parsing and managing the command line arguments:

sys module — System-specific parameters

The Python sys module provides access to any command-line arguments via the sys.argv. This serves two purposes −

• sys.argv is the list of command-line arguments.
• len(sys.argv) is the number of command-line arguments.

Here sys.argv[0] is the program ie. script name.

Example

Consider the following script test.py −

import sys print 'Number of arguments:', len(sys.argv), 'arguments.' print 'Argument List:', str(sys.argv)

Now run above script as below. All the programs in this tutorial need to be run from the command line, so we are unable to provide online compile & run option for these programs. Kindly try to run these programs at your computer.

$ python test.py arg1 arg2 arg3

This produce following result −

Number of arguments: 4 arguments. Argument List: ['test.py', 'arg1', 'arg2', 'arg3']

As mentioned above, first argument is always script name and it is also being counted in number of arguments.

Parsing Command-Line Arguments

Python provided a getopt module that helps you parse command-line options and arguments. This module provides two functions and an exception to enable command line argument parsing.

getopt.getopt method

This method parses command line options and parameter list. Following is simple syntax for this method −

getopt.getopt(args, options, [long_options])

Here is the detail of the parameters −

• args − This is the argument list to be parsed.
• options − This is the string of option letters that the script wants to recognize, with options that require an argument should be followed by a colon (:).
• long_options − This is optional parameter and if specified, must be a list of strings with the names of the long options, which should be supported. Long options, which require an argument should be followed by an equal sign (‘=’). To accept only long options, options should be an empty string.

This method getopt.getopt() returns value consisting of two elements: the first is a list of (option, value) pairs. The second is the list of program arguments left after the option list was stripped. Each option-and-value pair returned has the option as its first element, prefixed with a hyphen for short options (e.g., ‘-x’) or two hyphens for long options (e.g., ‘—long-option’).

Example

Following is a Python program which takes three arguments at command line:

1. First command line argument is -h which will be used to display the usage help of the program.
2. Second argument is either -i or —ifile which we are considering as input file.
3. Third argument is either -o or —ofile which we are considering as output file.

Here is the following script to test.py −

import sys, getopt def main(argv): inputfile = '' outputfile = '' opts, args = getopt.getopt(argv,"hi:o:",["ifile=","ofile="]) for opt, arg in opts: if opt == '-h': print ('test.py -i -o ') 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:])

Now, run above script as follows −

This will produce the following result:

Input file is IN Output file is OUT

We can also run the above program as follows:

$ python test.py --ifile IN --ofile OUT

This will produce the same result as in case of -i and -o:

Input file is IN Output file is OUT

We can use h option to check the usage of the program:

This will produce the following result:

Exception getopt.GetoptError

Consider we use some other option which has not been implemented in the program. This will raise an exception. For example, let’s try to run the same program with wrong option -p as follows:

This will raise an exception as below:

Traceback (most recent call last): File "test.py", line 21, in main(sys.argv[1:]) File "test.py", line 8, in main opts, args = getopt.getopt(argv,"hi:o:",["ifile=","ofile="]) File "/usr/lib64/python3.6/getopt.py", line 95, in getopt opts, args = do_shorts(opts, args[0][1:], shortopts, args[1:]) File "/usr/lib64/python3.6/getopt.py", line 195, in do_shorts if short_has_arg(opt, shortopts): File "/usr/lib64/python3.6/getopt.py", line 211, in short_has_arg raise GetoptError(_('option -%s not recognized') % opt, opt) getopt.GetoptError: option -j not recognized

This exception is raised when an unrecognized option is found in the argument list or when an option requiring an argument is given none. The argument to the exception is a string indicating the cause of the error. The attributes msg and opt give the error message and related option.

Example

Following is a correct Python program which makes use of try. except block and capture getopt.GetoptError exception:

import sys, getopt def main(argv): inputfile = '' outputfile = '' try: opts, args = getopt.getopt(argv,"hi:o:",["ifile=","ofile="]) except getopt.GetoptError: print ('test.py -i -o ') sys.exit(2) for opt, arg in opts: if opt == '-h': print ('test.py -i -o ') 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:])

Now, run above script as follows −

This will run the program gracefully and will display the program usage as we have implemented in exception section:

Python argparse Module

Python argparse module makes it easy to write user-friendly command-line interfaces. The program defines what arguments it requires, and argparse will figure out how to parse those out of sys.argv. The argparse module also automatically generates help and usage messages. The module will also issue errors when users give the program invalid arguments.

Example

Following is an example which makes simple use of argparse to accept a name parameter:<>/p>

import argparse argParser = argparse.ArgumentParser() argParser.add_argument("-n", "--name", help="your name") args = argParser.parse_args() print("args=%s" % args) print("args.name=%s" % args.name)

You can add as many arguments as you like using add_argument() method, infact you can also provide required data type of the argument as follows.

argParser.add_argument("-i", "--int", type=int, help="your numeric age ")

However, let’s try to run above program as follows:

This will display the following help:

usage: test.py [-h] [-n NAME] optional arguments: -h, --help show this help message and exit -n NAME, --name NAME your name

Now if we provide our name to the program as follows:

It will display following result:

args=Namespace(name='Zara') args.name=Zara

Источник

Python Command Line Arguments – 3 Ways to Read/Parse

Python command-line arguments are the parameters provided to the script while executing it. The command-line arguments are used to provide specific inputs to the program.

What is the benefit of Python Command Line Arguments?

Python command-line arguments help us to keep our program generic in nature. For example, we can write a program to process a CSV file. If we pass the CSV file name from the command-line, then our program will work for any CSV file. This will make our program loosely coupled and it will be easy to maintain it.

Another benefit of command-line arguments is the additional security that comes with it. Let’s say we have a program to save data into the database. If we store the database credentials in the script or some configuration file, it can be accessed and executed by anyone having access to the files. But, if the user/password is provided as a command-line argument, then it’s not present in the file system and our program is more secured.

How to Pass Command-line Arguments in Python?

If you are running the python script from the terminal, just pass the arguments after the script name. The arguments are separated with white space characters.

$ python script.py arg1 arg2 . argN

Passing Command-line arguments in PyCharm

PyCharm is the most popular IDE for Python programming. If you want to pass command-line arguments to a python program, go to “Run > Edit Configurations” and set the Parameters value and save it.

How to Read Command-line arguments in Python Script?

There are three popular modules to read and parse command-line arguments in the Python script.

1. Reading Python Command-line arguments using the sys module

The command-line arguments are stored in the sys module argv variable, which is a list of strings. We can read the command-line arguments from this list and use it in our program.

Note that the script name is also part of the command-line arguments in the sys.argv variable.

import sys if len(sys.argv) != 2: raise ValueError('Please provide email-id to send the email.') print(f'Script Name is ') email = sys.argv[1] print(f'Sending test email to ')

$ python3.7 command-line-args.py [email protected] Script Name is command-line-args.py Sending test email to [email protected] $ python3.7 command-line-args.py Traceback (most recent call last): File "command-line-args.py", line 4, in raise ValueError('Please provide email-id to send the email.') ValueError: Please provide email-id to send the email. $

2. Parsing Command-line arguments using the getopt module

Python getopt module works in a similar way as the Unix getopt() function. This module is helpful when you want the script to accept options and their values, similar to the many Unix commands.

This module works in conjunction with the sys.argv to parse the command-line arguments and extract the options values in a list of tuples.

import getopt import sys argv = sys.argv[1:] opts, args = getopt.getopt(argv, 'x:y:') # list of options tuple (opt, value) print(f'Options Tuple is ') # list of remaining command-line arguments print(f'Additional Command-line arguments list is ')

$ python3.7 command-line-args.py -x 1 -y 2 A B Options Tuple is [('-x', '1'), ('-y', '2')] Additional Command-line arguments list is ['A', 'B'] $

3. Parsing Command-line arguments using argparse module

We can use Python argparse module also to parse command-line arguments. There are a lot of options with argparse module.

• positional arguments
• the help message
• the default value for arguments
• specifying the data type of argument and many more.

import argparse # create parser parser = argparse.ArgumentParser() # add arguments to the parser parser.add_argument("language") parser.add_argument("name") # parse the arguments args = parser.parse_args() # get the arguments value if args.language == 'Python': print("I love Python too") else: print("Learn Python, you will like it") print(f'Hello , this was a simple introduction to argparse module')

$ python3.7 command-line-args.py Python David I love Python too Hello David, this was a simple introduction to argparse module $ $ python3.7 command-line-args.py Java Lisa Learn Python, you will like it Hello Lisa, this was a simple introduction to argparse module $ $ python3.7 command-line-args.py -h usage: command-line-args.py [-h] language name positional arguments: language name optional arguments: -h, --help show this help message and exit $

Notice that the help message is automatically generated by the argparse module.

Conclusion

If your script requires simple command-line arguments, you can go with sys.argv. But, if your program accepts a lot of positional arguments, default argument values, help messages, etc, then you should use argparse module. The getopt module works too but it’s confusing and hard to understand.

Источник