Подробный уровень с параметрами argparse и несколькими -v

Ответ 1

Вы можете сделать это с помощью nargs='?' (принять 0 или 1 аргумент после флага -v) и пользовательское действие (для обработки 0 или 1 аргумента):

import sys
import argparse

class VAction(argparse.Action):
    def __init__(self, option_strings, dest, nargs=None, const=None, 
                 default=None, type=None, choices=None, required=False, 
                 help=None, metavar=None):
        super(VAction, self).__init__(option_strings, dest, nargs, const, 
                                      default, type, choices, required, 
                                      help, metavar)
        self.values = 0
    def __call__(self, parser, args, values, option_string=None):
        # print('values: {v!r}'.format(v=values))
        if values is None:
            self.values += 1
        else:
            try:
                self.values = int(values)
            except ValueError:
                self.values = values.count('v')+1
        setattr(args, self.dest, self.values)

# test from the command line
parser = argparse.ArgumentParser()
parser.add_argument('-v', nargs='?', action=VAction, dest='verbose')
args = parser.parse_args()
print('{} --> {}'.format(sys.argv[1:], args))

print('-'*80)

for test in ['-v', '-v -v', '-v -v -v', '-vv', '-vvv', '-v 2']:
    parser = argparse.ArgumentParser()
    parser.add_argument('-v', nargs='?', action=VAction, dest='verbose')
    args=parser.parse_args([test])
    print('{:10} --> {}'.format(test, args))

Запуск script.py -v -v из командной строки дает

['-v', '-v'] --> Namespace(verbose=2)
--------------------------------------------------------------------------------
-v         --> Namespace(verbose=1)
-v -v      --> Namespace(verbose=2)
-v -v -v   --> Namespace(verbose=3)
-vv        --> Namespace(verbose=2)
-vvv       --> Namespace(verbose=3)
-v 2       --> Namespace(verbose=2)

Раскомментируйте оператор print, чтобы лучше увидеть, что делает VAction.

Ответ 2

У меня было именно это желание, и несколько месяцев назад было выполнено специальное действие, которое мне было больно, чтобы копировать скрипты, которые я продолжаю писать. Но я только что узнал, что argparse фактически поддерживает action='count', как это делал optparse, хотя это, как представляется, полностью недокументировано в стандартных библиотечных документах онлайн (этот отчет об ошибке отмечает отсутствие, патч был опубликован и просмотрен, поэтому предположительно он появится когда-нибудь).

import argparse

parser = argparse.ArgumentParser()
parser.add_argument('-v', '--verbose', action='count', default=0)

for c in ['', '-v', '-v -v', '-vv', '-vv -v', '-v -v --verbose -vvvv']:
    print parser.parse_args(c.split())

Вывод:

Namespace(verbose=0)
Namespace(verbose=1)
Namespace(verbose=2)
Namespace(verbose=2)
Namespace(verbose=3)
Namespace(verbose=7)

Единственное очень незначительное прикосновение - вы должны явно установить default=0, если вам не нужны аргументы -v, чтобы дать вам уровень детализации 0, а не None.

Ответ 3

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

import argparse

ap = argparse.ArgumentParser()
ap.add_argument('-v', action = 'append_const', const = 1)

for c in ['', '-v', '-v -v', '-vv', '-vv -v']:
    opt = ap.parse_args(c.split())
    opt.v = 0 if opt.v is None else sum(opt.v)
    print opt

Вывод:

Namespace(v=0)
Namespace(v=1)
Namespace(v=2)
Namespace(v=2)
Namespace(v=3)

Ответ 4

argparse поддерживает действие append, которое позволяет указать несколько аргументов. Проверьте http://docs.python.org/library/argparse.html, найдите "append".

Ответ 5

Расширяя ответ unutbu, здесь настраивается действие, включая обработку комбинации -quiet/-q. Это проверено на Python3. Использование его в Python >= 2.7 не должно иметь большого значения.

class ActionVerbose(argparse.Action):
    def __call__(self, parser, args, values, option_string=None):
        #print(parser, args, values, option_string)
        # Obtain previously set value in case this option call is incr/decr only
        if args.verbose == None:
            base = 0
        else:
            base = args.verbose
        # One incr/decr is determined in name of option in use (--quiet/-q/-v/--verbose)
        option_string = option_string.lstrip('-')
        if option_string[0] == 'q':
            incr = -1
        elif option_string[0] == 'v':
            incr = 1
        else:
            raise argparse.ArgumentError(self,
                                         'Option string for verbosity must start with v(erbose) or q(uiet)')
        # Determine if option only or values provided
        if values==None:
            values = base + incr
        else:
            # Values might be an absolute integer verbosity level or more 'q'/'v' combinations
            try:
                values = int(values)
            except ValueError:
                values = values.lower()
                if not re.match('^[vq]+$', values):
                    raise argparse.ArgumentError(self,
                                                 "Option string for -v/-q must contain only further 'v'/'q' letters")
                values = base + incr + values.count('v') - values.count('q')
        setattr(args, self.dest, values)
    @classmethod
    def add_to_parser(cls,
                      parser, dest='verbose', default=0,
                      help_detail='(0:errors, 1:info, 2:debug)'):
        parser.add_argument('--verbose', nargs='?', action=ActionVerbose, dest=dest, metavar='level',
                            default=default,
                            help='Increase or set level of verbosity {}'.format(help_detail))
        parser.add_argument('-v',        nargs='?', action=ActionVerbose, dest=dest, metavar='level',
                            help='Increase or set level of verbosity')
        parser.add_argument('--quiet',   nargs='?', action=ActionVerbose, dest=dest, metavar='level',
                            help='Decrease or set level of verbosity')
        parser.add_argument('-q',        nargs='?', action=ActionVerbose, dest=dest, metavar='level',
                            help='Decrease or set level of verbosity')

Существует метод класса удобства, который можно использовать для настройки всех четырех обработчиков параметров для --verbose, -v, -q, --quiet. Используйте его так:

parser = argparse.ArgumentParser()
ActionVerbose.add_to_parser(parser, default=defaults['verbose'])
# add more arguments here with: parser.add_argument(...)
args = parser.parse_args()

При использовании script с этими аргументами вы можете:

./script -vvvvvv -v 4 -v 0 -v -vvv --verbose --quiet 2 -v qqvvqvv

С помощью этой командной строки args.verbose будет 4.

• Любой -v/-q/--verbose/--quiet с заданным номером представляет собой жесткий, абсолютный набор args.verbose к данному заданному числу (= уровень детализации).
• Любой -v/--verbose без числа является приращением этого уровня.
• Любой -q/--quiet без числа - это декремент этого уровня.
• Любой -v/-q может быть немедленно обработан буквой v/q, итоговый уровень the old level + sum(count('v')) - sum(count('q'))
• Общее значение по умолчанию 0

Пользовательское действие должно быть довольно легко модифицировать, если вы хотите другое поведение. Например, некоторые люди предпочитают, чтобы любой --quiet сбрасывал уровень до 0 или даже до -1. Для этого dremove nargs из add_argument -q и --quiet, а также жесткого кода для установки value = 0 if option_string[0] == 'q'.

Правильные ошибки парсера красиво печатаются, если использование неверно:

./script -vvvvvv -v 4 -v 0 -v -vvv --verbose --quiet 2 -v qqvvqvav
usage: script [-h] [--verbose [level]]
              [-v [level]] [--quiet [level]] [-q [level]]
script: error: argument -v: Option string for -v/-q must contain only further 'v'/'q' letters

Ответ 6

Здесь я расскажу об этом, который не использует никаких новых классов, работает как в Python 2, так и в 3 и поддерживает относительные корректировки по умолчанию, используя "-v"/"- -v erbose" и "-q"/" - -q uiet ", но он не поддерживает использование чисел, например" -v 2 ":

#!/usr/bin/env python
import argparse
import logging
import sys

LOG_LEVELS = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
DEFAULT_LOG_LEVEL = "INFO"


def main(argv):
    parser = argparse.ArgumentParser()
    parser.add_argument(
        "--verbose", "-v",
        dest="log_level",
        action="append_const",
        const=1,
    )
    parser.add_argument(
        "--quiet", "-q",
        dest="log_level",
        action="append_const",
        const=-1,
    )

    args = parser.parse_args(argv[1:])
    log_level = LOG_LEVELS.index(DEFAULT_LOG_LEVEL)

    # For each "-q" and "-v" flag, adjust the logging verbosity accordingly
    # making sure to clamp off the value from 0 to 4, inclusive of both
    for adjustment in args.log_level or ():
        log_level = min(len(LOG_LEVELS) - 1, max(log_level + adjustment, 0))

    log_level_name = LOG_LEVELS[log_level]
    print(log_level_name)
    logging.getLogger().setLevel(log_level_name)


if __name__ == "__main__":
    main(sys.argv)

Пример:

$ python2 verbosity.py -vvv
DEBUG
$ python3 verbosity.py -vvv -q
INFO
$ python2 verbosity.py -qqq -vvv -q
WARNING
$ python2 verbosity.py -qqq
CRITICAL

Ответ 7

Ваш первый предложенный метод будет с большей вероятностью запутать. Различные имена опций для разных уровней многословности или один подробный флаг, необязательно сопровождаемый числовым индикатором уровня детализации, с меньшей вероятностью путают пользователя и позволят более гибко назначать уровни детализации.