Error argument expected one argument

Argparse Tutorial¶

This tutorial is intended to be a gentle introduction to argparse , the recommended command-line parsing module in the Python standard library.

There are two other modules that fulfill the same task, namely getopt (an equivalent for getopt() from the C language) and the deprecated optparse . Note also that argparse is based on optparse , and therefore very similar in terms of usage.

Concepts¶

Let’s show the sort of functionality that we are going to explore in this introductory tutorial by making use of the ls command:

A few concepts we can learn from the four commands:

The ls command is useful when run without any options at all. It defaults to displaying the contents of the current directory.

If we want beyond what it provides by default, we tell it a bit more. In this case, we want it to display a different directory, pypy . What we did is specify what is known as a positional argument. It’s named so because the program should know what to do with the value, solely based on where it appears on the command line. This concept is more relevant to a command like cp, whose most basic usage is cp SRC DEST . The first position is what you want copied, and the second position is where you want it copied to.

Now, say we want to change behaviour of the program. In our example, we display more info for each file instead of just showing the file names. The -l in that case is known as an optional argument.

That’s a snippet of the help text. It’s very useful in that you can come across a program you have never used before, and can figure out how it works simply by reading its help text.

The basics¶

Let us start with a very simple example which does (almost) nothing:

Following is a result of running the code:

Here is what is happening:

Running the script without any options results in nothing displayed to stdout. Not so useful.

The second one starts to display the usefulness of the argparse module. We have done almost nothing, but already we get a nice help message.

The —help option, which can also be shortened to -h , is the only option we get for free (i.e. no need to specify it). Specifying anything else results in an error. But even then, we do get a useful usage message, also for free.

Introducing Positional arguments¶

And running the code:

Here is what’s happening:

We’ve added the add_argument() method, which is what we use to specify which command-line options the program is willing to accept. In this case, I’ve named it echo so that it’s in line with its function.

Calling our program now requires us to specify an option.

The parse_args() method actually returns some data from the options specified, in this case, echo .

The variable is some form of ‘magic’ that argparse performs for free (i.e. no need to specify which variable that value is stored in). You will also notice that its name matches the string argument given to the method, echo .

Note however that, although the help display looks nice and all, it currently is not as helpful as it can be. For example we see that we got echo as a positional argument, but we don’t know what it does, other than by guessing or by reading the source code. So, let’s make it a bit more useful:

Now, how about doing something even more useful:

Источник

Argument -p: expected one argument #63

Facing the error below while trying to compile;

D:xampphtdocsprotestoneusage: jasperstarter process [-h] -f [ . ] [-o ] [-w]
[-a []] [-P [ . ]]
[-r []] [-t ] [-H ]
[-u ] [-p ] [-n ]
[—db-sid ] [—db-port ]
[—db-driver ] [—db-url ]
[—jdbc-dir

] [—data-file ]
[—csv-first-row] [—csv-columns ]
[—csv-record-del ]
[—csv-field-del ]
[—csv-charset ] [—xml-xpath ]
[—json-query ] [-N ] [-d]
[-s ] [-c ]
[—out-field-del ]
[—out-charset ]
jasperstarter: error: argument -p: expected one argument
PHP Fatal error: Uncaught exception ‘JasperPHPExceptionErrorCommandExecutable’ with message ‘Your report has an error and couldn ‘t be processed! Try to output the command using the functi
on output(); and run it manually in the console.’ in D:xampphtdocsprotestonevendorgeekcomphpjaspersrcJasperPHP.php:198
Stack trace:
#0 D:xampphtdocsprotestonereport.php(52): JasperPHPJasperPHP->execute()
#1

Related Searches: Python argparse, Python arguments, Python optional arguments, Python positional arguments, python argumentparser, python argparse example, python argparse boolean, python script arguments, python argparse list

In this tutorial we will explore argparse module from Python programming language. I will share multiple examples with different scenarios to use python argparse to process command line arguments. Now these input command line arguments can be optional or in the for of array of any other format. So our code must handle these accordingly.

What is command line argument?

Before we go ahead you should be familiar with the concept of command line arguments. Let us take a very simple example which I am sure you must have used in your career while working on Linux:

[root@server scripts]# ls -ltr /var/log/
total 1628
-rw-r--r--. 1 root root    489 Nov  7  2019 grubby_prune_debug
-rw-------. 1 root root  12174 May 25  2020 yum.log-20200525
-rw-------. 1 root root      0 Jul 23  2020 spooler-20210319
-rw-------. 1 root root    194 Mar 19 14:39 maillog-20210319
-rw-------. 1 root root   7880 Mar 19 15:06 yum.log-20210319
-rw-------. 1 root root 165274 Mar 19 15:12 messages-20210319
-rw-------. 1 root root  13106 Mar 19 15:12 secure-20210319
-rw-------. 1 root root   2948 Mar 19 15:46 cron-20210319
...

Here we are using ls command used to list files and directories. Along with the ls command I have used some command line arguments i.e. -ltr which can also be used separately or in different order ls -l -t -r /var/log and you should still get the same output.

ALSO READ: Python Compare Strings [10+ Examples]

You may also notice that ls command works just fine without these input arguments, which means that these are all optional arguments. We can add these arguments to further refine the command output.

Similarly when we write a python script, we may have a requirement to support command line arguments to collect different values. We will explore this further using different examples.

Overview on python argparse

Python’s standard library module for interpreting command-line arguments, argparse, supplies a host of features, making it easy to add argument handling to scripts in a fashion that is consistent with other tools. You can make arguments required or optional, have the user supply values for certain arguments, or define default values. argparse creates usage text, which the user can read using the —help argument, and checks the user-supplied arguments for validity.

Using argparse is a four-step process.

• Create a parser object.
• Add arguments your program accepts to the parser object.
• Tell the parser object to parse your script’s argv (short for argument vector, the list of arguments that were supplied to the script on launch); it checks them for consistency and stores the values.
• Use the object returned from the parser object in your script to access the values supplied in the arguments.

The default syntax to use ArgumentParser object from python argparse is:

argparse.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, allow_abbrev=True, exit_on_error=True)

Example-1: Create help or usage section

In this example we will create a basic help or usage section using python argparse. By default add_help is enabled with ArgumentParser so you can just execute the following code which will add a help section with an optional argument of -h or --help:

#!/usr/bin/env python3

import argparse

## You could also use
## parser = argparse.ArgumentParser(add_help=True)
parser = argparse.ArgumentParser()

parser.parse_args()

Output from this script:

ALSO READ: Numpy random Examples | rand() | randint() function

Example-2: Parse argument without value

In this example we will pass certain options to our script which do not expect any value. For example use -v or --verbose to enable verbose output or use -q or —quiet to suppress the output. Now these are optional arguments and do not require a value. The presence or absence of the option determines the appropriate Boolean in the parser.

#!/usr/bin/env python3

import argparse

parser = argparse.ArgumentParser()
parser.add_argument('-q', '--quiet',
                    action='store_true',
                    dest='quiet',
                    help='Suppress Output'
                    )
parser.add_argument('-v', '--verbose',
                    action='store_true',
                    help='Verbose Output'
                    )
args = parser.parse_args()

print('Quiet mode is %r.' % args.quiet)

We have defined our action variable as store_true, which is the reason why the parser will not expect a value. You can read more about action in Example-10 of this article.

Most options do not need an action to be specified (the default is store, which stores the value it receives). The specification of store_true or store_false is the most common way to indicate that an option is a flag and should not accept a value.

The dest keyword argument determines how to look up the parsed value (in this case, True or False) on the object you get back when you call parse_args. The string used here will be the attribute name on the object. In many cases, the dest keyword argument is optional.

ArgumentParser determines an intuitive name based on the name of the option itself. However, it is useful to explicitly provide this for readability and maintainability.

Output from this script with different optional arguments:

~]# python3 eg-2.py -h
usage: eg-2.py [-h] [-q] [-v]

optional arguments:
  -h, --help     show this help message and exit
  -q, --quiet    Suppress Output
  -v, --verbose  Verbose Output

~]# python3 eg-2.py -v
Quiet mode is False.

~]# python3 eg-2.py -q
Quiet mode is True.

ALSO READ: Learn python *args and **kwargs with simple examples

Example-3: Use different prefix for command line arguments

Normally in Linux and Uni we use single (-) or double hyphen (--) as the prefix for all the command line arguments. But for Windows we prefer forward slash (or simply slash) character (/).

You can change which characters are used for prefixes by providing the prefix_chars keyword argument to the ArgumentParser constructor, as shown here:

#!/usr/bin/env python3

import argparse

parser = argparse.ArgumentParser(prefix_chars='/')
parser.add_argument('/q', '//quiet',
                    action='store_true',
                    dest='quiet',
                    help='Suppress Output'
                    )
args = parser.parse_args()
print('Quiet mode is %r.' % args.quiet)

In this example, we changed the prefix character to /. Note that this also means that the argument itself (the one passed to add_argument) must change accordingly. Calling this script is still straightforward. You simply must use /q or //quiet (rather than -q or --quiet).

Output from this script:

Example-4: Pass single value to python argument

We already defined an option flag which doesn’t expect any value by using store_true for action keyword in Example-2 above. Here we have not defined any action so by default it would expect a value for the input argument.

#!/usr/bin/env python3

import argparse

parser = argparse.ArgumentParser()
parser.add_argument('-H', '--host',
                    default='localhost',
                    dest='host',
                    help='Provide destination host. Defaults to localhost',
                    type=str
                    )
args = parser.parse_args()
print(f'The host is "{args.host}"')

The script expects -H or --host argument with a single value which will be considered as destination host. We have defined a default value so that if we don’t define a host then localhost will be considered as the default destination. Additionally we are also using type keyword to convert the input argument value to string type.

ALSO READ: Python pwd module Explained [Practical Examples]

Here we are executing our sample script with different values using -H option:

Example-5: Pass multiple values in single argument

In the previous example we were passing single value to -H input argument. Let’s see, what would happen if I pass no value or more than one values to -H:

~]# python3 eg-4.py -H
usage: eg-4.py [-h] [-H HOST]
eg-4.py: error: argument -H/--host: expected one argument

~]# python3 eg-4.py -H host1 host2
usage: eg-4.py [-h] [-H HOST]
eg-4.py: error: unrecognized arguments: host2

So as expected, our parser argument fails to handle multiple values. You can set an option to accept an unbound number of arguments, or an exact number by using the nargs keyword argument to add_argument.

In this example section we will cover following scenarios:

• Argument expects exactly 2 values
• Argument expects 1 or more values
• Argument expects 0 or more values

Scenario-1: Argument expects exactly 2 values

In this example we will write a script which expects an argument with exactly two values.

#!/usr/bin/env python3

import argparse

parser = argparse.ArgumentParser()
parser.add_argument('--range',
                    default=[1-100],
                    dest='range',
                    help='Define the range. Default is 1-100',
                    type=int,
                    nargs=2
                    )
args = parser.parse_args()
print(f'The defined range is {args.range[0]}-{args.range[1]}')

This script expects --range argument which should have exactly 2 values. The input values will be converted to integer type. Using nargs=2 we are restricting the number of values for --range to exactly 2. Additionally we have also defined a default range value from 1-100.

Let us try this script with different values:

~]# python3 eg-5-scenario-1.py -h
usage: eg-5-scenario-1.py [-h] [--range RANGE RANGE]

optional arguments:
  -h, --help           show this help message and exit
  --range RANGE RANGE  Define the range. Default is 1-100

~]# python3 eg-5-scenario-1.py --range 5 100
The defined range is 5-100

~]# python3 eg-5-scenario-1.py --range 5
usage: eg-5-scenario-1.py [-h] [--range RANGE RANGE]
eg-5-scenario-1.py: error: argument --range: expected 2 arguments

~]# python3 eg-5-scenario-1.py --range 5 100 101
usage: eg-5-scenario-1.py [-h] [--range RANGE RANGE]
eg-5-scenario-1.py: error: unrecognized arguments: 101

As expected when we try to give more than or less than 2 values to --range argument, the script throws error because we have restricted the number of values to 2 using nargs.

ALSO READ: HackerRank Solution: Python Reduce Function [3 Methods]

Scenario-2: Argument expects 1 or more values

You can use the + value with nargs which indicates that the option expects one or more values to be provided. Let us look at this example where we will perform addition using all the values provided to --num argument.

#!/usr/bin/env python3

import argparse

parser = argparse.ArgumentParser()
parser.add_argument('--num',
                    dest='num',
                    help='Define integers to perform addition',
                    type=int,
                    nargs='+'
                    )
args = parser.parse_args()
print('%s = %d' % (
        ' + '.join([str(i) for i in args.num]),
        sum(args.num),))

Here we have defined nargs='+' for --num argument which means --num expects one or more values.

Let us execute this script with one or more values for --num argument:

~]# python3 eg-5-scenario-2.py --num 2
2 = 2

~]# python3 eg-5-scenario-2.py --num 2 3
2 + 3 = 5

~]# python3 eg-5-scenario-2.py --num 2 4 6 7
2 + 4 + 6 + 7 = 19

~]# python3 eg-5-scenario-2.py --num
usage: eg-5-scenario-2.py [-h] [--num NUM [NUM ...]]
eg-5-scenario-2.py: error: argument --num: expected at least one argument

~]# python3 eg-5-scenario-2.py -h
usage: eg-5-scenario-2.py [-h] [--num NUM [NUM ...]]

optional arguments:
  -h, --help           show this help message and exit
  --num NUM [NUM ...]  Define integers to perform addition

Scenario-3: Argument expects 0 or more values

Similar to (+) sign, you can use asterisk (*) with nargs to define zero or more values to a certain argument. We will update our script from Scenario-2 to use nargs='*' for --num argument and re-run the script:

~]# python3 eg-5-scenario-3.py --num
 = 0

~]# python3 eg-5-scenario-3.py --num 1 2 3
1 + 2 + 3 = 6

So now our script doesn’t fail when we don’t provide any value to --num argument.

ALSO READ: Python Deleter Property Decorators

Example-6: Pass mandatory argument using python argparse

In all our previous examples we were passing optional arguments to our python script. To pass a mandatory argument, you must use required keyword with True flag i.e. required=True.

#!/usr/bin/env python3

import argparse

parser = argparse.ArgumentParser()
parser.add_argument('-s', '--sleep',
                    required=True,
                    default=20,
                    dest='sleep',
                    help='Provide sleep timer',
                    type=int
                    )
args = parser.parse_args()

print('Provided sleep value is %r.' % args.sleep)

You may observe that when we execute this script and verify that -s or --sleep is required argument now.

~]# python3 eg-6.py
usage: eg-6.py [-h] -s SLEEP
eg-6.py: error: the following arguments are required: -s/--sleep

Although if you check the help section, -s or --sleep is shown under optional arguments section.

This is by design as parameters starting with - or -- are usually considered optional. All other parameters are positional parameters and as such required by design (like positional function arguments). To overcome this you can parse the arguments and store into two different objects.

#!/usr/bin/env python3

import argparse

parser = argparse.ArgumentParser()

# Create a new group to store required arguments
requiredName = parser.add_argument_group('required named arguments')

# Add required arguments to the parser
requiredName.add_argument('-s', '--sleep',
                    required=True,
                    default=20,
                    dest='sleep',
                    metavar='TIME',
                    help='Provide sleep timer',
                    type=int
                    )

# Add optional arguments to the parser
parser.add_argument('-q', '--quiet',
                    action='store_true',
                    dest='quiet',
                    help='Suppress Output'
                    )

args = parser.parse_args()

print('Provided sleep value is %r.' % args.sleep)

Output from this script:

Example-7: Pass multiple choices to python argument

Python ArgumentParser adds the capability to specify that an option may only be one of an enumerated set of choices. These can be handled by passing a container object as the choices keyword argument to add_argument(). When the command line is parsed, argument values will be checked, and an error message will be displayed if the argument was not one of the acceptable values:

This script expects any of the three values between blue, black and brown for --color argument. The default value would be blue if --color argument is not defined.

#!/usr/bin/env python3

import argparse

parser = argparse.ArgumentParser()
parser.add_argument('--color',
                    choices=('blue', 'black', 'brown'),
                    dest='color',
                    default='blue',
                    help='Guess my lucky color'
                    )
args = parser.parse_args()
print('You have chosen %r.' % args.color)

Let us execute this script with different values for --color argument:

~]# python3 eg-7.py -h
usage: eg-7.py [-h] [--color {blue,black,brown}]

optional arguments:
  -h, --help            show this help message and exit
  --color {blue,black,brown}
                        Guess my lucky color
~]# python3 eg-7.py
You have chosen 'blue'.

~]# python3 eg-7.py --color red
usage: eg-7.py [-h] [--color {blue,black,brown}]
eg-7.py: error: argument --color: invalid choice: 'red' (choose from 'blue', 'black', 'brown')

ALSO READ: How to create, read, append, write to file in Python

Example-8: Pass positional arguments with python argparse

With python argparse, you must declare your positional arguments explicitly. If you do not, the parser expects to have no arguments left over after it completes parsing, and it raises an error if arguments still remain.

How do we define optional and positional arguments?

The declaration for positional arguments is equivalent to the declaration for options, except that the leading hyphen is omitted.
When parse_args() is called, optional arguments will be identified by the - prefix, and the remaining arguments will be assumed to be positional.

For example, an optional argument could be created like:

>>> parser.add_argument('-f', '--foo')

while a positional argument could be created like:

>>> parser.add_argument('bar')

We will use the same code as we used in Example-5 to demonstrate nargs keyword. This script will expect integers as positional arguments which can be one or more. We will perform a SUM operation on these provided integers. We are explicitly converting the provided values into integers using type=int.

The code we used is mostly the same, except that the --num argument has been replaced with num, without the double-hyphen prefix.

#!/usr/bin/env python3

import argparse

parser = argparse.ArgumentParser()
parser.add_argument('num',
                    nargs='+',
                    type=int,
                    help='Provide integers to perform SUM'
                    )
args = parser.parse_args()

print('%s = %d' % (' + '.join([str(i) for i in args.num]),
        sum(args.num),))

You can see that there is a new section of positional arguments in the help section now:

ALSO READ: Python sort list [2 Methods and 8 Examples]

We can now execute our script without num argument:

~]# python3 eg-8.py 1 2 3
1 + 2 + 3 = 6

Example-9: Read a file as an input to python arguments

The Python argparse module provides a special class that can be sent to the type keyword argument of add_argument, which is argparse.FileType.

The argparse.FileType class expects the arguments that would be sent to Python’s open function, excluding the filename (which is what is being provided by the user invoking the program). If you are opening the file for reading, this may be nothing. open defaults to opening files only for reading. However, any arguments after the initial positional argument to open can be provided to FileType, and they will be passed on to open.

#!/usr/bin/env python3

import argparse

parser = argparse.ArgumentParser()
parser.add_argument('--file',
                    type=argparse.FileType('r'),
                    dest='myfile',
                    default='/tmp/file',
                    help='The config file to use'
                    )
args = parser.parse_args()
print(args.myfile.read())

This would read from /tmp/file by default, but allow you to specify a different file to read from using the --file argument. Rather than providing these options as text and forcing you to open the file yourself, you will simply be provided with an open file object:

~]# python3 eg-9.py
This is a test file

You may overwrite the default option by using --file argument:

~]# python3 eg-9.py --file /etc/hosts
127.0.0.1   localhost localhost.localdomain localhost4 localhost4.localdomain4
::1         localhost localhost.localdomain localhost6 localhost6.localdomain6
192.168.43.31   server1 server1.example.com

Following is the help section:

~]# python3 eg-9.py -h
usage: eg-9.py [-h] [--color MYFILE]

optional arguments:
  -h, --help      show this help message and exit
  --color MYFILE  The config file to use

ALSO READ: Python dictionary (15 easy examples with syntax)

Example-10: Using “action” with ArgumentParser

ArgumentParser objects associate command-line arguments with actions. These actions can do just about anything with the command-line arguments associated with them, though most actions simply add an attribute to the object returned by parse_args().

Any of six built-in actions can be triggered when an argument is encountered:

• store: Save the value, after optionally converting it to a different type. This is the default action taken if none is specified explicitly.
• store_const: Save a value defined as part of the argument specification, rather than a value that comes from the arguments being parsed. This is typically used to implement command-line flags that are not boolean values.
• store_true/store_false: Save the appropriate boolean value. These actions are used to implement Boolean switches.
• append: Save the value to a list. Multiple values are saved if the argument is repeated.
• append_const: Save a value defined in the argument specification to a list.
• version: Print the version details about the program and then exit.

In this example we have defined all the possible actions which can be used with ArgumentParser():

#!/usr/bin/env python3

import argparse

parser = argparse.ArgumentParser()
parser.add_argument('-s', action='store', dest='simple_value', help='Store a simple value')
parser.add_argument('-c', action='store_const', dest='constant_value', const='value-to-store', help='Store a constant value')
parser.add_argument('-t', action='store_true', default=False, dest='boolean_t', help='Set a switch to true')
parser.add_argument('-f', action='store_false', default=True, dest='boolean_f', help='Set a switch to false')
parser.add_argument('-a', action='append', dest='collection', default=[], help='Add repeated values to a list')
parser.add_argument('-A', action='append_const', dest='const_collection', const='value-1-to-append', default=[], help='Added different values to list')
parser.add_argument('-B', action='append_const', dest='const_collection', const='value-2-to-append', help='Add different values to list')
parser.add_argument('--version', action='version', version='%(prog)s 1.0')

results = parser.parse_args()
print('simple_value     = {!r}'.format(results.simple_value))
print('constant_value   = {!r}'.format(results.constant_value))
print('boolean_t        = {!r}'.format(results.boolean_t))
print('boolean_f        = {!r}'.format(results.boolean_f))
print('collection       = {!r}'.format(results.collection))
print('const_collection = {!r}'.format(results.const_collection))

Following is our help section:

ALSO READ: Python os.path.join() method [Practical Examples]

‘store’ — This just stores the argument’s value. This is the default action. For example:

‘store_const’ — This stores the value specified by the const keyword argument.

‘store_true’ and ‘store_false’ — These are special cases of ‘store_const’ used for storing the values True and False respectively.

‘append’ — This stores a list, and appends each argument value to the list. This is useful to allow an option to be specified multiple times.

‘append_const’ — This stores a list, and appends the value specified by the const keyword argument to the list.

‘version’ — This expects a version= keyword argument in the add_argument() call, and prints version information and exits when invoked

~]# python3 eg-10.py --version
eg-10.py 1.0

Summary

In this Python programming tutorial we learned about argparse module and it’s usage to create help section. The argparse modules provide very good support for reading data from the ­command line for Python programs that need to do this. The argparse module supersedes optparse module.

The argparse module supports essentially all of optparse’s features, and adds several additional ones, such as multiple arguments, better support for files, and more. Additionally, argparse’s handling of positional arguments is more consistent with its handling of options, and results in more robust handling as well as a more useful help output.

Правила использования необязательных аргументов командной строки.

Разберемся, как можно добавить необязательные параметры командной строки в файл prog.py:

# prog.py
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("--verbosity", help="increase output verbosity")
args = parser.parse_args()
if args.verbosity:
    print("verbosity turned on")

Запуск скрипта в командной строке даст вывод, представленный ниже.

$ python3 prog.py --verbosity 1
verbosity turned on
$ python3 prog.py
$ python3 prog.py --help
usage: prog.py [-h] [--verbosity VERBOSITY]

optional arguments:
  -h, --help            show this help message and exit
  --verbosity VERBOSITY
                        increase output verbosity
$ python3 prog.py --verbosity
usage: prog.py [-h] [--verbosity VERBOSITY]
prog.py: error: argument --verbosity: expected one argument

Вот что здесь происходит:

• Программа написана таким образом, чтобы что-то выводить, когда указан необязательный параметр --verbosity и ничего не выводить, если параметр не указан.

• Опция является необязательной, т.к. при запуске программы без нее не будет ошибок.

  Обратите внимание

  , если необязательный параметр в командной строке не используется, то переменной, в данном случае args.verbosity, по умолчанию присваивается значение None. Это и является причиной того, что она не проходит проверку истинности в операторе if.

• Справочное сообщение немного другое.

• При использовании опции командной строки --verbosity необходимо также указать какое-то значение.

В приведенном выше примере для --verbosity, в командной строке, указывается произвольные целочисленное значение, но для этой программы на самом деле полезны только два значения: True или False.

Для этого изменим соответствующим образом код:

# prog.py
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("--verbose", help="increase output verbosity",
                    action="store_true")
args = parser.parse_args()
if args.verbose:
    print("verbosity turned on")

И вывод скрипта prog.py при запуске:

$ python3 prog.py --verbose
verbosity turned on
$ python3 prog.py --verbose 1
usage: prog.py [-h] [--verbose]
prog.py: error: unrecognized arguments: 1
$ python3 prog.py --help
usage: prog.py [-h] [--verbose]

optional arguments:
  -h, --help  show this help message and exit
  --verbose   increase output verbosity

Вот что здесь происходит:

• Опция теперь больше похожа на флаг, чем на то, что требует значения. Мы изменили название опции на --verbose, чтобы соответствовать этой идее.

  Обратите внимание

  , что теперь указывается новое ключевое слово --verbose и присваиваем ему значение store_true. Это означает, что, если необязательный параметр указан, то модуль argparse присвоит args.verbose значение True. Отсутствие необязательного параметра --verbose в командной строке подразумевает args.verbose=False.

• Скрипт prog.py будет ругаться, если указать значение параметру --verbose.

• Обратите внимание на другой текст справки.

Короткие варианты необязательных параметров.

Если вы знакомы с использованием командной строки, то заметите, что еще не затронута тема коротких версий необязательных параметров.

Это довольно просто:

# prog.py
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("-v", "--verbose", help="increase output verbosity",
                    action="store_true")
args = parser.parse_args()
if args.verbose:
    print("verbosity turned on")

Вывод скрипта после его запуска. Обратите внимание, что новая возможность также отражена в тексте справки.

$ python3 prog.py -v
verbosity turned on
$ python3 prog.py --help
usage: prog.py [-h] [-v]

optional arguments:
  -h, --help     show this help message and exit
  -v, --verbose  increase output verbosity

The argparse module was added to Python 2.7 as a replacement
for optparse. The implementation of argparse supports
features that would not have been easy to add to optparse, and
that would have required backwards-incompatible API changes, so a new
module was brought into the library instead. optparse is still
supported, but is not likely to receive new features.

import argparse
parser = argparse.ArgumentParser(description='This is a PyMOTW sample program')

import argparse

parser = argparse.ArgumentParser(description='Short sample app')

parser.add_argument('-a', action="store_true", default=False)
parser.add_argument('-b', action="store", dest="b")
parser.add_argument('-c', action="store", dest="c", type=int)

print parser.parse_args(['-a', '-bval', '-c', '3'])

$ python argparse_short.py

Namespace(a=True, b='val', c=3)

import argparse

parser = argparse.ArgumentParser(description='Example with long option names')

parser.add_argument('--noarg', action="store_true", default=False)
parser.add_argument('--witharg', action="store", dest="witharg")
parser.add_argument('--witharg2', action="store", dest="witharg2", type=int)

print parser.parse_args([ '--noarg', '--witharg', 'val', '--witharg2=3' ])

$ python argparse_long.py

Namespace(noarg=True, witharg='val', witharg2=3)

import argparse

parser = argparse.ArgumentParser(description='Example with non-optional arguments')

parser.add_argument('count', action="store", type=int)
parser.add_argument('units', action="store")

print parser.parse_args()

$ python argparse_arguments.py 3 inches

Namespace(count=3, units='inches')

$ python argparse_arguments.py some inches

usage: argparse_arguments.py [-h] count units
argparse_arguments.py: error: argument count: invalid int value: 'some'

$ python argparse_arguments.py

usage: argparse_arguments.py [-h] count units
argparse_arguments.py: error: too few arguments

import argparse

parser = argparse.ArgumentParser()

parser.add_argument('-s', action='store', dest='simple_value',
                    help='Store a simple value')

parser.add_argument('-c', action='store_const', dest='constant_value',
                    const='value-to-store',
                    help='Store a constant value')

parser.add_argument('-t', action='store_true', default=False,
                    dest='boolean_switch',
                    help='Set a switch to true')
parser.add_argument('-f', action='store_false', default=False,
                    dest='boolean_switch',
                    help='Set a switch to false')

parser.add_argument('-a', action='append', dest='collection',
                    default=[],
                    help='Add repeated values to a list',
                    )

parser.add_argument('-A', action='append_const', dest='const_collection',
                    const='value-1-to-append',
                    default=[],
                    help='Add different values to list')
parser.add_argument('-B', action='append_const', dest='const_collection',
                    const='value-2-to-append',
                    help='Add different values to list')

parser.add_argument('--version', action='version', version='%(prog)s 1.0')

results = parser.parse_args()
print 'simple_value     =', results.simple_value
print 'constant_value   =', results.constant_value
print 'boolean_switch   =', results.boolean_switch
print 'collection       =', results.collection
print 'const_collection =', results.const_collection

$ python argparse_action.py -h

usage: argparse_action.py [-h] [-s SIMPLE_VALUE] [-c] [-t] [-f]
                          [-a COLLECTION] [-A] [-B] [--version]

optional arguments:
  -h, --help       show this help message and exit
  -s SIMPLE_VALUE  Store a simple value
  -c               Store a constant value
  -t               Set a switch to true
  -f               Set a switch to false
  -a COLLECTION    Add repeated values to a list
  -A               Add different values to list
  -B               Add different values to list
  --version        show program's version number and exit

$ python argparse_action.py -s value

simple_value     = value
constant_value   = None
boolean_switch   = False
collection       = []
const_collection = []

$ python argparse_action.py -c

simple_value     = None
constant_value   = value-to-store
boolean_switch   = False
collection       = []
const_collection = []

$ python argparse_action.py -t

simple_value     = None
constant_value   = None
boolean_switch   = True
collection       = []
const_collection = []

$ python argparse_action.py -f

simple_value     = None
constant_value   = None
boolean_switch   = False
collection       = []
const_collection = []

$ python argparse_action.py -a one -a two -a three

simple_value     = None
constant_value   = None
boolean_switch   = False
collection       = ['one', 'two', 'three']
const_collection = []

$ python argparse_action.py -B -A

simple_value     = None
constant_value   = None
boolean_switch   = False
collection       = []
const_collection = ['value-2-to-append', 'value-1-to-append']

$ python argparse_action.py --version

argparse_action.py 1.0

import argparse

parser = argparse.ArgumentParser(description='Change the option prefix characters',
                                 prefix_chars='-+/',
                                 )

parser.add_argument('-a', action="store_false", default=None,
                    help='Turn A off',
                    )
parser.add_argument('+a', action="store_true", default=None,
                    help='Turn A on',
                    )
parser.add_argument('//noarg', '++noarg', action="store_true", default=False)

print parser.parse_args()

$ python argparse_prefix_chars.py -h

usage: argparse_prefix_chars.py [-h] [-a] [+a] [//noarg]

Change the option prefix characters

optional arguments:
  -h, --help        show this help message and exit
  -a                Turn A off
  +a                Turn A on
  //noarg, ++noarg

$ python argparse_prefix_chars.py +a

Namespace(a=True, noarg=False)

$ python argparse_prefix_chars.py -a

Namespace(a=False, noarg=False)

$ python argparse_prefix_chars.py //noarg

Namespace(a=None, noarg=True)

$ python argparse_prefix_chars.py ++noarg

Namespace(a=None, noarg=True)

$ python argparse_prefix_chars.py --noarg

usage: argparse_prefix_chars.py [-h] [-a] [+a] [//noarg]
argparse_prefix_chars.py: error: unrecognized arguments: --noarg

import argparse
from ConfigParser import ConfigParser
import shlex

parser = argparse.ArgumentParser(description='Short sample app')

parser.add_argument('-a', action="store_true", default=False)
parser.add_argument('-b', action="store", dest="b")
parser.add_argument('-c', action="store", dest="c", type=int)

config = ConfigParser()
config.read('argparse_witH_shlex.ini')
config_value = config.get('cli', 'options')
print 'Config  :', config_value

argument_list = shlex.split(config_value)
print 'Arg List:', argument_list

print 'Results :', parser.parse_args(argument_list)

$ python argparse_with_shlex.py

Config  : -a -b 2
Arg List: ['-a', '-b', '2']
Results : Namespace(a=True, b='2', c=None)

import argparse
from ConfigParser import ConfigParser
import shlex

parser = argparse.ArgumentParser(description='Short sample app',
                                 fromfile_prefix_chars='@',
                                 )

parser.add_argument('-a', action="store_true", default=False)
parser.add_argument('-b', action="store", dest="b")
parser.add_argument('-c', action="store", dest="c", type=int)

print parser.parse_args(['@argparse_fromfile_prefix_chars.txt'])

$ python argparse_fromfile_prefix_chars.py

Namespace(a=True, b='2', c=None)

import argparse

parser = argparse.ArgumentParser(add_help=True)

parser.add_argument('-a', action="store_true", default=False)
parser.add_argument('-b', action="store", dest="b")
parser.add_argument('-c', action="store", dest="c", type=int)

print parser.parse_args()

import argparse

parser = argparse.ArgumentParser(add_help=False)

parser.add_argument('-a', action="store_true", default=False)
parser.add_argument('-b', action="store", dest="b")
parser.add_argument('-c', action="store", dest="c", type=int)

print parser.parse_args()

$ python argparse_with_help.py -h

usage: argparse_with_help.py [-h] [-a] [-b B] [-c C]

optional arguments:
  -h, --help  show this help message and exit
  -a
  -b B
  -c C

$ python argparse_without_help.py -h

usage: argparse_without_help.py [-a] [-b B] [-c C]
argparse_without_help.py: error: unrecognized arguments: -h

import argparse

parser = argparse.ArgumentParser(version='1.0')

parser.add_argument('-a', action="store_true", default=False)
parser.add_argument('-b', action="store", dest="b")
parser.add_argument('-c', action="store", dest="c", type=int)

print parser.parse_args()

print 'This is not printed'

$ python argparse_with_version.py -h

usage: argparse_with_version.py [-h] [-v] [-a] [-b B] [-c C]

optional arguments:
  -h, --help     show this help message and exit
  -v, --version  show program's version number and exit
  -a
  -b B
  -c C

$ python argparse_with_version.py -v

1.0

$ python argparse_with_version.py --version

1.0

import argparse

parser = argparse.ArgumentParser(add_help=False)

parser.add_argument('--user', action="store")
parser.add_argument('--password', action="store")

import argparse
import argparse_parent_base

parser = argparse.ArgumentParser(parents=[argparse_parent_base.parser])

parser.add_argument('--local-arg', action="store_true", default=False)

print parser.parse_args()

$ python argparse_uses_parent.py -h

usage: argparse_uses_parent.py [-h] [--user USER] [--password PASSWORD]
                               [--local-arg]

optional arguments:
  -h, --help           show this help message and exit
  --user USER
  --password PASSWORD
  --local-arg

import argparse

parser = argparse.ArgumentParser(conflict_handler='resolve')

parser.add_argument('-a', action="store")
parser.add_argument('-b', action="store", help='Short alone')
parser.add_argument('--long-b', '-b', action="store", help='Long and short together')

print parser.parse_args(['-h'])

$ python argparse_conflict_handler_resolve.py

usage: argparse_conflict_handler_resolve.py [-h] [-a A] [--long-b LONG_B]

optional arguments:
  -h, --help            show this help message and exit
  -a A
  --long-b LONG_B, -b LONG_B
                        Long and short together

import argparse

parser = argparse.ArgumentParser(conflict_handler='resolve')

parser.add_argument('-a', action="store")
parser.add_argument('--long-b', '-b', action="store", help='Long and short together')
parser.add_argument('-b', action="store", help='Short alone')

print parser.parse_args(['-h'])

$ python argparse_conflict_handler_resolve2.py

usage: argparse_conflict_handler_resolve2.py [-h] [-a A] [--long-b LONG_B]
                                             [-b B]

optional arguments:
  -h, --help       show this help message and exit
  -a A
  --long-b LONG_B  Long and short together
  -b B             Short alone

import argparse

parser = argparse.ArgumentParser(description='Short sample app')

parser.add_argument('--optional', action="store_true", default=False)
parser.add_argument('positional', action="store")

print parser.parse_args()

$ python argparse_default_grouping.py -h

usage: argparse_default_grouping.py [-h] [--optional] positional

Short sample app

positional arguments:
  positional

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

import argparse

parser = argparse.ArgumentParser(add_help=False)

group = parser.add_argument_group('authentication')

group.add_argument('--user', action="store")
group.add_argument('--password', action="store")

import argparse
import argparse_parent_with_group

parser = argparse.ArgumentParser(parents=[argparse_parent_with_group.parser])

parser.add_argument('--local-arg', action="store_true", default=False)

print parser.parse_args()

$ python argparse_uses_parent_with_group.py -h

usage: argparse_uses_parent_with_group.py [-h] [--user USER]
                                          [--password PASSWORD] [--local-arg]

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

authentication:
  --user USER
  --password PASSWORD

import argparse

parser = argparse.ArgumentParser()

group = parser.add_mutually_exclusive_group()
group.add_argument('-a', action='store_true')
group.add_argument('-b', action='store_true')

print parser.parse_args()

$ python argparse_mutually_exclusive.py -h

usage: argparse_mutually_exclusive.py [-h] [-a | -b]

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

$ python argparse_mutually_exclusive.py -a

Namespace(a=True, b=False)

$ python argparse_mutually_exclusive.py -b

Namespace(a=False, b=True)

$ python argparse_mutually_exclusive.py -a -b

usage: argparse_mutually_exclusive.py [-h] [-a | -b]
argparse_mutually_exclusive.py: error: argument -b: not allowed with argument -a

import argparse

parser = argparse.ArgumentParser()

subparsers = parser.add_subparsers(help='commands')

# A list command
list_parser = subparsers.add_parser('list', help='List contents')
list_parser.add_argument('dirname', action='store', help='Directory to list')

# A create command
create_parser = subparsers.add_parser('create', help='Create a directory')
create_parser.add_argument('dirname', action='store', help='New directory to create')
create_parser.add_argument('--read-only', default=False, action='store_true',
                           help='Set permissions to prevent writing to the directory',
                           )

# A delete command
delete_parser = subparsers.add_parser('delete', help='Remove a directory')
delete_parser.add_argument('dirname', action='store', help='The directory to remove')
delete_parser.add_argument('--recursive', '-r', default=False, action='store_true',
                           help='Remove the contents of the directory, too',
                           )

print parser.parse_args()

$ python argparse_subparsers.py -h

usage: argparse_subparsers.py [-h] {list,create,delete} ...

positional arguments:
  {list,create,delete}  commands
    list                List contents
    create              Create a directory
    delete              Remove a directory

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

$ python argparse_subparsers.py create -h

usage: argparse_subparsers.py create [-h] [--read-only] dirname

positional arguments:
  dirname      New directory to create

optional arguments:
  -h, --help   show this help message and exit
  --read-only  Set permissions to prevent writing to the directory

$ python argparse_subparsers.py delete -r foo

Namespace(dirname='foo', recursive=True)

import argparse

parser = argparse.ArgumentParser()

parser.add_argument('--three', nargs=3)
parser.add_argument('--optional', nargs='?')
parser.add_argument('--all', nargs='*', dest='all')
parser.add_argument('--one-or-more', nargs='+')

print parser.parse_args()

$ python argparse_nargs.py -h

usage: argparse_nargs.py [-h] [--three THREE THREE THREE]
                         [--optional [OPTIONAL]] [--all [ALL [ALL ...]]]
                         [--one-or-more ONE_OR_MORE [ONE_OR_MORE ...]]

optional arguments:
  -h, --help            show this help message and exit
  --three THREE THREE THREE
  --optional [OPTIONAL]
  --all [ALL [ALL ...]]
  --one-or-more ONE_OR_MORE [ONE_OR_MORE ...]

$ python argparse_nargs.py

Namespace(all=None, one_or_more=None, optional=None, three=None)

$ python argparse_nargs.py --three

usage: argparse_nargs.py [-h] [--three THREE THREE THREE]
                         [--optional [OPTIONAL]] [--all [ALL [ALL ...]]]
                         [--one-or-more ONE_OR_MORE [ONE_OR_MORE ...]]
argparse_nargs.py: error: argument --three: expected 3 argument(s)

$ python argparse_nargs.py --three a b c

Namespace(all=None, one_or_more=None, optional=None, three=['a', 'b', 'c'])

$ python argparse_nargs.py --optional

Namespace(all=None, one_or_more=None, optional=None, three=None)

$ python argparse_nargs.py --optional with_value

Namespace(all=None, one_or_more=None, optional='with_value', three=None)

$ python argparse_nargs.py --all with multiple values

Namespace(all=['with', 'multiple', 'values'], one_or_more=None, optional=None, three=None)

$ python argparse_nargs.py --one-or-more with_value

Namespace(all=None, one_or_more=['with_value'], optional=None, three=None)

$ python argparse_nargs.py --one-or-more with multiple values

Namespace(all=None, one_or_more=['with', 'multiple', 'values'], optional=None, three=None)

$ python argparse_nargs.py --one-or-more

usage: argparse_nargs.py [-h] [--three THREE THREE THREE]
                         [--optional [OPTIONAL]] [--all [ALL [ALL ...]]]
                         [--one-or-more ONE_OR_MORE [ONE_OR_MORE ...]]
argparse_nargs.py: error: argument --one-or-more: expected at least one argument

import argparse

parser = argparse.ArgumentParser()

parser.add_argument('-i', type=int)
parser.add_argument('-f', type=float)
parser.add_argument('--file', type=file)

try:
    print parser.parse_args()
except IOError, msg:
    parser.error(str(msg))

$ python argparse_type.py -i 1

Namespace(f=None, file=None, i=1)

$ python argparse_type.py -f 3.14

Namespace(f=3.14, file=None, i=None)

$ python argparse_type.py --file argparse_type.py

Namespace(f=None, file=<open file 'argparse_type.py', mode 'r' at 0x1004de270>, i=None)

$ python argparse_type.py -i a

usage: argparse_type.py [-h] [-i I] [-f F] [--file FILE]
argparse_type.py: error: argument -i: invalid int value: 'a'

$ python argparse_type.py -f 3.14.15

usage: argparse_type.py [-h] [-i I] [-f F] [--file FILE]
argparse_type.py: error: argument -f: invalid float value: '3.14.15'

$ python argparse_type.py --file does_not_exist.txt

usage: argparse_type.py [-h] [-i I] [-f F] [--file FILE]
argparse_type.py: error: [Errno 2] No such file or directory: 'does_not_exist.txt'

import argparse

parser = argparse.ArgumentParser()

parser.add_argument('--mode', choices=('read-only', 'read-write'))

print parser.parse_args()

$ python argparse_choices.py -h

usage: argparse_choices.py [-h] [--mode {read-only,read-write}]

optional arguments:
  -h, --help            show this help message and exit
  --mode {read-only,read-write}

$ python argparse_choices.py --mode read-only

Namespace(mode='read-only')

$ python argparse_choices.py --mode invalid

usage: argparse_choices.py [-h] [--mode {read-only,read-write}]
argparse_choices.py: error: argument --mode: invalid choice: 'invalid'
(choose from 'read-only', 'read-write')

import argparse

parser = argparse.ArgumentParser()

parser.add_argument('-i', metavar='in-file', type=argparse.FileType('rt'))
parser.add_argument('-o', metavar='out-file', type=argparse.FileType('wt'))

try:
    results = parser.parse_args()
    print 'Input file:', results.i
    print 'Output file:', results.o
except IOError, msg:
    parser.error(str(msg))
    

$ python argparse_FileType.py -h

usage: argparse_FileType.py [-h] [-i in-file] [-o out-file]

optional arguments:
  -h, --help   show this help message and exit
  -i in-file
  -o out-file

$ python argparse_FileType.py -i argparse_FileType.py -o temporary_file.
txt

Input file: <open file 'argparse_FileType.py', mode 'rt' at 0x1004de270>
Output file: <open file 'temporary_file.txt', mode 'wt' at 0x1004de300>

$ python argparse_FileType.py -i no_such_file.txt

usage: argparse_FileType.py [-h] [-i in-file] [-o out-file]
argparse_FileType.py: error: argument -i: can't open 'no_such_file.txt': [Errno 2] No such file or directory: 'no_such_file.txt'

import argparse

class CustomAction(argparse.Action):
    def __init__(self,
                 option_strings,
                 dest,
                 nargs=None,
                 const=None,
                 default=None,
                 type=None,
                 choices=None,
                 required=False,
                 help=None,
                 metavar=None):
        argparse.Action.__init__(self,
                                 option_strings=option_strings,
                                 dest=dest,
                                 nargs=nargs,
                                 const=const,
                                 default=default,
                                 type=type,
                                 choices=choices,
                                 required=required,
                                 help=help,
                                 metavar=metavar,
                                 )
        print
        print 'Initializing CustomAction'
        for name,value in sorted(locals().items()):
            if name == 'self' or value is None:
                continue
            print '  %s = %r' % (name, value)
        return

    def __call__(self, parser, namespace, values, option_string=None):
        print
        print 'Processing CustomAction for "%s"' % self.dest
        print '  parser = %s' % id(parser)
        print '  values = %r' % values
        print '  option_string = %r' % option_string
        
        # Do some arbitrary processing of the input values
        if isinstance(values, list):
            values = [ v.upper() for v in values ]
        else:
            values = values.upper()
        # Save the results in the namespace using the destination
        # variable given to our constructor.
        setattr(namespace, self.dest, values)

parser = argparse.ArgumentParser()

parser.add_argument('-a', action=CustomAction)
parser.add_argument('-m', nargs='*', action=CustomAction)
parser.add_argument('positional', action=CustomAction)

results = parser.parse_args(['-a', 'value', '-m' 'multi-value', 'positional-value'])
print
print results

$ python argparse_custom_action.py


Initializing CustomAction
  dest = 'a'
  option_strings = ['-a']
  required = False

Initializing CustomAction
  dest = 'm'
  nargs = '*'
  option_strings = ['-m']
  required = False

Initializing CustomAction
  dest = 'positional'
  option_strings = []
  required = True

Processing CustomAction for "a"
  parser = 4299616464
  values = 'value'
  option_string = '-a'

Processing CustomAction for "m"
  parser = 4299616464
  values = ['multi-value']
  option_string = '-m'

Processing CustomAction for "positional"
  parser = 4299616464
  values = 'positional-value'
  option_string = None

Namespace(a='VALUE', m=['MULTI-VALUE'], positional='POSITIONAL-VALUE')

При изучение питона решил изучить модуль optparse. В книге «Python в системном администрировании UNIX и Linux» этот модуль отлично описан, но в документаци сказанно, что развитие этого модуля будет продолжаться с argparse. Из-за этого я решил разобраться с этим модулем.

Далее попробую кратко разобрать модуль argparse.

Для примера был написан скрипт, который удаляет папки, дата которых больше определённого количества дней. Например, есть папка «2012-05-5», которая, при стандартном вызове скрипта, удалится через 7 дней от даты в имени.
Сам скрипт:

		#!/usr/bin/python
		#! -*- coding: utf-8 -*-
		import subprocess,datetime,os,argparse
		import proverka #модуль проверки на удаление


		def main():
		    m = argparse.ArgumentParser(description="Удаление папок с помощью %(prog)s", 
		                                               epilog="Эпилог программы %(prog)s",prog="del_f")
											
		    m.add_argument("--day","-d",type=int, default=7, 
		                        help="Количество дней, прошедших с даты в названии папки(для удаления)")
				
		    m.add_argument("--dir","-p",type=str,default='.', help="Путь к удаляемым папкам")
		    m.add_argument("--verbose","-v",action="store_true", 
		                        help="Выводить подробное описание действий",default=False)
		    m.add_argument("--exception","-e",type=str, default="",action="store",nargs='+', 
		                                         help="Исключить папки")
		    options = m.parse_args()
		    p=subprocess.Popen('ls',shell=True,stdout=subprocess.PIPE)
		    out = p.stdout.read()
		    mas_p=out.split('n')
		    options =  vars(options)
		    options['dir'] += '/'
		    ex = options['exception']
		    print options['exception']

		    for t in mas_p:
		        if t not in ex:
			    if (proverka.proverka(t,options['day'])[0] == 'True'):
			        dell = 'rm -rf ' + options['dir'] + proverka.proverka(t,options['day'])[1]
				if options['verbose']:
				    print "Folder '" + proverka.proverka(t,options['day'])[1]  + "' is Deleting"
				subprocess.call(dell,shell=True)

		if __name__ == '__main__':
		    main()
		

Создание класса argparse.ArgumentParser.

Для начала рассмотрим работу класса argparse.ArgumentParser, который имеет вид:

class argparse.ArgumentParser([description][, epilog][, prog][, usage][, add_help][, argument_default][, parents][, prefix_chars][, conflict_handler][, formatter_class])
Аргумент description производит краткое описание того, что делает программа.
Результат отображается перед дополнительными аргументами.
Аналогично description работает epilog, но результат выводится после дополнительных аргументов:

rroot@kanst9:> python py.py -h
			usage: ...
			Удаление папок
			optional arguments:
			  ...
			Эпилог

Рассмотрим 2 варианта работы программы с аргументом prog:

m = argparse.ArgumentParser(description="Удаление папок с помощью %(prog)s",
						epilog="Эпилог программы %(prog)s")

Результат 1:

root@kanst9:> python py.py -h
			usage: ...
			Удаление папок с помощью df.py
			optional arguments:
			 ...
			Эпилог программы df.py

Для вставки мы использовали конструкцию %(prog)s. По умолчанию используется sys.argv[0].Теперь установим значение prog=«del_f»

m = argparse.ArgumentParser(description="Удаление папок с помощью %(prog)s",
						epilog="Эпилог программы %(prog)s" ,prog="del_f")

Результат 2:

root@kanst9:> python py.py -h
			usage: ....
			Удаление папок с помощью del_f
			optional arguments:
			  ...
			Эпилог программы del_f

С помощью аргумента prog можно задать название программы, и использовать это в справке.

Для краткого описания работы можно использовать аргумент usage
Пример:

m = argparse.ArgumentParser(..., usage='%(prog)s [arguments]')

Результат:

root@kanst9:> python py.py -h
			usage: del_f [arguments]

По умолчанию usage выглядит так:

usage: %(prog)s [аргументы]

Описание остальных аргументов можно посмотреть тут.

Добавление аргументов.

После создания парсера можно перейти к добавлению аргументов
Метод добавления аргументов выглядит следующим образом:

ArgumentParser.add_argument(name or flags...[, action][, nargs][, const][, default][, type]
				[, choices][, required][, help][, metavar][, dest])

action=«store» — хранит значение аргумента.
action=«store_const» -хранит значение, указанное к *const*

parser.add_argument('--foo', action='store_const', const=2)

action=«store_true[false]» — аналогично store_const*, но хранит значения True и False.
version — добавляет аргумент версии.

parser.add_argument('--version', action='version', version='%(prog)s 2.0')

Добавим аргумент числа дней:

m.add_argument("--day","-d",type=int, default=7, help="Количество дней, прошедших с даты в названии папки(для удаления)")

Здесь:
type=int — указывает на формат данных.
default=7 -значение по умолчанию, равное 7.
help=»…» — описание аргумента, отображаемое в помощи.
Добавим аргумент пути:

m.add_argument("--dir","-p",type=str,default='.', help="Путь к удаляемым папкам")

Здесь всё как и в предыдущем аргументе.

Для подробного вывода работы скрипта создаётся аргумент:

m.add_argument("--verbose","-v",action="store_true", help="Выводить подробное описание действий", default=False)

action=«store_true» — показывает, что значение аргумента принимает только 2 значения True и False(по умолчанию)

Аргумент

m.add_argument("--exception","-e",type=str, default="", nargs='+', help="Исключить папки")

Исключает папки из удаляемых.
nargs=’+’ — заносит данные в список, причем если отсутствует хотя бы 1 аргумент, создаётся сообщение об ошибке.
При использовании nargs=’*’ сообщения об ошибке не будет.

root@kanst9:> python py.py -e
			usage: del_f [-h] [--day DAY] [--dir DIR] [--verbose]
				             [--exception EXCEPTION [EXCEPTION ...]]
			del_f: error: argument --exception/-e: expected at least one argument

Работа с аргументами.

С помощью метода parse_args() можно вывести аргументы:

print m.parse.args()
			Namespace(day=7, dir='.', exception='', verbose=False)

А с помощью vars(m.parse.args()) можно преобразовать результат в словарь:

print vars(m.parse.args())
			{'exception': '', 'day': 7, 'dir': '.', 'verbose': False}

Примеры работы скрипта:

root@kanst9:> ls
				2012-05-10/  2012-05-17/  2012-05-5/  df.py
				2012-05-13/  2012-05-4/   2012-05-9/  proverka.py
				root@kanst9:> python df.py -h    
				usage: del_f [-h] [--day DAY] [--dir DIR] [--verbose]
				             [--exception EXCEPTION [EXCEPTION ...]]

				Удаление папок с помощью del_f

				optional arguments:
				  -h, --help            show this help message and exit
				  --day DAY, -d DAY     Количество дней, прошедших с
				                        даты в названии папки(для
				                        удаления)
				  --dir DIR, -p DIR     Путь к удаляемым папкам
				  --verbose, -v         Выводить подробное описание
				                        действий
				  --exception EXCEPTION [EXCEPTION ...], -e EXCEPTION [EXCEPTION ...]
				                        Исключить папки

				Эпилог программы del_f

				root@kanst9:> python df.py -v  

				Folder  '2012-05-10'  is Deleting
				Folder  '2012-05-4'  is Deleting
				Folder  '2012-05-5'  is Deleting
				Folder  '2012-05-9'  is Deleting
				root@kanst9:> ls
				2012-05-10/  2012-05-17/  2012-05-5/  df.py
				2012-05-13/  2012-05-4/   2012-05-9/  proverka.py
				root@kanst9:> python df.py -v -d 10

				Folder  '2012-05-4'  is Deleting
				Folder  '2012-05-5'  is Deleting

				root@kanst9:> ls
				2012-05-10/  2012-05-17/  2012-05-5/  df.py
				2012-05-13/  2012-05-4/   2012-05-9/  proverka.py

				root@kanst9:> python df.py -v -d 10 -e 2012-05-4

				Folder  '2012-05-5'  is Deleting

P.S. Статью пишу первый раз. Хотелось бы услышать критику и пожелания.