argparse.md

1> **Источник:** https://python-all.ru/3.11/library/argparse.html2>3> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.45---67# [`argparse`](https://python-all.ru/3.11/library/argparse.html#module-argparse) – Парсер для параметров командной строки, аргументов и подкоманд89Новое в версии 3.2.1011**Исходный код:** [Lib/argparse.py](https://python-all.ru/src/3.11/Lib/argparse.py)1213---1415Учебное пособие1617На этой странице содержится справочная информация по API. Для более плавного введения в разбор командной строки Python обратитесь к [учебному пособию по argparse](https://python-all.ru/3.11/howto/argparse.html#argparse-tutorial).1819Модуль [`argparse`](https://python-all.ru/3.11/library/argparse.html#module-argparse) упрощает создание удобных интерфейсов командной строки. Программа определяет, какие аргументы ей требуются, а [`argparse`](https://python-all.ru/3.11/library/argparse.html#module-argparse) разбирается, как извлечь их из [`sys.argv`](https://python-all.ru/3.11/library/sys.html#sys.argv). Модуль [`argparse`](https://python-all.ru/3.11/library/argparse.html#module-argparse) также автоматически генерирует сообщения справки и использования. Модуль также выводит ошибки, когда пользователи передают программе недопустимые аргументы.2021## Основная функциональность2223Поддержка модулем [`argparse`](https://python-all.ru/3.11/library/argparse.html#module-argparse) интерфейсов командной строки построена вокруг экземпляра [`argparse.ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser). Он представляет собой контейнер для спецификаций аргументов и имеет параметры, применимые ко всему парсеру:2425```python26parser = argparse.ArgumentParser(27                    prog='ProgramName',28                    description='What the program does',29                    epilog='Text at the bottom of help')30```3132Метод [`ArgumentParser.add_argument()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.add_argument) добавляет в парсер отдельные спецификации аргументов. Он поддерживает позиционные аргументы, опции, принимающие значения, и флаги вкл/выкл:3334```python35parser.add_argument('filename')           # позиционный аргумент36parser.add_argument('-c', '--count')      # опция, которая принимает значение37parser.add_argument('-v', '--verbose',38                    action='store_true')  # флаг вкл/выкл39```4041Метод [`ArgumentParser.parse_args()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.parse_args) запускает парсер и помещает извлечённые данные в объект [`argparse.Namespace`](https://python-all.ru/3.11/library/argparse.html#argparse.Namespace):4243```python44args = parser.parse_args()45print(args.filename, args.count, args.verbose)46```4748## Быстрые ссылки для add\_argument()4950| Имя | Описание | Значения |51| --- | --- | --- |52| [action](https://python-all.ru/3.11/library/argparse.html#action) | Определяет, как обрабатывать аргумент | `'store'`, `'store_const'`, `'store_true'`, `'append'`, `'append_const'`, `'count'`, `'help'`, `'version'` |53| [choices](https://python-all.ru/3.11/library/argparse.html#choices) | Ограничивает значения заданным набором вариантов | `['foo', 'bar']`, `range(1, 10)` или экземпляр [`Container`](https://python-all.ru/3.11/library/collections.abc.html#collections.abc.Container) |54| [const](https://python-all.ru/3.11/library/argparse.html#const) | Сохраняет константное значение |  |55| [default](https://python-all.ru/3.11/library/argparse.html#default) | Значение по умолчанию, используемое, когда аргумент не указан | По умолчанию `None` |56| [dest](https://python-all.ru/3.11/library/argparse.html#dest) | Указывает имя атрибута, используемое в результирующем пространстве имён |  |57| [help](https://python-all.ru/3.11/library/argparse.html#help) | Текст справки для аргумента |  |58| [metavar](https://python-all.ru/3.11/library/argparse.html#metavar) | Альтернативное отображаемое имя аргумента (в справке) |  |59| [nargs](https://python-all.ru/3.11/library/argparse.html#nargs) | Количество раз, которое можно указать аргумент | [`int`](https://python-all.ru/3.11/library/functions.html#int), `'?'`, `'*'` или `'+'` |60| [required](https://python-all.ru/3.11/library/argparse.html#required) | Указывает, обязателен ли аргумент | `True` или `False` |61| [тип](https://python-all.ru/3.11/library/argparse.html#type) | Автоматически преобразует аргумент в указанный тип | [`int`](https://python-all.ru/3.11/library/functions.html#int), [`float`](https://python-all.ru/3.11/library/functions.html#float), `argparse.FileType('w')` или вызываемая функция |6263## Пример6465Следующий код представляет собой программу на Python, которая принимает список целых чисел и выводит либо сумму, либо максимум:6667```python68import argparse6970parser = argparse.ArgumentParser(description='Process some integers.')71parser.add_argument('integers', metavar='N', type=int, nargs='+',72                    help='an integer for the accumulator')73parser.add_argument('--sum', dest='accumulate', action='store_const',74                    const=sum, default=max,75                    help='sum the integers (default: find the max)')7677args = parser.parse_args()78print(args.accumulate(args.integers))79```8081Предполагая, что приведённый выше код на Python сохранён в файл `prog.py`, его можно запустить из командной строки, и он выведет полезные справочные сообщения:8283```console84$ python prog.py -h85usage: prog.py [-h] [--sum] N [N ...]8687Process some integers.8889positional arguments:90 N           an integer for the accumulator9192options:93 -h, --help  show this help message and exit94 --sum       sum the integers (default: find the max)95```9697При запуске с соответствующими аргументами программа выводит либо сумму, либо максимум переданных целых чисел:9899```console100$ python prog.py 1 2 3 41014102103$ python prog.py 1 2 3 4 --sum10410105```106107Если переданы недопустимые аргументы, будет выведена ошибка:108109```console110$ python prog.py a b c111usage: prog.py [-h] [--sum] N [N ...]112prog.py: error: argument N: invalid int value: 'a'113```114115В следующих разделах этот пример разбирается подробно.116117### Создание парсера118119Первый шаг при использовании [`argparse`](https://python-all.ru/3.11/library/argparse.html#module-argparse) – создание объекта [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser):120121```python122>>> parser = argparse.ArgumentParser(description='Process some integers.')123```124125Объект [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser) будет содержать всю информацию, необходимую для разбора командной строки в типы данных Python.126127### Добавление аргументов128129Заполнение объекта [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser) информацией об аргументах программы выполняется вызовами метода [`add_argument()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.add_argument). В общем случае эти вызовы сообщают [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser), как преобразовывать строки командной строки в объекты. Эта информация сохраняется и используется при вызове [`parse_args()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.parse_args). Например:130131```python132>>> parser.add_argument('integers', metavar='N', type=int, nargs='+',133...                     help='an integer for the accumulator')134>>> parser.add_argument('--sum', dest='accumulate', action='store_const',135...                     const=sum, default=max,136...                     help='sum the integers (default: find the max)')137```138139Позднее вызов [`parse_args()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.parse_args) вернёт объект с двумя атрибутами: `integers` и `accumulate`. Атрибут `integers` будет списком из одного или нескольких целых чисел, а атрибут `accumulate` будет либо функцией [`sum()`](https://python-all.ru/3.11/library/functions.html#sum), если `--sum` был указан в командной строке, либо функцией [`max()`](https://python-all.ru/3.11/library/functions.html#max) в противном случае.140141### Разбор аргументов142143[`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser) разбирает аргументы с помощью метода [`parse_args()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.parse_args). Этот метод проверяет командную строку, преобразует каждый аргумент в соответствующий тип и затем выполняет необходимое действие. В большинстве случаев это означает, что простой объект [`Namespace`](https://python-all.ru/3.11/library/argparse.html#argparse.Namespace) будет составлен из атрибутов, полученных при разборе командной строки:144145```python146>>> parser.parse_args(['--sum', '7', '-1', '42'])147Namespace(accumulate=<built-in function sum>, integers=[7, -1, 42])148```149150В скрипте [`parse_args()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.parse_args) обычно вызывается без аргументов, и [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser) автоматически определяет аргументы командной строки из [`sys.argv`](https://python-all.ru/3.11/library/sys.html#sys.argv).151152## Объекты ArgumentParser153154#### `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, allow_abbrev=True, exit_on_error=True)`155156Создаёт новый объект [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser). Все параметры должны передаваться как именованные аргументы. Каждый параметр имеет собственное подробное описание ниже, но вкратце они таковы:157158- [prog](https://python-all.ru/3.11/library/argparse.html#prog) – имя программы (по умолчанию: `os.path.basename(sys.argv[0])`)159- [usage](https://python-all.ru/3.11/library/argparse.html#usage) - строка, описывающая использование программы (по умолчанию генерируется из аргументов, добавленных в парсер)160- [description](https://python-all.ru/3.11/library/argparse.html#description) - текст, отображаемый перед справкой по аргументам (по умолчанию отсутствует)161- [epilog](https://python-all.ru/3.11/library/argparse.html#epilog) - текст, отображаемый после справки по аргументам (по умолчанию отсутствует)162- [parents](https://python-all.ru/3.11/library/argparse.html#parents) - список объектов [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser), аргументы которых также должны быть включены163- [formatter\_class](https://python-all.ru/3.11/library/argparse.html#formatter-class) - класс для настройки вывода справки164- [prefix\_chars](https://python-all.ru/3.11/library/argparse.html#prefix-chars) - набор символов, которые являются префиксом необязательных аргументов (по умолчанию: ‘-‘)165- [fromfile\_prefix\_chars](https://python-all.ru/3.11/library/argparse.html#fromfile-prefix-chars) - набор символов, которые являются префиксом файлов, из которых должны читаться дополнительные аргументы (по умолчанию: `None`)166- [argument\_default](https://python-all.ru/3.11/library/argparse.html#argument-default) - глобальное значение по умолчанию для аргументов (по умолчанию: `None`)167- [conflict\_handler](https://python-all.ru/3.11/library/argparse.html#conflict-handler) - стратегия разрешения конфликтов необязательных аргументов (обычно не требуется)168- [add\_help](https://python-all.ru/3.11/library/argparse.html#add-help) - добавить опцию `-h/--help` в парсер (по умолчанию: `True`)169- [allow\_abbrev](https://python-all.ru/3.11/library/argparse.html#allow-abbrev) – позволяет сокращать длинные параметры, если сокращение однозначно. (по умолчанию: `True`)170- [exit\_on\_error](https://python-all.ru/3.11/library/argparse.html#exit-on-error) – определяет, завершает ли ArgumentParser работу с сообщением об ошибке при её возникновении. (по умолчанию: `True`)171172Изменено в версии 3.5: *allow\_abbrev* – добавлен параметр.173174Изменено в версии 3.8: В предыдущих версиях *allow\_abbrev* также отключал группировку коротких флагов, например `-vv` для обозначения `-v -v`.175176Изменено в версии 3.9: *exit\_on\_error* – добавлен параметр.177178В следующих разделах описывается, как используется каждый из этих параметров.179180### prog181182По умолчанию объекты [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser) используют `sys.argv[0]`, чтобы определить, как отображать имя программы в справке. Это поведение почти всегда желательно, поскольку справка будет соответствовать тому, как программа была вызвана из командной строки. Например, рассмотрим файл с именем `myprogram.py` со следующим кодом:183184```python185import argparse186parser = argparse.ArgumentParser()187parser.add_argument('--foo', help='foo help')188args = parser.parse_args()189```190191Справка этой программы будет отображать `myprogram.py` в качестве имени программы (независимо от того, откуда была вызвана программа):192193```console194$ python myprogram.py --help195usage: myprogram.py [-h] [--foo FOO]196197options:198 -h, --help  show this help message and exit199 --foo FOO   foo help200$ cd ..201$ python subdir/myprogram.py --help202usage: myprogram.py [-h] [--foo FOO]203204options:205 -h, --help  show this help message and exit206 --foo FOO   foo help207```208209Чтобы изменить это поведение по умолчанию, можно указать другое значение с помощью аргумента `prog=` конструктора [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser):210211```python212>>> parser = argparse.ArgumentParser(prog='myprogram')213>>> parser.print_help()214usage: myprogram [-h]215216options:217 -h, --help  show this help message and exit218```219220Обратите внимание, что имя программы, будь оно определено из `sys.argv[0]` или из аргумента `prog=`, доступно в справочных сообщениях через форматный спецификатор `%(prog)s`.221222```python223>>> parser = argparse.ArgumentParser(prog='myprogram')224>>> parser.add_argument('--foo', help='foo of the %(prog)s program')225>>> parser.print_help()226usage: myprogram [-h] [--foo FOO]227228options:229 -h, --help  show this help message and exit230 --foo FOO   foo of the myprogram program231```232233### использование234235По умолчанию [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser) формирует сообщение об использовании на основе своих аргументов:236237```python238>>> parser = argparse.ArgumentParser(prog='PROG')239>>> parser.add_argument('--foo', nargs='?', help='foo help')240>>> parser.add_argument('bar', nargs='+', help='bar help')241>>> parser.print_help()242usage: PROG [-h] [--foo [FOO]] bar [bar ...]243244positional arguments:245 bar          bar help246247options:248 -h, --help   show this help message and exit249 --foo [FOO]  foo help250```251252Сообщение по умолчанию можно переопределить с помощью именованного аргумента `usage=`:253254```python255>>> parser = argparse.ArgumentParser(prog='PROG', usage='%(prog)s [options]')256>>> parser.add_argument('--foo', nargs='?', help='foo help')257>>> parser.add_argument('bar', nargs='+', help='bar help')258>>> parser.print_help()259usage: PROG [options]260261positional arguments:262 bar          bar help263264options:265 -h, --help   show this help message and exit266 --foo [FOO]  foo help267```268269Спецификатор формата `%(prog)s` используется для подстановки имени программы в сообщения об использовании.270271### описание272273В большинстве вызовов конструктора [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser) используется именованный аргумент `description=`. Этот аргумент содержит краткое описание того, что делает программа и как она работает. В сообщениях справки это описание выводится между строкой использования командной строки и справкой по отдельным аргументам:274275```python276>>> parser = argparse.ArgumentParser(description='A foo that bars')277>>> parser.print_help()278usage: argparse.py [-h]279280A foo that bars281282options:283 -h, --help  show this help message and exit284```285286По умолчанию описание переносится по строкам, чтобы уместиться в отведённом пространстве. Чтобы изменить это поведение, обратитесь к аргументу [formatter\_class](https://python-all.ru/3.11/library/argparse.html#formatter-class).287288### эпилог289290Некоторые программы выводят дополнительное описание после описания аргументов. Такой текст можно указать с помощью аргумента `epilog=` для [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser):291292```python293>>> parser = argparse.ArgumentParser(294...     description='A foo that bars',295...     epilog="And that's how you'd foo a bar")296>>> parser.print_help()297usage: argparse.py [-h]298299A foo that bars300301options:302 -h, --help  show this help message and exit303304And that's how you'd foo a bar305```306307Как и для аргумента [description](https://python-all.ru/3.11/library/argparse.html#description), текст `epilog=` по умолчанию переносится по строкам, но это поведение можно настроить с помощью аргумента [formatter\_class](https://python-all.ru/3.11/library/argparse.html#formatter-class) для [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser).308309### родительские парсеры310311Иногда несколько парсеров используют общий набор аргументов. Вместо того чтобы повторять определения этих аргументов, можно использовать один парсер со всеми общими аргументами, передав его в аргумент `parents=` для [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser). Аргумент `parents=` принимает список объектов [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser), собирает из них все позиционные и опциональные действия и добавляет эти действия в создаваемый объект [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser):312313```python314>>> parent_parser = argparse.ArgumentParser(add_help=False)315>>> parent_parser.add_argument('--parent', type=int)316317>>> foo_parser = argparse.ArgumentParser(parents=[parent_parser])318>>> foo_parser.add_argument('foo')319>>> foo_parser.parse_args(['--parent', '2', 'XXX'])320Namespace(foo='XXX', parent=2)321322>>> bar_parser = argparse.ArgumentParser(parents=[parent_parser])323>>> bar_parser.add_argument('--bar')324>>> bar_parser.parse_args(['--bar', 'YYY'])325Namespace(bar='YYY', parent=None)326```327328Обратите внимание, что большинство родительских парсеров указывают `add_help=False`. В противном случае [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser) увидит две опции `-h/--help` (одну в родительском парсере, другую – в дочернем) и вызовет ошибку.329330> **Примечание**331>332> Парсеры должны быть полностью инициализированы перед передачей через `parents=`. Если изменить родительские парсеры после создания дочернего, эти изменения не отразятся на дочернем парсере.333334### класс форматирования335336Объекты [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser) позволяют настраивать форматирование справки, указывая альтернативный класс форматирования. На данный момент существует четыре таких класса:337338#### `class argparse.RawDescriptionHelpFormatter`339340#### `class argparse.RawTextHelpFormatter`341342#### `class argparse.ArgumentDefaultsHelpFormatter`343344#### `class argparse.MetavarTypeHelpFormatter`345346[`RawDescriptionHelpFormatter`](https://python-all.ru/3.11/library/argparse.html#argparse.RawDescriptionHelpFormatter) и [`RawTextHelpFormatter`](https://python-all.ru/3.11/library/argparse.html#argparse.RawTextHelpFormatter) дают больше контроля над отображением текстовых описаний. По умолчанию объекты [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser) переносят текст [description](https://python-all.ru/3.11/library/argparse.html#description) и [epilog](https://python-all.ru/3.11/library/argparse.html#epilog) в сообщениях справки командной строки:347348```python349>>> parser = argparse.ArgumentParser(350...     prog='PROG',351...     description='''this description352...         was indented weird353...             but that is okay''',354...     epilog='''355...             likewise for this epilog whose whitespace will356...         be cleaned up and whose words will be wrapped357...         across a couple lines''')358>>> parser.print_help()359usage: PROG [-h]360361this description was indented weird but that is okay362363options:364 -h, --help  show this help message and exit365366likewise for this epilog whose whitespace will be cleaned up and whose words367will be wrapped across a couple lines368```369370Передача [`RawDescriptionHelpFormatter`](https://python-all.ru/3.11/library/argparse.html#argparse.RawDescriptionHelpFormatter) в качестве `formatter_class=` означает, что [description](https://python-all.ru/3.11/library/argparse.html#description) и [epilog](https://python-all.ru/3.11/library/argparse.html#epilog) уже правильно отформатированы и не должны переноситься по строкам:371372```python373>>> parser = argparse.ArgumentParser(374...     prog='PROG',375...     formatter_class=argparse.RawDescriptionHelpFormatter,376...     description=textwrap.dedent('''\377...         Please do not mess up this text!378...         --------------------------------379...             I have indented it380...             exactly the way381...             I want it382...         '''))383>>> parser.print_help()384usage: PROG [-h]385386Please do not mess up this text!387--------------------------------388   I have indented it389   exactly the way390   I want it391392options:393 -h, --help  show this help message and exit394```395396[`RawTextHelpFormatter`](https://python-all.ru/3.11/library/argparse.html#argparse.RawTextHelpFormatter) сохраняет пробелы во всех видах текста справки, включая описания аргументов. Однако множественные переносы строк заменяются одним. Если нужно сохранить несколько пустых строк, добавьте пробелы между переносами.397398[`ArgumentDefaultsHelpFormatter`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentDefaultsHelpFormatter) автоматически добавляет информацию о значениях по умолчанию в сообщения справки каждого аргумента:399400```python401>>> parser = argparse.ArgumentParser(402...     prog='PROG',403...     formatter_class=argparse.ArgumentDefaultsHelpFormatter)404>>> parser.add_argument('--foo', type=int, default=42, help='FOO!')405>>> parser.add_argument('bar', nargs='*', default=[1, 2, 3], help='BAR!')406>>> parser.print_help()407usage: PROG [-h] [--foo FOO] [bar ...]408409positional arguments:410 bar         BAR! (default: [1, 2, 3])411412options:413 -h, --help  show this help message and exit414 --foo FOO   FOO! (default: 42)415```416417[`MetavarTypeHelpFormatter`](https://python-all.ru/3.11/library/argparse.html#argparse.MetavarTypeHelpFormatter) использует имя аргумента [type](https://python-all.ru/3.11/library/argparse.html#type) для каждого аргумента в качестве отображаемого имени для его значений (вместо [dest](https://python-all.ru/3.11/library/argparse.html#dest), как это делает обычный форматировщик):418419```python420>>> parser = argparse.ArgumentParser(421...     prog='PROG',422...     formatter_class=argparse.MetavarTypeHelpFormatter)423>>> parser.add_argument('--foo', type=int)424>>> parser.add_argument('bar', type=float)425>>> parser.print_help()426usage: PROG [-h] [--foo int] float427428positional arguments:429  float430431options:432  -h, --help  show this help message and exit433  --foo int434```435436### символы префикса437438Большинство параметров командной строки используют `-` в качестве префикса, например `-f/--foo`. Парсеры, которым нужно поддерживать другие или дополнительные символы префикса, например для параметров вроде `+f` или `/foo`, могут указать их с помощью аргумента `prefix_chars=` конструктора ArgumentParser:439440```python441>>> parser = argparse.ArgumentParser(prog='PROG', prefix_chars='-+')442>>> parser.add_argument('+f')443>>> parser.add_argument('++bar')444>>> parser.parse_args('+f X ++bar Y'.split())445Namespace(bar='Y', f='X')446```447448Аргумент `prefix_chars=` по умолчанию равен `'-'`. Если указать набор символов, не включающий `-`, то опции `-f/--foo` будут запрещены.449450### символы префикса из файла451452Иногда при работе с особенно длинным списком аргументов может иметь смысл хранить список аргументов в файле, а не набирать его в командной строке. Если аргумент `fromfile_prefix_chars=` передан конструктору [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser), то аргументы, начинающиеся с любого из указанных символов, будут рассматриваться как файлы и заменяться на содержащиеся в них аргументы. Например:453454```python455>>> with open('args.txt', 'w') as fp:456...     fp.write('-f\nbar')457>>> parser = argparse.ArgumentParser(fromfile_prefix_chars='@')458>>> parser.add_argument('-f')459>>> parser.parse_args(['-f', 'foo', '@args.txt'])460Namespace(f='bar')461```462463Аргументы, читаемые из файла, по умолчанию должны быть по одному на строку (но см. также [`convert_arg_line_to_args()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.convert_arg_line_to_args)) и обрабатываются так, как если бы они находились на том же месте, что и исходный файл, ссылающийся на аргумент в командной строке. Таким образом, в приведённом примере выражение `['-f', 'foo', '@args.txt']` считается эквивалентным выражению `['-f', 'foo', '-f', 'bar']`.464465Аргумент `fromfile_prefix_chars=` по умолчанию равен `None`, что означает, что аргументы никогда не будут рассматриваться как ссылки на файлы.466467### argument\_default468469Обычно значения аргументов по умолчанию задаются либо передачей значения по умолчанию в [`add_argument()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.add_argument), либо вызовом методов [`set_defaults()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.set_defaults) с определённым набором пар имя-значение. Однако иногда может быть полезно указать единое значение по умолчанию для всех аргументов синтаксического анализатора. Это можно сделать, передав именованный аргумент `argument_default=` в [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser). Например, чтобы глобально отключить создание атрибутов при вызовах [`parse_args()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.parse_args), укажите `argument_default=SUPPRESS`:470471```python472>>> parser = argparse.ArgumentParser(argument_default=argparse.SUPPRESS)473>>> parser.add_argument('--foo')474>>> parser.add_argument('bar', nargs='?')475>>> parser.parse_args(['--foo', '1', 'BAR'])476Namespace(bar='BAR', foo='1')477>>> parser.parse_args([])478Namespace()479```480481### allow\_abbrev482483Обычно при передаче списка аргументов методу [`parse_args()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.parse_args) объекта [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser) он [распознаёт сокращения](https://python-all.ru/3.11/library/argparse.html#prefix-matching) длинных опций.484485Эту возможность можно отключить, установив `allow_abbrev` в `False`:486487```python488>>> parser = argparse.ArgumentParser(prog='PROG', allow_abbrev=False)489>>> parser.add_argument('--foobar', action='store_true')490>>> parser.add_argument('--foonley', action='store_false')491>>> parser.parse_args(['--foon'])492usage: PROG [-h] [--foobar] [--foonley]493PROG: error: unrecognized arguments: --foon494```495496Новое в версии 3.5.497498### conflict\_handler499500Объекты [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser) не допускают два действия с одной и той же строкой опции. По умолчанию объекты [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser) вызывают исключение при попытке создать аргумент со строкой опции, которая уже используется:501502```python503>>> parser = argparse.ArgumentParser(prog='PROG')504>>> parser.add_argument('-f', '--foo', help='old foo help')505>>> parser.add_argument('--foo', help='new foo help')506Traceback (most recent call last):507 ..508ArgumentError: argument --foo: conflicting option string(s): --foo509```510511Иногда (например, при использовании [parents](https://python-all.ru/3.11/library/argparse.html#parents)) бывает полезно просто переопределить все старые аргументы с той же строкой опции. Для получения такого поведения значение `'resolve'` можно передать в аргумент `conflict_handler=` функции [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser):512513```python514>>> parser = argparse.ArgumentParser(prog='PROG', conflict_handler='resolve')515>>> parser.add_argument('-f', '--foo', help='old foo help')516>>> parser.add_argument('--foo', help='new foo help')517>>> parser.print_help()518usage: PROG [-h] [-f FOO] [--foo FOO]519520options:521 -h, --help  show this help message and exit522 -f FOO      old foo help523 --foo FOO   new foo help524```525526Обратите внимание, что объекты [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser) удаляют действие только в том случае, если все его строки опций переопределены. Поэтому в приведённом выше примере старое действие `-f/--foo` сохраняется как действие `-f`, поскольку была переопределена только строка опции `--foo`.527528### add\_help529530По умолчанию объекты ArgumentParser добавляют параметр, который просто показывает справку парсера. Например, рассмотрим файл с именем `myprogram.py`, содержащий следующий код:531532```python533import argparse534parser = argparse.ArgumentParser()535parser.add_argument('--foo', help='foo help')536args = parser.parse_args()537```538539Если указать `-h` или `--help` в командной строке, будет выведена справка ArgumentParser:540541```console542$ python myprogram.py --help543usage: myprogram.py [-h] [--foo FOO]544545options:546 -h, --help  show this help message and exit547 --foo FOO   foo help548```549550Иногда может быть полезно отключить добавление этой опции справки. Это можно сделать, передав `False` в качестве аргумента `add_help=` функции [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser):551552```python553>>> parser = argparse.ArgumentParser(prog='PROG', add_help=False)554>>> parser.add_argument('--foo', help='foo help')555>>> parser.print_help()556usage: PROG [--foo FOO]557558options:559 --foo FOO  foo help560```561562Обычно опция справки – это `-h/--help`. Исключение составляет случай, когда указан `prefix_chars=` и не включает `-`; в этом случае `-h` и `--help` не являются допустимыми опциями. В таком случае первый символ в `prefix_chars` используется в качестве префикса для опций справки:563564```python565>>> parser = argparse.ArgumentParser(prog='PROG', prefix_chars='+/')566>>> parser.print_help()567usage: PROG [+h]568569options:570  +h, ++help  show this help message and exit571```572573### exit\_on\_error574575Обычно при передаче недопустимого списка аргументов методу [`parse_args()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.parse_args) объекта [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser) происходит завершение с сообщением об ошибке.576577Если требуется перехватывать ошибки вручную, эту возможность можно включить, установив `exit_on_error` в `False`:578579```python580>>> parser = argparse.ArgumentParser(exit_on_error=False)581>>> parser.add_argument('--integers', type=int)582_StoreAction(option_strings=['--integers'], dest='integers', nargs=None, const=None, default=None, type=<class 'int'>, choices=None, help=None, metavar=None)583>>> try:584...     parser.parse_args('--integers a'.split())585... except argparse.ArgumentError:586...     print('Catching an argumentError')587...588Catching an argumentError589```590591Новое в версии 3.9.592593## Метод add\_argument()594595#### `ArgumentParser.add_argument(name or flags...[, action][, nargs][, const][, default][, type][, choices][, required][, help][, metavar][, dest])`596597Определяет, как должен разбираться один аргумент командной строки. Каждый параметр подробно описан ниже, а кратко они таковы:598599- [name or flags](https://python-all.ru/3.11/library/argparse.html#id5) – имя или список строк параметров, например `foo` или `-f, --foo`.600- [action](https://python-all.ru/3.11/library/argparse.html#action) – базовый тип действия, которое выполняется при встрече этого аргумента в командной строке.601- [nargs](https://python-all.ru/3.11/library/argparse.html#nargs) – количество аргументов командной строки, которое должно быть потреблено.602- [const](https://python-all.ru/3.11/library/argparse.html#const) – постоянное значение, требуемое некоторыми значениями [action](https://python-all.ru/3.11/library/argparse.html#action) и [nargs](https://python-all.ru/3.11/library/argparse.html#nargs).603- [default](https://python-all.ru/3.11/library/argparse.html#default) – значение, которое используется, если аргумент отсутствует в командной строке и в объекте namespace.604- [type](https://python-all.ru/3.11/library/argparse.html#type) – тип, в который следует преобразовать аргумент командной строки.605- [choices](https://python-all.ru/3.11/library/argparse.html#choices) – последовательность допустимых значений для аргумента.606- [required](https://python-all.ru/3.11/library/argparse.html#required) – может ли параметр командной строки быть опущен (только для опциональных параметров).607- [help](https://python-all.ru/3.11/library/argparse.html#help) – краткое описание того, что делает аргумент.608- [metavar](https://python-all.ru/3.11/library/argparse.html#metavar) – имя аргумента в сообщениях об использовании.609- [dest](https://python-all.ru/3.11/library/argparse.html#dest) – имя атрибута, добавляемого в объект, возвращаемый [`parse_args()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.parse_args).610611В следующих разделах описывается, как используется каждый из этих параметров.612613### имя или флаги614615Методу [`add_argument()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.add_argument) необходимо знать, ожидается ли опциональный аргумент (например, `-f` или `--foo`) или позиционный (например, список имён файлов). Поэтому первыми аргументами, передаваемыми в [`add_argument()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.add_argument), должны быть либо серия флагов, либо просто имя аргумента.616617Например, опциональный аргумент можно создать так:618619```python620>>> parser.add_argument('-f', '--foo')621```622623а позиционный – так:624625```python626>>> parser.add_argument('bar')627```628629При вызове [`parse_args()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.parse_args) опциональные аргументы опознаются по префиксу `-`, а остальные аргументы считаются позиционными:630631```python632>>> parser = argparse.ArgumentParser(prog='PROG')633>>> parser.add_argument('-f', '--foo')634>>> parser.add_argument('bar')635>>> parser.parse_args(['BAR'])636Namespace(bar='BAR', foo=None)637>>> parser.parse_args(['BAR', '--foo', 'FOO'])638Namespace(bar='BAR', foo='FOO')639>>> parser.parse_args(['--foo', 'FOO'])640usage: PROG [-h] [-f FOO] bar641PROG: error: the following arguments are required: bar642```643644### action645646Объекты [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser) связывают аргументы командной строки с действиями. Эти действия могут делать с аргументами практически что угодно, но чаще всего они просто добавляют атрибут в объект, возвращаемый [`parse_args()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.parse_args). Ключевой аргумент `action` определяет, как следует обрабатывать аргументы командной строки. Доступны следующие действия:647648- `'store'` – просто сохраняет значение аргумента. Это действие по умолчанию. Например:649650  ```python651  >>> parser = argparse.ArgumentParser()652  >>> parser.add_argument('--foo')653  >>> parser.parse_args('--foo 1'.split())654  Namespace(foo='1')655  ```656- `'store_const'` – сохраняет значение, указанное ключевым аргументом [const](https://python-all.ru/3.11/library/argparse.html#const); обратите внимание, что ключевой аргумент [const](https://python-all.ru/3.11/library/argparse.html#const) по умолчанию равен `None`. Действие `'store_const'` чаще всего используется с опциональными аргументами, задающими какой-либо флаг. Например:657658  ```python659  >>> parser = argparse.ArgumentParser()660  >>> parser.add_argument('--foo', action='store_const', const=42)661  >>> parser.parse_args(['--foo'])662  Namespace(foo=42)663  ```664- `'store_true'` и `'store_false'` – это частные случаи `'store_const'`, используемые для хранения значений `True` и `False` соответственно. Кроме того, они создают значения по умолчанию `False` и `True` соответственно. Например:665666  ```python667  >>> parser = argparse.ArgumentParser()668  >>> parser.add_argument('--foo', action='store_true')669  >>> parser.add_argument('--bar', action='store_false')670  >>> parser.add_argument('--baz', action='store_false')671  >>> parser.parse_args('--foo --bar'.split())672  Namespace(foo=True, bar=False, baz=True)673  ```674- `'append'` – сохраняет список и добавляет в него каждое значение аргумента. Это полезно, чтобы разрешить указывать параметр несколько раз. Если значение по умолчанию не пусто, элементы по умолчанию будут присутствовать в разобранном значении для этого параметра, а все значения из командной строки будут добавлены после них. Пример использования:675676  ```python677  >>> parser = argparse.ArgumentParser()678  >>> parser.add_argument('--foo', action='append')679  >>> parser.parse_args('--foo 1 --foo 2'.split())680  Namespace(foo=['1', '2'])681  ```682- `'append_const'` – сохраняет список и добавляет в него значение, указанное ключевым аргументом [const](https://python-all.ru/3.11/library/argparse.html#const); обратите внимание, что ключевой аргумент [const](https://python-all.ru/3.11/library/argparse.html#const) по умолчанию равен `None`. Действие `'append_const'` обычно полезно, когда несколько аргументов должны сохранять константы в один и тот же список. Например:683684  ```python685  >>> parser = argparse.ArgumentParser()686  >>> parser.add_argument('--str', dest='types', action='append_const', const=str)687  >>> parser.add_argument('--int', dest='types', action='append_const', const=int)688  >>> parser.parse_args('--str --int'.split())689  Namespace(types=[<class 'str'>, <class 'int'>])690  ```691- `'count'` – подсчитывает, сколько раз встречается именованный аргумент. Например, это полезно для повышения уровня подробности вывода:692693  ```python694  >>> parser = argparse.ArgumentParser()695  >>> parser.add_argument('--verbose', '-v', action='count', default=0)696  >>> parser.parse_args(['-vvv'])697  Namespace(verbose=3)698  ```699700  Обратите внимание: значение *default* будет `None`, если только оно явно не установлено в *0*.701- `'help'` – выводит полное справочное сообщение для всех параметров текущего анализатора и завершает работу. По умолчанию действие справки автоматически добавляется в анализатор. Подробности о том, как формируется вывод, см. в [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser).702- `'version'` – ожидает именованный аргумент `version=` в вызове [`add_argument()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.add_argument) и при вызове выводит информацию о версии и завершает работу:703704  ```python705  >>> import argparse706  >>> parser = argparse.ArgumentParser(prog='PROG')707  >>> parser.add_argument('--version', action='version', version='%(prog)s 2.0')708  >>> parser.parse_args(['--version'])709  PROG 2.0710  ```711- `'extend'` – сохраняет список и добавляет каждое значение аргумента в этот список. Пример использования:712713  ```python714  >>> parser = argparse.ArgumentParser()715  >>> parser.add_argument("--foo", action="extend", nargs="+", type=str)716  >>> parser.parse_args(["--foo", "f1", "--foo", "f2", "f3", "f4"])717  Namespace(foo=['f1', 'f2', 'f3', 'f4'])718  ```719720  Новое в версии 3.8.721722Также можно задать произвольное действие, передав подкласс Action или другой объект, реализующий тот же интерфейс. `BooleanOptionalAction` доступен в `argparse` и добавляет поддержку булевых действий, таких как `--foo` и `--no-foo`:723724```python725>>> import argparse726>>> parser = argparse.ArgumentParser()727>>> parser.add_argument('--foo', action=argparse.BooleanOptionalAction)728>>> parser.parse_args(['--no-foo'])729Namespace(foo=False)730```731732Новое в версии 3.9.733734Рекомендуемый способ создания пользовательского действия – расширить [`Action`](https://python-all.ru/3.11/library/argparse.html#argparse.Action), переопределив метод `__call__` и, при необходимости, методы `__init__` и `format_usage`.735736Пример пользовательского действия:737738```python739>>> class FooAction(argparse.Action):740...     def __init__(self, option_strings, dest, nargs=None, **kwargs):741...         if nargs is not None:742...             raise ValueError("nargs not allowed")743...         super().__init__(option_strings, dest, **kwargs)744...     def __call__(self, parser, namespace, values, option_string=None):745...         print('%r %r %r' % (namespace, values, option_string))746...         setattr(namespace, self.dest, values)747...748>>> parser = argparse.ArgumentParser()749>>> parser.add_argument('--foo', action=FooAction)750>>> parser.add_argument('bar', action=FooAction)751>>> args = parser.parse_args('1 --foo 2'.split())752Namespace(bar=None, foo=None) '1' None753Namespace(bar='1', foo=None) '2' '--foo'754>>> args755Namespace(bar='1', foo='2')756```757758Подробнее см. в [`Action`](https://python-all.ru/3.11/library/argparse.html#argparse.Action).759760### nargs761762Объекты ArgumentParser обычно связывают один аргумент командной строки с одним действием. Именованный аргумент `nargs` связывает другое количество аргументов командной строки с одним действием. Допустимые значения:763764- `N` (целое число). Аргументы `N` из командной строки будут собраны в список. Например:765766  ```python767  >>> parser = argparse.ArgumentParser()768  >>> parser.add_argument('--foo', nargs=2)769  >>> parser.add_argument('bar', nargs=1)770  >>> parser.parse_args('c --foo a b'.split())771  Namespace(bar=['c'], foo=['a', 'b'])772  ```773774  Обратите внимание, что `nargs=1` создаёт список из одного элемента. Это отличается от поведения по умолчанию, при котором элемент создаётся сам по себе.775776- `'?'`. Если возможно, будет потреблён один аргумент командной строки и выдан как отдельный элемент. Если аргумент командной строки отсутствует, будет выдано значение из [default](https://python-all.ru/3.11/library/argparse.html#default). Обратите внимание, что для необязательных аргументов есть дополнительный случай: строка параметра присутствует, но за ней не следует аргумент командной строки. В этом случае будет выдано значение из [const](https://python-all.ru/3.11/library/argparse.html#const). Некоторые примеры для иллюстрации:777778  ```python779  >>> parser = argparse.ArgumentParser()780  >>> parser.add_argument('--foo', nargs='?', const='c', default='d')781  >>> parser.add_argument('bar', nargs='?', default='d')782  >>> parser.parse_args(['XX', '--foo', 'YY'])783  Namespace(bar='XX', foo='YY')784  >>> parser.parse_args(['XX', '--foo'])785  Namespace(bar='XX', foo='c')786  >>> parser.parse_args([])787  Namespace(bar='d', foo='d')788  ```789790  Одно из наиболее распространённых применений `nargs='?'` – разрешение необязательных входных и выходных файлов:791792  ```python793  >>> parser = argparse.ArgumentParser()794  >>> parser.add_argument('infile', nargs='?', type=argparse.FileType('r'),795  ...                     default=sys.stdin)796  >>> parser.add_argument('outfile', nargs='?', type=argparse.FileType('w'),797  ...                     default=sys.stdout)798  >>> parser.parse_args(['input.txt', 'output.txt'])799  Namespace(infile=<_io.TextIOWrapper name='input.txt' encoding='UTF-8'>,800            outfile=<_io.TextIOWrapper name='output.txt' encoding='UTF-8'>)801  >>> parser.parse_args([])802  Namespace(infile=<_io.TextIOWrapper name='<stdin>' encoding='UTF-8'>,803            outfile=<_io.TextIOWrapper name='<stdout>' encoding='UTF-8'>)804  ```805806- `'*'`. Все присутствующие аргументы командной строки собираются в список. Обратите внимание, что обычно не имеет смысла указывать более одного позиционного аргумента с `nargs='*'`, но возможно несколько необязательных аргументов с `nargs='*'`. Например:807808  ```python809  >>> parser = argparse.ArgumentParser()810  >>> parser.add_argument('--foo', nargs='*')811  >>> parser.add_argument('--bar', nargs='*')812  >>> parser.add_argument('baz', nargs='*')813  >>> parser.parse_args('a b --foo x y --bar 1 2'.split())814  Namespace(bar=['1', '2'], baz=['a', 'b'], foo=['x', 'y'])815  ```816817- `'+'`. Как и `'*'`, все присутствующие аргументы командной строки собираются в список. Кроме того, будет выдано сообщение об ошибке, если не было хотя бы одного аргумента командной строки. Например:818819  ```python820  >>> parser = argparse.ArgumentParser(prog='PROG')821  >>> parser.add_argument('foo', nargs='+')822  >>> parser.parse_args(['a', 'b'])823  Namespace(foo=['a', 'b'])824  >>> parser.parse_args([])825  usage: PROG [-h] foo [foo ...]826  PROG: error: the following arguments are required: foo827  ```828829Если именованный аргумент `nargs` не указан, количество потребляемых аргументов определяется действием [action](https://python-all.ru/3.11/library/argparse.html#action). Обычно это означает, что будет потреблён один аргумент командной строки и создан один элемент (не список).830831### const832833Аргумент `const` функции [`add_argument()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.add_argument) используется для хранения постоянных значений, которые не считываются из командной строки, но требуются для различных действий [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser). Два наиболее распространённых его применения:834835- Когда [`add_argument()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.add_argument) вызывается с `action='store_const'` или `action='append_const'`. Эти действия добавляют значение `const` к одному из атрибутов объекта, возвращаемого [`parse_args()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.parse_args). Примеры см. в описании [action](https://python-all.ru/3.11/library/argparse.html#action). Если `const` не передан в [`add_argument()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.add_argument), он получит значение по умолчанию `None`.836- Когда [`add_argument()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.add_argument) вызывается со строками параметров (например, `-f` или `--foo`) и `nargs='?'`. Это создаёт дополнительный аргумент, за которым может следовать ноль или один аргумент командной строки. При разборе командной строки, если строка параметра встречена без следующего за ней аргумента командной строки, значение `const` будет считаться равным `None`. См. описание [nargs](https://python-all.ru/3.11/library/argparse.html#nargs) с примерами.837838Изменено в версии 3.11: `const=None` по умолчанию, в том числе когда `action='append_const'` или `action='store_const'`.839840### default841842Все необязательные аргументы и некоторые позиционные аргументы могут быть опущены в командной строке. Именованный аргумент `default` функции [`add_argument()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.add_argument), значение которого по умолчанию равно `None`, указывает, какое значение следует использовать, если аргумент командной строки отсутствует. Для необязательных аргументов значение `default` используется, когда строка параметра отсутствовала в командной строке:843844```python845>>> parser = argparse.ArgumentParser()846>>> parser.add_argument('--foo', default=42)847>>> parser.parse_args(['--foo', '2'])848Namespace(foo='2')849>>> parser.parse_args([])850Namespace(foo=42)851```852853Если в целевом пространстве имён уже установлен атрибут, действие *default* не перезапишет его:854855```python856>>> parser = argparse.ArgumentParser()857>>> parser.add_argument('--foo', default=42)858>>> parser.parse_args([], namespace=argparse.Namespace(foo=101))859Namespace(foo=101)860```861862Если значение `default` является строкой, анализатор разбирает его так, как если бы это был аргумент командной строки. В частности, анализатор применяет любой аргумент преобразования [type](https://python-all.ru/3.11/library/argparse.html#type), если он указан, перед установкой атрибута в возвращаемом значении [`Namespace`](https://python-all.ru/3.11/library/argparse.html#argparse.Namespace). В противном случае анализатор использует значение как есть:863864```python865>>> parser = argparse.ArgumentParser()866>>> parser.add_argument('--length', default='10', type=int)867>>> parser.add_argument('--width', default=10.5, type=int)868>>> parser.parse_args()869Namespace(length=10, width=10.5)870```871872Для позиционных аргументов с [nargs](https://python-all.ru/3.11/library/argparse.html#nargs), равным `?` или `*`, значение `default` используется, когда аргумент командной строки отсутствовал:873874```python875>>> parser = argparse.ArgumentParser()876>>> parser.add_argument('foo', nargs='?', default=42)877>>> parser.parse_args(['a'])878Namespace(foo='a')879>>> parser.parse_args([])880Namespace(foo=42)881```882883Указание `default=argparse.SUPPRESS` приводит к тому, что атрибут не добавляется, если аргумент командной строки отсутствовал:884885```python886>>> parser = argparse.ArgumentParser()887>>> parser.add_argument('--foo', default=argparse.SUPPRESS)888>>> parser.parse_args([])889Namespace()890>>> parser.parse_args(['--foo', '1'])891Namespace(foo='1')892```893894### тип895896По умолчанию анализатор считывает аргументы командной строки как простые строки. Однако довольно часто строку командной строки следует интерпретировать как другой тип, например [`float`](https://python-all.ru/3.11/library/functions.html#float) или [`int`](https://python-all.ru/3.11/library/functions.html#int). Именованный аргумент `type` функции [`add_argument()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.add_argument) позволяет выполнять любые необходимые проверки и преобразования типов.897898Если именованный аргумент [type](https://python-all.ru/3.11/library/argparse.html#type) используется вместе с [default](https://python-all.ru/3.11/library/argparse.html#default), преобразователь типа применяется только в том случае, если значение по умолчанию является строкой.899900Аргумент `type` может быть любым вызываемым объектом, принимающим одну строку. Если функция вызывает исключения [`ArgumentTypeError`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentTypeError), [`TypeError`](https://python-all.ru/3.11/library/exceptions.html#TypeError) или [`ValueError`](https://python-all.ru/3.11/library/exceptions.html#ValueError), оно перехватывается и отображается красиво отформатированное сообщение об ошибке. Другие типы исключений не обрабатываются.901902Распространённые встроенные типы и функции можно использовать в качестве преобразователей типов:903904```python905import argparse906import pathlib907908parser = argparse.ArgumentParser()909parser.add_argument('count', type=int)910parser.add_argument('distance', type=float)911parser.add_argument('street', type=ascii)912parser.add_argument('code_point', type=ord)913parser.add_argument('source_file', type=open)914parser.add_argument('dest_file', type=argparse.FileType('w', encoding='latin-1'))915parser.add_argument('datapath', type=pathlib.Path)916```917918Пользовательские функции также можно использовать:919920```pycon921>>> def hyphenated(string):922...     return '-'.join([word[:4] for word in string.casefold().split()])923...924>>> parser = argparse.ArgumentParser()925>>> _ = parser.add_argument('short_title', type=hyphenated)926>>> parser.parse_args(['"The Tale of Two Cities"'])927Namespace(short_title='"the-tale-of-two-citi')928```929930Функция [`bool()`](https://python-all.ru/3.11/library/functions.html#bool) не рекомендуется в качестве преобразователя типов. Она лишь преобразует пустые строки в `False`, а непустые – в `True`. Обычно это не то, что нужно.931932В целом, ключевое слово `type` – это удобство, которое следует использовать только для простых преобразований, способных вызывать лишь одно из трёх поддерживаемых исключений. Всё, что связано с более сложной обработкой ошибок или управлением ресурсами, должно выполняться ниже по потоку после разбора аргументов.933934Например, преобразования JSON или YAML содержат сложные случаи ошибок, которые требуют более детального отчёта, чем может дать ключевое слово `type`. Сообщение [`JSONDecodeError`](https://python-all.ru/3.11/library/json.html#json.JSONDecodeError) не будет хорошо отформатировано, а исключение [`FileNotFoundError`](https://python-all.ru/3.11/library/exceptions.html#FileNotFoundError) вообще не будет обработано.935936Даже [`FileType`](https://python-all.ru/3.11/library/argparse.html#argparse.FileType) имеет свои ограничения при использовании с ключевым словом `type`. Если один аргумент использует *FileType*, а затем следующий аргумент завершается ошибкой, сообщается об ошибке, но файл не закрывается автоматически. В этом случае лучше подождать, пока парсер завершит работу, а затем использовать оператор [`with`](https://python-all.ru/3.11/reference/compound_stmts.html#with) для управления файлами.937938Для проверок типов, которые просто сравнивают с фиксированным набором значений, рассмотрите вместо этого использование ключевого слова [choices](https://python-all.ru/3.11/library/argparse.html#choices).939940### choices941942Некоторые аргументы командной строки должны выбираться из ограниченного набора значений. Это можно обработать, передав объект-последовательность в качестве ключевого аргумента *choices* в [`add_argument()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.add_argument). При разборе командной строки значения аргументов будут проверены, и если аргумент не окажется среди допустимых значений, будет выведено сообщение об ошибке:943944```python945>>> parser = argparse.ArgumentParser(prog='game.py')946>>> parser.add_argument('move', choices=['rock', 'paper', 'scissors'])947>>> parser.parse_args(['rock'])948Namespace(move='rock')949>>> parser.parse_args(['fire'])950usage: game.py [-h] {rock,paper,scissors}951game.py: error: argument move: invalid choice: 'fire' (choose from 'rock',952'paper', 'scissors')953```954955Обратите внимание, что включение в последовательность *choices* проверяется после выполнения преобразований [type](https://python-all.ru/3.11/library/argparse.html#type), поэтому тип объектов в последовательности *choices* должен соответствовать указанному [type](https://python-all.ru/3.11/library/argparse.html#type).956957```python958>>> parser = argparse.ArgumentParser(prog='doors.py')959>>> parser.add_argument('door', type=int, choices=range(1, 4))960>>> print(parser.parse_args(['3']))961Namespace(door=3)962>>> parser.parse_args(['4'])963usage: doors.py [-h] {1,2,3}964doors.py: error: argument door: invalid choice: 4 (choose from 1, 2, 3)965```966967В качестве значения *choices* можно передать любую последовательность, поэтому поддерживаются объекты [`list`](https://python-all.ru/3.11/library/stdtypes.html#list), объекты [`tuple`](https://python-all.ru/3.11/library/stdtypes.html#tuple) и пользовательские последовательности.968969Использование [`enum.Enum`](https://python-all.ru/3.11/library/enum.html#enum.Enum) не рекомендуется, поскольку сложно контролировать его отображение в сообщениях об использовании, справке и ошибках.970971Форматированные choices переопределяют значение *metavar* по умолчанию, которое обычно выводится из *dest*. Обычно это именно то, что нужно, поскольку пользователь никогда не видит параметр *dest*. Если такое отображение нежелательно (например, из-за большого количества вариантов), просто укажите явный [metavar](https://python-all.ru/3.11/library/argparse.html#metavar).972973### required974975В целом, модуль [`argparse`](https://python-all.ru/3.11/library/argparse.html#module-argparse) предполагает, что флаги вида `-f` и `--bar` обозначают *необязательные* аргументы, которые всегда можно опустить в командной строке. Чтобы сделать опцию *обязательной*, для ключевого аргумента `required=` функции [`add_argument()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.add_argument) можно указать `True`:976977```python978>>> parser = argparse.ArgumentParser()979>>> parser.add_argument('--foo', required=True)980>>> parser.parse_args(['--foo', 'BAR'])981Namespace(foo='BAR')982>>> parser.parse_args([])983usage: [-h] --foo FOO984: error: the following arguments are required: --foo985```986987Как показано в примере, если опция помечена как `required`, [`parse_args()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.parse_args) сообщит об ошибке, если эта опция отсутствует в командной строке.988989> **Примечание**990>991> Обязательные опции обычно считаются дурным тоном, поскольку пользователи ожидают, что *опции* будут *необязательными*, поэтому их следует по возможности избегать.992993### help994995Значение `help` – это строка, содержащая краткое описание аргумента. Когда пользователь запрашивает справку (обычно с помощью `-h` или `--help` в командной строке), эти описания `help` отображаются для каждого аргумента:996997```python998>>> parser = argparse.ArgumentParser(prog='frobble')999>>> parser.add_argument('--foo', action='store_true',1000...                     help='foo the bars before frobbling')1001>>> parser.add_argument('bar', nargs='+',1002...                     help='one of the bars to be frobbled')1003>>> parser.parse_args(['-h'])1004usage: frobble [-h] [--foo] bar [bar ...]10051006positional arguments:1007 bar     one of the bars to be frobbled10081009options:1010 -h, --help  show this help message and exit1011 --foo   foo the bars before frobbling1012```10131014Строки `help` могут содержать различные спецификаторы формата, чтобы избежать повторения таких элементов, как имя программы или [значение по умолчанию](https://python-all.ru/3.11/library/argparse.html#default) аргумента. Доступные спецификаторы включают имя программы, `%(prog)s` и большинство ключевых аргументов функции [`add_argument()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.add_argument), например `%(default)s`, `%(type)s` и т.д.:10151016```python1017>>> parser = argparse.ArgumentParser(prog='frobble')1018>>> parser.add_argument('bar', nargs='?', type=int, default=42,1019...                     help='the bar to %(prog)s (default: %(default)s)')1020>>> parser.print_help()1021usage: frobble [-h] [bar]10221023positional arguments:1024 bar     the bar to frobble (default: 42)10251026options:1027 -h, --help  show this help message and exit1028```10291030Поскольку строка справки поддерживает %-форматирование, если требуется, чтобы в ней отображался литерал `%`, его нужно экранировать как `%%`.10311032[`argparse`](https://python-all.ru/3.11/library/argparse.html#module-argparse) поддерживает скрытие записи справки для определённых опций путём установки значения `help` в `argparse.SUPPRESS`:10331034```python1035>>> parser = argparse.ArgumentParser(prog='frobble')1036>>> parser.add_argument('--foo', help=argparse.SUPPRESS)1037>>> parser.print_help()1038usage: frobble [-h]10391040options:1041  -h, --help  show this help message and exit1042```10431044### metavar10451046Когда [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser) генерирует сообщения справки, ему нужен способ ссылаться на каждый ожидаемый аргумент. По умолчанию объекты ArgumentParser используют значение [dest](https://python-all.ru/3.11/library/argparse.html#dest) в качестве «имени» каждого объекта. По умолчанию для позиционных аргументов значение [dest](https://python-all.ru/3.11/library/argparse.html#dest) используется напрямую, а для опциональных аргументов значение [dest](https://python-all.ru/3.11/library/argparse.html#dest) преобразуется в верхний регистр. Таким образом, один позиционный аргумент с `dest='bar'` будет называться `bar`. Один опциональный аргумент `--foo`, за которым должен следовать один аргумент командной строки, будет называться `FOO`. Пример:10471048```python1049>>> parser = argparse.ArgumentParser()1050>>> parser.add_argument('--foo')1051>>> parser.add_argument('bar')1052>>> parser.parse_args('X --foo Y'.split())1053Namespace(bar='X', foo='Y')1054>>> parser.print_help()1055usage:  [-h] [--foo FOO] bar10561057positional arguments:1058 bar10591060options:1061 -h, --help  show this help message and exit1062 --foo FOO1063```10641065Альтернативное имя можно указать с помощью `metavar`:10661067```python1068>>> parser = argparse.ArgumentParser()1069>>> parser.add_argument('--foo', metavar='YYY')1070>>> parser.add_argument('bar', metavar='XXX')1071>>> parser.parse_args('X --foo Y'.split())1072Namespace(bar='X', foo='Y')1073>>> parser.print_help()1074usage:  [-h] [--foo YYY] XXX10751076positional arguments:1077 XXX10781079options:1080 -h, --help  show this help message and exit1081 --foo YYY1082```10831084Обратите внимание, что `metavar` изменяет только *отображаемое* имя – имя атрибута объекта [`parse_args()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.parse_args) по-прежнему определяется значением [dest](https://python-all.ru/3.11/library/argparse.html#dest).10851086Разные значения `nargs` могут привести к тому, что метапеременная будет использована несколько раз. Передача кортежа в `metavar` задаёт различное отображение для каждого из аргументов:10871088```python1089>>> parser = argparse.ArgumentParser(prog='PROG')1090>>> parser.add_argument('-x', nargs=2)1091>>> parser.add_argument('--foo', nargs=2, metavar=('bar', 'baz'))1092>>> parser.print_help()1093usage: PROG [-h] [-x X X] [--foo bar baz]10941095options:1096 -h, --help     show this help message and exit1097 -x X X1098 --foo bar baz1099```11001101### dest11021103Большинство действий [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser) добавляют некоторое значение как атрибут объекта, возвращаемого [`parse_args()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.parse_args). Имя этого атрибута определяется ключевым аргументом `dest` функции [`add_argument()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.add_argument). Для действий с позиционными аргументами `dest` обычно передаётся первым аргументом в [`add_argument()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.add_argument):11041105```python1106>>> parser = argparse.ArgumentParser()1107>>> parser.add_argument('bar')1108>>> parser.parse_args(['XXX'])1109Namespace(bar='XXX')1110```11111112Для действий необязательных аргументов значение `dest` обычно выводится из строк опций. [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser) генерирует значение `dest`, беря первую длинную строку опции и удаляя начальную строку `--`. Если длинные строки опций не были предоставлены, `dest` будет получен из первой короткой строки опции путем удаления начального символа `-`. Любые внутренние символы `-` будут преобразованы в символы `_`, чтобы гарантировать, что строка является допустимым именем атрибута. Примеры ниже иллюстрируют это поведение:11131114```python1115>>> parser = argparse.ArgumentParser()1116>>> parser.add_argument('-f', '--foo-bar', '--foo')1117>>> parser.add_argument('-x', '-y')1118>>> parser.parse_args('-f 1 -x 2'.split())1119Namespace(foo_bar='1', x='2')1120>>> parser.parse_args('--foo 1 -y 2'.split())1121Namespace(foo_bar='1', x='2')1122```11231124`dest` позволяет указать пользовательское имя атрибута:11251126```python1127>>> parser = argparse.ArgumentParser()1128>>> parser.add_argument('--foo', dest='bar')1129>>> parser.parse_args('--foo XXX'.split())1130Namespace(bar='XXX')1131```11321133### Классы действий11341135Классы действий реализуют API Action – вызываемый объект, который возвращает вызываемый объект, обрабатывающий аргументы командной строки. Любой объект, следующий этому API, может быть передан в качестве параметра `action` в [`add_argument()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.add_argument).11361137#### `class argparse.Action(option_strings, dest, nargs=None, const=None, default=None, type=None, choices=None, required=False, help=None, metavar=None)`11381139Объекты Action используются ArgumentParser для представления информации, необходимой для разбора одного аргумента из одной или нескольких строк командной строки. Класс Action должен принимать два позиционных аргумента плюс любые именованные аргументы, переданные в [`ArgumentParser.add_argument()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.add_argument), за исключением самого `action`.11401141Экземпляры Action (или возвращаемое значение любого вызываемого объекта для параметра `action`) должны иметь определённые атрибуты «dest», «option\_strings», «default», «type», «required», «help» и т.д. Самый простой способ гарантировать, что эти атрибуты определены – вызвать `Action.__init__`.11421143Экземпляры Action должны быть вызываемыми, поэтому подклассы должны переопределять метод `__call__`, который должен принимать четыре параметра:11441145- `parser` – объект ArgumentParser, содержащий это действие.1146- `namespace` – объект [`Namespace`](https://python-all.ru/3.11/library/argparse.html#argparse.Namespace), который будет возвращён [`parse_args()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.parse_args). Большинство действий добавляют атрибут к этому объекту с помощью [`setattr()`](https://python-all.ru/3.11/library/functions.html#setattr).1147- `values` – соответствующие аргументы командной строки с применёнными преобразованиями типов. Преобразования типов задаются с помощью именованного аргумента [type](https://python-all.ru/3.11/library/argparse.html#type) для [`add_argument()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.add_argument).1148- `option_string` – строка опции, которая использовалась для вызова этого действия. Аргумент `option_string` является необязательным и будет отсутствовать, если действие связано с позиционным аргументом.11491150Метод `__call__` может выполнять произвольные действия, но обычно устанавливает атрибуты объекта `namespace` на основе `dest` и `values`.11511152Подклассы Action могут определять метод `format_usage`, который не принимает аргументов и возвращает строку, используемую при выводе справки об использовании программы. Если такой метод не предоставлен, будет использовано разумное значение по умолчанию.11531154## Метод parse\_args()11551156#### `ArgumentParser.parse_args(args=None, namespace=None)`11571158Преобразует строки аргументов в объекты и назначает их в качестве атрибутов пространства имён. Возвращает заполненное пространство имён.11591160Предыдущие вызовы [`add_argument()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.add_argument) определяют, какие объекты создаются и как они назначаются. Подробнее см. документацию [`add_argument()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.add_argument).11611162- [args](https://python-all.ru/3.11/library/argparse.html#args) – список строк для разбора. По умолчанию берётся из [`sys.argv`](https://python-all.ru/3.11/library/sys.html#sys.argv).1163- [namespace](https://python-all.ru/3.11/library/argparse.html#namespace) – объект, в который будут помещены атрибуты. По умолчанию – новый пустой объект [`Namespace`](https://python-all.ru/3.11/library/argparse.html#argparse.Namespace).11641165### Синтаксис значений параметров11661167Метод [`parse_args()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.parse_args) поддерживает несколько способов указания значения параметра (если он принимает значение). В простейшем случае параметр и его значение передаются как два отдельных аргумента:11681169```python1170>>> parser = argparse.ArgumentParser(prog='PROG')1171>>> parser.add_argument('-x')1172>>> parser.add_argument('--foo')1173>>> parser.parse_args(['-x', 'X'])1174Namespace(foo=None, x='X')1175>>> parser.parse_args(['--foo', 'FOO'])1176Namespace(foo='FOO', x=None)1177```11781179Для длинных параметров (с именами длиннее одного символа) параметр и значение могут быть переданы как один аргумент командной строки, используя `=` для их разделения:11801181```python1182>>> parser.parse_args(['--foo=FOO'])1183Namespace(foo='FOO', x=None)1184```11851186Для коротких опций (опции длиной в один символ) опция и её значение могут быть объединены:11871188```python1189>>> parser.parse_args(['-xX'])1190Namespace(foo=None, x='X')1191```11921193Несколько коротких опций можно объединить, используя только один префикс `-`, при условии, что только последняя опция (или ни одна из них) требует значения:11941195```python1196>>> parser = argparse.ArgumentParser(prog='PROG')1197>>> parser.add_argument('-x', action='store_true')1198>>> parser.add_argument('-y', action='store_true')1199>>> parser.add_argument('-z')1200>>> parser.parse_args(['-xyzZ'])1201Namespace(x=True, y=True, z='Z')1202```12031204### Недопустимые аргументы12051206При разборе командной строки [`parse_args()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.parse_args) проверяет различные ошибки, включая неоднозначные опции, некорректные типы, неверные опции, неправильное количество позиционных аргументов и т.д. При обнаружении такой ошибки программа завершается и выводит сообщение об ошибке вместе со справкой по использованию:12071208```python1209>>> parser = argparse.ArgumentParser(prog='PROG')1210>>> parser.add_argument('--foo', type=int)1211>>> parser.add_argument('bar', nargs='?')12121213>>> # недопустимый тип1214>>> parser.parse_args(['--foo', 'spam'])1215usage: PROG [-h] [--foo FOO] [bar]1216PROG: error: argument --foo: invalid int value: 'spam'12171218>>> # недопустимая опция1219>>> parser.parse_args(['--bar'])1220usage: PROG [-h] [--foo FOO] [bar]1221PROG: error: no such option: --bar12221223>>> # неверное количество аргументов1224>>> parser.parse_args(['spam', 'badger'])1225usage: PROG [-h] [--foo FOO] [bar]1226PROG: error: extra arguments found: badger1227```12281229### Аргументы, содержащие `-`12301231Метод [`parse_args()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.parse_args) старается выдавать ошибки всякий раз, когда пользователь явно ошибся, но некоторые ситуации по своей природе неоднозначны. Например, аргумент командной строки `-1` может быть как попыткой указать опцию, так и попыткой передать позиционный аргумент. Метод [`parse_args()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.parse_args) здесь действует осторожно: позиционные аргументы могут начинаться с `-` только если они похожи на отрицательные числа, и в анализаторе нет опций, которые выглядят как отрицательные числа:12321233```python1234>>> parser = argparse.ArgumentParser(prog='PROG')1235>>> parser.add_argument('-x')1236>>> parser.add_argument('foo', nargs='?')12371238>>> # нет опций с отрицательными числами, поэтому -1 – позиционный аргумент1239>>> parser.parse_args(['-x', '-1'])1240Namespace(foo=None, x='-1')12411242>>> # нет опций с отрицательными числами, поэтому -1 и -5 – позиционные аргументы1243>>> parser.parse_args(['-x', '-1', '-5'])1244Namespace(foo='-5', x='-1')12451246>>> parser = argparse.ArgumentParser(prog='PROG')1247>>> parser.add_argument('-1', dest='one')1248>>> parser.add_argument('foo', nargs='?')12491250>>> # опции с отрицательными числами присутствуют, поэтому -1 – это опция1251>>> parser.parse_args(['-1', 'X'])1252Namespace(foo=None, one='X')12531254>>> # опции с отрицательными числами присутствуют, поэтому -2 – это опция1255>>> parser.parse_args(['-2'])1256usage: PROG [-h] [-1 ONE] [foo]1257PROG: error: no such option: -212581259>>> # опции с отрицательными числами присутствуют, поэтому обе -1 – это опции1260>>> parser.parse_args(['-1', '-1'])1261usage: PROG [-h] [-1 ONE] [foo]1262PROG: error: argument -1: expected one argument1263```12641265Если позиционные аргументы должны начинаться с `-` и не похожи на отрицательные числа, можно вставить псевдоаргумент `'--'`, который сообщает [`parse_args()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.parse_args), что всё после него является позиционным аргументом:12661267```python1268>>> parser.parse_args(['--', '-f'])1269Namespace(foo='-f', one=None)1270```12711272### Сокращения аргументов (совпадение по префиксу)12731274Метод [`parse_args()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.parse_args) [по умолчанию](https://python-all.ru/3.11/library/argparse.html#allow-abbrev) позволяет сокращать длинные опции до префикса, если сокращение является однозначным (префикс соответствует уникальной опции):12751276```python1277>>> parser = argparse.ArgumentParser(prog='PROG')1278>>> parser.add_argument('-bacon')1279>>> parser.add_argument('-badger')1280>>> parser.parse_args('-bac MMM'.split())1281Namespace(bacon='MMM', badger=None)1282>>> parser.parse_args('-bad WOOD'.split())1283Namespace(bacon=None, badger='WOOD')1284>>> parser.parse_args('-ba BA'.split())1285usage: PROG [-h] [-bacon BACON] [-badger BADGER]1286PROG: error: ambiguous option: -ba could match -badger, -bacon1287```12881289Выдаётся ошибка для аргументов, которые могут соответствовать нескольким опциям. Эту возможность можно отключить, установив [allow\_abbrev](https://python-all.ru/3.11/library/argparse.html#allow-abbrev) в `False`.12901291### За пределами `sys.argv`12921293Иногда может быть полезно, чтобы ArgumentParser разбирал аргументы, отличные от аргументов [`sys.argv`](https://python-all.ru/3.11/library/sys.html#sys.argv). Этого можно достичь, передав список строк в [`parse_args()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.parse_args). Это полезно для тестирования в интерактивной командной строке:12941295```python1296>>> parser = argparse.ArgumentParser()1297>>> parser.add_argument(1298...     'integers', metavar='int', type=int, choices=range(10),1299...     nargs='+', help='an integer in the range 0..9')1300>>> parser.add_argument(1301...     '--sum', dest='accumulate', action='store_const', const=sum,1302...     default=max, help='sum the integers (default: find the max)')1303>>> parser.parse_args(['1', '2', '3', '4'])1304Namespace(accumulate=<built-in function max>, integers=[1, 2, 3, 4])1305>>> parser.parse_args(['1', '2', '3', '4', '--sum'])1306Namespace(accumulate=<built-in function sum>, integers=[1, 2, 3, 4])1307```13081309### Объект Namespace13101311#### `class argparse.Namespace`13121313Простой класс, используемый по умолчанию в [`parse_args()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.parse_args) для создания объекта, содержащего атрибуты, и его возврата.13141315Этот класс намеренно прост, всего лишь подкласс [`object`](https://python-all.ru/3.11/library/functions.html#object) с читаемым строковым представлением. Если нужно dict-подобное представление атрибутов, можно воспользоваться стандартной идиомой Python, [`vars()`](https://python-all.ru/3.11/library/functions.html#vars):13161317```python1318>>> parser = argparse.ArgumentParser()1319>>> parser.add_argument('--foo')1320>>> args = parser.parse_args(['--foo', 'BAR'])1321>>> vars(args)1322{'foo': 'BAR'}1323```13241325Также может быть полезно, чтобы [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser) присваивал атрибуты уже существующему объекту, а не новому объекту [`Namespace`](https://python-all.ru/3.11/library/argparse.html#argparse.Namespace). Этого можно достичь, указав именованный аргумент `namespace=`:13261327```python1328>>> class C:1329...     pass1330...1331>>> c = C()1332>>> parser = argparse.ArgumentParser()1333>>> parser.add_argument('--foo')1334>>> parser.parse_args(args=['--foo', 'BAR'], namespace=c)1335>>> c.foo1336'BAR'1337```13381339## Другие утилиты13401341### Подкоманды13421343#### `ArgumentParser.add_subparsers([title][, description][, prog][, parser_class][, action][, option_strings][, dest][, required][, help][, metavar])`13441345Многие программы разделяют свою функциональность на несколько подкоманд, например, программа `svn` может вызывать подкоманды `svn checkout`, `svn update` и `svn commit`. Разделение функциональности таким образом может быть особенно хорошей идеей, когда программа выполняет несколько различных функций, требующих разных типов аргументов командной строки. [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser) поддерживает создание таких подкоманд с помощью метода [`add_subparsers()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.add_subparsers). Метод [`add_subparsers()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.add_subparsers) обычно вызывается без аргументов и возвращает специальный объект действия. Этот объект имеет единственный метод `add_parser()`, который принимает имя команды и любые аргументы конструктора [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser), и возвращает объект [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser), который можно изменять как обычно.13461347Описание параметров:13481349- title – заголовок для группы подпарсеров в выводе справки; по умолчанию «subcommands», если указано описание, в противном случае используется заголовок для позиционных аргументов.1350- description – описание для группы подпарсеров в выводе справки, по умолчанию `None`1351- prog – информация об использовании, которая будет отображаться в справке подкоманды; по умолчанию – имя программы и любые позиционные аргументы перед аргументом подпарсера1352- parser\_class – класс, который будет использоваться для создания экземпляров подпарсера; по умолчанию – класс текущего парсера (например, ArgumentParser)1353- [action](https://python-all.ru/3.11/library/argparse.html#action) – базовый тип действия, которое будет выполнено при обнаружении этого аргумента в командной строке1354- [dest](https://python-all.ru/3.11/library/argparse.html#dest) – имя атрибута, в котором будет сохранено имя подкоманды; по умолчанию `None`, значение не сохраняется1355- [required](https://python-all.ru/3.11/library/argparse.html#required) – указывает, обязательно ли должна быть указана подкоманда; по умолчанию `False` (добавлено в версии 3.7)1356- [help](https://python-all.ru/3.11/library/argparse.html#help) – справка для группы подпарсеров в выводе справки; по умолчанию `None`1357- [metavar](https://python-all.ru/3.11/library/argparse.html#metavar) – строка, представляющая доступные подкоманды в справке; по умолчанию это `None` и представляет подкоманды в форме {cmd1, cmd2, ..}13581359Пример использования:13601361```python1362>>> # создать парсер верхнего уровня1363>>> parser = argparse.ArgumentParser(prog='PROG')1364>>> parser.add_argument('--foo', action='store_true', help='foo help')1365>>> subparsers = parser.add_subparsers(help='sub-command help')1366>>>1367>>> # создать парсер для команды "a"1368>>> parser_a = subparsers.add_parser('a', help='a help')1369>>> parser_a.add_argument('bar', type=int, help='bar help')1370>>>1371>>> # создать парсер для команды "b"1372>>> parser_b = subparsers.add_parser('b', help='b help')1373>>> parser_b.add_argument('--baz', choices='XYZ', help='baz help')1374>>>1375>>> # разобрать некоторые списки аргументов1376>>> parser.parse_args(['a', '12'])1377Namespace(bar=12, foo=False)1378>>> parser.parse_args(['--foo', 'b', '--baz', 'Z'])1379Namespace(baz='Z', foo=True)1380```13811382Обратите внимание, что объект, возвращаемый [`parse_args()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.parse_args), будет содержать только атрибуты главного парсера и того подпарсера, который был выбран из командной строки (а не любых других подпарсеров). Так, в приведённом выше примере, когда указана команда `a`, присутствуют только атрибуты `foo` и `bar`, а когда указана команда `b` – только атрибуты `foo` и `baz`.13831384Аналогично, при запросе справки от подпарсера выводится только справка этого конкретного парсера. Сообщение справки не включает сообщения родительского парсера или соседних парсеров. (Однако справку для каждой команды подпарсера можно задать, передав аргумент `help=` функции `add_parser()`, как показано выше.)13851386```python1387>>> parser.parse_args(['--help'])1388usage: PROG [-h] [--foo] {a,b} ...13891390positional arguments:1391  {a,b}   sub-command help1392    a     a help1393    b     b help13941395options:1396  -h, --help  show this help message and exit1397  --foo   foo help13981399>>> parser.parse_args(['a', '--help'])1400usage: PROG a [-h] bar14011402positional arguments:1403  bar     bar help14041405options:1406  -h, --help  show this help message and exit14071408>>> parser.parse_args(['b', '--help'])1409usage: PROG b [-h] [--baz {X,Y,Z}]14101411options:1412  -h, --help     show this help message and exit1413  --baz {X,Y,Z}  baz help1414```14151416Метод [`add_subparsers()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.add_subparsers) также поддерживает именованные аргументы `title` и `description`. Когда любой из них присутствует, команды подпарсера отображаются в собственной группе в выводе справки. Например:14171418```python1419>>> parser = argparse.ArgumentParser()1420>>> subparsers = parser.add_subparsers(title='subcommands',1421...                                    description='valid subcommands',1422...                                    help='additional help')1423>>> subparsers.add_parser('foo')1424>>> subparsers.add_parser('bar')1425>>> parser.parse_args(['-h'])1426usage:  [-h] {foo,bar} ...14271428options:1429  -h, --help  show this help message and exit14301431subcommands:1432  valid subcommands14331434  {foo,bar}   additional help1435```14361437Кроме того, `add_parser` поддерживает дополнительный аргумент `aliases`, позволяющий нескольким строкам ссылаться на один и тот же подпарсер. Этот пример, как и `svn`, задаёт псевдоним `co` как сокращение для `checkout`:14381439```python1440>>> parser = argparse.ArgumentParser()1441>>> subparsers = parser.add_subparsers()1442>>> checkout = subparsers.add_parser('checkout', aliases=['co'])1443>>> checkout.add_argument('foo')1444>>> parser.parse_args(['co', 'bar'])1445Namespace(foo='bar')1446```14471448Один из особенно эффективных способов работы с подкомандами – комбинировать использование метода [`add_subparsers()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.add_subparsers) с вызовами [`set_defaults()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.set_defaults), чтобы каждый подпарсер знал, какую функцию Python он должен выполнить. Например:14491450```python1451>>> # функции подкоманд1452>>> def foo(args):1453...     print(args.x * args.y)1454...1455>>> def bar(args):1456...     print('((%s))' % args.z)1457...1458>>> # создать парсер верхнего уровня1459>>> parser = argparse.ArgumentParser()1460>>> subparsers = parser.add_subparsers(required=True)1461>>>1462>>> # создать парсер для команды "foo"1463>>> parser_foo = subparsers.add_parser('foo')1464>>> parser_foo.add_argument('-x', type=int, default=1)1465>>> parser_foo.add_argument('y', type=float)1466>>> parser_foo.set_defaults(func=foo)1467>>>1468>>> # создать парсер для команды "bar"1469>>> parser_bar = subparsers.add_parser('bar')1470>>> parser_bar.add_argument('z')1471>>> parser_bar.set_defaults(func=bar)1472>>>1473>>> # разобрать аргументы и вызвать выбранную функцию1474>>> args = parser.parse_args('foo 1 -x 2'.split())1475>>> args.func(args)14762.01477>>>1478>>> # разобрать аргументы и вызвать выбранную функцию1479>>> args = parser.parse_args('bar XYZYX'.split())1480>>> args.func(args)1481((XYZYX))1482```14831484Таким образом, можно поручить [`parse_args()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.parse_args) задачу вызова соответствующей функции после завершения разбора аргументов. Связывание функций с действиями таким образом – обычно самый простой способ обработать разные действия для каждого из ваших подпарсеров. Однако, если необходимо проверить имя вызванного подпарсера, сработает именованный аргумент `dest` при вызове [`add_subparsers()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.add_subparsers):14851486```python1487>>> parser = argparse.ArgumentParser()1488>>> subparsers = parser.add_subparsers(dest='subparser_name')1489>>> subparser1 = subparsers.add_parser('1')1490>>> subparser1.add_argument('-x')1491>>> subparser2 = subparsers.add_parser('2')1492>>> subparser2.add_argument('y')1493>>> parser.parse_args(['2', 'frobble'])1494Namespace(subparser_name='2', y='frobble')1495```14961497Изменено в версии 3.7: Новый *required* именованный аргумент.14981499### Объекты FileType15001501#### `class argparse.FileType(mode='r', bufsize=-1, encoding=None, errors=None)`15021503Фабрика [`FileType`](https://python-all.ru/3.11/library/argparse.html#argparse.FileType) создаёт объекты, которые можно передать в аргумент type функции [`ArgumentParser.add_argument()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.add_argument). Аргументы, имеющие объекты [`FileType`](https://python-all.ru/3.11/library/argparse.html#argparse.FileType) в качестве типа, будут открывать аргументы командной строки как файлы с указанными режимами, размерами буфера, кодировками и обработкой ошибок (см. функцию [`open()`](https://python-all.ru/3.11/library/functions.html#open) для подробностей):15041505```python1506>>> parser = argparse.ArgumentParser()1507>>> parser.add_argument('--raw', type=argparse.FileType('wb', 0))1508>>> parser.add_argument('out', type=argparse.FileType('w', encoding='UTF-8'))1509>>> parser.parse_args(['--raw', 'raw.dat', 'file.txt'])1510Namespace(out=<_io.TextIOWrapper name='file.txt' mode='w' encoding='UTF-8'>, raw=<_io.FileIO name='raw.dat' mode='wb'>)1511```15121513Объекты FileType понимают псевдоаргумент `'-'` и автоматически преобразуют его в [`sys.stdin`](https://python-all.ru/3.11/library/sys.html#sys.stdin) для читаемых объектов [`FileType`](https://python-all.ru/3.11/library/argparse.html#argparse.FileType) и в [`sys.stdout`](https://python-all.ru/3.11/library/sys.html#sys.stdout) для записываемых объектов [`FileType`](https://python-all.ru/3.11/library/argparse.html#argparse.FileType):15141515```python1516>>> parser = argparse.ArgumentParser()1517>>> parser.add_argument('infile', type=argparse.FileType('r'))1518>>> parser.parse_args(['-'])1519Namespace(infile=<_io.TextIOWrapper name='<stdin>' encoding='UTF-8'>)1520```15211522Изменено в версии 3.4: Добавлены параметры *encodings* и *errors*.15231524### Группы аргументов15251526#### `ArgumentParser.add_argument_group(title=None, description=None)`15271528По умолчанию [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser) группирует аргументы командной строки на «позиционные аргументы» и «опции» при отображении сообщений справки. Если существует более осмысленная концептуальная группировка аргументов, чем эта, можно создать соответствующие группы с помощью метода [`add_argument_group()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.add_argument_group):15291530```python1531>>> parser = argparse.ArgumentParser(prog='PROG', add_help=False)1532>>> group = parser.add_argument_group('group')1533>>> group.add_argument('--foo', help='foo help')1534>>> group.add_argument('bar', help='bar help')1535>>> parser.print_help()1536usage: PROG [--foo FOO] bar15371538group:1539  bar    bar help1540  --foo FOO  foo help1541```15421543Метод [`add_argument_group()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.add_argument_group) возвращает объект группы аргументов, у которого есть метод [`add_argument()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.add_argument), как и у обычного [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser). Когда аргумент добавляется в группу, парсер обрабатывает его как обычный аргумент, но при выводе справки отображает его в отдельной группе. Метод [`add_argument_group()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.add_argument_group) принимает аргументы *title* и *description*, которые можно использовать для настройки этого отображения:15441545```python1546>>> parser = argparse.ArgumentParser(prog='PROG', add_help=False)1547>>> group1 = parser.add_argument_group('group1', 'group1 description')1548>>> group1.add_argument('foo', help='foo help')1549>>> group2 = parser.add_argument_group('group2', 'group2 description')1550>>> group2.add_argument('--bar', help='bar help')1551>>> parser.print_help()1552usage: PROG [--bar BAR] foo15531554group1:1555  group1 description15561557  foo    foo help15581559group2:1560  group2 description15611562  --bar BAR  bar help1563```15641565Обратите внимание, что любые аргументы, не входящие в ваши пользовательские группы, окажутся обратно в обычных разделах «позиционные аргументы» и «опциональные аргументы».15661567Изменено в версии 3.11: Вызов [`add_argument_group()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.add_argument_group) для группы аргументов устарел. Эта возможность никогда не поддерживалась и не всегда работает корректно. Функция присутствует в API случайно, из-за наследования, и будет удалена в будущем.15681569### Взаимное исключение15701571#### `ArgumentParser.add_mutually_exclusive_group(required=False)`15721573Создаёт взаимоисключающую группу. [`argparse`](https://python-all.ru/3.11/library/argparse.html#module-argparse) гарантирует, что в командной строке присутствовал только один из аргументов взаимоисключающей группы:15741575```python1576>>> parser = argparse.ArgumentParser(prog='PROG')1577>>> group = parser.add_mutually_exclusive_group()1578>>> group.add_argument('--foo', action='store_true')1579>>> group.add_argument('--bar', action='store_false')1580>>> parser.parse_args(['--foo'])1581Namespace(bar=True, foo=True)1582>>> parser.parse_args(['--bar'])1583Namespace(bar=False, foo=False)1584>>> parser.parse_args(['--foo', '--bar'])1585usage: PROG [-h] [--foo | --bar]1586PROG: error: argument --bar: not allowed with argument --foo1587```15881589Метод [`add_mutually_exclusive_group()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.add_mutually_exclusive_group) также принимает аргумент *required*, чтобы указать, что требуется хотя бы один из взаимоисключающих аргументов:15901591```python1592>>> parser = argparse.ArgumentParser(prog='PROG')1593>>> group = parser.add_mutually_exclusive_group(required=True)1594>>> group.add_argument('--foo', action='store_true')1595>>> group.add_argument('--bar', action='store_false')1596>>> parser.parse_args([])1597usage: PROG [-h] (--foo | --bar)1598PROG: error: one of the arguments --foo --bar is required1599```16001601Обратите внимание, что в настоящее время группы взаимоисключающих аргументов не поддерживают аргументы *title* и *description* из [`add_argument_group()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.add_argument_group).16021603Изменено в версии 3.11: Вызов [`add_argument_group()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.add_argument_group) или [`add_mutually_exclusive_group()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.add_mutually_exclusive_group) для взаимоисключающей группы устарел. Эти возможности никогда не поддерживались и не всегда работают корректно. Функции присутствуют в API случайно, из-за наследования, и будут удалены в будущем.16041605### Умолчания парсера16061607#### `ArgumentParser.set_defaults(**kwargs)`16081609В большинстве случаев атрибуты объекта, возвращаемого [`parse_args()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.parse_args), полностью определяются путём анализа аргументов командной строки и действий аргументов. [`set_defaults()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.set_defaults) позволяет добавить некоторые дополнительные атрибуты, которые определяются без какого-либо анализа командной строки:16101611```python1612>>> parser = argparse.ArgumentParser()1613>>> parser.add_argument('foo', type=int)1614>>> parser.set_defaults(bar=42, baz='badger')1615>>> parser.parse_args(['736'])1616Namespace(bar=42, baz='badger', foo=736)1617```16181619Обратите внимание: значения по умолчанию на уровне анализатора всегда переопределяют значения по умолчанию на уровне аргументов:16201621```python1622>>> parser = argparse.ArgumentParser()1623>>> parser.add_argument('--foo', default='bar')1624>>> parser.set_defaults(foo='spam')1625>>> parser.parse_args([])1626Namespace(foo='spam')1627```16281629Умолчания на уровне парсера могут быть особенно полезны при работе с несколькими парсерами. См. пример этого типа в методе [`add_subparsers()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.add_subparsers).16301631#### `ArgumentParser.get_default(dest)`16321633Возвращает значение по умолчанию для атрибута пространства имён, заданное либо [`add_argument()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.add_argument), либо [`set_defaults()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.set_defaults):16341635```python1636>>> parser = argparse.ArgumentParser()1637>>> parser.add_argument('--foo', default='badger')1638>>> parser.get_default('foo')1639'badger'1640```16411642### Вывод справки16431644В большинстве типичных приложений [`parse_args()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.parse_args) берёт на себя форматирование и вывод всех сообщений об использовании и ошибок. Однако доступно несколько методов форматирования:16451646#### `ArgumentParser.print_usage(file=None)`16471648Выводит краткое описание того, как [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser) должен вызываться в командной строке. Если *file* равен `None`, предполагается [`sys.stdout`](https://python-all.ru/3.11/library/sys.html#sys.stdout).16491650#### `ArgumentParser.print_help(file=None)`16511652Выводит справочное сообщение, включая использование программы и информацию об аргументах, зарегистрированных в [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser). Если *file* равен `None`, предполагается [`sys.stdout`](https://python-all.ru/3.11/library/sys.html#sys.stdout).16531654Существуют также варианты этих методов, которые просто возвращают строку вместо её вывода:16551656#### `ArgumentParser.format_usage()`16571658Возвращает строку с кратким описанием того, как [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser) должен вызываться в командной строке.16591660#### `ArgumentParser.format_help()`16611662Возвращает строку со справочным сообщением, включая использование программы и информацию об аргументах, зарегистрированных в [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser).16631664### Частичный разбор16651666#### `ArgumentParser.parse_known_args(args=None, namespace=None)`16671668Иногда скрипт может разобрать только часть аргументов командной строки, передавая остальные другому скрипту или программе. В таких случаях может пригодиться метод [`parse_known_args()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.parse_known_args). Он работает почти как [`parse_args()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.parse_args), за исключением того, что не вызывает ошибку при наличии лишних аргументов. Вместо этого он возвращает кортеж из двух элементов: заполненное пространство имён и список оставшихся строк аргументов.16691670```python1671>>> parser = argparse.ArgumentParser()1672>>> parser.add_argument('--foo', action='store_true')1673>>> parser.add_argument('bar')1674>>> parser.parse_known_args(['--foo', '--badger', 'BAR', 'spam'])1675(Namespace(bar='BAR', foo=True), ['--badger', 'spam'])1676```16771678> **Предупреждение**1679>1680> Правила [совпадения по префиксу](https://python-all.ru/3.11/library/argparse.html#prefix-matching) применяются к [`parse_known_args()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.parse_known_args). Парсер может поглотить параметр, даже если он является всего лишь префиксом одного из известных параметров, вместо того чтобы оставить его в списке оставшихся аргументов.16811682### Настройка разбора файлов16831684#### `ArgumentParser.convert_arg_line_to_args(arg_line)`16851686Аргументы, читаемые из файла (см. именованный аргумент *fromfile\_prefix\_chars* конструктора [`ArgumentParser`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser)), читаются по одному аргументу на строку. [`convert_arg_line_to_args()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.convert_arg_line_to_args) можно переопределить для более сложного чтения.16871688Этот метод принимает один аргумент *arg\_line* – строку, прочитанную из файла аргументов. Он возвращает список аргументов, разобранных из этой строки. Метод вызывается по одному разу для каждой строки из файла аргументов, по порядку.16891690Полезным переопределением этого метода будет то, которое рассматривает каждое отделённое пробелом слово как аргумент. Следующий пример показывает, как это сделать:16911692```python1693class MyArgumentParser(argparse.ArgumentParser):1694    def convert_arg_line_to_args(self, arg_line):1695        return arg_line.split()1696```16971698### Методы завершения16991700#### `ArgumentParser.exit(status=0, message=None)`17011702Этот метод завершает программу, выходя с указанным *status* и, если задано, перед этим выводит *message*. Пользователь может переопределить этот метод, чтобы обрабатывать эти шаги иначе:17031704```python1705class ErrorCatchingArgumentParser(argparse.ArgumentParser):1706    def exit(self, status=0, message=None):1707        if status:1708            raise Exception(f'Exiting because of an error: {message}')1709        exit(status)1710```17111712#### `ArgumentParser.error(message)`17131714Этот метод выводит сообщение об использовании, включая *message*, в стандартный поток ошибок и завершает программу с кодом возврата 2.17151716### Смешанный разбор17171718#### `ArgumentParser.parse_intermixed_args(args=None, namespace=None)`17191720#### `ArgumentParser.parse_known_intermixed_args(args=None, namespace=None)`17211722Многие команды Unix позволяют пользователю смешивать опциональные аргументы с позиционными. Методы [`parse_intermixed_args()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.parse_intermixed_args) и [`parse_known_intermixed_args()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.parse_known_intermixed_args) поддерживают такой стиль разбора.17231724Эти парсеры не поддерживают все возможности argparse и вызывают исключения при использовании неподдерживаемых возможностей. В частности, подпарсеры и группы взаимоисключающих аргументов, включающие как опциональные, так и позиционные аргументы, не поддерживаются.17251726Следующий пример показывает разницу между [`parse_known_args()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.parse_known_args) и [`parse_intermixed_args()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.parse_intermixed_args): первый возвращает `['2', '3']` как неразобранные аргументы, в то время как второй собирает все позиционные аргументы в `rest`.17271728```python1729>>> parser = argparse.ArgumentParser()1730>>> parser.add_argument('--foo')1731>>> parser.add_argument('cmd')1732>>> parser.add_argument('rest', nargs='*', type=int)1733>>> parser.parse_known_args('doit 1 --foo bar 2 3'.split())1734(Namespace(cmd='doit', foo='bar', rest=[1]), ['2', '3'])1735>>> parser.parse_intermixed_args('doit 1 --foo bar 2 3'.split())1736Namespace(cmd='doit', foo='bar', rest=[1, 2, 3])1737```17381739[`parse_known_intermixed_args()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.parse_known_intermixed_args) возвращает кортеж из двух элементов, содержащий заполненное пространство имён и список оставшихся строк аргументов. [`parse_intermixed_args()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.parse_intermixed_args) вызывает ошибку, если остаются какие-либо неразобранные строки аргументов.17401741Добавлено в версии 3.7.17421743## Обновление кода optparse17441745Изначально модуль [`argparse`](https://python-all.ru/3.11/library/argparse.html#module-argparse) пытался сохранять совместимость с [`optparse`](https://python-all.ru/3.11/library/optparse.html#module-optparse). Однако [`optparse`](https://python-all.ru/3.11/library/optparse.html#module-optparse) было сложно прозрачно расширять, особенно с изменениями, необходимыми для поддержки новых спецификаторов `nargs=` и более качественных сообщений об использовании. Когда почти всё в [`optparse`](https://python-all.ru/3.11/library/optparse.html#module-optparse) было либо скопировано, либо пропатчено (monkey-patched), попытки поддерживать обратную совместимость перестали казаться практичными.17461747Модуль [`argparse`](https://python-all.ru/3.11/library/argparse.html#module-argparse) превосходит стандартный модуль библиотеки [`optparse`](https://python-all.ru/3.11/library/optparse.html#module-optparse) по ряду параметров, включая:17481749- Обработка позиционных аргументов.1750- Поддержка подкоманд.1751- Разрешение альтернативных префиксов параметров, например `+` и `/`.1752- Обработка аргументов в стиле «ноль или более» и «один или более».1753- Формирование более информативных сообщений об использовании.1754- Предоставление гораздо более простого интерфейса для пользовательских `type` и `action`.17551756Частичный путь перехода с [`optparse`](https://python-all.ru/3.11/library/optparse.html#module-optparse) на [`argparse`](https://python-all.ru/3.11/library/argparse.html#module-argparse):17571758- Замените все вызовы [`optparse.OptionParser.add_option()`](https://python-all.ru/3.11/library/optparse.html#optparse.OptionParser.add_option) на вызовы [`ArgumentParser.add_argument()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.add_argument).1759- Замените `(options, args) = parser.parse_args()` на `args = parser.parse_args()` и добавьте дополнительные вызовы [`ArgumentParser.add_argument()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.add_argument) для позиционных аргументов. Имейте в виду, что то, что ранее называлось `options`, теперь в контексте [`argparse`](https://python-all.ru/3.11/library/argparse.html#module-argparse) называется `args`.1760- Замените [`optparse.OptionParser.disable_interspersed_args()`](https://python-all.ru/3.11/library/optparse.html#optparse.OptionParser.disable_interspersed_args), используя [`parse_intermixed_args()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.parse_intermixed_args) вместо [`parse_args()`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentParser.parse_args).1761- Замените колбэк-действия и аргументы-ключевые слова `callback_*` на аргументы `type` или `action`.1762- Замените строковые имена для ключевых аргументов `type` соответствующими объектами типов (например, int, float, complex и т.д.).1763- Замените [`optparse.Values`](https://python-all.ru/3.11/library/optparse.html#optparse.Values) на [`Namespace`](https://python-all.ru/3.11/library/argparse.html#argparse.Namespace), а [`optparse.OptionError`](https://python-all.ru/3.11/library/optparse.html#optparse.OptionError) и [`optparse.OptionValueError`](https://python-all.ru/3.11/library/optparse.html#optparse.OptionValueError) на [`ArgumentError`](https://python-all.ru/3.11/library/argparse.html#argparse.ArgumentError).1764- Замените строки с неявными аргументами, такими как `%default` или `%prog`, на стандартный синтаксис Python для использования словарей при форматировании строк, то есть `%(default)s` и `%(prog)s`.1765- Замените аргумент `version` конструктора OptionParser на вызов `parser.add_argument('--version', action='version', version='<the version>')`.17661767## Исключения17681769#### `exception argparse.ArgumentError`17701771Ошибка при создании или использовании аргумента (опционального или позиционного).17721773Строковое значение этого исключения – это сообщение, дополненное информацией об аргументе, который его вызвал.17741775#### `exception argparse.ArgumentTypeError`17761777Вызывается, когда что-то идёт не так при преобразовании строки командной строки в тип.1778