Shulou(Shulou.com)06/03 Report--

This article mainly introduces the Python command line parameter parsing module which has a certain reference value, interested friends can refer to, I hope you can learn a lot after reading this article, the following let the editor take you to understand.

As a scripting language, Python can easily write various tools. When you want to run a tool or service on the server, entering parameters seems to be a requirement (you can also do it through a configuration file, of course).

If you want to execute on the command line, you need to parse a command-line parameter parsing module to help you do the coolie work.

Python itself provides three command-line parameter parsing modules, and I'll give you an overview of them here.

Getopt, which can only simply handle command line arguments

Optparse, powerful and easy to use, can easily generate standard command line instructions that conform to the Unix/Posix specification.

Argparse, which makes it easier to write a user-friendly command line interface. It requires the process of the parameter definition, argparse will be better parsing sys.argv. At the same time, argparse module can also automatically generate help and prompt information when users input wrong parameters.

Many beginners may use getopt, and it is easy to get started with simple functions. For example, when optget cannot parse multiple values of a parameter, such as-- file file1 file2 file3, I haven't actually used optparse, but considering that it has been deprecated and no longer maintained after Python2.7, we usually don't use it either.

All that's left is the argparse artifact, which meets almost all my needs for a command parser. It supports parsing a parameter with multiple values, can automatically generate help commands and help documents, supports sub-parsers, supports limiting the range of parameters, and so on.

0. HelloWorld

No matter what you learn, the first step should be to master its general framework.

Before using argparse, the framework is very simple, you only need to remember these three lines.

# mytest.pyimport argparseparser = argparse.ArgumentParser (description= "used for test") args = parser.parse_args ()

You can try it now.

[root@localhost] # python mytest.py-husage: mytest.py [- h] used for testoptional arguments:-h,-- help show this help message and exit [root@localhost ~] # [root@localhost ~] # [root@localhost ~] # python mytest.py [root@localhost ~] #

It's ready to use.

1. Getting started with configuration

First of all, let's talk about the more common parameter configuration.

Debugging: debug

Version number: version

Import argparseparser = argparse.ArgumentParser () parser.add_argument ('--version','- version, action='version', version='% (prog) s version: v 0.01, help='show the version') parser.add_argument ('--debug','- dudes, action='store_true', help='show the version', default=False) args = parser.parse_args () print ("= = end = =")

The above configuration at debug needs to talk about the functions and differences between action='store_true' and default = False.

Store_true: once-d or-- debug is specified, the value is True,store_false and vice versa

Default=False: if-d or-- debug is not specified, its value defaults to False

When we execute python mytest.py-v, we print the contents of the version.

[root@localhost] # python mytest.py-vmytest.py version: V0.01 [root@localhost] #

Once the parameter-v is specified, execution to parser.parse_args () exits the program, and the final = = end = = is not printed.

two。 Parameter category

Parameters can be divided into required parameters (positional arguments) and optional parameters (optional arguments).

How to implement it in argsparse?

Required parameters

Use words as parameters. Default is required.

# mytest.pyimport argparseparser = argparse.ArgumentParser () parser.add_argument ("name") args = parser.parse_args () print (args.name)

Run it without specifying the name parameter: python mytest.py

[root@localhost ~] # python mytest.py usage: mytest.py [- h] namemytest.py: error: too few arguments [root@localhost ~] #

As expected, an error was reported, saying that the parameters were missing. Then let's specify: python mytest.py name wangbm

[root@localhost ~] # python mytest.py wangbmwangbm [root@localhost ~] #

Optional parameter

There are two ways:

Single underscore-to specify a short parameter, such as-h

Double underscore-to specify a long parameter, such as-- help

# mytest.pyimport argparseparser = argparse.ArgumentParser () parser.add_argument ("- v", "- verbosity", help= "increase output verbosity") args = parser.parse_args () if args.verbosity: print ("verbosity turned on") else: print ("verbosity turned off")

Try to run python mytest.py and you won't get an error.

[root@localhost ~] # python mytest.pyverbosity turned off [root@localhost ~] #

3. Parameter type

Some parameters are strings, and some parameters are numeric values.

In order to effectively constrain the parameters on the command line, we can declare the type of the parameters in advance. Argparse verifies the parameters. If it fails, an error will be thrown directly.

# mytest.pyimport argparseparser = argparse.ArgumentParser () parser.add_argument ("name") parser.add_argument ("age", type=int) args = parser.parse_args () print (args.name) print (args.age)

Test it out.

[root@localhost] # python mytest.py wangbm eighteenusage: mytest.py [- h] name agemytest.py: error: argument age: invalid int value: 'eighteen' [root@localhost] # [root@localhost] # python mytest.py wangbm 18wangbm18 [root@localhost] #

You see, it is not possible to write eighteen, the prompt type is illegal, only 18 can be written.

4. Mutually exclusive parameter

Some parameters are mutually exclusive, with you without me. For example, gender.

How to implement it in argparse?

Import argparseparser = argparse.ArgumentParser () group = parser.add_mutually_exclusive_group () group.add_argument ("- m", "- male", action= "store_true") group.add_argument ("- f", "- female", action= "store_true") args = parser.parse_args ()

If both parameters are specified, an error will be reported.

[root@localhost ~] # python mytest.py-f [root@localhost ~] # python mytest.py-m [root@localhost ~] # python mytest.py-m-f usage: mytest.py [- h] [- m |-f] mytest.py: error: argument-f/--female: not allowed with argument-m/--male [root@localhost ~] #

5. Optional value

If it is gender, you can put it in two parameters as above and constrain it with a mutex, or you can put it in a parameter, restrict it in argparse, and then make a judgment on the outer layer.

# mytest.pyimport argparseparser = argparse.ArgumentParser () parser.add_argument ("- g", "--gender", default='male', choices= ['male',' female']) args = parser.parse_args () print (args.gender)

Try to implement it and find that the gender can only be male or female, not a shemale.

[root@localhost ~] # python mytest.py-- gender malemale [root@localhost ~] # python mytest.py-- gender femalefemale [root@localhost ~] # [root@localhost ~] # [root@localhost ~] # python mytest.py-- gender otherusage: mytest.py [- h] [- g {male,female}] mytest.py: error: argument-g/--gender: invalid choice: 'other' (choose from' male', 'female') [root@localhost] #

6. Specify a file

There is often the need to specify a configuration file or other file in a script. You can use the following configuration

Import argparseparser = argparse.ArgumentParser () parser.add_argument ('--file','- fallow, action='append', dest='files', help= ('additional yaml configuration files to use'), type=argparse.FileType (' rb')) args = parser.parse_args ()

Dest=files, which means that the parameter value of-- file on the command line is assigned to the variable files, which you can access with args.files.

Action=append, since we will have the need to specify multiple files, specify multiple times-- file, and argparse will put it in a list.

Type=argparse.FileType ('rb'), since it is a specified file, the parameter should be the path and the open mode should be rb. If you want to get the contents of the file, you can use args.files [0] .read ()

7. Child parser

If you have had enough contact with the command line, you will know that in some cases there will be child parsers.

Here I would like to give an example of what I have come across in my work.

Cloud-init-- debug single-name mymodule

Where single is followed by a child parser.

# cloud-init.pydef main_single (name, args): print ("name:", name) print ("args:", args) print ("I am main_single") # add a child parser subparsers = parser.add_subparsers () parser_single = subparsers.add_parser ('single',help='run a single module') # add an action function to the single child parser Parser_single.set_defaults (action= ('single', main_single)) # require=True, which means that if you specify a single parser on the command line, you must take the argument-- name. Parser_single.add_argument ("- name",'- nasty, action= "store", help= "module name to run", required=True) args = parser.parse_args () (name, functor) = args.actionif name in ["single"]: functor (name, args)

Execute the command cloud-init single-name mymodule, with the following output

Name: single

Args: Namespace (action= ('single',), debug=False, file=None, name='mymodule')

I am main_single

Thank you for reading this article carefully. I hope the article "what are the command line parameter parsing modules in Python" shared by the editor will be helpful to everyone? at the same time, I also hope that you will support us and pay attention to the industry information channel. More related knowledge is waiting for you to learn!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.