Detailed explanation of the usage of Python command line parsing tool Argparse

This article mainly explains the usage of the Python command line parsing tool Argparse in detail. Interested friends can refer to it

Recently researching pathon's command line parsing tool, argparse, which is the Python standard library A tool recommended for writing command line programs.

I used to do UI programs. Today I tried the command line program. It feels very good. I don’t have to spend a lot of time studying interface problems, especially in vc++, which is particularly cumbersome.

Now we use python to implement the command line. For the core computing module, we can write our own extension library in c, and the effect is quite good.

I learned argparse, found an article toturial in the official documentation, and briefly translated it.

http://docs.python.org/2/howto/argparse.html#id1

Argparse Tutorial
This tutorial provides a concise introduction to Python The use of Argparse, the command line parameter parsing module recommended by the standard library.

1. Basic concepts

In this tutorial, we use a common ls command to demonstrate the function of argparse.

$ ls
cpython devguide prog.py pypy rm-unused-function.patch
$ ls pypy
ctypes_configure demo dotviewer include lib_pypy lib-python ...
$ ls -l
total 20
drwxr-xr-x 19 wena wena 4096 Feb 18 18:51 cpython
drwxr-xr-x 4 wena wena 4096 Feb 8 12:04 devguide
-rwxr-xr-x 1 wena wena 535 Feb 19 00:05 prog.py
drwxr-xr-x 14 wena wena 4096 Feb 7 00:59 pypy
-rw-r--r-- 1 wena wena 741 Feb 18 01:01 rm-unused-function.patch
$ ls --help
Usage: ls [OPTION]... [FILE]...
List information about the FILEs (the current directory by default).
Sort entries alphabetically if none of -cftuvSUX nor --sort is specified.

From the above four commands, we can understand the following basic concepts:

1), the ls command has no parameters It can also be run, and by default prints out all the contents in the current directory.
2) If we want it to display more content, then we need to give it more parameters. In this case, we want to display a different directory, pypy. What we have done is specify the common positional argument, named so because the program needs to decide what to do based on the position of the argument in the command line. This concept is closer to the command cp. Its usage is cp src dest. src represents the file you want to copy, and dest represents where you want to copy the file.
3) Now, I want to change the behavior of the program. In our example, I want to display the westward information of the file instead of just the file name. The parameter -l is the optional argument we know (optinal argument)
4), and the last sentence is to display the help document. A snippet that you can use to learn how to use a command you've never used before.

2. Basic understanding

We start with a basic program (it does nothing)

import argparse
parser = argparse.ArgumentParser()
parser.parse_args()

Running results:

$ python prog.py
$ python prog.py --help
usage: prog.py [-h]

optional arguments:
 -h, --help show this help message and exit
$ python prog.py --verbose
usage: prog.py [-h]
prog.py: error: unrecognized arguments: --verbose
$ python prog.py foo
usage: prog.py [-h]
prog.py: error: unrecognized arguments: foo

Result analysis:

1) If you run this program without giving parameters, you will not get any result.
2) The second naming shows the benefits of using argparse. You did nothing but got a good help message.
3) We can get a good help message without manually setting the --help parameter. But if other parameters (such as foo) are given, an error will be generated.

3. Positional parameters

First, give an example:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("echo")
args = parser.parse_args()
print args.echo

Running result:

$ python prog.py
usage: prog.py [-h] echo
prog.py: error: the following arguments are required: echo
$ python prog.py --help
usage: prog.py [-h] echo

positional arguments:
 echo

optional arguments:
 -h, --help show this help message and exit
$ python prog.py foo
foo

Result analysis:

This time, we added an add_argument() method to set the command line parameters acceptable to the program.
Now to run the program, you must set a parameter.
The parse_args() method actually returns some data from our command line parameters, in the above example it is echo
This "magic"-like process is automatically completed by argparse.
Although the automatically generated help information is beautifully displayed, we still cannot know what it does based only on the echo parameter. So, we added a few things to make it more useful.

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("echo", help="echo the string you use here")
args = parser.parse_args()
print args.echo

Run result:

$ python prog.py -h
usage: prog.py [-h] echo

positional arguments:
 echo    echo the string you use here

optional arguments:
 -h, --help show this help message and exit

On this basis, let’s make more changes One point: (calculate the square of the input parameter square)

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("square", help="display a square of a given number")
args = parser.parse_args()
print args.square**2

The following is the running result:

$ python prog.py 4
Traceback (most recent call last):
 File "prog.py", line 5, in <module>
  print args.square**2
TypeError: unsupported operand type(s) for ** or pow(): &#39;str&#39; and &#39;int&#39;

This program does not run correctly because argparse will treat the input as a string, so we need to set its type: (type=int)

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("square", help="display a square of a given number",
          type=int)
args = parser.parse_args()
print args.square**2

The following is the running result:

$ python prog.py 4
16
$ python prog.py four
usage: prog.py [-h] square
prog.py: error: argument square: invalid int value: 'four'

Now, this program can run smoothly and can handle some incorrect inputs.

The above is a simple tutorial on using the Python command line parsing tool Argparse. I hope it will be helpful to everyone.

The above is the detailed content of Detailed explanation of the usage of Python command line parsing tool Argparse. For more information, please follow other related articles on the PHP Chinese website!