argparse.md

1> **Источник:** https://python-all.ru/2.7/library/argparse.html2>3> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.45---67# 15.4. [`argparse`](https://python-all.ru/2.7/library/argparse.html#module-argparse) – Парсер для параметров командной строки, аргументов и подкоманд89Новое в версии 2.7.1011**Исходный код:** [Lib/argparse.py](https://python-all.ru/src/2.7/Lib/argparse.py)1213---1415Учебное пособие1617На этой странице содержится справочная информация по API. Для более плавного введения в разбор командной строки Python обратитесь к [учебному пособию по argparse](https://python-all.ru/2.7/howto/argparse.html#id1).1819Модуль [`argparse`](https://python-all.ru/2.7/library/argparse.html#module-argparse) упрощает создание удобных интерфейсов командной строки. Программа определяет, какие аргументы ей нужны, а [`argparse`](https://python-all.ru/2.7/library/argparse.html#module-argparse) сам решает, как извлечь их из [`sys.argv`](https://python-all.ru/2.7/library/sys.html#sys.argv). Модуль [`argparse`](https://python-all.ru/2.7/library/argparse.html#module-argparse) также автоматически формирует сообщения справки и подсказки по использованию и выводит ошибки, когда пользователь передаёт программе неверные аргументы.2021## 15.4.1. Пример2223Следующий код представляет собой программу на Python, которая принимает список целых чисел и выводит либо сумму, либо максимум:2425```python26import argparse2728parser = argparse.ArgumentParser(description='Process some integers.')29parser.add_argument('integers', metavar='N', type=int, nargs='+',30                    help='an integer for the accumulator')31parser.add_argument('--sum', dest='accumulate', action='store_const',32                    const=sum, default=max,33                    help='sum the integers (default: find the max)')3435args = parser.parse_args()36print args.accumulate(args.integers)37```3839Если приведенный выше код Python сохранен в файл `prog.py`, его можно запустить из командной строки, и он выдаст полезные сообщения справки:4041```console42$ python prog.py -h43usage: prog.py [-h] [--sum] N [N ...]4445Process some integers.4647positional arguments:48 N           an integer for the accumulator4950optional arguments:51 -h, --help  show this help message and exit52 --sum       sum the integers (default: find the max)53```5455При запуске с соответствующими аргументами программа выводит либо сумму, либо максимум переданных целых чисел:5657```console58$ python prog.py 1 2 3 45946061$ python prog.py 1 2 3 4 --sum621063```6465Если передать неверные аргументы, будет выдана ошибка:6667```console68$ python prog.py a b c69usage: prog.py [-h] [--sum] N [N ...]70prog.py: error: argument N: invalid int value: 'a'71```7273В следующих разделах этот пример разбирается подробно.7475### 15.4.1.1. Создание парсера7677Первый шаг при использовании [`argparse`](https://python-all.ru/2.7/library/argparse.html#module-argparse) – создание объекта [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser):7879```python80>>> parser = argparse.ArgumentParser(description='Process some integers.')81```8283Объект [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser) будет содержать всю информацию, необходимую для разбора командной строки в типы данных Python.8485### 15.4.1.2. Добавление аргументов8687Заполнение объекта [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser) информацией об аргументах программы выполняется вызовами метода [`add_argument()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.add_argument). В общем случае эти вызовы сообщают [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser), как преобразовывать строки командной строки в объекты. Эта информация сохраняется и используется при вызове [`parse_args()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.parse_args). Например:8889```python90>>> parser.add_argument('integers', metavar='N', type=int, nargs='+',91...                     help='an integer for the accumulator')92>>> parser.add_argument('--sum', dest='accumulate', action='store_const',93...                     const=sum, default=max,94...                     help='sum the integers (default: find the max)')95```9697Впоследствии вызов [`parse_args()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.parse_args) вернет объект с двумя атрибутами: `integers` и `accumulate`. Атрибут `integers` будет списком из одного или нескольких целых чисел, а атрибут `accumulate` будет либо функцией [`sum()`](https://python-all.ru/2.7/library/functions.html#sum), если в командной строке был указан `--sum`, либо функцией [`max()`](https://python-all.ru/2.7/library/functions.html#max), если нет.9899### 15.4.1.3. Разбор аргументов100101[`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser) разбирает аргументы с помощью метода [`parse_args()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.parse_args). Этот метод проверяет командную строку, преобразует каждый аргумент в соответствующий тип и затем выполняет необходимое действие. В большинстве случаев это означает, что простой объект [`Namespace`](https://python-all.ru/2.7/library/argparse.html#argparse.Namespace) будет составлен из атрибутов, полученных при разборе командной строки:102103```python104>>> parser.parse_args(['--sum', '7', '-1', '42'])105Namespace(accumulate=<built-in function sum>, integers=[7, -1, 42])106```107108В скрипте [`parse_args()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.parse_args) обычно вызывается без аргументов, и [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser) автоматически определяет аргументы командной строки из [`sys.argv`](https://python-all.ru/2.7/library/sys.html#sys.argv).109110## 15.4.2. Объекты ArgumentParser111112#### `class 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)`113114Создаёт новый объект [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser). Все параметры должны передаваться как именованные аргументы. Каждый параметр имеет собственное подробное описание ниже, но вкратце они таковы:115116- [prog](https://python-all.ru/2.7/library/argparse.html#prog) – имя программы (по умолчанию: `sys.argv[0]`)117- [usage](https://python-all.ru/2.7/library/argparse.html#usage) - строка, описывающая использование программы (по умолчанию генерируется из аргументов, добавленных в парсер)118- [description](https://python-all.ru/2.7/library/argparse.html#description) – текст, отображаемый перед справкой по аргументам (по умолчанию: нет)119- [epilog](https://python-all.ru/2.7/library/argparse.html#epilog) – текст, отображаемый после справки по аргументам (по умолчанию: нет)120- [parents](https://python-all.ru/2.7/library/argparse.html#parents) - список объектов [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser), аргументы которых также должны быть включены121- [formatter\_class](https://python-all.ru/2.7/library/argparse.html#formatter-class) - класс для настройки вывода справки122- [prefix\_chars](https://python-all.ru/2.7/library/argparse.html#prefix-chars) - набор символов, которые являются префиксом необязательных аргументов (по умолчанию: ‘-‘)123- [fromfile\_prefix\_chars](https://python-all.ru/2.7/library/argparse.html#fromfile-prefix-chars) - набор символов, которые являются префиксом файлов, из которых должны читаться дополнительные аргументы (по умолчанию: `None`)124- [argument\_default](https://python-all.ru/2.7/library/argparse.html#argument-default) - глобальное значение по умолчанию для аргументов (по умолчанию: `None`)125- [conflict\_handler](https://python-all.ru/2.7/library/argparse.html#conflict-handler) - стратегия разрешения конфликтов необязательных аргументов (обычно не требуется)126- [add\_help](https://python-all.ru/2.7/library/argparse.html#add-help) - добавить опцию `-h/--help` в парсер (по умолчанию: `True`)127128В следующих разделах описывается, как используется каждый из этих параметров.129130### 15.4.2.1. prog131132По умолчанию объекты [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser) используют `sys.argv[0]`, чтобы определить, как отображать имя программы в справке. Это поведение почти всегда желательно, поскольку справка будет соответствовать тому, как программа была вызвана из командной строки. Например, рассмотрим файл с именем `myprogram.py` со следующим кодом:133134```python135import argparse136parser = argparse.ArgumentParser()137parser.add_argument('--foo', help='foo help')138args = parser.parse_args()139```140141Справка этой программы будет отображать `myprogram.py` в качестве имени программы (независимо от того, откуда была вызвана программа):142143```console144$ python myprogram.py --help145usage: myprogram.py [-h] [--foo FOO]146147optional arguments:148 -h, --help  show this help message and exit149 --foo FOO   foo help150$ cd ..151$ python subdir/myprogram.py --help152usage: myprogram.py [-h] [--foo FOO]153154optional arguments:155 -h, --help  show this help message and exit156 --foo FOO   foo help157```158159Чтобы изменить это поведение по умолчанию, можно указать другое значение с помощью аргумента `prog=` конструктора [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser):160161```python162>>> parser = argparse.ArgumentParser(prog='myprogram')163>>> parser.print_help()164usage: myprogram [-h]165166optional arguments:167 -h, --help  show this help message and exit168```169170Обратите внимание, что имя программы, будь оно определено из `sys.argv[0]` или из аргумента `prog=`, доступно в справочных сообщениях через форматный спецификатор `%(prog)s`.171172```python173>>> parser = argparse.ArgumentParser(prog='myprogram')174>>> parser.add_argument('--foo', help='foo of the %(prog)s program')175>>> parser.print_help()176usage: myprogram [-h] [--foo FOO]177178optional arguments:179 -h, --help  show this help message and exit180 --foo FOO   foo of the myprogram program181```182183### 15.4.2.2. usage184185По умолчанию [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser) формирует сообщение об использовании на основе своих аргументов:186187```python188>>> parser = argparse.ArgumentParser(prog='PROG')189>>> parser.add_argument('--foo', nargs='?', help='foo help')190>>> parser.add_argument('bar', nargs='+', help='bar help')191>>> parser.print_help()192usage: PROG [-h] [--foo [FOO]] bar [bar ...]193194positional arguments:195 bar          bar help196197optional arguments:198 -h, --help   show this help message and exit199 --foo [FOO]  foo help200```201202Сообщение по умолчанию можно переопределить с помощью именованного аргумента `usage=`:203204```python205>>> parser = argparse.ArgumentParser(prog='PROG', usage='%(prog)s [options]')206>>> parser.add_argument('--foo', nargs='?', help='foo help')207>>> parser.add_argument('bar', nargs='+', help='bar help')208>>> parser.print_help()209usage: PROG [options]210211positional arguments:212 bar          bar help213214optional arguments:215 -h, --help   show this help message and exit216 --foo [FOO]  foo help217```218219Спецификатор формата `%(prog)s` используется для подстановки имени программы в сообщения об использовании.220221### 15.4.2.3. description222223В большинстве вызовов конструктора [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser) используется именованный аргумент `description=`. Этот аргумент содержит краткое описание того, что делает программа и как она работает. В сообщениях справки это описание выводится между строкой использования командной строки и справкой по отдельным аргументам:224225```python226>>> parser = argparse.ArgumentParser(description='A foo that bars')227>>> parser.print_help()228usage: argparse.py [-h]229230A foo that bars231232optional arguments:233 -h, --help  show this help message and exit234```235236По умолчанию описание переносится по строкам, чтобы уместиться в отведённом пространстве. Чтобы изменить это поведение, обратитесь к аргументу [formatter\_class](https://python-all.ru/2.7/library/argparse.html#formatter-class).237238### 15.4.2.4. epilog239240Некоторые программы выводят дополнительное описание после описания аргументов. Такой текст можно указать с помощью аргумента `epilog=` для [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser):241242```python243>>> parser = argparse.ArgumentParser(244...     description='A foo that bars',245...     epilog="And that's how you'd foo a bar")246>>> parser.print_help()247usage: argparse.py [-h]248249A foo that bars250251optional arguments:252 -h, --help  show this help message and exit253254And that's how you'd foo a bar255```256257Как и для аргумента [description](https://python-all.ru/2.7/library/argparse.html#description), текст `epilog=` по умолчанию переносится по строкам, но это поведение можно настроить с помощью аргумента [formatter\_class](https://python-all.ru/2.7/library/argparse.html#formatter-class) для [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser).258259### 15.4.2.5. parents260261Иногда несколько парсеров используют общий набор аргументов. Вместо того чтобы повторять определения этих аргументов, можно использовать один парсер со всеми общими аргументами, передав его в аргумент `parents=` для [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser). Аргумент `parents=` принимает список объектов [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser), собирает из них все позиционные и опциональные действия и добавляет эти действия в создаваемый объект [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser):262263```python264>>> parent_parser = argparse.ArgumentParser(add_help=False)265>>> parent_parser.add_argument('--parent', type=int)266267>>> foo_parser = argparse.ArgumentParser(parents=[parent_parser])268>>> foo_parser.add_argument('foo')269>>> foo_parser.parse_args(['--parent', '2', 'XXX'])270Namespace(foo='XXX', parent=2)271272>>> bar_parser = argparse.ArgumentParser(parents=[parent_parser])273>>> bar_parser.add_argument('--bar')274>>> bar_parser.parse_args(['--bar', 'YYY'])275Namespace(bar='YYY', parent=None)276```277278Обратите внимание, что большинство родительских парсеров указывают `add_help=False`. В противном случае [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser) увидит две опции `-h/--help` (одну в родительском парсере, другую – в дочернем) и вызовет ошибку.279280> **Примечание**281>282> Парсеры должны быть полностью инициализированы перед передачей через `parents=`. Если изменить родительские парсеры после создания дочернего, эти изменения не отразятся на дочернем парсере.283284### 15.4.2.6. formatter\_class285286[`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser) объекты позволяют настраивать форматирование справки, задавая альтернативный класс форматирования. В настоящее время есть три таких класса:287288#### `class argparse.RawDescriptionHelpFormatter`289290#### `class argparse.RawTextHelpFormatter`291292#### `class argparse.ArgumentDefaultsHelpFormatter`293294Первые два позволяют больше контролировать отображение текстовых описаний, в то время как последний автоматически добавляет информацию о значениях по умолчанию аргументов.295296По умолчанию объекты [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser) переносят по строкам текст [description](https://python-all.ru/2.7/library/argparse.html#description) и [epilog](https://python-all.ru/2.7/library/argparse.html#epilog) в сообщениях справки командной строки:297298```python299>>> parser = argparse.ArgumentParser(300...     prog='PROG',301...     description='''this description302...         was indented weird303...             but that is okay''',304...     epilog='''305...             likewise for this epilog whose whitespace will306...         be cleaned up and whose words will be wrapped307...         across a couple lines''')308>>> parser.print_help()309usage: PROG [-h]310311this description was indented weird but that is okay312313optional arguments:314 -h, --help  show this help message and exit315316likewise for this epilog whose whitespace will be cleaned up and whose words317will be wrapped across a couple lines318```319320Передача [`RawDescriptionHelpFormatter`](https://python-all.ru/2.7/library/argparse.html#argparse.RawDescriptionHelpFormatter) в качестве `formatter_class=` означает, что [description](https://python-all.ru/2.7/library/argparse.html#description) и [epilog](https://python-all.ru/2.7/library/argparse.html#epilog) уже правильно отформатированы и не должны переноситься по строкам:321322```python323>>> parser = argparse.ArgumentParser(324...     prog='PROG',325...     formatter_class=argparse.RawDescriptionHelpFormatter,326...     description=textwrap.dedent('''\327...         Please do not mess up this text!328...         --------------------------------329...             I have indented it330...             exactly the way331...             I want it332...         '''))333>>> parser.print_help()334usage: PROG [-h]335336Please do not mess up this text!337--------------------------------338   I have indented it339   exactly the way340   I want it341342optional arguments:343 -h, --help  show this help message and exit344```345346[`RawTextHelpFormatter`](https://python-all.ru/2.7/library/argparse.html#argparse.RawTextHelpFormatter) сохраняет пробелы во всех видах текста справки, включая описания аргументов. Однако множественные переносы строк заменяются одним. Если нужно сохранить несколько пустых строк, добавьте пробелы между переносами.347348Другой доступный класс форматирования, [`ArgumentDefaultsHelpFormatter`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentDefaultsHelpFormatter), добавляет информацию о значении по умолчанию каждого из аргументов:349350```python351>>> parser = argparse.ArgumentParser(352...     prog='PROG',353...     formatter_class=argparse.ArgumentDefaultsHelpFormatter)354>>> parser.add_argument('--foo', type=int, default=42, help='FOO!')355>>> parser.add_argument('bar', nargs='*', default=[1, 2, 3], help='BAR!')356>>> parser.print_help()357usage: PROG [-h] [--foo FOO] [bar [bar ...]]358359positional arguments:360 bar         BAR! (default: [1, 2, 3])361362optional arguments:363 -h, --help  show this help message and exit364 --foo FOO   FOO! (default: 42)365```366367### 15.4.2.7. prefix\_chars368369Большинство параметров командной строки используют `-` в качестве префикса, например `-f/--foo`. Парсеры, которым нужно поддерживать другие или дополнительные символы префикса, например для параметров вроде `+f` или `/foo`, могут указать их с помощью аргумента `prefix_chars=` конструктора ArgumentParser:370371```python372>>> parser = argparse.ArgumentParser(prog='PROG', prefix_chars='-+')373>>> parser.add_argument('+f')374>>> parser.add_argument('++bar')375>>> parser.parse_args('+f X ++bar Y'.split())376Namespace(bar='Y', f='X')377```378379Аргумент `prefix_chars=` по умолчанию равен `'-'`. Если указать набор символов, не включающий `-`, то опции `-f/--foo` будут запрещены.380381### 15.4.2.8. fromfile\_prefix\_chars382383Иногда, например при работе с особенно длинными списками аргументов, имеет смысл хранить список аргументов в файле, а не набирать его в командной строке. Если аргумент `fromfile_prefix_chars=` передан конструктору [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser), то аргументы, начинающиеся с любого из указанных символов, будут рассматриваться как файлы и заменяться на содержащиеся в них аргументы. Например:384385```python386>>> with open('args.txt', 'w') as fp:387...     fp.write('-f\nbar')388>>> parser = argparse.ArgumentParser(fromfile_prefix_chars='@')389>>> parser.add_argument('-f')390>>> parser.parse_args(['-f', 'foo', '@args.txt'])391Namespace(f='bar')392```393394Аргументы, читаемые из файла, по умолчанию должны быть по одному на строку (но см. также [`convert_arg_line_to_args()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.convert_arg_line_to_args)) и обрабатываются так, как если бы они находились на том же месте, что и исходный файл, ссылающийся на аргумент в командной строке. Таким образом, в приведённом примере выражение `['-f', 'foo', '@args.txt']` считается эквивалентным выражению `['-f', 'foo', '-f', 'bar']`.395396Аргумент `fromfile_prefix_chars=` по умолчанию равен `None`, что означает, что аргументы никогда не будут рассматриваться как ссылки на файлы.397398### 15.4.2.9. argument\_default399400Обычно значения аргументов по умолчанию задаются либо передачей значения по умолчанию в [`add_argument()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.add_argument), либо вызовом методов [`set_defaults()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.set_defaults) с определённым набором пар имя-значение. Однако иногда может быть полезно указать единое значение по умолчанию для всех аргументов синтаксического анализатора. Это можно сделать, передав именованный аргумент `argument_default=` в [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser). Например, чтобы глобально отключить создание атрибутов при вызовах [`parse_args()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.parse_args), укажите `argument_default=SUPPRESS`:401402```python403>>> parser = argparse.ArgumentParser(argument_default=argparse.SUPPRESS)404>>> parser.add_argument('--foo')405>>> parser.add_argument('bar', nargs='?')406>>> parser.parse_args(['--foo', '1', 'BAR'])407Namespace(bar='BAR', foo='1')408>>> parser.parse_args([])409Namespace()410```411412### 15.4.2.10. conflict\_handler413414Объекты [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser) не допускают два действия с одной и той же строкой опции. По умолчанию объекты [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser) вызывают исключение при попытке создать аргумент со строкой опции, которая уже используется:415416```python417>>> parser = argparse.ArgumentParser(prog='PROG')418>>> parser.add_argument('-f', '--foo', help='old foo help')419>>> parser.add_argument('--foo', help='new foo help')420Traceback (most recent call last):421 ..422ArgumentError: argument --foo: conflicting option string(s): --foo423```424425Иногда (например, при использовании [parents](https://python-all.ru/2.7/library/argparse.html#parents)) бывает полезно просто переопределить все старые аргументы с той же строкой опции. Для получения такого поведения значение `'resolve'` можно передать в аргумент `conflict_handler=` функции [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser):426427```python428>>> parser = argparse.ArgumentParser(prog='PROG', conflict_handler='resolve')429>>> parser.add_argument('-f', '--foo', help='old foo help')430>>> parser.add_argument('--foo', help='new foo help')431>>> parser.print_help()432usage: PROG [-h] [-f FOO] [--foo FOO]433434optional arguments:435 -h, --help  show this help message and exit436 -f FOO      old foo help437 --foo FOO   new foo help438```439440Обратите внимание, что объекты [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser) удаляют действие только в том случае, если все его строки опций переопределены. Поэтому в приведённом выше примере старое действие `-f/--foo` сохраняется как действие `-f`, поскольку была переопределена только строка опции `--foo`.441442### 15.4.2.11. add\_help443444По умолчанию объекты ArgumentParser добавляют параметр, который просто показывает справку парсера. Например, рассмотрим файл с именем `myprogram.py`, содержащий следующий код:445446```python447import argparse448parser = argparse.ArgumentParser()449parser.add_argument('--foo', help='foo help')450args = parser.parse_args()451```452453Если указать `-h` или `--help` в командной строке, будет выведена справка ArgumentParser:454455```console456$ python myprogram.py --help457usage: myprogram.py [-h] [--foo FOO]458459optional arguments:460 -h, --help  show this help message and exit461 --foo FOO   foo help462```463464Иногда может быть полезно отключить добавление этой опции справки. Это можно сделать, передав `False` в качестве аргумента `add_help=` функции [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser):465466```python467>>> parser = argparse.ArgumentParser(prog='PROG', add_help=False)468>>> parser.add_argument('--foo', help='foo help')469>>> parser.print_help()470usage: PROG [--foo FOO]471472optional arguments:473 --foo FOO  foo help474```475476Обычно опция справки – это `-h/--help`. Исключение составляет случай, когда указан `prefix_chars=` и не включает `-`; в этом случае `-h` и `--help` не являются допустимыми опциями. В таком случае первый символ в `prefix_chars` используется в качестве префикса для опций справки:477478```python479>>> parser = argparse.ArgumentParser(prog='PROG', prefix_chars='+/')480>>> parser.print_help()481usage: PROG [+h]482483optional arguments:484  +h, ++help  show this help message and exit485```486487## 15.4.3. Метод add\_argument()488489#### `ArgumentParser.add_argument(name or flags...[, action][, nargs][, const][, default][, type][, choices][, required][, help][, metavar][, dest])`490491Определяет, как должен разбираться один аргумент командной строки. Каждый параметр подробно описан ниже, а кратко они таковы:492493- [name or flags](https://python-all.ru/2.7/library/argparse.html#name-or-flags) – имя или список строк параметров, например `foo` или `-f, --foo`.494- [action](https://python-all.ru/2.7/library/argparse.html#action) – базовый тип действия, которое выполняется при встрече этого аргумента в командной строке.495- [nargs](https://python-all.ru/2.7/library/argparse.html#nargs) – количество аргументов командной строки, которое должно быть потреблено.496- [const](https://python-all.ru/2.7/library/argparse.html#const) – постоянное значение, требуемое некоторыми значениями [action](https://python-all.ru/2.7/library/argparse.html#action) и [nargs](https://python-all.ru/2.7/library/argparse.html#nargs).497- [default](https://python-all.ru/2.7/library/argparse.html#default) – Значение, создаваемое, если аргумент отсутствует в командной строке.498- [type](https://python-all.ru/2.7/library/argparse.html#type) – тип, в который следует преобразовать аргумент командной строки.499- [choices](https://python-all.ru/2.7/library/argparse.html#choices) – Контейнер допустимых значений для аргумента.500- [required](https://python-all.ru/2.7/library/argparse.html#required) – может ли параметр командной строки быть опущен (только для опциональных параметров).501- [help](https://python-all.ru/2.7/library/argparse.html#help) – краткое описание того, что делает аргумент.502- [metavar](https://python-all.ru/2.7/library/argparse.html#metavar) – имя аргумента в сообщениях об использовании.503- [dest](https://python-all.ru/2.7/library/argparse.html#dest) – имя атрибута, добавляемого в объект, возвращаемый [`parse_args()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.parse_args).504505В следующих разделах описывается, как используется каждый из этих параметров.506507### 15.4.3.1. имя или флаги508509Метод [`add_argument()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.add_argument) должен знать, ожидается ли необязательный аргумент (например, `-f` или `--foo`) или позиционный аргумент (например, список имён файлов). Поэтому первыми аргументами, передаваемыми в [`add_argument()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.add_argument), должна быть либо последовательность флагов, либо просто имя аргумента. Например, необязательный аргумент можно создать так:510511```python512>>> parser.add_argument('-f', '--foo')513```514515а позиционный – так:516517```python518>>> parser.add_argument('bar')519```520521При вызове [`parse_args()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.parse_args) опциональные аргументы опознаются по префиксу `-`, а остальные аргументы считаются позиционными:522523```python524>>> parser = argparse.ArgumentParser(prog='PROG')525>>> parser.add_argument('-f', '--foo')526>>> parser.add_argument('bar')527>>> parser.parse_args(['BAR'])528Namespace(bar='BAR', foo=None)529>>> parser.parse_args(['BAR', '--foo', 'FOO'])530Namespace(bar='BAR', foo='FOO')531>>> parser.parse_args(['--foo', 'FOO'])532usage: PROG [-h] [-f FOO] bar533PROG: error: too few arguments534```535536### 15.4.3.2. action537538Объекты [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser) связывают аргументы командной строки с действиями. Эти действия могут делать с аргументами практически что угодно, но чаще всего они просто добавляют атрибут в объект, возвращаемый [`parse_args()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.parse_args). Ключевой аргумент `action` определяет, как следует обрабатывать аргументы командной строки. Доступны следующие действия:539540- `'store'` – просто сохраняет значение аргумента. Это действие по умолчанию. Например:541542  ```python543  >>> parser = argparse.ArgumentParser()544  >>> parser.add_argument('--foo')545  >>> parser.parse_args('--foo 1'.split())546  Namespace(foo='1')547  ```548- `'store_const'` – сохраняет значение, заданное именованным аргументом [const](https://python-all.ru/2.7/library/argparse.html#const). Действие `'store_const'` чаще всего используется с необязательными аргументами, задающими какой-либо флаг. Например:549550  ```python551  >>> parser = argparse.ArgumentParser()552  >>> parser.add_argument('--foo', action='store_const', const=42)553  >>> parser.parse_args(['--foo'])554  Namespace(foo=42)555  ```556- `'store_true'` и `'store_false'` – это частные случаи `'store_const'`, используемые для хранения значений `True` и `False` соответственно. Кроме того, они создают значения по умолчанию равные `False` и `True` соответственно. Например:557558  ```python559  >>> parser = argparse.ArgumentParser()560  >>> parser.add_argument('--foo', action='store_true')561  >>> parser.add_argument('--bar', action='store_false')562  >>> parser.add_argument('--baz', action='store_false')563  >>> parser.parse_args('--foo --bar'.split())564  Namespace(bar=False, baz=True, foo=True)565  ```566- `'append'` – сохраняет список и добавляет в него каждое значение аргумента. Это полезно, чтобы разрешить указание параметра несколько раз. Пример использования:567568  ```python569  >>> parser = argparse.ArgumentParser()570  >>> parser.add_argument('--foo', action='append')571  >>> parser.parse_args('--foo 1 --foo 2'.split())572  Namespace(foo=['1', '2'])573  ```574- `'append_const'` – сохраняет список и добавляет в него значение, заданное именованным аргументом [const](https://python-all.ru/2.7/library/argparse.html#const). (Обратите внимание, что именованный аргумент [const](https://python-all.ru/2.7/library/argparse.html#const) по умолчанию равен `None`.) Действие `'append_const'` обычно полезно, когда несколько аргументов должны сохранять константы в один и тот же список. Например:575576  ```python577  >>> parser = argparse.ArgumentParser()578  >>> parser.add_argument('--str', dest='types', action='append_const', const=str)579  >>> parser.add_argument('--int', dest='types', action='append_const', const=int)580  >>> parser.parse_args('--str --int'.split())581  Namespace(types=[<type 'str'>, <type 'int'>])582  ```583- `'count'` – подсчитывает, сколько раз встречается именованный аргумент. Например, это полезно для повышения уровня подробности вывода:584585  ```python586  >>> parser = argparse.ArgumentParser()587  >>> parser.add_argument('--verbose', '-v', action='count')588  >>> parser.parse_args(['-vvv'])589  Namespace(verbose=3)590  ```591- `'help'` – выводит полное справочное сообщение для всех параметров текущего анализатора и завершает работу. По умолчанию действие справки автоматически добавляется в анализатор. Подробности о том, как формируется вывод, см. в [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser).592- `'version'` – ожидает именованный аргумент `version=` в вызове [`add_argument()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.add_argument) и при вызове выводит информацию о версии и завершает работу:593594  ```python595  >>> import argparse596  >>> parser = argparse.ArgumentParser(prog='PROG')597  >>> parser.add_argument('--version', action='version', version='%(prog)s 2.0')598  >>> parser.parse_args(['--version'])599  PROG 2.0600  ```601602Вы также можете указать произвольное действие, передав подкласс Action или другой объект, реализующий тот же интерфейс. Рекомендуемый способ – расширить [`Action`](https://python-all.ru/2.7/library/argparse.html#argparse.Action), переопределив метод `__call__` и, опционально, метод `__init__`.603604Пример пользовательского действия:605606```python607>>> class FooAction(argparse.Action):608...     def __init__(self, option_strings, dest, nargs=None, **kwargs):609...         if nargs is not None:610...             raise ValueError("nargs not allowed")611...         super(FooAction, self).__init__(option_strings, dest, **kwargs)612...     def __call__(self, parser, namespace, values, option_string=None):613...         print '%r %r %r' % (namespace, values, option_string)614...         setattr(namespace, self.dest, values)615...616>>> parser = argparse.ArgumentParser()617>>> parser.add_argument('--foo', action=FooAction)618>>> parser.add_argument('bar', action=FooAction)619>>> args = parser.parse_args('1 --foo 2'.split())620Namespace(bar=None, foo=None) '1' None621Namespace(bar='1', foo=None) '2' '--foo'622>>> args623Namespace(bar='1', foo='2')624```625626Подробнее см. в [`Action`](https://python-all.ru/2.7/library/argparse.html#argparse.Action).627628### 15.4.3.3. nargs629630Объекты ArgumentParser обычно связывают один аргумент командной строки с одним действием. Именованный аргумент `nargs` связывает другое количество аргументов командной строки с одним действием. Допустимые значения:631632- `N` (целое число). Аргументы `N` из командной строки будут собраны в список. Например:633634  ```python635  >>> parser = argparse.ArgumentParser()636  >>> parser.add_argument('--foo', nargs=2)637  >>> parser.add_argument('bar', nargs=1)638  >>> parser.parse_args('c --foo a b'.split())639  Namespace(bar=['c'], foo=['a', 'b'])640  ```641642  Обратите внимание, что `nargs=1` создаёт список из одного элемента. Это отличается от поведения по умолчанию, при котором элемент создаётся сам по себе.643- `'?'`. Если возможно, будет потреблён один аргумент командной строки и выдан как отдельный элемент. Если аргумент командной строки отсутствует, будет выдано значение из [default](https://python-all.ru/2.7/library/argparse.html#default). Обратите внимание, что для необязательных аргументов есть дополнительный случай: строка параметра присутствует, но за ней не следует аргумент командной строки. В этом случае будет выдано значение из [const](https://python-all.ru/2.7/library/argparse.html#const). Некоторые примеры для иллюстрации:644645  ```python646  >>> parser = argparse.ArgumentParser()647  >>> parser.add_argument('--foo', nargs='?', const='c', default='d')648  >>> parser.add_argument('bar', nargs='?', default='d')649  >>> parser.parse_args(['XX', '--foo', 'YY'])650  Namespace(bar='XX', foo='YY')651  >>> parser.parse_args(['XX', '--foo'])652  Namespace(bar='XX', foo='c')653  >>> parser.parse_args([])654  Namespace(bar='d', foo='d')655  ```656657  Одно из наиболее распространённых применений `nargs='?'` – разрешение необязательных входных и выходных файлов:658659  ```python660  >>> parser = argparse.ArgumentParser()661  >>> parser.add_argument('infile', nargs='?', type=argparse.FileType('r'),662  ...                     default=sys.stdin)663  >>> parser.add_argument('outfile', nargs='?', type=argparse.FileType('w'),664  ...                     default=sys.stdout)665  >>> parser.parse_args(['input.txt', 'output.txt'])666  Namespace(infile=<open file 'input.txt', mode 'r' at 0x...>,667            outfile=<open file 'output.txt', mode 'w' at 0x...>)668  >>> parser.parse_args([])669  Namespace(infile=<open file '<stdin>', mode 'r' at 0x...>,670            outfile=<open file '<stdout>', mode 'w' at 0x...>)671  ```672- `'*'`. Все присутствующие аргументы командной строки собираются в список. Обратите внимание, что обычно не имеет смысла указывать более одного позиционного аргумента с `nargs='*'`, но возможно несколько необязательных аргументов с `nargs='*'`. Например:673674  ```python675  >>> parser = argparse.ArgumentParser()676  >>> parser.add_argument('--foo', nargs='*')677  >>> parser.add_argument('--bar', nargs='*')678  >>> parser.add_argument('baz', nargs='*')679  >>> parser.parse_args('a b --foo x y --bar 1 2'.split())680  Namespace(bar=['1', '2'], baz=['a', 'b'], foo=['x', 'y'])681  ```682- `'+'`. Как и `'*'`, все присутствующие аргументы командной строки собираются в список. Кроме того, будет выдано сообщение об ошибке, если не было хотя бы одного аргумента командной строки. Например:683684  ```python685  >>> parser = argparse.ArgumentParser(prog='PROG')686  >>> parser.add_argument('foo', nargs='+')687  >>> parser.parse_args(['a', 'b'])688  Namespace(foo=['a', 'b'])689  >>> parser.parse_args([])690  usage: PROG [-h] foo [foo ...]691  PROG: error: too few arguments692  ```693694- `argparse.REMAINDER`. Все остальные аргументы командной строки собираются в список. Это часто полезно для утилит командной строки, которые вызывают другие утилиты командной строки:695696  ```python697  >>> parser = argparse.ArgumentParser(prog='PROG')698  >>> parser.add_argument('--foo')699  >>> parser.add_argument('command')700  >>> parser.add_argument('args', nargs=argparse.REMAINDER)701  >>> print parser.parse_args('--foo B cmd --arg1 XX ZZ'.split())702  Namespace(args=['--arg1', 'XX', 'ZZ'], command='cmd', foo='B')703  ```704705Если именованный аргумент `nargs` не указан, количество потребляемых аргументов определяется действием [action](https://python-all.ru/2.7/library/argparse.html#action). Обычно это означает, что будет потреблён один аргумент командной строки и создан один элемент (не список).706707### 15.4.3.4. const708709Аргумент `const` функции [`add_argument()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.add_argument) используется для хранения постоянных значений, которые не считываются из командной строки, но требуются для различных действий [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser). Два наиболее распространённых его применения:710711- Когда [`add_argument()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.add_argument) вызывается с `action='store_const'` или `action='append_const'`. Эти действия добавляют значение `const` к одному из атрибутов объекта, возвращаемого [`parse_args()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.parse_args). Примеры см. в описании [action](https://python-all.ru/2.7/library/argparse.html#action).712- Когда [`add_argument()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.add_argument) вызывается со строками параметров (например, `-f` или `--foo`) и `nargs='?'`. Это создаёт необязательный аргумент, за которым может следовать ноль или один аргумент командной строки. При разборе командной строки, если строка параметра встречается без следующего за ней аргумента, вместо него будет использоваться значение `const`. Примеры см. в описании [nargs](https://python-all.ru/2.7/library/argparse.html#nargs).713714Для действий `'store_const'` и `'append_const'` необходимо указать именованный аргумент `const`. Для других действий по умолчанию используется `None`.715716### 15.4.3.5. default717718Все необязательные аргументы и некоторые позиционные аргументы могут быть опущены в командной строке. Именованный аргумент `default` функции [`add_argument()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.add_argument), значение которого по умолчанию равно `None`, указывает, какое значение следует использовать, если аргумент командной строки отсутствует. Для необязательных аргументов значение `default` используется, когда строка параметра отсутствовала в командной строке:719720```python721>>> parser = argparse.ArgumentParser()722>>> parser.add_argument('--foo', default=42)723>>> parser.parse_args(['--foo', '2'])724Namespace(foo='2')725>>> parser.parse_args([])726Namespace(foo=42)727```728729Если значение `default` является строкой, анализатор разбирает его так, как если бы это был аргумент командной строки. В частности, анализатор применяет любой аргумент преобразования [type](https://python-all.ru/2.7/library/argparse.html#type), если он указан, перед установкой атрибута в возвращаемом значении [`Namespace`](https://python-all.ru/2.7/library/argparse.html#argparse.Namespace). В противном случае анализатор использует значение как есть:730731```python732>>> parser = argparse.ArgumentParser()733>>> parser.add_argument('--length', default='10', type=int)734>>> parser.add_argument('--width', default=10.5, type=int)735>>> parser.parse_args()736Namespace(length=10, width=10.5)737```738739Для позиционных аргументов с [nargs](https://python-all.ru/2.7/library/argparse.html#nargs), равным `?` или `*`, значение `default` используется, когда аргумент командной строки отсутствовал:740741```python742>>> parser = argparse.ArgumentParser()743>>> parser.add_argument('foo', nargs='?', default=42)744>>> parser.parse_args(['a'])745Namespace(foo='a')746>>> parser.parse_args([])747Namespace(foo=42)748```749750Указание `default=argparse.SUPPRESS` приводит к тому, что атрибут не добавляется, если аргумент командной строки не был указан.:751752```python753>>> parser = argparse.ArgumentParser()754>>> parser.add_argument('--foo', default=argparse.SUPPRESS)755>>> parser.parse_args([])756Namespace()757>>> parser.parse_args(['--foo', '1'])758Namespace(foo='1')759```760761### 15.4.3.6. type762763По умолчанию объекты [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser) читают аргументы командной строки как простые строки. Однако довольно часто строку командной строки нужно интерпретировать как другой тип, например [`float`](https://python-all.ru/2.7/library/functions.html#float) или [`int`](https://python-all.ru/2.7/library/functions.html#int). Ключевой аргумент `type` метода [`add_argument()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.add_argument) позволяет выполнять любые необходимые проверки типов и преобразования типов. Обычные встроенные типы и функции можно использовать непосредственно в качестве значения аргумента `type`:764765```python766>>> parser = argparse.ArgumentParser()767>>> parser.add_argument('foo', type=int)768>>> parser.add_argument('bar', type=file)769>>> parser.parse_args('2 temp.txt'.split())770Namespace(bar=<open file 'temp.txt', mode 'r' at 0x...>, foo=2)771```772773См. раздел о ключевом аргументе [default](https://python-all.ru/2.7/library/argparse.html#default) для получения информации о том, когда аргумент `type` применяется к аргументам по умолчанию.774775Чтобы упростить работу с различными типами файлов, модуль argparse предоставляет фабрику FileType, которая принимает аргументы `mode=` и `bufsize=` объекта `file`. Например, `FileType('w')` можно использовать для создания файла для записи:776777```python778>>> parser = argparse.ArgumentParser()779>>> parser.add_argument('bar', type=argparse.FileType('w'))780>>> parser.parse_args(['out.txt'])781Namespace(bar=<open file 'out.txt', mode 'w' at 0x...>)782```783784`type=` может принимать любой вызываемый объект, который принимает один строковый аргумент и возвращает преобразованное значение:785786```python787>>> def perfect_square(string):788...     value = int(string)789...     sqrt = math.sqrt(value)790...     if sqrt != int(sqrt):791...         msg = "%r is not a perfect square" % string792...         raise argparse.ArgumentTypeError(msg)793...     return value794...795>>> parser = argparse.ArgumentParser(prog='PROG')796>>> parser.add_argument('foo', type=perfect_square)797>>> parser.parse_args(['9'])798Namespace(foo=9)799>>> parser.parse_args(['7'])800usage: PROG [-h] foo801PROG: error: argument foo: '7' is not a perfect square802```803804Ключевой аргумент [choices](https://python-all.ru/2.7/library/argparse.html#choices) может быть удобнее для проверок типов, которые просто проверяют попадание в диапазон значений:805806```python807>>> parser = argparse.ArgumentParser(prog='PROG')808>>> parser.add_argument('foo', type=int, choices=xrange(5, 10))809>>> parser.parse_args(['7'])810Namespace(foo=7)811>>> parser.parse_args(['11'])812usage: PROG [-h] {5,6,7,8,9}813PROG: error: argument foo: invalid choice: 11 (choose from 5, 6, 7, 8, 9)814```815816См. раздел [choices](https://python-all.ru/2.7/library/argparse.html#choices) для получения дополнительных сведений.817818### 15.4.3.7. choices819820Некоторые аргументы командной строки должны выбираться из ограниченного набора значений. Это можно обработать, передав контейнерный объект в качестве аргумента *choices* для [`add_argument()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.add_argument). Когда командная строка разбирается, значения аргументов проверяются, и будет выведено сообщение об ошибке, если аргумент не был одним из допустимых значений:821822```python823>>> parser = argparse.ArgumentParser(prog='game.py')824>>> parser.add_argument('move', choices=['rock', 'paper', 'scissors'])825>>> parser.parse_args(['rock'])826Namespace(move='rock')827>>> parser.parse_args(['fire'])828usage: game.py [-h] {rock,paper,scissors}829game.py: error: argument move: invalid choice: 'fire' (choose from 'rock',830'paper', 'scissors')831```832833Обратите внимание: вхождение в контейнер *choices* проверяется после всех преобразований типа [type](https://python-all.ru/2.7/library/argparse.html#type), поэтому тип объектов в *choices* должен соответствовать указанному [type](https://python-all.ru/2.7/library/argparse.html#type):834835```python836>>> parser = argparse.ArgumentParser(prog='doors.py')837>>> parser.add_argument('door', type=int, choices=range(1, 4))838>>> print(parser.parse_args(['3']))839Namespace(door=3)840>>> parser.parse_args(['4'])841usage: doors.py [-h] {1,2,3}842doors.py: error: argument door: invalid choice: 4 (choose from 1, 2, 3)843```844845Любой объект, поддерживающий оператор `in`, может быть передан как значение *choices* , поэтому объекты [`dict`](https://python-all.ru/2.7/library/stdtypes.html#dict), [`set`](https://python-all.ru/2.7/library/stdtypes.html#set), пользовательские контейнеры и т.д. – все поддерживаются.846847### 15.4.3.8. required848849В целом, модуль [`argparse`](https://python-all.ru/2.7/library/argparse.html#module-argparse) предполагает, что флаги вида `-f` и `--bar` обозначают *необязательные* аргументы, которые всегда можно опустить в командной строке. Чтобы сделать опцию *обязательной*, для ключевого аргумента `required=` функции [`add_argument()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.add_argument) можно указать `True`:850851```python852>>> parser = argparse.ArgumentParser()853>>> parser.add_argument('--foo', required=True)854>>> parser.parse_args(['--foo', 'BAR'])855Namespace(foo='BAR')856>>> parser.parse_args([])857usage: argparse.py [-h] [--foo FOO]858argparse.py: error: option --foo is required859```860861Как показано в примере, если опция помечена как `required`, [`parse_args()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.parse_args) сообщит об ошибке, если эта опция отсутствует в командной строке.862863> **Примечание**864>865> Обязательные опции обычно считаются дурным тоном, поскольку пользователи ожидают, что *опции* будут *необязательными*, поэтому их следует по возможности избегать.866867### 15.4.3.9. help868869Значение `help` – это строка, содержащая краткое описание аргумента. Когда пользователь запрашивает справку (обычно с помощью `-h` или `--help` в командной строке), эти описания `help` отображаются для каждого аргумента:870871```python872>>> parser = argparse.ArgumentParser(prog='frobble')873>>> parser.add_argument('--foo', action='store_true',874...                     help='foo the bars before frobbling')875>>> parser.add_argument('bar', nargs='+',876...                     help='one of the bars to be frobbled')877>>> parser.parse_args(['-h'])878usage: frobble [-h] [--foo] bar [bar ...]879880positional arguments:881 bar     one of the bars to be frobbled882883optional arguments:884 -h, --help  show this help message and exit885 --foo   foo the bars before frobbling886```887888Строки `help` могут содержать различные спецификаторы формата, чтобы избежать повторения таких элементов, как имя программы или [значение по умолчанию](https://python-all.ru/2.7/library/argparse.html#default) аргумента. Доступные спецификаторы включают имя программы, `%(prog)s` и большинство ключевых аргументов функции [`add_argument()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.add_argument), например `%(default)s`, `%(type)s` и т.д.:889890```python891>>> parser = argparse.ArgumentParser(prog='frobble')892>>> parser.add_argument('bar', nargs='?', type=int, default=42,893...                     help='the bar to %(prog)s (default: %(default)s)')894>>> parser.print_help()895usage: frobble [-h] [bar]896897positional arguments:898 bar     the bar to frobble (default: 42)899900optional arguments:901 -h, --help  show this help message and exit902```903904[`argparse`](https://python-all.ru/2.7/library/argparse.html#module-argparse) поддерживает скрытие записи справки для определённых опций путём установки значения `help` в `argparse.SUPPRESS`:905906```python907>>> parser = argparse.ArgumentParser(prog='frobble')908>>> parser.add_argument('--foo', help=argparse.SUPPRESS)909>>> parser.print_help()910usage: frobble [-h]911912optional arguments:913  -h, --help  show this help message and exit914```915916### 15.4.3.10. metavar917918Когда [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser) генерирует сообщения справки, ему нужен способ ссылаться на каждый ожидаемый аргумент. По умолчанию объекты ArgumentParser используют значение [dest](https://python-all.ru/2.7/library/argparse.html#dest) в качестве «имени» каждого объекта. По умолчанию для позиционных аргументов значение [dest](https://python-all.ru/2.7/library/argparse.html#dest) используется напрямую, а для опциональных аргументов значение [dest](https://python-all.ru/2.7/library/argparse.html#dest) преобразуется в верхний регистр. Таким образом, один позиционный аргумент с `dest='bar'` будет называться `bar`. Один опциональный аргумент `--foo`, за которым должен следовать один аргумент командной строки, будет называться `FOO`. Пример:919920```python921>>> parser = argparse.ArgumentParser()922>>> parser.add_argument('--foo')923>>> parser.add_argument('bar')924>>> parser.parse_args('X --foo Y'.split())925Namespace(bar='X', foo='Y')926>>> parser.print_help()927usage:  [-h] [--foo FOO] bar928929positional arguments:930 bar931932optional arguments:933 -h, --help  show this help message and exit934 --foo FOO935```936937Альтернативное имя можно указать с помощью `metavar`:938939```python940>>> parser = argparse.ArgumentParser()941>>> parser.add_argument('--foo', metavar='YYY')942>>> parser.add_argument('bar', metavar='XXX')943>>> parser.parse_args('X --foo Y'.split())944Namespace(bar='X', foo='Y')945>>> parser.print_help()946usage:  [-h] [--foo YYY] XXX947948positional arguments:949 XXX950951optional arguments:952 -h, --help  show this help message and exit953 --foo YYY954```955956Обратите внимание, что `metavar` изменяет только *отображаемое* имя – имя атрибута объекта [`parse_args()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.parse_args) по-прежнему определяется значением [dest](https://python-all.ru/2.7/library/argparse.html#dest).957958Разные значения `nargs` могут привести к тому, что метапеременная будет использована несколько раз. Передача кортежа в `metavar` задаёт различное отображение для каждого из аргументов:959960```python961>>> parser = argparse.ArgumentParser(prog='PROG')962>>> parser.add_argument('-x', nargs=2)963>>> parser.add_argument('--foo', nargs=2, metavar=('bar', 'baz'))964>>> parser.print_help()965usage: PROG [-h] [-x X X] [--foo bar baz]966967optional arguments:968 -h, --help     show this help message and exit969 -x X X970 --foo bar baz971```972973### 15.4.3.11. dest974975Большинство действий [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser) добавляют некоторое значение как атрибут объекта, возвращаемого [`parse_args()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.parse_args). Имя этого атрибута определяется ключевым аргументом `dest` функции [`add_argument()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.add_argument). Для действий с позиционными аргументами `dest` обычно передаётся первым аргументом в [`add_argument()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.add_argument):976977```python978>>> parser = argparse.ArgumentParser()979>>> parser.add_argument('bar')980>>> parser.parse_args(['XXX'])981Namespace(bar='XXX')982```983984Для действий необязательных аргументов значение `dest` обычно выводится из строк опций. [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser) генерирует значение `dest`, беря первую длинную строку опции и удаляя начальную строку `--`. Если длинные строки опций не были предоставлены, `dest` будет получен из первой короткой строки опции путем удаления начального символа `-`. Любые внутренние символы `-` будут преобразованы в символы `_`, чтобы гарантировать, что строка является допустимым именем атрибута. Примеры ниже иллюстрируют это поведение:985986```python987>>> parser = argparse.ArgumentParser()988>>> parser.add_argument('-f', '--foo-bar', '--foo')989>>> parser.add_argument('-x', '-y')990>>> parser.parse_args('-f 1 -x 2'.split())991Namespace(foo_bar='1', x='2')992>>> parser.parse_args('--foo 1 -y 2'.split())993Namespace(foo_bar='1', x='2')994```995996`dest` позволяет указать пользовательское имя атрибута:997998```python999>>> parser = argparse.ArgumentParser()1000>>> parser.add_argument('--foo', dest='bar')1001>>> parser.parse_args('--foo XXX'.split())1002Namespace(bar='XXX')1003```10041005### 15.4.3.12. Классы действий10061007Классы действий реализуют API Action – вызываемый объект, который возвращает вызываемый объект, обрабатывающий аргументы командной строки. Любой объект, соответствующий этому API, может быть передан как параметр `action` в `add_argument()`.10081009#### `class argparse.Action(option_strings, dest, nargs=None, const=None, default=None, type=None, choices=None, required=False, help=None, metavar=None)`10101011Объекты Action используются ArgumentParser для представления информации, необходимой для разбора одного аргумента из одной или нескольких строк командной строки. Класс Action должен принимать два позиционных аргумента, а также все именованные аргументы, переданные в [`ArgumentParser.add_argument()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.add_argument), кроме самого `action`.10121013Экземпляры Action (или возвращаемое значение любого вызываемого объекта для параметра `action`) должны иметь определённые атрибуты «dest», «option\_strings», «default», «type», «required», «help» и т.д. Самый простой способ гарантировать, что эти атрибуты определены – вызвать `Action.__init__`.10141015Экземпляры Action должны быть вызываемыми, поэтому подклассы должны переопределять метод `__call__`, который должен принимать четыре параметра:10161017- `parser` – объект ArgumentParser, содержащий это действие.1018- `namespace` – объект [`Namespace`](https://python-all.ru/2.7/library/argparse.html#argparse.Namespace), который будет возвращён [`parse_args()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.parse_args). Большинство действий добавляют атрибут к этому объекту с помощью [`setattr()`](https://python-all.ru/2.7/library/functions.html#setattr).1019- `values` – соответствующие аргументы командной строки с применёнными преобразованиями типов. Преобразования типов задаются с помощью именованного аргумента [type](https://python-all.ru/2.7/library/argparse.html#type) для [`add_argument()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.add_argument).1020- `option_string` – строка опции, которая использовалась для вызова этого действия. Аргумент `option_string` является необязательным и будет отсутствовать, если действие связано с позиционным аргументом.10211022Метод `__call__` может выполнять произвольные действия, но обычно устанавливает атрибуты объекта `namespace` на основе `dest` и `values`.10231024## 15.4.4. Метод parse\_args()10251026#### `ArgumentParser.parse_args(args=None, namespace=None)`10271028Преобразует строки аргументов в объекты и назначает их в качестве атрибутов пространства имён. Возвращает заполненное пространство имён.10291030Предыдущие вызовы [`add_argument()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.add_argument) определяют, какие объекты создаются и как они назначаются. Подробнее см. документацию [`add_argument()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.add_argument).10311032- [args](https://python-all.ru/2.7/library/argparse.html#args) – список строк для разбора. По умолчанию берётся из [`sys.argv`](https://python-all.ru/2.7/library/sys.html#sys.argv).1033- [namespace](https://python-all.ru/2.7/library/argparse.html#namespace) – объект, в который будут помещены атрибуты. По умолчанию – новый пустой объект [`Namespace`](https://python-all.ru/2.7/library/argparse.html#argparse.Namespace).10341035### 15.4.4.1. Синтаксис значений параметров10361037Метод [`parse_args()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.parse_args) поддерживает несколько способов указания значения параметра (если он принимает значение). В простейшем случае параметр и его значение передаются как два отдельных аргумента:10381039```python1040>>> parser = argparse.ArgumentParser(prog='PROG')1041>>> parser.add_argument('-x')1042>>> parser.add_argument('--foo')1043>>> parser.parse_args(['-x', 'X'])1044Namespace(foo=None, x='X')1045>>> parser.parse_args(['--foo', 'FOO'])1046Namespace(foo='FOO', x=None)1047```10481049Для длинных параметров (с именами длиннее одного символа) параметр и значение могут быть переданы как один аргумент командной строки, используя `=` для их разделения:10501051```python1052>>> parser.parse_args(['--foo=FOO'])1053Namespace(foo='FOO', x=None)1054```10551056Для коротких опций (опции длиной в один символ) опция и её значение могут быть объединены:10571058```python1059>>> parser.parse_args(['-xX'])1060Namespace(foo=None, x='X')1061```10621063Несколько коротких опций можно объединить, используя только один префикс `-`, при условии, что только последняя опция (или ни одна из них) требует значения:10641065```python1066>>> parser = argparse.ArgumentParser(prog='PROG')1067>>> parser.add_argument('-x', action='store_true')1068>>> parser.add_argument('-y', action='store_true')1069>>> parser.add_argument('-z')1070>>> parser.parse_args(['-xyzZ'])1071Namespace(x=True, y=True, z='Z')1072```10731074### 15.4.4.2. Недопустимые аргументы10751076При разборе командной строки [`parse_args()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.parse_args) проверяет различные ошибки, включая неоднозначные опции, некорректные типы, неверные опции, неправильное количество позиционных аргументов и т.д. При обнаружении такой ошибки программа завершается и выводит сообщение об ошибке вместе со справкой по использованию:10771078```python1079>>> parser = argparse.ArgumentParser(prog='PROG')1080>>> parser.add_argument('--foo', type=int)1081>>> parser.add_argument('bar', nargs='?')10821083>>> # недопустимый тип1084>>> parser.parse_args(['--foo', 'spam'])1085usage: PROG [-h] [--foo FOO] [bar]1086PROG: error: argument --foo: invalid int value: 'spam'10871088>>> # недопустимая опция1089>>> parser.parse_args(['--bar'])1090usage: PROG [-h] [--foo FOO] [bar]1091PROG: error: no such option: --bar10921093>>> # неверное количество аргументов1094>>> parser.parse_args(['spam', 'badger'])1095usage: PROG [-h] [--foo FOO] [bar]1096PROG: error: extra arguments found: badger1097```10981099### 15.4.4.3. Аргументы, содержащие `-`11001101Метод [`parse_args()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.parse_args) старается выдавать ошибки всякий раз, когда пользователь явно ошибся, но некоторые ситуации по своей природе неоднозначны. Например, аргумент командной строки `-1` может быть как попыткой указать опцию, так и попыткой передать позиционный аргумент. Метод [`parse_args()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.parse_args) здесь действует осторожно: позиционные аргументы могут начинаться с `-` только если они похожи на отрицательные числа, и в анализаторе нет опций, которые выглядят как отрицательные числа:11021103```python1104>>> parser = argparse.ArgumentParser(prog='PROG')1105>>> parser.add_argument('-x')1106>>> parser.add_argument('foo', nargs='?')11071108>>> # нет опций с отрицательными числами, поэтому -1 – позиционный аргумент1109>>> parser.parse_args(['-x', '-1'])1110Namespace(foo=None, x='-1')11111112>>> # нет опций с отрицательными числами, поэтому -1 и -5 – позиционные аргументы1113>>> parser.parse_args(['-x', '-1', '-5'])1114Namespace(foo='-5', x='-1')11151116>>> parser = argparse.ArgumentParser(prog='PROG')1117>>> parser.add_argument('-1', dest='one')1118>>> parser.add_argument('foo', nargs='?')11191120>>> # опции с отрицательными числами присутствуют, поэтому -1 – это опция1121>>> parser.parse_args(['-1', 'X'])1122Namespace(foo=None, one='X')11231124>>> # опции с отрицательными числами присутствуют, поэтому -2 – это опция1125>>> parser.parse_args(['-2'])1126usage: PROG [-h] [-1 ONE] [foo]1127PROG: error: no such option: -211281129>>> # опции с отрицательными числами присутствуют, поэтому обе -1 – это опции1130>>> parser.parse_args(['-1', '-1'])1131usage: PROG [-h] [-1 ONE] [foo]1132PROG: error: argument -1: expected one argument1133```11341135Если позиционные аргументы должны начинаться с `-` и не похожи на отрицательные числа, можно вставить псевдоаргумент `'--'`, который сообщает [`parse_args()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.parse_args), что всё после него является позиционным аргументом:11361137```python1138>>> parser.parse_args(['--', '-f'])1139Namespace(foo='-f', one=None)1140```11411142### 15.4.4.4. Сокращённые аргументы (сопоставление по префиксу)11431144Метод [`parse_args()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.parse_args) позволяет сокращать длинные опции до префикса, если сокращение однозначно (префикс соответствует единственной опции):11451146```python1147>>> parser = argparse.ArgumentParser(prog='PROG')1148>>> parser.add_argument('-bacon')1149>>> parser.add_argument('-badger')1150>>> parser.parse_args('-bac MMM'.split())1151Namespace(bacon='MMM', badger=None)1152>>> parser.parse_args('-bad WOOD'.split())1153Namespace(bacon=None, badger='WOOD')1154>>> parser.parse_args('-ba BA'.split())1155usage: PROG [-h] [-bacon BACON] [-badger BADGER]1156PROG: error: ambiguous option: -ba could match -badger, -bacon1157```11581159Для аргументов, которые могут соответствовать более чем одной опции, выдаётся ошибка.11601161### 15.4.4.5. За пределами `sys.argv`11621163Иногда может быть полезно, чтобы ArgumentParser разбирал аргументы, отличные от аргументов [`sys.argv`](https://python-all.ru/2.7/library/sys.html#sys.argv). Этого можно достичь, передав список строк в [`parse_args()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.parse_args). Это полезно для тестирования в интерактивной командной строке:11641165```python1166>>> parser = argparse.ArgumentParser()1167>>> parser.add_argument(1168...     'integers', metavar='int', type=int, choices=xrange(10),1169...     nargs='+', help='an integer in the range 0..9')1170>>> parser.add_argument(1171...     '--sum', dest='accumulate', action='store_const', const=sum,1172...     default=max, help='sum the integers (default: find the max)')1173>>> parser.parse_args(['1', '2', '3', '4'])1174Namespace(accumulate=<built-in function max>, integers=[1, 2, 3, 4])1175>>> parser.parse_args(['1', '2', '3', '4', '--sum'])1176Namespace(accumulate=<built-in function sum>, integers=[1, 2, 3, 4])1177```11781179### 15.4.4.6. Объект Namespace11801181#### `class argparse.Namespace`11821183Простой класс, используемый по умолчанию в [`parse_args()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.parse_args) для создания объекта, содержащего атрибуты, и его возврата.11841185Этот класс намеренно прост, всего лишь подкласс [`object`](https://python-all.ru/2.7/library/functions.html#object) с читаемым строковым представлением. Если нужно dict-подобное представление атрибутов, можно воспользоваться стандартной идиомой Python, [`vars()`](https://python-all.ru/2.7/library/functions.html#vars):11861187```python1188>>> parser = argparse.ArgumentParser()1189>>> parser.add_argument('--foo')1190>>> args = parser.parse_args(['--foo', 'BAR'])1191>>> vars(args)1192{'foo': 'BAR'}1193```11941195Также может быть полезно, чтобы [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser) присваивал атрибуты уже существующему объекту, а не новому объекту [`Namespace`](https://python-all.ru/2.7/library/argparse.html#argparse.Namespace). Этого можно достичь, указав именованный аргумент `namespace=`:11961197```python1198>>> class C(object):1199...     pass1200...1201>>> c = C()1202>>> parser = argparse.ArgumentParser()1203>>> parser.add_argument('--foo')1204>>> parser.parse_args(args=['--foo', 'BAR'], namespace=c)1205>>> c.foo1206'BAR'1207```12081209## 15.4.5. Прочие утилиты12101211### 15.4.5.1. Подкоманды12121213#### `ArgumentParser.add_subparsers([title][, description][, prog][, parser_class][, action][, option_string][, dest][, help][, metavar])`12141215Многие программы разделяют свою функциональность на несколько подкоманд, например, программа `svn` может вызывать подкоманды `svn checkout`, `svn update` и `svn commit`. Разделение функциональности таким образом может быть особенно хорошей идеей, когда программа выполняет несколько различных функций, требующих разных типов аргументов командной строки. [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser) поддерживает создание таких подкоманд с помощью метода [`add_subparsers()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.add_subparsers). Метод [`add_subparsers()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.add_subparsers) обычно вызывается без аргументов и возвращает специальный объект действия. Этот объект имеет единственный метод `add_parser()`, который принимает имя команды и любые аргументы конструктора [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser), и возвращает объект [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser), который можно изменять как обычно.12161217Описание параметров:12181219- title – заголовок для группы подпарсеров в выводе справки; по умолчанию «subcommands», если указано описание, в противном случае используется заголовок для позиционных аргументов.1220- description – описание для группы подпарсеров в выводе справки, по умолчанию `None`1221- prog – информация об использовании, которая будет отображаться в справке подкоманды; по умолчанию – имя программы и любые позиционные аргументы перед аргументом подпарсера1222- parser\_class – класс, который будет использоваться для создания экземпляров подпарсера; по умолчанию – класс текущего парсера (например, ArgumentParser)1223- [action](https://python-all.ru/2.7/library/argparse.html#action) – базовый тип действия, которое будет выполнено при обнаружении этого аргумента в командной строке1224- [dest](https://python-all.ru/2.7/library/argparse.html#dest) – имя атрибута, в котором будет сохранено имя подкоманды; по умолчанию `None`, значение не сохраняется1225- [help](https://python-all.ru/2.7/library/argparse.html#help) – справка для группы подпарсеров в выводе справки; по умолчанию `None`1226- [metavar](https://python-all.ru/2.7/library/argparse.html#metavar) – строка, представляющая доступные подкоманды в справке; по умолчанию это `None` и представляет подкоманды в форме {cmd1, cmd2, ..}12271228Пример использования:12291230```python1231>>> # создать парсер верхнего уровня1232>>> parser = argparse.ArgumentParser(prog='PROG')1233>>> parser.add_argument('--foo', action='store_true', help='foo help')1234>>> subparsers = parser.add_subparsers(help='sub-command help')1235>>>1236>>> # создать парсер для команды "a"1237>>> parser_a = subparsers.add_parser('a', help='a help')1238>>> parser_a.add_argument('bar', type=int, help='bar help')1239>>>1240>>> # создать парсер для команды "b"1241>>> parser_b = subparsers.add_parser('b', help='b help')1242>>> parser_b.add_argument('--baz', choices='XYZ', help='baz help')1243>>>1244>>> # разобрать некоторые списки аргументов1245>>> parser.parse_args(['a', '12'])1246Namespace(bar=12, foo=False)1247>>> parser.parse_args(['--foo', 'b', '--baz', 'Z'])1248Namespace(baz='Z', foo=True)1249```12501251Обратите внимание, что объект, возвращаемый [`parse_args()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.parse_args), будет содержать только атрибуты главного парсера и того подпарсера, который был выбран из командной строки (а не любых других подпарсеров). Так, в приведённом выше примере, когда указана команда `a`, присутствуют только атрибуты `foo` и `bar`, а когда указана команда `b` – только атрибуты `foo` и `baz`.12521253Аналогично, при запросе справки от подпарсера выводится только справка этого конкретного парсера. Сообщение справки не включает сообщения родительского парсера или соседних парсеров. (Однако справку для каждой команды подпарсера можно задать, передав аргумент `help=` функции `add_parser()`, как показано выше.)12541255```python1256>>> parser.parse_args(['--help'])1257usage: PROG [-h] [--foo] {a,b} ...12581259positional arguments:1260  {a,b}   sub-command help1261    a     a help1262    b     b help12631264optional arguments:1265  -h, --help  show this help message and exit1266  --foo   foo help12671268>>> parser.parse_args(['a', '--help'])1269usage: PROG a [-h] bar12701271positional arguments:1272  bar     bar help12731274optional arguments:1275  -h, --help  show this help message and exit12761277>>> parser.parse_args(['b', '--help'])1278usage: PROG b [-h] [--baz {X,Y,Z}]12791280optional arguments:1281  -h, --help     show this help message and exit1282  --baz {X,Y,Z}  baz help1283```12841285Метод [`add_subparsers()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.add_subparsers) также поддерживает именованные аргументы `title` и `description`. Когда любой из них присутствует, команды подпарсера отображаются в собственной группе в выводе справки. Например:12861287```python1288>>> parser = argparse.ArgumentParser()1289>>> subparsers = parser.add_subparsers(title='subcommands',1290...                                    description='valid subcommands',1291...                                    help='additional help')1292>>> subparsers.add_parser('foo')1293>>> subparsers.add_parser('bar')1294>>> parser.parse_args(['-h'])1295usage:  [-h] {foo,bar} ...12961297optional arguments:1298  -h, --help  show this help message and exit12991300subcommands:1301  valid subcommands13021303  {foo,bar}   additional help1304```13051306Один из особенно эффективных способов работы с подкомандами – комбинировать использование метода [`add_subparsers()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.add_subparsers) с вызовами [`set_defaults()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.set_defaults), чтобы каждый подпарсер знал, какую функцию Python он должен выполнить. Например:13071308```python1309>>> # функции подкоманд1310>>> def foo(args):1311...     print args.x * args.y1312...1313>>> def bar(args):1314...     print '((%s))' % args.z1315...1316>>> # создать парсер верхнего уровня1317>>> parser = argparse.ArgumentParser()1318>>> subparsers = parser.add_subparsers()1319>>>1320>>> # создать парсер для команды "foo"1321>>> parser_foo = subparsers.add_parser('foo')1322>>> parser_foo.add_argument('-x', type=int, default=1)1323>>> parser_foo.add_argument('y', type=float)1324>>> parser_foo.set_defaults(func=foo)1325>>>1326>>> # создать парсер для команды "bar"1327>>> parser_bar = subparsers.add_parser('bar')1328>>> parser_bar.add_argument('z')1329>>> parser_bar.set_defaults(func=bar)1330>>>1331>>> # разобрать аргументы и вызвать выбранную функцию1332>>> args = parser.parse_args('foo 1 -x 2'.split())1333>>> args.func(args)13342.01335>>>1336>>> # разобрать аргументы и вызвать выбранную функцию1337>>> args = parser.parse_args('bar XYZYX'.split())1338>>> args.func(args)1339((XYZYX))1340```13411342Таким образом, можно поручить [`parse_args()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.parse_args) задачу вызова соответствующей функции после завершения разбора аргументов. Связывание функций с действиями таким образом – обычно самый простой способ обработать разные действия для каждого из ваших подпарсеров. Однако, если необходимо проверить имя вызванного подпарсера, сработает именованный аргумент `dest` при вызове [`add_subparsers()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.add_subparsers):13431344```python1345>>> parser = argparse.ArgumentParser()1346>>> subparsers = parser.add_subparsers(dest='subparser_name')1347>>> subparser1 = subparsers.add_parser('1')1348>>> subparser1.add_argument('-x')1349>>> subparser2 = subparsers.add_parser('2')1350>>> subparser2.add_argument('y')1351>>> parser.parse_args(['2', 'frobble'])1352Namespace(subparser_name='2', y='frobble')1353```13541355### 15.4.5.2. Объекты FileType13561357#### `class argparse.FileType(mode='r', bufsize=None)`13581359Фабрика [`FileType`](https://python-all.ru/2.7/library/argparse.html#argparse.FileType) создаёт объекты, которые можно передавать в аргумент type функции [`ArgumentParser.add_argument()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.add_argument). Аргументы, имеющие в качестве типа объекты [`FileType`](https://python-all.ru/2.7/library/argparse.html#argparse.FileType), будут открывать аргументы командной строки как файлы с запрошенными режимами и размерами буфера:13601361```python1362>>> parser = argparse.ArgumentParser()1363>>> parser.add_argument('--output', type=argparse.FileType('wb', 0))1364>>> parser.parse_args(['--output', 'out'])1365Namespace(output=<open file 'out', mode 'wb' at 0x...>)1366```13671368Объекты FileType понимают псевдоаргумент `'-'` и автоматически преобразуют его в `sys.stdin` для читаемых объектов [`FileType`](https://python-all.ru/2.7/library/argparse.html#argparse.FileType) и в `sys.stdout` для записываемых объектов [`FileType`](https://python-all.ru/2.7/library/argparse.html#argparse.FileType):13691370```python1371>>> parser = argparse.ArgumentParser()1372>>> parser.add_argument('infile', type=argparse.FileType('r'))1373>>> parser.parse_args(['-'])1374Namespace(infile=<open file '<stdin>', mode 'r' at 0x...>)1375```13761377### 15.4.5.3. Группы аргументов13781379#### `ArgumentParser.add_argument_group(title=None, description=None)`13801381По умолчанию [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser) группирует аргументы командной строки на «позиционные аргументы» и «необязательные аргументы» при выводе справочных сообщений. Если существует более удачная концептуальная группировка аргументов, чем стандартная, подходящие группы можно создать с помощью метода [`add_argument_group()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.add_argument_group):13821383```python1384>>> parser = argparse.ArgumentParser(prog='PROG', add_help=False)1385>>> group = parser.add_argument_group('group')1386>>> group.add_argument('--foo', help='foo help')1387>>> group.add_argument('bar', help='bar help')1388>>> parser.print_help()1389usage: PROG [--foo FOO] bar13901391group:1392  bar    bar help1393  --foo FOO  foo help1394```13951396Метод [`add_argument_group()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.add_argument_group) возвращает объект группы аргументов, у которого есть метод [`add_argument()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.add_argument), как и у обычного [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser). Когда аргумент добавляется в группу, парсер обрабатывает его как обычный аргумент, но при выводе справки отображает его в отдельной группе. Метод [`add_argument_group()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.add_argument_group) принимает аргументы *title* и *description*, которые можно использовать для настройки этого отображения:13971398```python1399>>> parser = argparse.ArgumentParser(prog='PROG', add_help=False)1400>>> group1 = parser.add_argument_group('group1', 'group1 description')1401>>> group1.add_argument('foo', help='foo help')1402>>> group2 = parser.add_argument_group('group2', 'group2 description')1403>>> group2.add_argument('--bar', help='bar help')1404>>> parser.print_help()1405usage: PROG [--bar BAR] foo14061407group1:1408  group1 description14091410  foo    foo help14111412group2:1413  group2 description14141415  --bar BAR  bar help1416```14171418Обратите внимание, что любые аргументы, не входящие в ваши пользовательские группы, окажутся обратно в обычных разделах «позиционные аргументы» и «опциональные аргументы».14191420### 15.4.5.4. Взаимное исключение14211422#### `ArgumentParser.add_mutually_exclusive_group(required=False)`14231424Создаёт взаимоисключающую группу. [`argparse`](https://python-all.ru/2.7/library/argparse.html#module-argparse) гарантирует, что в командной строке присутствовал только один из аргументов взаимоисключающей группы:14251426```python1427>>> parser = argparse.ArgumentParser(prog='PROG')1428>>> group = parser.add_mutually_exclusive_group()1429>>> group.add_argument('--foo', action='store_true')1430>>> group.add_argument('--bar', action='store_false')1431>>> parser.parse_args(['--foo'])1432Namespace(bar=True, foo=True)1433>>> parser.parse_args(['--bar'])1434Namespace(bar=False, foo=False)1435>>> parser.parse_args(['--foo', '--bar'])1436usage: PROG [-h] [--foo | --bar]1437PROG: error: argument --bar: not allowed with argument --foo1438```14391440Метод [`add_mutually_exclusive_group()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.add_mutually_exclusive_group) также принимает аргумент *required*, чтобы указать, что требуется хотя бы один из взаимоисключающих аргументов:14411442```python1443>>> parser = argparse.ArgumentParser(prog='PROG')1444>>> group = parser.add_mutually_exclusive_group(required=True)1445>>> group.add_argument('--foo', action='store_true')1446>>> group.add_argument('--bar', action='store_false')1447>>> parser.parse_args([])1448usage: PROG [-h] (--foo | --bar)1449PROG: error: one of the arguments --foo --bar is required1450```14511452Обратите внимание, что в настоящее время группы взаимоисключающих аргументов не поддерживают аргументы *title* и *description* из [`add_argument_group()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.add_argument_group).14531454### 15.4.5.5. Значения по умолчанию парсера14551456#### `ArgumentParser.set_defaults(**kwargs)`14571458В большинстве случаев атрибуты объекта, возвращаемого [`parse_args()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.parse_args), полностью определяются путём анализа аргументов командной строки и действий аргументов. [`set_defaults()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.set_defaults) позволяет добавить некоторые дополнительные атрибуты, которые определяются без какого-либо анализа командной строки:14591460```python1461>>> parser = argparse.ArgumentParser()1462>>> parser.add_argument('foo', type=int)1463>>> parser.set_defaults(bar=42, baz='badger')1464>>> parser.parse_args(['736'])1465Namespace(bar=42, baz='badger', foo=736)1466```14671468Обратите внимание: значения по умолчанию на уровне анализатора всегда переопределяют значения по умолчанию на уровне аргументов:14691470```python1471>>> parser = argparse.ArgumentParser()1472>>> parser.add_argument('--foo', default='bar')1473>>> parser.set_defaults(foo='spam')1474>>> parser.parse_args([])1475Namespace(foo='spam')1476```14771478Умолчания на уровне парсера могут быть особенно полезны при работе с несколькими парсерами. См. пример этого типа в методе [`add_subparsers()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.add_subparsers).14791480#### `ArgumentParser.get_default(dest)`14811482Возвращает значение по умолчанию для атрибута пространства имён, заданное либо [`add_argument()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.add_argument), либо [`set_defaults()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.set_defaults):14831484```python1485>>> parser = argparse.ArgumentParser()1486>>> parser.add_argument('--foo', default='badger')1487>>> parser.get_default('foo')1488'badger'1489```14901491### 15.4.5.6. Вывод справки14921493В большинстве типичных приложений [`parse_args()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.parse_args) берёт на себя форматирование и вывод всех сообщений об использовании и ошибок. Однако доступно несколько методов форматирования:14941495#### `ArgumentParser.print_usage(file=None)`14961497Выводит краткое описание того, как [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser) должен вызываться в командной строке. Если *file* равен `None`, предполагается [`sys.stdout`](https://python-all.ru/2.7/library/sys.html#sys.stdout).14981499#### `ArgumentParser.print_help(file=None)`15001501Выводит справочное сообщение, включая использование программы и информацию об аргументах, зарегистрированных в [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser). Если *file* равен `None`, предполагается [`sys.stdout`](https://python-all.ru/2.7/library/sys.html#sys.stdout).15021503Существуют также варианты этих методов, которые просто возвращают строку вместо её вывода:15041505#### `ArgumentParser.format_usage()`15061507Возвращает строку с кратким описанием того, как [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser) должен вызываться в командной строке.15081509#### `ArgumentParser.format_help()`15101511Возвращает строку со справочным сообщением, включая использование программы и информацию об аргументах, зарегистрированных в [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser).15121513### 15.4.5.7. Частичный разбор15141515#### `ArgumentParser.parse_known_args(args=None, namespace=None)`15161517Иногда скрипт может разобрать только часть аргументов командной строки, передавая остальные другому скрипту или программе. В таких случаях может пригодиться метод [`parse_known_args()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.parse_known_args). Он работает почти как [`parse_args()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.parse_args), за исключением того, что не вызывает ошибку при наличии лишних аргументов. Вместо этого он возвращает кортеж из двух элементов: заполненное пространство имён и список оставшихся строк аргументов.15181519```python1520>>> parser = argparse.ArgumentParser()1521>>> parser.add_argument('--foo', action='store_true')1522>>> parser.add_argument('bar')1523>>> parser.parse_known_args(['--foo', '--badger', 'BAR', 'spam'])1524(Namespace(bar='BAR', foo=True), ['--badger', 'spam'])1525```15261527> **Предупреждение**1528>1529> Правила [совпадения по префиксу](https://python-all.ru/2.7/library/argparse.html#prefix-matching) применяются к `parse_known_args()`. Парсер может поглотить параметр, даже если он является всего лишь префиксом одного из известных параметров, вместо того чтобы оставить его в списке оставшихся аргументов.15301531### 15.4.5.8. Настройка разбора файлов15321533#### `ArgumentParser.convert_arg_line_to_args(arg_line)`15341535Аргументы, читаемые из файла (см. именованный аргумент *fromfile\_prefix\_chars* конструктора [`ArgumentParser`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser)), читаются по одному аргументу на строку. [`convert_arg_line_to_args()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.convert_arg_line_to_args) можно переопределить для более сложного чтения.15361537Этот метод принимает один аргумент *arg\_line* – строку, прочитанную из файла аргументов. Он возвращает список аргументов, разобранных из этой строки. Метод вызывается по одному разу для каждой строки из файла аргументов, по порядку.15381539Полезный вариант переопределения этого метода – такой, который воспринимает каждое слово, разделённое пробелом, как отдельный аргумент.15401541```python1542def convert_arg_line_to_args(self, arg_line):1543    return arg_line.split()1544```15451546### 15.4.5.9. Методы завершения15471548#### `ArgumentParser.exit(status=0, message=None)`15491550Этот метод завершает программу, выходя с указанным *статус* и, если задан, выводит *сообщение* перед этим.15511552#### `ArgumentParser.error(message)`15531554Этот метод выводит сообщение об использовании, включая *message*, в стандартный поток ошибок и завершает программу с кодом возврата 2.15551556## 15.4.6. Обновление кода optparse15571558Изначально модуль [`argparse`](https://python-all.ru/2.7/library/argparse.html#module-argparse) пытался сохранять совместимость с [`optparse`](https://python-all.ru/2.7/library/optparse.html#module-optparse). Однако [`optparse`](https://python-all.ru/2.7/library/optparse.html#module-optparse) было сложно прозрачно расширять, особенно с изменениями, необходимыми для поддержки новых спецификаторов `nargs=` и более качественных сообщений об использовании. Когда почти всё в [`optparse`](https://python-all.ru/2.7/library/optparse.html#module-optparse) было либо скопировано, либо пропатчено (monkey-patched), попытки поддерживать обратную совместимость перестали казаться практичными.15591560Модуль [`argparse`](https://python-all.ru/2.7/library/argparse.html#module-argparse) превосходит стандартный модуль библиотеки [`optparse`](https://python-all.ru/2.7/library/optparse.html#module-optparse) по ряду параметров, включая:15611562- Обработка позиционных аргументов.1563- Поддержка подкоманд.1564- Разрешение альтернативных префиксов параметров, например `+` и `/`.1565- Обработка аргументов в стиле «ноль или более» и «один или более».1566- Формирование более информативных сообщений об использовании.1567- Предоставление гораздо более простого интерфейса для пользовательских `type` и `action`.15681569Частичный путь перехода с [`optparse`](https://python-all.ru/2.7/library/optparse.html#module-optparse) на [`argparse`](https://python-all.ru/2.7/library/argparse.html#module-argparse):15701571- Замените все вызовы [`optparse.OptionParser.add_option()`](https://python-all.ru/2.7/library/optparse.html#optparse.OptionParser.add_option) на вызовы [`ArgumentParser.add_argument()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.add_argument).1572- Замените `(options, args) = parser.parse_args()` на `args = parser.parse_args()` и добавьте дополнительные вызовы [`ArgumentParser.add_argument()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.add_argument) для позиционных аргументов. Имейте в виду, что то, что ранее называлось `options`, теперь в контексте [`argparse`](https://python-all.ru/2.7/library/argparse.html#module-argparse) называется `args`.1573- Замените [`optparse.OptionParser.disable_interspersed_args()`](https://python-all.ru/2.7/library/optparse.html#optparse.OptionParser.disable_interspersed_args), установив `nargs` позиционного аргумента в [argparse.REMAINDER](https://python-all.ru/2.7/library/argparse.html#argparse-remainder), или используйте [`parse_known_args()`](https://python-all.ru/2.7/library/argparse.html#argparse.ArgumentParser.parse_known_args) для сбора неразобранных строк аргументов в отдельном списке.1574- Замените колбэк-действия и аргументы-ключевые слова `callback_*` на аргументы `type` или `action`.1575- Замените строковые имена для ключевых аргументов `type` соответствующими объектами типов (например, int, float, complex и т.д.).1576- Замените `optparse.Values` на [`Namespace`](https://python-all.ru/2.7/library/argparse.html#argparse.Namespace), а `optparse.OptionError` и `optparse.OptionValueError` на `ArgumentError`.1577- Замените строки с неявными аргументами, такими как `%default` или `%prog`, на стандартный синтаксис Python для использования словарей при форматировании строк, то есть `%(default)s` и `%(prog)s`.1578- Замените аргумент `version` конструктора OptionParser на вызов `parser.add_argument('--version', action='version', version='<the version>')`.1579