After 2.7, Python no longer extends the Optparse module, and the Python standard library recommends using the Argparse module to parse the command line.
1.example
There is an interview question: Write a script main.py, using the following methods:
Main.py-u http://www.sohu.com -d ' a=1,b=2,c=3 '-o/tmp/index.html
Feature Requirements: Open the page specified by-u, add the parameter a=1&b=2&c=3 after all the links in the page (you need to consider the problem that the specified parameter already exists in the link), and then save to the file specified by-O.
Import argparseimport urllibfrom pyquery import pyquery as Pqdef Getargs (): parse=argparse. Argumentparser () parse.add_argument ('-u ', type=str) parse.add_argument ('-d ', type=str) parse.add_ Argument ('-o ', type=str) Args=parse.parse_args () return VARs (args) def urladdquery (url,query): query= Query.replace (', ', ' & ') if '? ' in URL: return url.replace ('? ', '? ') +query+ ' & ') else: return url+ '? ' +querydef gethref (): Args=getargs () url=args[' u '] query=args[' d '].strip ("\ '") Filename=args [' O '] DOC=PQ (Url=url) with open (FileName, ' W ') as F: For A in doc (' a '): a=pq (a) href=a.attr (' href ') if href: newurl=urladdquery (href,query) f.write (newurl+ ' \ n ') if __name__== ' __main__ ': Gethref ()
2. Create a parser
Import Argparseparser = Argparse. Argumentparser ()
class Argumentparser (Prog=none, Usage=none, Description=none, Epilog=none, parents=[], Formatter_class=argparse. Helpformatter, prefix_chars= '-', Fromfile_prefix_chars=none, Argument_default=none, conflict_handler= ' error ', add_ Help=true)
Creates an Argumentparser instance object, and the parameters of the Argumentparser object are the keyword parameters.
Prog: The name of the program, which defaults to sys.argv[0], is used to describe the name of the program in the Help information.
>>> parser = Argparse. Argumentparser (prog= ' MyProgram ') >>> parser.print_help () Usage:myprogram [-h]optional arguments:-H,--help Show this help message and exit
usage: A string describing the purpose of the program
>>> parser = Argparse. Argumentparser (prog= ' prog ', usage= '% (Prog) s [Options] ') >>> parser.add_argument ('--foo ', nargs= '? ', help= ' Foo help ') >>> parser.add_argument (' Bar ', nargs= ' + ', help= ' Bar help ') >>> parser.print_help () Usage: PROG [options]positional arguments:bar Bar helpoptional arguments:-H,--help show this help message and exit--f oo [foo] foo Help
Description: The text before the help message.
Epilog: Information after help information
>>> parser = Argparse. Argumentparser ( ... description= ' A foo that bars ',... Epilog= "and that's how you're ' d foo a bar") >>> parser.print_help () usage:argparse.py [-h]a foo that barsoptional arg Uments:-H,--help show this help message and Exitand that's how you ' d foo a bar
parents: A list of Argumentparser objects whose arguments options are included in the new Argumentparser object.
>>> Parent_parser = Argparse. Argumentparser (Add_help=false) >>> parent_parser.add_argument ('--parent ', type=int) >>> Foo_ Parser = Argparse. Argumentparser (Parents=[parent_parser]) >>> foo_parser.add_argument (' foo ') >>> foo_parser.parse_ Args (['--parent ', ' 2 ', ' xxx ']) Namespace (foo= ' xxx ', parent=2)
formatter_class: The format of the Help information output,
prefix_chars: Parameter prefix, default to '-'
>>> parser = Argparse. Argumentparser (prog= ' prog ', prefix_chars= '-+ ') >>> parser.add_argument (' +f ') >>> parser.add_ Argument (' ++bar ') >>> Parser.parse_args (' +f x ++bar Y '. Split ()) Namespace (bar= ' Y ', f= ' X ')
fromfile_prefix_chars: prefix character, preceded by file name
>>> with open (' Args.txt ', ' W ') as FP: ... Fp.write ('-f\nbar ') >>> parser = Argparse. Argumentparser (fromfile_prefix_chars= ' @ ') >>> parser.add_argument ('-f ') >>> Parser.parse_args ([' -F ', ' foo ', ' @args. txt ']) Namespace (f= ' bar)
When there are too many parameters, the parameters can be read in the file, in the example Parser.parse_args (['-F ', ' foo ', ' @args. txt ') parsing will be read from the file Args.txt, equivalent to ['-F ', ' foo ', ' -F ', ' bar '.
Argument_default: The global default value of the parameter. For example, to disallow Parse_args when a parameter is added by default, we can:
>>> parser = Argparse. Argumentparser (Argument_default=argparse. Suppress) >>> parser.add_argument ('--foo ') >>> parser.add_argument (' Bar ', nargs= '? ') >>> Parser.parse_args (['--foo ', ' 1 ', ' Bar ']) Namespace (bar= ' bar ', foo= ' 1 ') >>> Parser.parse_args () Namespace ()
Foo and bar are not resolved automatically when Parser.parse_args ().
conflict_handler: Resolves a conflicting policy, by default the error occurs:
>>> parser = Argparse. Argumentparser (prog= ' prog ') >>> parser.add_argument ('-f ', '--foo ', help= ' old foo-help ') >>> Parser.add_argument ('--foo ', help= ' new foo help ') Traceback (most recent call last): ... Argumenterror:argument--foo:conflicting option String (s):--foo
We can set the conflict resolution policy:
>>> parser = Argparse. Argumentparser (prog= ' prog ', conflict_handler= ' resolve ') >>> parser.add_argument ('-f ', '--foo ', help= ' old Foo help ') >>> parser.add_argument ('--foo ', help= ' new foo help ') >>> parser.print_help () Usage:prog [- h] [-f FOO] [--foo foo]optional arguments:-H,--help show this help message and exit-f FOO old FOO help--foo FO O new Foo Help
add_help: When set to false, the-H--help message is no longer displayed in the Help message.
3. Add Parameter Options
>>> parser.add_argument (' integers ', metavar= ' N ', type=int, nargs= ' + ',... Help= ' An integer for the accumulator ') >>> parser.add_argument ('--sum ', dest= ' accumulate ', action= ' store_ Const ',... Const=sum, Default=max,... help= ' Sum the integers (default:find the max)
add_argument (Name or flags ...) [, Action] [, Nargs] [, Const] [, Default] [, type] [, Choices] [, Required] [, help] [, Metavar] [, Dest])
name or flags: There are two types of arguments, optional parameters and positional parameters.
To add an optional parameter:
>>> parser.add_argument ('-f ', '--foo ')
Add Location Parameters:
>>> parser.add_argument (' Bar ')
The Parse_args () runtime uses '-' to authenticate the optional parameters, and the rest is the positional parameters.
>>> parser = Argparse. Argumentparser (prog= ' prog ') >>> parser.add_argument ('-f ', '--foo ') >>> parser.add_argument (' Bar ') >>> Parser.parse_args ([' Bar ']) Namespace (bar= ' bar ', Foo=none) >>> Parser.parse_args ([' Bar ', '--foo ', ' FOO ']) Namespace (bar= ' bar ', foo= ' foo ') >>> Parser.parse_args (['--foo ', ' foo ']) Usage:prog [-h] [-F FOO] BarPROG:error:too few arguments
Parsing without positional parameters will be an error.
action: default to store
Store_const, the value is stored in the const:
>>> parser = Argparse. Argumentparser () >>> parser.add_argument ('--foo ', action= ' store_const ', const=42) >>> Parser.parse _args ('--foo '. Split ()) Namespace (foo=42)
Store_true and Store_false, with a value of true or False
>>> parser = Argparse. Argumentparser () >>> parser.add_argument ('--foo ', action= ' store_true ') >>> parser.add_argument ('- -bar ', action= ' Store_false ') >>> parser.add_argument ('--baz ', action= ' store_false ') >>> Parser.parse_args ('--foo--bar '. Split ()) Namespace (Bar=false, Baz=true, Foo=true)
Append: Save As List
>>> parser = Argparse. Argumentparser () >>> parser.add_argument ('--foo ', action= ' append ') >>> Parser.parse_args ('--foo 1- -foo 2 '. Split ()) Namespace (foo=[' 1 ', ' 2 '))
Append_const: Saved as a list, it is added according to the const key parameters:
>>> parser = Argparse. Argumentparser () >>> parser.add_argument ('--str ', dest= ' types ', action= ' append_const ', const=str) >> > parser.add_argument ('--int ', dest= ' types ', action= ' append_const ', const=int) >>> Parser.parse_args ('-- Str--int '. Split ()) Namespace (Types=[<type ' str ';, <type ' int ';])
Count: Number of occurrences of statistical parameters
>>> parser = Argparse. Argumentparser () >>> parser.add_argument ('--verbose ', '-V ', action= ' count ') >>> Parser.parse_args ( '-VVV '. Split ()) Namespace (verbose=3)
Help:help Information
Version: Versions
>>> Import argparse>>> parser = Argparse. Argumentparser (prog= ' prog ') >>> parser.add_argument ('--version ', action= ' version ', version= '% (Prog) S 2.0 ') >>> Parser.parse_args (['--version ']) PROG 2.0
Nrgs: Number of parameters
The value can be an integer n (n), * (any number), + (one or more)
>>> parser = Argparse. Argumentparser () >>> parser.add_argument ('--foo ', nargs= ' * ') >>> parser.add_argument ('--bar ', nargs= ' * ') >>> parser.add_argument (' Baz ', nargs= ' * ') >>> Parser.parse_args (' a b--foo x y--bar 1 2 '. Split ()) Namespace (bar=[' 1 ', ' 2 '], baz=[' A ', ' B '], foo=[' x ', ' Y '])
Value is? , the parameters are obtained from the command line first, if none are obtained from the const, and then obtained from the default:
>>> parser = Argparse. Argumentparser () >>> parser.add_argument ('--foo ', nargs= '? ', const= ' C ', default= ' d ') >>> Parser.add _argument (' Bar ', nargs= '? ', default= ' d ') >>> Parser.parse_args (' xx--foo YY '. Split ()) Namespace (bar= ' xx ', foo = ' YY ') >>> Parser.parse_args (' xx--foo '. Split ()) Namespace (bar= ' xx ', foo= ' C ') >>> Parser.parse_args (". Split ()) Namespace (bar= ' d ', foo= ' d ')
A more common scenario is to allow the parameter to be a file
>>> parser = Argparse. Argumentparser () >>> parser.add_argument (' infile ', nargs= '? ', Type=argparse. FileType (' R '),... Default=sys.stdin) >>> parser.add_argument (' outfile ', nargs= '? ', Type=argparse. FileType (' W '),... Default=sys.stdout) >>> Parser.parse_args ([' Input.txt ', ' output.txt ']) Namespace (infile=<open file ' Input.txt ', mode ' r ' at 0x...>, outfile=<open file ' output.txt ', Mode ' W ' at 0x...>) >>> Parser.pars E_args ([]) Namespace (infile=<open file ' <stdin> ', mode ' r ' at 0x...>, outfile=<open file ' <stdout > ', Mode ' W ' at 0x...>)
Const: Saving a constant
Default: Defaults
Type: Parameter types
choices: Values to choose from
>>> parser = Argparse. Argumentparser (prog= ' doors.py ') >>> parser.add_argument (' door ', Type=int, Choices=range (1, 4)) >>> Print (Parser.parse_args ([' 3 ')]) Namespace (door=3) >>> Parser.parse_args ([' 4 ']) usage:doors.py [-h] Doors.py:error:argument door:invalid Choice:4 (choose from 1, 2, 3)
Required: is required
Desk: Can be used as the name of the parameter
>>> parser = Argparse. Argumentparser () >>> parser.add_argument ('--foo ', dest= ' bar ') >>> Parser.parse_args ('--foo XXX '). Split ()) Namespace (bar= ' XXX ')
4. Parsing parameters
The parameters are written in several ways:
The most common spaces are separated:
>>> parser = Argparse. Argumentparser (prog= ' prog ') >>> parser.add_argument ('-X ') >>> parser.add_argument ('--foo ') > >> Parser.parse_args (' x x '. Split ()) Namespace (Foo=none, x= ' x ') >>> Parser.parse_args ('--foo foo '). Split ()) Namespace (foo= ' foo ', X=none)
Long option with = separate
>>> Parser.parse_args ('--foo=foo '. Split ()) Namespace (foo= ' foo ', X=none)
The short options can be written together:
>>> Parser.parse_args ('-xx '. Split ()) Namespace (Foo=none, x= ' x ')
The return value of the Parse_args () method is namespace and can be built into a dictionary with the VARs () function:
>>> parser = Argparse. Argumentparser () >>> parser.add_argument ('--foo ') >>> args = Parser.parse_args (['--foo ', ' BAR ']) >>> VARs (args) {' foo ': ' BAR '}