Python command line Parsing Library argparse, pythonargparse
Python no longer extends the optparse module after 2.7. We recommend that you use the argparse module to parse the command line in the python standard library.
1. example
There is an interview question: compile a script main. py, which is used as follows:
Main. py-u http://www.sohu.com-d 'a = 1, B = 2, c = 3'-o/tmp/index.html
Function requirements: Open the page specified by-u, add the parameter a = 1 & B = 2 & c = 3 after all links on the page (you need to consider the problem that the specified parameter already exists in the link ), then save it 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)
Create an ArgumentParser instance object. Parameters of the ArgumentParser object are all keyword parameters.
Prog: Program name. The default value is sys. argv [0]. It is used to describe the program name 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: String that describes 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 --foo [FOO] foo help
Description: Text before help information.
Epilog: Information after help
>>> parser = argparse.ArgumentParser(... description='A foo that bars',... epilog="And that's how you'd foo a bar")>>> parser.print_help()usage: argparse.py [-h]A foo that barsoptional arguments: -h, --help show this help message and exitAnd that's how you'd foo a bar
Parents: A list composed of ArgumentParser objects. Their 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: Help information output format,
Prefix_chars: Parameter prefix. The default value is '-'
>>> 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, before 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, you can put them in the file for reading. In this example, parser. parse_args (['-F', 'foo', '@args.txt'will be read from args.txt, which is equivalent to ['-F', 'foo', '-F', 'bar'].
Argument_default: Global default value of the parameter. For example, if you want to disable parse_args from being added by default, you 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()
When parser. parse_args (), foo and bar are not automatically parsed.
Conflict_handler: Conflict resolution policy. By default, an error occurs in the conflict:
>>> 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 a 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 FOO new foo help
Add_help: If it is set to False, the-h -- help information is no longer displayed in the help information.
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 parameters: optional parameters and location parameters.
Add optional parameters:
>>> parser.add_argument('-f', '--foo')
Add location parameters:
>>> parser.add_argument('bar')
When parse_args () is running, '-' is used to authenticate the optional parameter, and the rest is the location parameter.
>>> 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
If there is no location parameter during parsing, an error will be reported.
Action:The default value is store.
Store_const, whose values are stored in 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. The value is 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: Save As a list and add it according to key const 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 times the parameter appears
>>> parser = argparse.ArgumentParser()>>> parser.add_argument('--verbose', '-v', action='count')>>> parser.parse_args('-vvv'.split())Namespace(verbose=3)
Help: help information
Version: version
>>> 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 of 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? First, obtain the parameter from the command line. If not, obtain the parameter from the const, and then get the parameter 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 case 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.parse_args([])Namespace(infile=<open file '<stdin>', mode 'r' at 0x...>, outfile=<open file '<stdout>', mode 'w' at 0x...>)
Const: Save a constant
Default: Default Value
Type: Parameter type
Choices: Available values
>>> 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] {1,2,3}doors.py: error: argument door: invalid choice: 4 (choose from 1, 2, 3)
Required: Required
Desk: Can be used as a parameter name
>>> parser = argparse.ArgumentParser()>>> parser.add_argument('--foo', dest='bar')>>> parser.parse_args('--foo XXX'.split())Namespace(bar='XXX')
4. parsing Parameters
Parameters can be written in the following ways:
The most common space separation:
>>> 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 Options are separated by =
>>> parser.parse_args('--foo=FOO'.split())Namespace(foo='FOO', x=None)
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. You can use the vars () built-in function to convert it into a dictionary:
>>> parser = argparse.ArgumentParser()>>> parser.add_argument('--foo')>>> args = parser.parse_args(['--foo', 'BAR'])>>> vars(args){'foo': 'BAR'}
How does python get the content in the cmd command box?
Use popen to run the process and open the pipeline to perform input and output operations through the pipeline. See the subprocess documentation for an example:
Data = subprocess. Popen (cmd, stdout = subprocess. PIPE, stderr = subprocess. PIPE, shell = True) li = data. stdout. readline ()
How does python clear command lines?
In the idle interaction environment, ctrl + f6 can clear the impact of previous command lines in the interaction environment.
Windows command line, no way, only exit () first, then cls clear
I don't know what you want to do to clear the command line?