Python get cli parameter

How to get CLI arguments in Python3?

In Python 3, you can get the Command Line Interface (CLI) parameters using the sys module. Consider the following example:

import sys

# The first parameter is always the name of the program itself
print("Program name:", sys.argv[0])

# The rest of the parameters are the command line arguments
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:

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

# Create the parser
parser = argparse.ArgumentParser(description='Example script to demonstrate argparse usage')

# Add some arguments
parser.add_argument('input_file', help='Input file name')
parser.add_argument('--output', '-o', help='Output file name')

# Parse the arguments
args = parser.parse_args()

# Access the parsed arguments
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.

Источник

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.

Источник