argparse.md

1> **Источник:** https://python-all.ru/3.13/library/argparse.html2>3> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.45---67# `argparse` – парсер для параметров командной строки, аргументов и подкоманд89Добавлено в версии 3.2.1011**Исходный код:** [Lib/argparse.py](https://python-all.ru/src/3.13/Lib/argparse.py)1213> **Примечание**14>15> Хотя `argparse` является рекомендуемым модулем стандартной библиотеки для реализации простых приложений командной строки, у авторов с более строгими требованиями к точному поведению их приложений командной строки может возникнуть ощущение, что он не обеспечивает необходимый уровень контроля. Обратитесь к [Выбор библиотеки для разбора аргументов](https://python-all.ru/3.13/library/optparse.html#choosing-an-argument-parser) для альтернатив, которые стоит рассмотреть, если `argparse` не поддерживает поведение, необходимое приложению (например, полное отключение поддержки перемешанных параметров и позиционных аргументов, или принятие значений параметров, начинающихся с `-`, даже если они соответствуют другому определённому параметру).1617---1819Учебное пособие2021На этой странице содержится справочная информация по API. Для более плавного введения в разбор командной строки Python обратитесь к [учебному пособию по argparse](https://python-all.ru/3.13/howto/argparse.html#argparse-tutorial).2223Модуль `argparse` упрощает создание удобных интерфейсов командной строки. Программа определяет, какие аргументы ей требуются, а `argparse` разбирается, как извлечь их из [`sys.argv`](https://python-all.ru/3.13/library/sys.html#sys.argv). Модуль `argparse` также автоматически генерирует сообщения справки и использования. Модуль также выводит ошибки, когда пользователи передают программе недопустимые аргументы.2425Поддержка интерфейсов командной строки модуля `argparse` построена вокруг экземпляра [`argparse.ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser). Он является контейнером для спецификаций аргументов и имеет параметры, которые применяются к парсеру в целом:2627```python28parser = argparse.ArgumentParser(29                    prog='ProgramName',30                    description='What the program does',31                    epilog='Text at the bottom of help')32```3334Метод [`ArgumentParser.add_argument()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.add_argument) добавляет в парсер отдельные спецификации аргументов. Он поддерживает позиционные аргументы, опции, принимающие значения, и флаги вкл/выкл:3536```python37parser.add_argument('filename')           # позиционный аргумент38parser.add_argument('-c', '--count')      # опция, которая принимает значение39parser.add_argument('-v', '--verbose',40                    action='store_true')  # флаг вкл/выкл41```4243Метод [`ArgumentParser.parse_args()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.parse_args) запускает парсер и помещает извлечённые данные в объект [`argparse.Namespace`](https://python-all.ru/3.13/library/argparse.html#argparse.Namespace):4445```python46args = parser.parse_args()47print(args.filename, args.count, args.verbose)48```4950> **Примечание**51>52> Если вы ищете руководство по обновлению кода с [`optparse`](https://python-all.ru/3.13/library/optparse.html#module-optparse) на `argparse`, смотрите [Обновление кода Optparse](https://python-all.ru/3.13/howto/argparse-optparse.html#upgrading-optparse-code).5354## Объекты ArgumentParser5556#### `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)`5758Создаёт новый объект `ArgumentParser`. Все параметры должны передаваться как именованные аргументы. Каждый параметр имеет собственное подробное описание ниже, но вкратце они таковы:5960- [prog](https://python-all.ru/3.13/library/argparse.html#prog) – имя программы (по умолчанию: `os.path.basename(sys.argv[0])`)61- [usage](https://python-all.ru/3.13/library/argparse.html#usage) - строка, описывающая использование программы (по умолчанию генерируется из аргументов, добавленных в парсер)62- [description](https://python-all.ru/3.13/library/argparse.html#description) - текст, отображаемый перед справкой по аргументам (по умолчанию отсутствует)63- [epilog](https://python-all.ru/3.13/library/argparse.html#epilog) - текст, отображаемый после справки по аргументам (по умолчанию отсутствует)64- [parents](https://python-all.ru/3.13/library/argparse.html#parents) - список объектов `ArgumentParser`, аргументы которых также должны быть включены65- [formatter\_class](https://python-all.ru/3.13/library/argparse.html#formatter-class) - класс для настройки вывода справки66- [prefix\_chars](https://python-all.ru/3.13/library/argparse.html#prefix-chars) - набор символов, которые являются префиксом необязательных аргументов (по умолчанию: ‘-‘)67- [fromfile\_prefix\_chars](https://python-all.ru/3.13/library/argparse.html#fromfile-prefix-chars) - набор символов, которые являются префиксом файлов, из которых должны читаться дополнительные аргументы (по умолчанию: `None`)68- [argument\_default](https://python-all.ru/3.13/library/argparse.html#argument-default) - глобальное значение по умолчанию для аргументов (по умолчанию: `None`)69- [conflict\_handler](https://python-all.ru/3.13/library/argparse.html#conflict-handler) - стратегия разрешения конфликтов необязательных аргументов (обычно не требуется)70- [add\_help](https://python-all.ru/3.13/library/argparse.html#add-help) - добавить опцию `-h/--help` в парсер (по умолчанию: `True`)71- [allow\_abbrev](https://python-all.ru/3.13/library/argparse.html#allow-abbrev) – позволяет сокращать длинные параметры, если сокращение однозначно. (по умолчанию: `True`)72- [exit\_on\_error](https://python-all.ru/3.13/library/argparse.html#exit-on-error) - определяет, завершает ли `ArgumentParser` работу с сообщением об ошибке при возникновении ошибки (по умолчанию: `True`)7374Изменено в версии 3.5: *allow\_abbrev* – добавлен параметр.7576Изменено в версии 3.8: В предыдущих версиях *allow\_abbrev* также отключал группировку коротких флагов, например `-vv` для обозначения `-v -v`.7778Изменено в версии 3.9: *exit\_on\_error* – добавлен параметр.7980В следующих разделах описывается, как используется каждый из этих параметров.8182### prog8384По умолчанию [`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser) вычисляет имя программы для отображения в справочных сообщениях в зависимости от того, как был запущен интерпретатор Python:8586- Имя [`base name`](https://python-all.ru/3.13/library/os.path.html#os.path.basename) `sys.argv[0]`, если в качестве аргумента был передан файл.87- Имя интерпретатора Python, за которым следует `sys.argv[0]`, если в качестве аргумента была передана директория или zip-файл.88- Имя интерпретатора Python, за которым следует `-m`, а затем имя модуля или пакета, если была использована опция [`-m`](https://python-all.ru/3.13/using/cmdline.html#cmdoption-m).8990Это поведение по умолчанию почти всегда желательно, поскольку оно делает сообщения справки соответствующими строке, которая использовалась для запуска программы в командной строке. Однако чтобы изменить это поведение, можно указать другое значение с помощью аргумента `prog=` для [`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser):9192```python93>>> parser = argparse.ArgumentParser(prog='myprogram')94>>> parser.print_help()95usage: myprogram [-h]9697options:98 -h, --help  show this help message and exit99```100101Обратите внимание, что имя программы, будь оно определено из `sys.argv[0]` или из аргумента `prog=`, доступно в справочных сообщениях через форматный спецификатор `%(prog)s`.102103```python104>>> parser = argparse.ArgumentParser(prog='myprogram')105>>> parser.add_argument('--foo', help='foo of the %(prog)s program')106>>> parser.print_help()107usage: myprogram [-h] [--foo FOO]108109options:110 -h, --help  show this help message and exit111 --foo FOO   foo of the myprogram program112```113114### использование115116По умолчанию [`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser) формирует сообщение об использовании из своих аргументов. Стандартное сообщение можно переопределить с помощью именованного аргумента `usage=`:117118```python119>>> parser = argparse.ArgumentParser(prog='PROG', usage='%(prog)s [options]')120>>> parser.add_argument('--foo', nargs='?', help='foo help')121>>> parser.add_argument('bar', nargs='+', help='bar help')122>>> parser.print_help()123usage: PROG [options]124125positional arguments:126 bar          bar help127128options:129 -h, --help   show this help message and exit130 --foo [FOO]  foo help131```132133Спецификатор формата `%(prog)s` используется для подстановки имени программы в сообщения об использовании.134135### описание136137Большинство вызовов конструктора [`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser) используют именованный аргумент `description=`. Этот аргумент задаёт краткое описание того, что делает программа и как она работает. В сообщениях справки описание отображается между строкой использования командной строки и справкой по различным аргументам.138139По умолчанию описание переносится по строкам, чтобы уместиться в отведённом пространстве. Чтобы изменить это поведение, обратитесь к аргументу [formatter\_class](https://python-all.ru/3.13/library/argparse.html#formatter-class).140141### эпилог142143Некоторые программы выводят дополнительное описание после описания аргументов. Такой текст можно указать с помощью аргумента `epilog=` для [`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser):144145```python146>>> parser = argparse.ArgumentParser(147...     description='A foo that bars',148...     epilog="And that's how you'd foo a bar")149>>> parser.print_help()150usage: argparse.py [-h]151152A foo that bars153154options:155 -h, --help  show this help message and exit156157And that's how you'd foo a bar158```159160Как и для аргумента [description](https://python-all.ru/3.13/library/argparse.html#description), текст `epilog=` по умолчанию переносится по строкам, но это поведение можно настроить с помощью аргумента [formatter\_class](https://python-all.ru/3.13/library/argparse.html#formatter-class) для [`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser).161162### родительские парсеры163164Иногда несколько парсеров используют общий набор аргументов. Вместо того чтобы повторять определения этих аргументов, можно использовать один парсер со всеми общими аргументами, передав его в аргумент `parents=` для [`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser). Аргумент `parents=` принимает список объектов `ArgumentParser`, собирает из них все позиционные и опциональные действия и добавляет эти действия в создаваемый объект `ArgumentParser`:165166```python167>>> parent_parser = argparse.ArgumentParser(add_help=False)168>>> parent_parser.add_argument('--parent', type=int)169170>>> foo_parser = argparse.ArgumentParser(parents=[parent_parser])171>>> foo_parser.add_argument('foo')172>>> foo_parser.parse_args(['--parent', '2', 'XXX'])173Namespace(foo='XXX', parent=2)174175>>> bar_parser = argparse.ArgumentParser(parents=[parent_parser])176>>> bar_parser.add_argument('--bar')177>>> bar_parser.parse_args(['--bar', 'YYY'])178Namespace(bar='YYY', parent=None)179```180181Обратите внимание, что большинство родительских парсеров указывают `add_help=False`. В противном случае [`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser) увидит две опции `-h/--help` (одну в родительском парсере, другую – в дочернем) и вызовет ошибку.182183> **Примечание**184>185> Парсеры должны быть полностью инициализированы перед передачей через `parents=`. Если изменить родительские парсеры после создания дочернего, эти изменения не отразятся на дочернем парсере.186187### класс форматирования188189Объекты [`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser) позволяют настраивать форматирование справки, указывая альтернативный класс форматирования. На данный момент существует четыре таких класса:190191#### `class argparse.RawDescriptionHelpFormatter`192193#### `class argparse.RawTextHelpFormatter`194195#### `class argparse.ArgumentDefaultsHelpFormatter`196197#### `class argparse.MetavarTypeHelpFormatter`198199[`RawDescriptionHelpFormatter`](https://python-all.ru/3.13/library/argparse.html#argparse.RawDescriptionHelpFormatter) и [`RawTextHelpFormatter`](https://python-all.ru/3.13/library/argparse.html#argparse.RawTextHelpFormatter) дают больше контроля над отображением текстовых описаний. По умолчанию объекты [`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser) переносят текст [description](https://python-all.ru/3.13/library/argparse.html#description) и [epilog](https://python-all.ru/3.13/library/argparse.html#epilog) в сообщениях справки командной строки:200201```python202>>> parser = argparse.ArgumentParser(203...     prog='PROG',204...     description='''this description205...         was indented weird206...             but that is okay''',207...     epilog='''208...             likewise for this epilog whose whitespace will209...         be cleaned up and whose words will be wrapped210...         across a couple lines''')211>>> parser.print_help()212usage: PROG [-h]213214this description was indented weird but that is okay215216options:217 -h, --help  show this help message and exit218219likewise for this epilog whose whitespace will be cleaned up and whose words220will be wrapped across a couple lines221```222223Передача [`RawDescriptionHelpFormatter`](https://python-all.ru/3.13/library/argparse.html#argparse.RawDescriptionHelpFormatter) в качестве `formatter_class=` означает, что [description](https://python-all.ru/3.13/library/argparse.html#description) и [epilog](https://python-all.ru/3.13/library/argparse.html#epilog) уже правильно отформатированы и не должны переноситься по строкам:224225```python226>>> parser = argparse.ArgumentParser(227...     prog='PROG',228...     formatter_class=argparse.RawDescriptionHelpFormatter,229...     description=textwrap.dedent('''\230...         Please do not mess up this text!231...         --------------------------------232...             I have indented it233...             exactly the way234...             I want it235...         '''))236>>> parser.print_help()237usage: PROG [-h]238239Please do not mess up this text!240--------------------------------241   I have indented it242   exactly the way243   I want it244245options:246 -h, --help  show this help message and exit247```248249[`RawTextHelpFormatter`](https://python-all.ru/3.13/library/argparse.html#argparse.RawTextHelpFormatter) сохраняет пробельные символы для всех видов текста справки, включая описания аргументов. Однако несколько символов новой строки заменяются на один. Если нужно сохранить несколько пустых строк, добавьте пробелы между ними.250251[`ArgumentDefaultsHelpFormatter`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentDefaultsHelpFormatter) автоматически добавляет информацию о значениях по умолчанию в сообщения справки каждого аргумента:252253```python254>>> parser = argparse.ArgumentParser(255...     prog='PROG',256...     formatter_class=argparse.ArgumentDefaultsHelpFormatter)257>>> parser.add_argument('--foo', type=int, default=42, help='FOO!')258>>> parser.add_argument('bar', nargs='*', default=[1, 2, 3], help='BAR!')259>>> parser.print_help()260usage: PROG [-h] [--foo FOO] [bar ...]261262positional arguments:263 bar         BAR! (default: [1, 2, 3])264265options:266 -h, --help  show this help message and exit267 --foo FOO   FOO! (default: 42)268```269270[`MetavarTypeHelpFormatter`](https://python-all.ru/3.13/library/argparse.html#argparse.MetavarTypeHelpFormatter) использует имя аргумента [type](https://python-all.ru/3.13/library/argparse.html#type) для каждого аргумента в качестве отображаемого имени для его значений (вместо [dest](https://python-all.ru/3.13/library/argparse.html#dest), как это делает обычный форматировщик):271272```python273>>> parser = argparse.ArgumentParser(274...     prog='PROG',275...     formatter_class=argparse.MetavarTypeHelpFormatter)276>>> parser.add_argument('--foo', type=int)277>>> parser.add_argument('bar', type=float)278>>> parser.print_help()279usage: PROG [-h] [--foo int] float280281positional arguments:282  float283284options:285  -h, --help  show this help message and exit286  --foo int287```288289### символы префикса290291Большинство опций командной строки используют `-` в качестве префикса, например `-f/--foo`. Парсеры, которым нужно поддерживать другие или дополнительные символы префикса, например для опций вроде `+f` или `/foo`, могут указать их с помощью аргумента `prefix_chars=` конструктора [`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser):292293```python294>>> parser = argparse.ArgumentParser(prog='PROG', prefix_chars='-+')295>>> parser.add_argument('+f')296>>> parser.add_argument('++bar')297>>> parser.parse_args('+f X ++bar Y'.split())298Namespace(bar='Y', f='X')299```300301Аргумент `prefix_chars=` по умолчанию равен `'-'`. Если указать набор символов, не включающий `-`, то опции `-f/--foo` будут запрещены.302303### символы префикса из файла304305Иногда при работе с особенно длинным списком аргументов может иметь смысл хранить список аргументов в файле, а не набирать его в командной строке. Если аргумент `fromfile_prefix_chars=` передан конструктору [`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser), то аргументы, начинающиеся с любого из указанных символов, будут рассматриваться как файлы и заменяться на содержащиеся в них аргументы. Например:306307```python308>>> with open('args.txt', 'w', encoding=sys.getfilesystemencoding()) as fp:309...     fp.write('-f\nbar')310...311>>> parser = argparse.ArgumentParser(fromfile_prefix_chars='@')312>>> parser.add_argument('-f')313>>> parser.parse_args(['-f', 'foo', '@args.txt'])314Namespace(f='bar')315```316317По умолчанию аргументы из файла должны быть по одному на строку (но см. также [`convert_arg_line_to_args()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.convert_arg_line_to_args)) и обрабатываются так, как если бы они находились на том же месте, что и исходный аргумент, ссылающийся на файл в командной строке. Таким образом, в примере выше выражение `['-f', 'foo', '@args.txt']` считается эквивалентным выражению `['-f', 'foo', '-f', 'bar']`.318319> **Примечание**320>321> Каждая строка рассматривается как отдельный аргумент, поэтому пустая строка читается как пустая строка (`''`).322323[`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser) использует [кодировку и обработчик ошибок файловой системы](https://python-all.ru/3.13/glossary.html#term-filesystem-encoding-and-error-handler) для чтения файла, содержащего аргументы.324325Аргумент `fromfile_prefix_chars=` по умолчанию равен `None`, что означает, что аргументы никогда не будут рассматриваться как ссылки на файлы.326327Изменено в версии 3.12: [`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser) изменил кодировку и обработку ошибок при чтении файлов аргументов с используемых по умолчанию (например, [`locale.getpreferredencoding(False)`](https://python-all.ru/3.13/library/locale.html#locale.getpreferredencoding) и `"strict"`) на [кодировку и обработчик ошибок файловой системы](https://python-all.ru/3.13/glossary.html#term-filesystem-encoding-and-error-handler). Файлы аргументов должны быть закодированы в UTF-8 вместо кодовой страницы ANSI в Windows.328329### argument\_default330331Обычно значения аргументов по умолчанию задаются либо передачей значения по умолчанию в [`add_argument()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.add_argument), либо вызовом методов [`set_defaults()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.set_defaults) с определённым набором пар имя-значение. Однако иногда может быть полезно указать единое значение по умолчанию для всех аргументов синтаксического анализатора. Это можно сделать, передав именованный аргумент `argument_default=` в [`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser). Например, чтобы глобально отключить создание атрибутов при вызовах [`parse_args()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.parse_args), укажите `argument_default=SUPPRESS`:332333```python334>>> parser = argparse.ArgumentParser(argument_default=argparse.SUPPRESS)335>>> parser.add_argument('--foo')336>>> parser.add_argument('bar', nargs='?')337>>> parser.parse_args(['--foo', '1', 'BAR'])338Namespace(bar='BAR', foo='1')339>>> parser.parse_args([])340Namespace()341```342343### allow\_abbrev344345Обычно при передаче списка аргументов методу [`parse_args()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.parse_args) объекта [`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser) он [распознаёт сокращения](https://python-all.ru/3.13/library/argparse.html#prefix-matching) длинных опций.346347Эту возможность можно отключить, установив `allow_abbrev` в `False`:348349```python350>>> parser = argparse.ArgumentParser(prog='PROG', allow_abbrev=False)351>>> parser.add_argument('--foobar', action='store_true')352>>> parser.add_argument('--foonley', action='store_false')353>>> parser.parse_args(['--foon'])354usage: PROG [-h] [--foobar] [--foonley]355PROG: error: unrecognized arguments: --foon356```357358Добавлено в версии 3.5.359360### conflict\_handler361362Объекты [`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser) не допускают два действия с одной и той же строкой опции. По умолчанию объекты `ArgumentParser` вызывают исключение при попытке создать аргумент со строкой опции, которая уже используется:363364```python365>>> parser = argparse.ArgumentParser(prog='PROG')366>>> parser.add_argument('-f', '--foo', help='old foo help')367>>> parser.add_argument('--foo', help='new foo help')368Traceback (most recent call last):369 ..370ArgumentError: argument --foo: conflicting option string(s): --foo371```372373Иногда (например, при использовании [parents](https://python-all.ru/3.13/library/argparse.html#parents)) бывает полезно просто переопределить все старые аргументы с той же строкой опции. Для получения такого поведения значение `'resolve'` можно передать в аргумент `conflict_handler=` функции [`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser):374375```python376>>> parser = argparse.ArgumentParser(prog='PROG', conflict_handler='resolve')377>>> parser.add_argument('-f', '--foo', help='old foo help')378>>> parser.add_argument('--foo', help='new foo help')379>>> parser.print_help()380usage: PROG [-h] [-f FOO] [--foo FOO]381382options:383 -h, --help  show this help message and exit384 -f FOO      old foo help385 --foo FOO   new foo help386```387388Обратите внимание, что объекты [`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser) удаляют действие только в том случае, если все его строки опций переопределены. Поэтому в приведённом выше примере старое действие `-f/--foo` сохраняется как действие `-f`, поскольку была переопределена только строка опции `--foo`.389390### add\_help391392По умолчанию объекты [`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser) добавляют опцию, которая просто отображает справочное сообщение синтаксического анализатора. Если в командной строке указано `-h` или `--help`, будет выведена справка `ArgumentParser`.393394Иногда может быть полезно отключить добавление этой опции справки. Это можно сделать, передав `False` в качестве аргумента `add_help=` функции [`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser):395396```python397>>> parser = argparse.ArgumentParser(prog='PROG', add_help=False)398>>> parser.add_argument('--foo', help='foo help')399>>> parser.print_help()400usage: PROG [--foo FOO]401402options:403 --foo FOO  foo help404```405406Обычно опция справки – это `-h/--help`. Исключение составляет случай, когда указан `prefix_chars=` и не включает `-`; в этом случае `-h` и `--help` не являются допустимыми опциями. В таком случае первый символ в `prefix_chars` используется в качестве префикса для опций справки:407408```python409>>> parser = argparse.ArgumentParser(prog='PROG', prefix_chars='+/')410>>> parser.print_help()411usage: PROG [+h]412413options:414  +h, ++help  show this help message and exit415```416417### exit\_on\_error418419Обычно при передаче недопустимого списка аргументов методу [`parse_args()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.parse_args) объекта [`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser) он выводит *сообщение* в [`sys.stderr`](https://python-all.ru/3.13/library/sys.html#sys.stderr) и завершает работу с кодом возврата 2.420421Если требуется перехватывать ошибки вручную, эту возможность можно включить, установив `exit_on_error` в `False`:422423```python424>>> parser = argparse.ArgumentParser(exit_on_error=False)425>>> parser.add_argument('--integers', type=int)426_StoreAction(option_strings=['--integers'], dest='integers', nargs=None, const=None, default=None, type=<class 'int'>, choices=None, help=None, metavar=None)427>>> try:428...     parser.parse_args('--integers a'.split())429... except argparse.ArgumentError:430...     print('Catching an argumentError')431...432Catching an argumentError433```434435Добавлено в версии 3.9.436437## Метод add\_argument()438439#### `ArgumentParser.add_argument(name or flags..., *[, action][, nargs][, const][, default][, type][, choices][, required][, help][, metavar][, dest][, deprecated])`440441Определяет, как должен разбираться один аргумент командной строки. Каждый параметр подробно описан ниже, а кратко они таковы:442443- [name or flags](https://python-all.ru/3.13/library/argparse.html#name-or-flags) – имя или список строк параметров, например `'foo'` или `'-f', '--foo'`.444- [action](https://python-all.ru/3.13/library/argparse.html#action) – базовый тип действия, которое выполняется при встрече этого аргумента в командной строке.445- [nargs](https://python-all.ru/3.13/library/argparse.html#nargs) – количество аргументов командной строки, которое должно быть потреблено.446- [const](https://python-all.ru/3.13/library/argparse.html#const) – постоянное значение, требуемое некоторыми значениями [action](https://python-all.ru/3.13/library/argparse.html#action) и [nargs](https://python-all.ru/3.13/library/argparse.html#nargs).447- [default](https://python-all.ru/3.13/library/argparse.html#default) – значение, которое используется, если аргумент отсутствует в командной строке и в объекте namespace.448- [type](https://python-all.ru/3.13/library/argparse.html#type) – тип, в который следует преобразовать аргумент командной строки.449- [choices](https://python-all.ru/3.13/library/argparse.html#choices) – последовательность допустимых значений для аргумента.450- [required](https://python-all.ru/3.13/library/argparse.html#required) – может ли параметр командной строки быть опущен (только для опциональных параметров).451- [help](https://python-all.ru/3.13/library/argparse.html#help) – краткое описание того, что делает аргумент.452- [metavar](https://python-all.ru/3.13/library/argparse.html#metavar) – имя аргумента в сообщениях об использовании.453- [dest](https://python-all.ru/3.13/library/argparse.html#dest) – имя атрибута, добавляемого в объект, возвращаемый [`parse_args()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.parse_args).454- [deprecated](https://python-all.ru/3.13/library/argparse.html#deprecated) – указывает, устарел ли аргумент.455456Метод возвращает объект [`Action`](https://python-all.ru/3.13/library/argparse.html#argparse.Action), представляющий аргумент.457458В следующих разделах описывается, как используется каждый из этих параметров.459460### имя или флаги461462Методу [`add_argument()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.add_argument) необходимо знать, ожидается ли опциональный аргумент (например, `-f` или `--foo`) или позиционный (например, список имён файлов). Поэтому первыми аргументами, передаваемыми в `add_argument()`, должны быть либо серия флагов, либо просто имя аргумента.463464Например, опциональный аргумент можно создать так:465466```python467>>> parser.add_argument('-f', '--foo')468```469470а позиционный – так:471472```python473>>> parser.add_argument('bar')474```475476При вызове [`parse_args()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.parse_args) опциональные аргументы опознаются по префиксу `-`, а остальные аргументы считаются позиционными:477478```python479>>> parser = argparse.ArgumentParser(prog='PROG')480>>> parser.add_argument('-f', '--foo')481>>> parser.add_argument('bar')482>>> parser.parse_args(['BAR'])483Namespace(bar='BAR', foo=None)484>>> parser.parse_args(['BAR', '--foo', 'FOO'])485Namespace(bar='BAR', foo='FOO')486>>> parser.parse_args(['--foo', 'FOO'])487usage: PROG [-h] [-f FOO] bar488PROG: error: the following arguments are required: bar489```490491### action492493Объекты [`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser) связывают аргументы командной строки с действиями. Эти действия могут делать с аргументами практически что угодно, но чаще всего они просто добавляют атрибут в объект, возвращаемый [`parse_args()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.parse_args). Ключевой аргумент `action` определяет, как следует обрабатывать аргументы командной строки. Доступны следующие действия:494495- `'store'` – просто сохраняет значение аргумента. Это действие по умолчанию.496- `'store_const'` – сохраняет значение, указанное ключевым аргументом [const](https://python-all.ru/3.13/library/argparse.html#const); обратите внимание, что ключевой аргумент [const](https://python-all.ru/3.13/library/argparse.html#const) по умолчанию равен `None`. Действие `'store_const'` чаще всего используется с опциональными аргументами, задающими какой-либо флаг. Например:497498  ```python499  >>> parser = argparse.ArgumentParser()500  >>> parser.add_argument('--foo', action='store_const', const=42)501  >>> parser.parse_args(['--foo'])502  Namespace(foo=42)503  ```504- `'store_true'` и `'store_false'` – частные случаи `'store_const'`, которые сохраняют значения `True` и `False` соответственно, со значениями по умолчанию `False` и `True`:505506  ```python507  >>> parser = argparse.ArgumentParser()508  >>> parser.add_argument('--foo', action='store_true')509  >>> parser.add_argument('--bar', action='store_false')510  >>> parser.add_argument('--baz', action='store_false')511  >>> parser.parse_args('--foo --bar'.split())512  Namespace(foo=True, bar=False, baz=True)513  ```514- `'append'` – добавляет каждое значение аргумента в список. Удобно, когда параметр можно указать несколько раз. Если значением по умолчанию является непустой список, разобранное значение будет начинаться с элементов этого списка, а все значения из командной строки будут добавлены после них. Пример использования:515516  ```python517  >>> parser = argparse.ArgumentParser()518  >>> parser.add_argument('--foo', action='append', default=['0'])519  >>> parser.parse_args('--foo 1 --foo 2'.split())520  Namespace(foo=['0', '1', '2'])521  ```522- `'append_const'` – добавляет значение, указанное ключевым аргументом [const](https://python-all.ru/3.13/library/argparse.html#const), в список; обратите внимание, что [const](https://python-all.ru/3.13/library/argparse.html#const) по умолчанию равно `None`. Действие `'append_const'` обычно полезно, когда несколько аргументов должны сохранять константы в один и тот же список. Например:523524  ```python525  >>> parser = argparse.ArgumentParser()526  >>> parser.add_argument('--str', dest='types', action='append_const', const=str)527  >>> parser.add_argument('--int', dest='types', action='append_const', const=int)528  >>> parser.parse_args('--str --int'.split())529  Namespace(types=[<class 'str'>, <class 'int'>])530  ```531- `'extend'` – добавляет каждый элемент многозначного аргумента в список. Действие `'extend'` обычно используется с ключевым аргументом [nargs](https://python-all.ru/3.13/library/argparse.html#nargs), имеющим значение `'+'` или `'*'`. Обратите внимание: если [nargs](https://python-all.ru/3.13/library/argparse.html#nargs) равно `None` (по умолчанию) или `'?'`, каждый символ строки аргумента будет добавлен в список. Пример использования:532533  ```python534  >>> parser = argparse.ArgumentParser()535  >>> parser.add_argument("--foo", action="extend", nargs="+", type=str)536  >>> parser.parse_args(["--foo", "f1", "--foo", "f2", "f3", "f4"])537  Namespace(foo=['f1', 'f2', 'f3', 'f4'])538  ```539540  Добавлено в версии 3.8.541- `'count'` – подсчитывает, сколько раз встречается аргумент. Например, это удобно для увеличения уровня подробности вывода:542543  ```python544  >>> parser = argparse.ArgumentParser()545  >>> parser.add_argument('--verbose', '-v', action='count', default=0)546  >>> parser.parse_args(['-vvv'])547  Namespace(verbose=3)548  ```549550  Обратите внимание: значение *default* будет `None`, если только оно явно не установлено в *0*.551- `'help'` – выводит полное справочное сообщение для всех параметров текущего анализатора и завершает работу. По умолчанию действие справки автоматически добавляется в анализатор. Подробности о том, как формируется вывод, см. в [`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser).552- `'version'` – ожидает именованный аргумент `version=` в вызове [`add_argument()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.add_argument) и при вызове выводит информацию о версии и завершает работу:553554  ```python555  >>> import argparse556  >>> parser = argparse.ArgumentParser(prog='PROG')557  >>> parser.add_argument('--version', action='version', version='%(prog)s 2.0')558  >>> parser.parse_args(['--version'])559  PROG 2.0560  ```561562Можно также указать произвольное действие, передав подкласс [`Action`](https://python-all.ru/3.13/library/argparse.html#argparse.Action) (например, [`BooleanOptionalAction`](https://python-all.ru/3.13/library/argparse.html#argparse.BooleanOptionalAction)) или другой объект, реализующий тот же интерфейс. Только действия, которые потребляют аргументы командной строки (например, `'store'`, `'append'`, `'extend'` или пользовательские действия с ненулевым `nargs`), могут использоваться с позиционными аргументами.563564Рекомендуемый способ создания пользовательского действия – расширить [`Action`](https://python-all.ru/3.13/library/argparse.html#argparse.Action), переопределив метод `__call__()` и, при необходимости, методы `__init__()` и `format_usage()`. Также можно зарегистрировать пользовательские действия с помощью метода [`register()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.register) и ссылаться на них по зарегистрированному имени.565566Пример пользовательского действия:567568```python569>>> class FooAction(argparse.Action):570...     def __init__(self, option_strings, dest, nargs=None, **kwargs):571...         if nargs is not None:572...             raise ValueError("nargs not allowed")573...         super().__init__(option_strings, dest, **kwargs)574...     def __call__(self, parser, namespace, values, option_string=None):575...         print('%r %r %r' % (namespace, values, option_string))576...         setattr(namespace, self.dest, values)577...578>>> parser = argparse.ArgumentParser()579>>> parser.add_argument('--foo', action=FooAction)580>>> parser.add_argument('bar', action=FooAction)581>>> args = parser.parse_args('1 --foo 2'.split())582Namespace(bar=None, foo=None) '1' None583Namespace(bar='1', foo=None) '2' '--foo'584>>> args585Namespace(bar='1', foo='2')586```587588Подробнее см. в [`Action`](https://python-all.ru/3.13/library/argparse.html#argparse.Action).589590### nargs591592Объекты [`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser) обычно связывают один аргумент командной строки с одним выполняемым действием. Именованный аргумент `nargs` связывает другое количество аргументов командной строки с одним действием. См. также [Указание неоднозначных аргументов](https://python-all.ru/3.13/howto/argparse.html#specifying-ambiguous-arguments). Поддерживаемые значения:593594- `N` (целое число). Аргументы `N` из командной строки будут собраны в список. Например:595596  ```python597  >>> parser = argparse.ArgumentParser()598  >>> parser.add_argument('--foo', nargs=2)599  >>> parser.add_argument('bar', nargs=1)600  >>> parser.parse_args('c --foo a b'.split())601  Namespace(bar=['c'], foo=['a', 'b'])602  ```603604  Обратите внимание, что `nargs=1` создаёт список из одного элемента. Это отличается от поведения по умолчанию, при котором элемент создаётся сам по себе.605606- `'?'`. Если возможно, будет потреблён один аргумент командной строки и выдан как отдельный элемент. Если аргумент командной строки отсутствует, будет выдано значение из [default](https://python-all.ru/3.13/library/argparse.html#default). Обратите внимание, что для необязательных аргументов есть дополнительный случай: строка параметра присутствует, но за ней не следует аргумент командной строки. В этом случае будет выдано значение из [const](https://python-all.ru/3.13/library/argparse.html#const). Некоторые примеры для иллюстрации:607608  ```python609  >>> parser = argparse.ArgumentParser()610  >>> parser.add_argument('--foo', nargs='?', const='c', default='d')611  >>> parser.add_argument('bar', nargs='?', default='d')612  >>> parser.parse_args(['XX', '--foo', 'YY'])613  Namespace(bar='XX', foo='YY')614  >>> parser.parse_args(['XX', '--foo'])615  Namespace(bar='XX', foo='c')616  >>> parser.parse_args([])617  Namespace(bar='d', foo='d')618  ```619620  Одно из наиболее распространённых применений `nargs='?'` – разрешение необязательных входных и выходных файлов:621622  ```python623  >>> parser = argparse.ArgumentParser()624  >>> parser.add_argument('infile', nargs='?', type=argparse.FileType('r'),625  ...                     default=sys.stdin)626  >>> parser.add_argument('outfile', nargs='?', type=argparse.FileType('w'),627  ...                     default=sys.stdout)628  >>> parser.parse_args(['input.txt', 'output.txt'])629  Namespace(infile=<_io.TextIOWrapper name='input.txt' encoding='UTF-8'>,630            outfile=<_io.TextIOWrapper name='output.txt' encoding='UTF-8'>)631  >>> parser.parse_args([])632  Namespace(infile=<_io.TextIOWrapper name='<stdin>' encoding='UTF-8'>,633            outfile=<_io.TextIOWrapper name='<stdout>' encoding='UTF-8'>)634  ```635636- `'*'`. Все присутствующие аргументы командной строки собираются в список. Обратите внимание, что обычно не имеет смысла указывать более одного позиционного аргумента с `nargs='*'`, но возможно несколько необязательных аргументов с `nargs='*'`. Например:637638  ```python639  >>> parser = argparse.ArgumentParser()640  >>> parser.add_argument('--foo', nargs='*')641  >>> parser.add_argument('--bar', nargs='*')642  >>> parser.add_argument('baz', nargs='*')643  >>> parser.parse_args('a b --foo x y --bar 1 2'.split())644  Namespace(bar=['1', '2'], baz=['a', 'b'], foo=['x', 'y'])645  ```646647- `'+'`. Как и `'*'`, все присутствующие аргументы командной строки собираются в список. Дополнительно будет сгенерировано сообщение об ошибке, если не было хотя бы одного аргумента командной строки. Например:648649  ```python650  >>> parser = argparse.ArgumentParser(prog='PROG')651  >>> parser.add_argument('foo', nargs='+')652  >>> parser.parse_args(['a', 'b'])653  Namespace(foo=['a', 'b'])654  >>> parser.parse_args([])655  usage: PROG [-h] foo [foo ...]656  PROG: error: the following arguments are required: foo657  ```658659Если именованный аргумент `nargs` не указан, количество потребляемых аргументов определяется действием [action](https://python-all.ru/3.13/library/argparse.html#action). Обычно это означает, что будет потреблён один аргумент командной строки и выдан один элемент (не список). Действия, которые не потребляют аргументы командной строки (например, `'store_const'`), устанавливают `nargs=0`.660661### const662663Аргумент `const` функции [`add_argument()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.add_argument) используется для хранения постоянных значений, которые не считываются из командной строки, но требуются для различных действий [`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser). Два наиболее распространённых его применения:664665- Когда [`add_argument()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.add_argument) вызывается с `action='store_const'` или `action='append_const'`. Эти действия добавляют значение `const` к одному из атрибутов объекта, возвращаемого [`parse_args()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.parse_args). Примеры см. в описании [action](https://python-all.ru/3.13/library/argparse.html#action). Если `const` не передан в `add_argument()`, он получит значение по умолчанию `None`.666- Когда [`add_argument()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.add_argument) вызывается со строками параметров (например, `-f` или `--foo`) и `nargs='?'`. Это создаёт необязательный аргумент, за которым может следовать ноль или один аргумент командной строки. При разборе командной строки, если встречена строка параметра без следующего за ней аргумента командной строки, будет использовано значение из `const`. Примеры см. в описании [nargs](https://python-all.ru/3.13/library/argparse.html#nargs).667668Изменено в версии 3.11: `const=None` по умолчанию, в том числе когда `action='append_const'` или `action='store_const'`.669670### default671672Все необязательные аргументы и некоторые позиционные аргументы могут быть опущены в командной строке. Именованный аргумент `default` функции [`add_argument()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.add_argument), значение которого по умолчанию равно `None`, указывает, какое значение следует использовать, если аргумент командной строки отсутствует. Для необязательных аргументов значение `default` используется, когда строка параметра отсутствовала в командной строке:673674```python675>>> parser = argparse.ArgumentParser()676>>> parser.add_argument('--foo', default=42)677>>> parser.parse_args(['--foo', '2'])678Namespace(foo='2')679>>> parser.parse_args([])680Namespace(foo=42)681```682683Если в целевом пространстве имён уже установлен атрибут, действие *default* не перезапишет его:684685```python686>>> parser = argparse.ArgumentParser()687>>> parser.add_argument('--foo', default=42)688>>> parser.parse_args([], namespace=argparse.Namespace(foo=101))689Namespace(foo=101)690```691692Если значение `default` является строкой, анализатор разбирает его так, как если бы это был аргумент командной строки. В частности, анализатор применяет любой аргумент преобразования [type](https://python-all.ru/3.13/library/argparse.html#type), если он указан, перед установкой атрибута в возвращаемом значении [`Namespace`](https://python-all.ru/3.13/library/argparse.html#argparse.Namespace). В противном случае анализатор использует значение как есть:693694```python695>>> parser = argparse.ArgumentParser()696>>> parser.add_argument('--length', default='10', type=int)697>>> parser.add_argument('--width', default=10.5, type=int)698>>> parser.parse_args()699Namespace(length=10, width=10.5)700```701702Для позиционных аргументов с [nargs](https://python-all.ru/3.13/library/argparse.html#nargs), равным `?` или `*`, значение `default` используется, когда аргумент командной строки отсутствовал:703704```python705>>> parser = argparse.ArgumentParser()706>>> parser.add_argument('foo', nargs='?', default=42)707>>> parser.parse_args(['a'])708Namespace(foo='a')709>>> parser.parse_args([])710Namespace(foo=42)711```712713Поскольку `nargs='*'` собирает все предоставленные значения в список, отсутствующий позиционный аргумент даёт пустой список (`[]`). Только значение *default*, не равное `None`, переопределяет это (поэтому `default=None` по-прежнему даёт `[]`).714715Для аргументов [required](https://python-all.ru/3.13/library/argparse.html#required) значение `default` игнорируется. Например, это относится к позиционным аргументам со значениями [nargs](https://python-all.ru/3.13/library/argparse.html#nargs), отличными от `?` или `*`, или к необязательным аргументам, помеченным как `required=True`.716717Указание `default=argparse.SUPPRESS` приводит к тому, что атрибут не добавляется, если аргумент командной строки отсутствовал:718719```python720>>> parser = argparse.ArgumentParser()721>>> parser.add_argument('--foo', default=argparse.SUPPRESS)722>>> parser.parse_args([])723Namespace()724>>> parser.parse_args(['--foo', '1'])725Namespace(foo='1')726```727728### тип729730По умолчанию анализатор считывает аргументы командной строки как простые строки. Однако довольно часто строку командной строки следует интерпретировать как другой тип, например [`float`](https://python-all.ru/3.13/library/functions.html#float) или [`int`](https://python-all.ru/3.13/library/functions.html#int). Именованный аргумент `type` функции [`add_argument()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.add_argument) позволяет выполнять любые необходимые проверки и преобразования типов.731732Если именованный аргумент [type](https://python-all.ru/3.13/library/argparse.html#type) используется вместе с [default](https://python-all.ru/3.13/library/argparse.html#default), преобразователь типа применяется только в том случае, если значение по умолчанию является строкой.733734Аргумент `type` может быть вызываемым объектом, принимающим одну строку, или именем зарегистрированного типа (см. [`register()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.register)). Если функция вызывает исключение [`ArgumentTypeError`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentTypeError), [`TypeError`](https://python-all.ru/3.13/library/exceptions.html#TypeError) или [`ValueError`](https://python-all.ru/3.13/library/exceptions.html#ValueError), исключение перехватывается и выводится хорошо оформленное сообщение об ошибке. Другие типы исключений не обрабатываются.735736Распространённые встроенные типы и функции можно использовать в качестве преобразователей типов:737738```python739import argparse740import pathlib741742parser = argparse.ArgumentParser()743parser.add_argument('count', type=int)744parser.add_argument('distance', type=float)745parser.add_argument('street', type=ascii)746parser.add_argument('code_point', type=ord)747parser.add_argument('dest_file', type=argparse.FileType('w', encoding='latin-1'))748parser.add_argument('datapath', type=pathlib.Path)749```750751Пользовательские функции также можно использовать:752753```pycon754>>> def hyphenated(string):755...     return '-'.join([word[:4] for word in string.casefold().split()])756...757>>> parser = argparse.ArgumentParser()758>>> _ = parser.add_argument('short_title', type=hyphenated)759>>> parser.parse_args(['"The Tale of Two Cities"'])760Namespace(short_title='"the-tale-of-two-citi')761```762763Функция [`bool()`](https://python-all.ru/3.13/library/functions.html#bool) не рекомендуется в качестве преобразователя типа. Всё, что она делает – преобразует пустые строки в `False`, а непустые в `True`. Обычно это не то, что нужно:764765```python766>>> parser = argparse.ArgumentParser()767>>> _ = parser.add_argument('--verbose', type=bool)768>>> parser.parse_args(['--verbose', 'False'])769Namespace(verbose=True)770```771772См. [`BooleanOptionalAction`](https://python-all.ru/3.13/library/argparse.html#argparse.BooleanOptionalAction) или `action='store_true'` для распространённых альтернатив.773774В целом, ключевое слово `type` – это удобство, которое следует использовать только для простых преобразований, способных вызывать лишь одно из трёх поддерживаемых исключений. Всё, что связано с более сложной обработкой ошибок или управлением ресурсами, должно выполняться ниже по потоку после разбора аргументов.775776Например, преобразования JSON или YAML содержат сложные случаи ошибок, которые требуют более детального отчёта, чем может дать ключевое слово `type`. Сообщение [`JSONDecodeError`](https://python-all.ru/3.13/library/json.html#json.JSONDecodeError) не будет хорошо отформатировано, а исключение [`FileNotFoundError`](https://python-all.ru/3.13/library/exceptions.html#FileNotFoundError) вообще не будет обработано.777778Даже [`FileType`](https://python-all.ru/3.13/library/argparse.html#argparse.FileType) имеет ограничения при использовании с ключевым словом `type`. Если один аргумент использует `FileType`, а затем следующий аргумент завершается ошибкой, сообщается об ошибке, но файл не закрывается автоматически. В этом случае лучше подождать, пока завершит работу парсер, а затем использовать оператор [`with`](https://python-all.ru/3.13/reference/compound_stmts.html#with) для управления файлами.779780Для проверок типов, которые просто сравнивают с фиксированным набором значений, рассмотрите вместо этого использование ключевого слова [choices](https://python-all.ru/3.13/library/argparse.html#choices).781782### choices783784Некоторые аргументы командной строки должны выбираться из ограниченного набора значений. Это можно обработать, передав объект-последовательность в качестве ключевого аргумента *choices* в [`add_argument()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.add_argument). При разборе командной строки значения аргументов будут проверены, и если аргумент не окажется среди допустимых значений, будет выведено сообщение об ошибке:785786```python787>>> parser = argparse.ArgumentParser(prog='game.py')788>>> parser.add_argument('move', choices=['rock', 'paper', 'scissors'])789>>> parser.parse_args(['rock'])790Namespace(move='rock')791>>> parser.parse_args(['fire'])792usage: game.py [-h] {rock,paper,scissors}793game.py: error: argument move: invalid choice: 'fire' (choose from 'rock',794'paper', 'scissors')795```796797В качестве значения *choices* можно передать любую последовательность, поэтому поддерживаются объекты [`list`](https://python-all.ru/3.13/library/stdtypes.html#list), объекты [`tuple`](https://python-all.ru/3.13/library/stdtypes.html#tuple) и пользовательские последовательности.798799Использование [`enum.Enum`](https://python-all.ru/3.13/library/enum.html#enum.Enum) не рекомендуется, поскольку сложно контролировать его отображение в сообщениях об использовании, справке и ошибках.800801Обратите внимание, что *choices* проверяются после применения любых преобразований [type](https://python-all.ru/3.13/library/argparse.html#type), поэтому объекты в *choices* должны соответствовать указанному [type](https://python-all.ru/3.13/library/argparse.html#type). Из-за этого *choices* могут выглядеть непривычно в сообщениях об использовании, справке или ошибках.802803Чтобы *choices* оставались удобными для пользователя, рассмотрите пользовательскую обёртку типа, которая преобразует и форматирует значения, либо опустите [type](https://python-all.ru/3.13/library/argparse.html#type) и обрабатывайте преобразование в коде приложения.804805Форматированные choices переопределяют значение *metavar* по умолчанию, которое обычно выводится из *dest*. Обычно это именно то, что нужно, поскольку пользователь никогда не видит параметр *dest*. Если такое отображение нежелательно (например, из-за большого количества вариантов), просто укажите явный [metavar](https://python-all.ru/3.13/library/argparse.html#metavar).806807### required808809В целом, модуль `argparse` предполагает, что флаги вида `-f` и `--bar` обозначают *необязательные* аргументы, которые всегда можно опустить в командной строке. Чтобы сделать опцию *обязательной*, для ключевого аргумента `required=` функции [`add_argument()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.add_argument) можно указать `True`:810811```python812>>> parser = argparse.ArgumentParser()813>>> parser.add_argument('--foo', required=True)814>>> parser.parse_args(['--foo', 'BAR'])815Namespace(foo='BAR')816>>> parser.parse_args([])817usage: [-h] --foo FOO818: error: the following arguments are required: --foo819```820821Как показано в примере, если опция помечена как `required`, [`parse_args()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.parse_args) сообщит об ошибке, если эта опция отсутствует в командной строке.822823> **Примечание**824>825> Обязательные опции обычно считаются дурным тоном, поскольку пользователи ожидают, что *опции* будут *необязательными*, поэтому их следует по возможности избегать.826827### help828829Значение `help` – это строка с кратким описанием аргумента. Когда пользователь запрашивает справку (обычно с помощью `-h` или `--help` в командной строке), эти описания `help` отображаются для каждого аргумента.830831Строки `help` могут содержать различные спецификаторы формата, чтобы избежать повторения таких элементов, как имя программы или [значение по умолчанию](https://python-all.ru/3.13/library/argparse.html#default) аргумента. Доступные спецификаторы включают имя программы, `%(prog)s` и большинство ключевых аргументов функции [`add_argument()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.add_argument), например `%(default)s`, `%(type)s` и т.д.:832833```python834>>> parser = argparse.ArgumentParser(prog='frobble')835>>> parser.add_argument('bar', nargs='?', type=int, default=42,836...                     help='the bar to %(prog)s (default: %(default)s)')837>>> parser.print_help()838usage: frobble [-h] [bar]839840positional arguments:841 bar     the bar to frobble (default: 42)842843options:844 -h, --help  show this help message and exit845```846847Поскольку строка справки поддерживает %-форматирование, если требуется, чтобы в ней отображался литерал `%`, его нужно экранировать как `%%`.848849`argparse` поддерживает скрытие записи справки для определённых опций путём установки значения `help` в `argparse.SUPPRESS`:850851```python852>>> parser = argparse.ArgumentParser(prog='frobble')853>>> parser.add_argument('--foo', help=argparse.SUPPRESS)854>>> parser.print_help()855usage: frobble [-h]856857options:858  -h, --help  show this help message and exit859```860861### metavar862863Когда [`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser) генерирует сообщения справки, ему нужен способ ссылаться на каждый ожидаемый аргумент. По умолчанию объекты `ArgumentParser` используют значение [dest](https://python-all.ru/3.13/library/argparse.html#dest) в качестве «имени» каждого объекта. Для действий с позиционными аргументами значение [dest](https://python-all.ru/3.13/library/argparse.html#dest) используется напрямую, а для действий с необязательными аргументами значение [dest](https://python-all.ru/3.13/library/argparse.html#dest) пишется заглавными буквами. Таким образом, одиночный позиционный аргумент с `dest='bar'` будет называться `bar`. Одиночный необязательный аргумент `--foo`, за которым должен следовать один аргумент командной строки, будет называться `FOO`. Пример:864865```python866>>> parser = argparse.ArgumentParser()867>>> parser.add_argument('--foo')868>>> parser.add_argument('bar')869>>> parser.parse_args('X --foo Y'.split())870Namespace(bar='X', foo='Y')871>>> parser.print_help()872usage:  [-h] [--foo FOO] bar873874positional arguments:875 bar876877options:878 -h, --help  show this help message and exit879 --foo FOO880```881882Альтернативное имя можно указать с помощью `metavar`:883884```python885>>> parser = argparse.ArgumentParser()886>>> parser.add_argument('--foo', metavar='YYY')887>>> parser.add_argument('bar', metavar='XXX')888>>> parser.parse_args('X --foo Y'.split())889Namespace(bar='X', foo='Y')890>>> parser.print_help()891usage:  [-h] [--foo YYY] XXX892893positional arguments:894 XXX895896options:897 -h, --help  show this help message and exit898 --foo YYY899```900901Обратите внимание, что `metavar` изменяет только *отображаемое* имя – имя атрибута объекта [`parse_args()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.parse_args) по-прежнему определяется значением [dest](https://python-all.ru/3.13/library/argparse.html#dest).902903Разные значения `nargs` могут привести к тому, что метапеременная будет использована несколько раз. Передача кортежа в `metavar` задаёт различное отображение для каждого из аргументов:904905```python906>>> parser = argparse.ArgumentParser(prog='PROG')907>>> parser.add_argument('-x', nargs=2)908>>> parser.add_argument('--foo', nargs=2, metavar=('bar', 'baz'))909>>> parser.print_help()910usage: PROG [-h] [-x X X] [--foo bar baz]911912options:913 -h, --help     show this help message and exit914 -x X X915 --foo bar baz916```917918### dest919920Большинство действий [`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser) добавляют некоторое значение как атрибут объекта, возвращаемого [`parse_args()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.parse_args). Имя этого атрибута определяется ключевым аргументом `dest` функции [`add_argument()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.add_argument). Для действий с позиционными аргументами `dest` обычно передаётся первым аргументом в `add_argument()`:921922```python923>>> parser = argparse.ArgumentParser()924>>> parser.add_argument('bar')925>>> parser.parse_args(['XXX'])926Namespace(bar='XXX')927```928929Для действий необязательных аргументов значение `dest` обычно выводится из строк опций. [`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser) генерирует значение `dest`, беря первую длинную строку опции и удаляя начальную строку `--`. Если длинные строки опций не были предоставлены, `dest` будет получен из первой короткой строки опции путем удаления начального символа `-`. Любые внутренние символы `-` будут преобразованы в символы `_`, чтобы гарантировать, что строка является допустимым именем атрибута. Примеры ниже иллюстрируют это поведение:930931```python932>>> parser = argparse.ArgumentParser()933>>> parser.add_argument('-f', '--foo-bar', '--foo')934>>> parser.add_argument('-x', '-y')935>>> parser.parse_args('-f 1 -x 2'.split())936Namespace(foo_bar='1', x='2')937>>> parser.parse_args('--foo 1 -y 2'.split())938Namespace(foo_bar='1', x='2')939```940941`dest` позволяет указать пользовательское имя атрибута:942943```python944>>> parser = argparse.ArgumentParser()945>>> parser.add_argument('--foo', dest='bar')946>>> parser.parse_args('--foo XXX'.split())947Namespace(bar='XXX')948```949950Несколько аргументов могут ссылаться на один и тот же `dest`. По умолчанию используется значение из последнего такого аргумента, переданного в командной строке. Используйте `action='append'`, чтобы собирать значения от всех таких аргументов в список. Для конфликтующих *строк параметров*, а не`dest` имён, см. [conflict\_handler](https://python-all.ru/3.13/library/argparse.html#conflict-handler).951952### устарело953954В течение жизненного цикла проекта некоторые аргументы могут потребовать удаления из командной строки. Перед удалением следует сообщить пользователям, что эти аргументы устарели и будут удалены. Ключевой аргумент `deprecated` метода [`add_argument()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.add_argument), который по умолчанию равен `False`, указывает, что аргумент устарел и будет удалён в будущем. Для аргументов, если `deprecated` равно `True`, то при использовании аргумента будет выведено предупреждение в [`sys.stderr`](https://python-all.ru/3.13/library/sys.html#sys.stderr):955956```python957>>> import argparse958>>> parser = argparse.ArgumentParser(prog='snake.py')959>>> parser.add_argument('--legs', default=0, type=int, deprecated=True)960>>> parser.parse_args([])961Namespace(legs=0)962>>> parser.parse_args(['--legs', '4'])963snake.py: warning: option '--legs' is deprecated964Namespace(legs=4)965```966967Добавлено в версии 3.13.968969### Классы действий970971`Action` классы реализуют Action API – вызываемый объект, который возвращает вызываемый объект, обрабатывающий аргументы из командной строки. Любой объект, соответствующий этому API, может быть передан в качестве параметра `action` в [`add_argument()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.add_argument).972973#### `class argparse.Action(option_strings, dest, nargs=None, const=None, default=None, type=None, choices=None, required=False, help=None, metavar=None)`974975`Action` объекты используются [`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser) для представления информации, необходимой для разбора одного аргумента из одной или нескольких строк командной строки. Класс `Action` должен принимать два позиционных аргумента и любые ключевые аргументы, переданные в [`ArgumentParser.add_argument()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.add_argument), кроме самого `action`.976977Экземпляры `Action` (или возвращаемое значение любого вызываемого объекта для параметра `action`) должны иметь атрибуты `dest`, `option_strings`, `default`, `type`, `required`, `help` и т.д. Проще всего гарантировать наличие этих атрибутов – вызвать `Action.__init__()`.978979#### `__call__(parser, namespace, values, option_string=None)`980981Экземпляры `Action` должны быть вызываемыми, поэтому подклассы должны переопределять метод `__call__()`, который принимает четыре параметра:982983- *parser* – объект [`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser), содержащий это действие.984- *namespace* – объект [`Namespace`](https://python-all.ru/3.13/library/argparse.html#argparse.Namespace), который будет возвращён [`parse_args()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.parse_args). Обычно действия добавляют атрибут к этому объекту с помощью [`setattr()`](https://python-all.ru/3.13/library/functions.html#setattr).985- *values* – связанные аргументы командной строки с применёнными преобразованиями типов. Преобразования типов задаются ключевым аргументом [type](https://python-all.ru/3.13/library/argparse.html#type) в [`add_argument()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.add_argument).986- *option\_string* – строка параметра, которая использовалась для вызова этого действия. Аргумент `option_string` необязателен и будет отсутствовать, если действие связано с позиционным аргументом.987988Метод `__call__()` может выполнять произвольные действия, но обычно устанавливает атрибуты объекта `namespace` на основе `dest` и `values`.989990#### `format_usage()`991992Подклассы `Action` могут определить метод `format_usage()` без аргументов, возвращающий строку, которая будет использоваться при выводе справки об использовании программы. Если такой метод не предоставлен, используется разумное значение по умолчанию.993994#### `class argparse.BooleanOptionalAction`995996Подкласс [`Action`](https://python-all.ru/3.13/library/argparse.html#argparse.Action) для обработки булевых флагов с положительными и отрицательными параметрами. Добавление одного аргумента, например `--foo`, автоматически создаёт оба параметра `--foo` и `--no-foo`, сохраняя `True` и `False` соответственно:997998```python999>>> import argparse1000>>> parser = argparse.ArgumentParser()1001>>> parser.add_argument('--foo', action=argparse.BooleanOptionalAction)1002>>> parser.parse_args(['--no-foo'])1003Namespace(foo=False)1004```10051006Добавлено в версии 3.9.10071008## Метод parse\_args()10091010#### `ArgumentParser.parse_args(args=None, namespace=None)`10111012Преобразует строки аргументов в объекты и назначает их в качестве атрибутов пространства имён. Возвращает заполненное пространство имён.10131014Предыдущие вызовы [`add_argument()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.add_argument) определяют, какие объекты создаются и как они назначаются. Подробнее см. документацию `add_argument()`.10151016- [args](https://python-all.ru/3.13/library/argparse.html#args) – список строк для разбора. По умолчанию берётся из [`sys.argv`](https://python-all.ru/3.13/library/sys.html#sys.argv).1017- [namespace](https://python-all.ru/3.13/library/argparse.html#namespace) – объект, в который будут помещены атрибуты. По умолчанию – новый пустой объект [`Namespace`](https://python-all.ru/3.13/library/argparse.html#argparse.Namespace).10181019### Синтаксис значений параметров10201021Метод [`parse_args()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.parse_args) поддерживает несколько способов указания значения параметра (если он принимает значение). В простейшем случае параметр и его значение передаются как два отдельных аргумента:10221023```python1024>>> parser = argparse.ArgumentParser(prog='PROG')1025>>> parser.add_argument('-x')1026>>> parser.add_argument('--foo')1027>>> parser.parse_args(['-x', 'X'])1028Namespace(foo=None, x='X')1029>>> parser.parse_args(['--foo', 'FOO'])1030Namespace(foo='FOO', x=None)1031```10321033Для длинных параметров (с именами длиннее одного символа) параметр и значение могут быть переданы как один аргумент командной строки, используя `=` для их разделения:10341035```python1036>>> parser.parse_args(['--foo=FOO'])1037Namespace(foo='FOO', x=None)1038```10391040Для коротких опций (опции длиной в один символ) опция и её значение могут быть объединены:10411042```python1043>>> parser.parse_args(['-xX'])1044Namespace(foo=None, x='X')1045```10461047Несколько коротких опций можно объединить, используя только один префикс `-`, при условии, что только последняя опция (или ни одна из них) требует значения:10481049```python1050>>> parser = argparse.ArgumentParser(prog='PROG')1051>>> parser.add_argument('-x', action='store_true')1052>>> parser.add_argument('-y', action='store_true')1053>>> parser.add_argument('-z')1054>>> parser.parse_args(['-xyzZ'])1055Namespace(x=True, y=True, z='Z')1056```10571058### Недопустимые аргументы10591060При разборе командной строки [`parse_args()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.parse_args) проверяет различные ошибки, включая неоднозначные опции, некорректные типы, неверные опции, неправильное количество позиционных аргументов и т.д. При обнаружении такой ошибки программа завершается и выводит сообщение об ошибке вместе со справкой по использованию:10611062```python1063>>> parser = argparse.ArgumentParser(prog='PROG')1064>>> parser.add_argument('--foo', type=int)1065>>> parser.add_argument('bar', nargs='?')10661067>>> # недопустимый тип1068>>> parser.parse_args(['--foo', 'spam'])1069usage: PROG [-h] [--foo FOO] [bar]1070PROG: error: argument --foo: invalid int value: 'spam'10711072>>> # недопустимая опция1073>>> parser.parse_args(['--bar'])1074usage: PROG [-h] [--foo FOO] [bar]1075PROG: error: no such option: --bar10761077>>> # неверное количество аргументов1078>>> parser.parse_args(['spam', 'badger'])1079usage: PROG [-h] [--foo FOO] [bar]1080PROG: error: extra arguments found: badger1081```10821083### Аргументы, содержащие `-`10841085Метод [`parse_args()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.parse_args) старается выдавать ошибки всякий раз, когда пользователь явно ошибся, но некоторые ситуации по своей природе неоднозначны. Например, аргумент командной строки `-1` может быть как попыткой указать опцию, так и попыткой передать позиционный аргумент. Метод `parse_args()` здесь действует осторожно: позиционные аргументы могут начинаться с `-` только если они похожи на отрицательные числа, и в анализаторе нет опций, которые выглядят как отрицательные числа:10861087```python1088>>> parser = argparse.ArgumentParser(prog='PROG')1089>>> parser.add_argument('-x')1090>>> parser.add_argument('foo', nargs='?')10911092>>> # нет опций с отрицательными числами, поэтому -1 – позиционный аргумент1093>>> parser.parse_args(['-x', '-1'])1094Namespace(foo=None, x='-1')10951096>>> # нет опций с отрицательными числами, поэтому -1 и -5 – позиционные аргументы1097>>> parser.parse_args(['-x', '-1', '-5'])1098Namespace(foo='-5', x='-1')10991100>>> parser = argparse.ArgumentParser(prog='PROG')1101>>> parser.add_argument('-1', dest='one')1102>>> parser.add_argument('foo', nargs='?')11031104>>> # опции с отрицательными числами присутствуют, поэтому -1 – это опция1105>>> parser.parse_args(['-1', 'X'])1106Namespace(foo=None, one='X')11071108>>> # опции с отрицательными числами присутствуют, поэтому -2 – это опция1109>>> parser.parse_args(['-2'])1110usage: PROG [-h] [-1 ONE] [foo]1111PROG: error: no such option: -211121113>>> # опции с отрицательными числами присутствуют, поэтому обе -1 – это опции1114>>> parser.parse_args(['-1', '-1'])1115usage: PROG [-h] [-1 ONE] [foo]1116PROG: error: argument -1: expected one argument1117```11181119Если позиционные аргументы должны начинаться с `-` и не похожи на отрицательные числа, можно вставить псевдоаргумент `'--'`, который сообщает [`parse_args()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.parse_args), что всё после него является позиционным аргументом:11201121```python1122>>> parser.parse_args(['--', '-f'])1123Namespace(foo='-f', one=None)1124```11251126См. также [руководство по argparse о неоднозначных аргументах](https://python-all.ru/3.13/howto/argparse.html#specifying-ambiguous-arguments) для получения дополнительных сведений.11271128### Сокращения аргументов (совпадение по префиксу)11291130Метод [`parse_args()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.parse_args) [по умолчанию](https://python-all.ru/3.13/library/argparse.html#allow-abbrev) позволяет сокращать длинные опции до префикса, если сокращение является однозначным (префикс соответствует уникальной опции):11311132```python1133>>> parser = argparse.ArgumentParser(prog='PROG')1134>>> parser.add_argument('-bacon')1135>>> parser.add_argument('-badger')1136>>> parser.parse_args('-bac MMM'.split())1137Namespace(bacon='MMM', badger=None)1138>>> parser.parse_args('-bad WOOD'.split())1139Namespace(bacon=None, badger='WOOD')1140>>> parser.parse_args('-ba BA'.split())1141usage: PROG [-h] [-bacon BACON] [-badger BADGER]1142PROG: error: ambiguous option: -ba could match -badger, -bacon1143```11441145Выдаётся ошибка для аргументов, которые могут соответствовать нескольким опциям. Эту возможность можно отключить, установив [allow\_abbrev](https://python-all.ru/3.13/library/argparse.html#allow-abbrev) в `False`.11461147### За пределами `sys.argv`11481149Иногда бывает полезно, чтобы [`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser) разбирал аргументы, отличные от аргументов [`sys.argv`](https://python-all.ru/3.13/library/sys.html#sys.argv). Это можно сделать, передав список строк в [`parse_args()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.parse_args). Это удобно для тестирования в интерактивной оболочке:11501151```python1152>>> parser = argparse.ArgumentParser()1153>>> parser.add_argument(1154...     'integers', metavar='int', type=int, choices=range(10),1155...     nargs='+', help='an integer in the range 0..9')1156>>> parser.add_argument(1157...     '--sum', dest='accumulate', action='store_const', const=sum,1158...     default=max, help='sum the integers (default: find the max)')1159>>> parser.parse_args(['1', '2', '3', '4'])1160Namespace(accumulate=<built-in function max>, integers=[1, 2, 3, 4])1161>>> parser.parse_args(['1', '2', '3', '4', '--sum'])1162Namespace(accumulate=<built-in function sum>, integers=[1, 2, 3, 4])1163```11641165### Объект Namespace11661167#### `class argparse.Namespace`11681169Простой класс, используемый по умолчанию в [`parse_args()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.parse_args) для создания объекта, содержащего атрибуты, и его возврата.11701171Этот класс намеренно прост, всего лишь подкласс [`object`](https://python-all.ru/3.13/library/functions.html#object) с читаемым строковым представлением. Если нужно dict-подобное представление атрибутов, можно воспользоваться стандартной идиомой Python, [`vars()`](https://python-all.ru/3.13/library/functions.html#vars):11721173```python1174>>> parser = argparse.ArgumentParser()1175>>> parser.add_argument('--foo')1176>>> args = parser.parse_args(['--foo', 'BAR'])1177>>> vars(args)1178{'foo': 'BAR'}1179```11801181Также может быть полезно, чтобы [`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser) присваивал атрибуты уже существующему объекту, а не новому объекту `Namespace`. Этого можно достичь, указав именованный аргумент `namespace=`:11821183```python1184>>> class C:1185...     pass1186...1187>>> c = C()1188>>> parser = argparse.ArgumentParser()1189>>> parser.add_argument('--foo')1190>>> parser.parse_args(args=['--foo', 'BAR'], namespace=c)1191>>> c.foo1192'BAR'1193```11941195## Другие утилиты11961197### Подкоманды11981199#### `ArgumentParser.add_subparsers(*[, title][, description][, prog][, parser_class][, action][, dest][, required][, help][, metavar])`12001201Многие программы разделяют свою функциональность на несколько подкоманд; например, программа `svn` может вызывать подкоманды `svn checkout`, `svn update` и `svn commit`. Такое разделение функциональности может быть особенно удачной идеей, когда программа выполняет несколько различных функций, требующих разных видов аргументов командной строки. [`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser) поддерживает создание таких подкоманд с помощью метода `add_subparsers()`. Метод `add_subparsers()` обычно вызывается без аргументов и возвращает специальный объект действия. Этот объект имеет единственный метод, `add_parser()`, который принимает имя команды и любые аргументы конструктора `ArgumentParser`, и возвращает объект `ArgumentParser`, который можно изменять обычным образом.12021203Описание параметров:12041205- *title* – заголовок для группы подпарсеров в выводе справки; по умолчанию «subcommands», если указано описание, в противном случае используется заголовок для позиционных аргументов1206- *description* – описание для группы подпарсеров в выводе справки; по умолчанию `None`1207- *prog* – информация об использовании, которая будет отображаться в справке подкоманды; по умолчанию – имя программы и любые позиционные аргументы перед аргументом подпарсера1208- *parser\_class* – класс, который будет использоваться для создания экземпляров подпарсеров; по умолчанию – класс текущего парсера (например, [`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser))1209- [action](https://python-all.ru/3.13/library/argparse.html#action) – базовый тип действия, которое будет выполнено при обнаружении этого аргумента в командной строке1210- [dest](https://python-all.ru/3.13/library/argparse.html#dest) – имя атрибута, в котором будет сохранено имя подкоманды; по умолчанию `None` и значение не сохраняется1211- [required](https://python-all.ru/3.13/library/argparse.html#required) – указывает, обязательно ли должна быть указана подкоманда; по умолчанию `False` (добавлено в версии 3.7)1212- [help](https://python-all.ru/3.13/library/argparse.html#help) – справка для группы подпарсеров в выводе справки; по умолчанию `None`1213- [metavar](https://python-all.ru/3.13/library/argparse.html#metavar) – строка, представляющая доступные подкоманды в справке; по умолчанию `None`, и подкоманды отображаются в виде {cmd1, cmd2, ..}12141215Пример использования:12161217```python1218>>> # создать парсер верхнего уровня1219>>> parser = argparse.ArgumentParser(prog='PROG')1220>>> parser.add_argument('--foo', action='store_true', help='foo help')1221>>> subparsers = parser.add_subparsers(help='subcommand help')1222>>>1223>>> # создать парсер для команды "a"1224>>> parser_a = subparsers.add_parser('a', help='a help')1225>>> parser_a.add_argument('bar', type=int, help='bar help')1226>>>1227>>> # создать парсер для команды "b"1228>>> parser_b = subparsers.add_parser('b', help='b help')1229>>> parser_b.add_argument('--baz', choices=('X', 'Y', 'Z'), help='baz help')1230>>>1231>>> # разобрать некоторые списки аргументов1232>>> parser.parse_args(['a', '12'])1233Namespace(bar=12, foo=False)1234>>> parser.parse_args(['--foo', 'b', '--baz', 'Z'])1235Namespace(baz='Z', foo=True)1236```12371238Обратите внимание, что объект, возвращаемый [`parse_args()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.parse_args), будет содержать только атрибуты главного парсера и того подпарсера, который был выбран из командной строки (а не любых других подпарсеров). Так, в приведённом выше примере, когда указана команда `a`, присутствуют только атрибуты `foo` и `bar`, а когда указана команда `b` – только атрибуты `foo` и `baz`.12391240Если подпарсер определяет аргумент с тем же `dest`, что и родительский парсер, они разделяют один атрибут пространства имён, поэтому значение родителя не будет сохранено. Пользователям следует задать им разные значения `dest`, чтобы сохранить оба.12411242Аналогично, при запросе справки от подпарсера выводится только справка этого конкретного парсера. Сообщение справки не включает сообщения родительского парсера или соседних парсеров. (Однако справку для каждой команды подпарсера можно задать, передав аргумент `help=` функции `add_parser()`, как показано выше.)12431244```python1245>>> parser.parse_args(['--help'])1246usage: PROG [-h] [--foo] {a,b} ...12471248positional arguments:1249  {a,b}   subcommand help1250    a     a help1251    b     b help12521253options:1254  -h, --help  show this help message and exit1255  --foo   foo help12561257>>> parser.parse_args(['a', '--help'])1258usage: PROG a [-h] bar12591260positional arguments:1261  bar     bar help12621263options:1264  -h, --help  show this help message and exit12651266>>> parser.parse_args(['b', '--help'])1267usage: PROG b [-h] [--baz {X,Y,Z}]12681269options:1270  -h, --help     show this help message and exit1271  --baz {X,Y,Z}  baz help1272```12731274Метод `add_subparsers()` также поддерживает именованные аргументы `title` и `description`. Когда любой из них присутствует, команды подпарсера отображаются в собственной группе в выводе справки. Например:12751276```python1277>>> parser = argparse.ArgumentParser()1278>>> subparsers = parser.add_subparsers(title='subcommands',1279...                                    description='valid subcommands',1280...                                    help='additional help')1281>>> subparsers.add_parser('foo')1282>>> subparsers.add_parser('bar')1283>>> parser.parse_args(['-h'])1284usage:  [-h] {foo,bar} ...12851286options:1287  -h, --help  show this help message and exit12881289subcommands:1290  valid subcommands12911292  {foo,bar}   additional help1293```12941295Кроме того, `add_parser()` поддерживает дополнительный аргумент *aliases*, который позволяет нескольким строкам ссылаться на один и тот же подпарсер. Этот пример, как и `svn`, использует псевдоним `co` как сокращение для `checkout`:12961297```python1298>>> parser = argparse.ArgumentParser()1299>>> subparsers = parser.add_subparsers()1300>>> checkout = subparsers.add_parser('checkout', aliases=['co'])1301>>> checkout.add_argument('foo')1302>>> parser.parse_args(['co', 'bar'])1303Namespace(foo='bar')1304```13051306`add_parser()` также поддерживает дополнительный аргумент *устарело*, который позволяет пометить подпарсер как устаревший.13071308```python1309>>> import argparse1310>>> parser = argparse.ArgumentParser(prog='chicken.py')1311>>> subparsers = parser.add_subparsers()1312>>> run = subparsers.add_parser('run')1313>>> fly = subparsers.add_parser('fly', deprecated=True)1314>>> parser.parse_args(['fly'])1315chicken.py: warning: command 'fly' is deprecated1316Namespace()1317```13181319Добавлено в версии 3.13.13201321Один из особенно эффективных способов обработки подкоманд – комбинировать использование метода `add_subparsers()` с вызовами [`set_defaults()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.set_defaults), чтобы каждый подпарсер знал, какую функцию Python он должен выполнить. Например:13221323```python1324>>> # функции подкоманд1325>>> def foo(args):1326...     print(args.x * args.y)1327...1328>>> def bar(args):1329...     print('((%s))' % args.z)1330...1331>>> # создать парсер верхнего уровня1332>>> parser = argparse.ArgumentParser()1333>>> subparsers = parser.add_subparsers(required=True)1334>>>1335>>> # создать парсер для команды "foo"1336>>> parser_foo = subparsers.add_parser('foo')1337>>> parser_foo.add_argument('-x', type=int, default=1)1338>>> parser_foo.add_argument('y', type=float)1339>>> parser_foo.set_defaults(func=foo)1340>>>1341>>> # создать парсер для команды "bar"1342>>> parser_bar = subparsers.add_parser('bar')1343>>> parser_bar.add_argument('z')1344>>> parser_bar.set_defaults(func=bar)1345>>>1346>>> # разобрать аргументы и вызвать выбранную функцию1347>>> args = parser.parse_args('foo 1 -x 2'.split())1348>>> args.func(args)13492.01350>>>1351>>> # разобрать аргументы и вызвать выбранную функцию1352>>> args = parser.parse_args('bar XYZYX'.split())1353>>> args.func(args)1354((XYZYX))1355```13561357Таким образом, можно поручить [`parse_args()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.parse_args) задачу вызова соответствующей функции после завершения разбора аргументов. Связывание функций с действиями таким образом – обычно самый простой способ обработать разные действия для каждого из ваших подпарсеров. Однако, если необходимо проверить имя вызванного подпарсера, сработает именованный аргумент `dest` при вызове `add_subparsers()`:13581359```python1360>>> parser = argparse.ArgumentParser()1361>>> subparsers = parser.add_subparsers(dest='subparser_name')1362>>> subparser1 = subparsers.add_parser('1')1363>>> subparser1.add_argument('-x')1364>>> subparser2 = subparsers.add_parser('2')1365>>> subparser2.add_argument('y')1366>>> parser.parse_args(['2', 'frobble'])1367Namespace(subparser_name='2', y='frobble')1368```13691370Изменено в версии 3.7: Новый именованный параметр *required*.13711372### Объекты FileType13731374#### `class argparse.FileType(mode='r', bufsize=-1, encoding=None, errors=None)`13751376Фабрика `FileType` создаёт объекты, которые можно передать в аргумент type функции [`ArgumentParser.add_argument()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.add_argument). Аргументы, имеющие объекты `FileType` в качестве типа, будут открывать аргументы командной строки как файлы с указанными режимами, размерами буфера, кодировками и обработкой ошибок (см. функцию [`open()`](https://python-all.ru/3.13/library/functions.html#open) для подробностей):13771378```python1379>>> parser = argparse.ArgumentParser()1380>>> parser.add_argument('--raw', type=argparse.FileType('wb', 0))1381>>> parser.add_argument('out', type=argparse.FileType('w', encoding='UTF-8'))1382>>> parser.parse_args(['--raw', 'raw.dat', 'file.txt'])1383Namespace(out=<_io.TextIOWrapper name='file.txt' mode='w' encoding='UTF-8'>, raw=<_io.FileIO name='raw.dat' mode='wb'>)1384```13851386Объекты FileType понимают псевдоаргумент `'-'` и автоматически преобразуют его в [`sys.stdin`](https://python-all.ru/3.13/library/sys.html#sys.stdin) для читаемых объектов `FileType` и в [`sys.stdout`](https://python-all.ru/3.13/library/sys.html#sys.stdout) для записываемых объектов `FileType`:13871388```python1389>>> parser = argparse.ArgumentParser()1390>>> parser.add_argument('infile', type=argparse.FileType('r'))1391>>> parser.parse_args(['-'])1392Namespace(infile=<_io.TextIOWrapper name='<stdin>' encoding='UTF-8'>)1393```13941395Изменено в версии 3.4: Добавлены параметры *encoding* и *errors*.13961397### Группы аргументов13981399#### `ArgumentParser.add_argument_group(title=None, description=None, *[, argument_default][, conflict_handler])`14001401По умолчанию [`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser) группирует аргументы командной строки на «позиционные аргументы» и «опции» при отображении сообщений справки. Если существует более осмысленная концептуальная группировка аргументов, чем эта, можно создать соответствующие группы с помощью метода `add_argument_group()`:14021403```python1404>>> parser = argparse.ArgumentParser(prog='PROG', add_help=False)1405>>> group = parser.add_argument_group('group')1406>>> group.add_argument('--foo', help='foo help')1407>>> group.add_argument('bar', help='bar help')1408>>> parser.print_help()1409usage: PROG [--foo FOO] bar14101411group:1412  bar    bar help1413  --foo FOO  foo help1414```14151416Метод `add_argument_group()` возвращает объект группы аргументов, у которого есть метод [`add_argument()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.add_argument), как и у обычного [`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser). Когда аргумент добавляется в группу, парсер обрабатывает его как обычный аргумент, но при выводе справки отображает его в отдельной группе. Метод `add_argument_group()` принимает аргументы *title* и *description*, которые можно использовать для настройки этого отображения:14171418```python1419>>> parser = argparse.ArgumentParser(prog='PROG', add_help=False)1420>>> group1 = parser.add_argument_group('group1', 'group1 description')1421>>> group1.add_argument('foo', help='foo help')1422>>> group2 = parser.add_argument_group('group2', 'group2 description')1423>>> group2.add_argument('--bar', help='bar help')1424>>> parser.print_help()1425usage: PROG [--bar BAR] foo14261427group1:1428  group1 description14291430  foo    foo help14311432group2:1433  group2 description14341435  --bar BAR  bar help1436```14371438Необязательные именованные параметры [argument\_default](https://python-all.ru/3.13/library/argparse.html#argument-default) и [conflict\_handler](https://python-all.ru/3.13/library/argparse.html#conflict-handler) позволяют более детально управлять поведением группы аргументов. Эти параметры имеют тот же смысл, что и в конструкторе [`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser), но применяются именно к группе аргументов, а не ко всему парсеру.14391440Обратите внимание, что любые аргументы, не входящие в ваши пользовательские группы, окажутся обратно в обычных разделах «позиционные аргументы» и «опциональные аргументы».14411442Внутри каждой группы аргументов они отображаются в выводе справки в порядке их добавления.14431444Изменено в версии 3.11: Вызов `add_argument_group()` для группы аргументов устарел. Эта возможность никогда не поддерживалась и не всегда работает корректно. Функция присутствует в API случайно, из-за наследования, и будет удалена в будущем.14451446### Взаимное исключение14471448#### `ArgumentParser.add_mutually_exclusive_group(required=False)`14491450Создаёт взаимоисключающую группу. `argparse` гарантирует, что в командной строке присутствовал только один из аргументов взаимоисключающей группы:14511452```python1453>>> parser = argparse.ArgumentParser(prog='PROG')1454>>> group = parser.add_mutually_exclusive_group()1455>>> group.add_argument('--foo', action='store_true')1456>>> group.add_argument('--bar', action='store_false')1457>>> parser.parse_args(['--foo'])1458Namespace(bar=True, foo=True)1459>>> parser.parse_args(['--bar'])1460Namespace(bar=False, foo=False)1461>>> parser.parse_args(['--foo', '--bar'])1462usage: PROG [-h] [--foo | --bar]1463PROG: error: argument --bar: not allowed with argument --foo1464```14651466Метод `add_mutually_exclusive_group()` также принимает аргумент *required*, чтобы указать, что требуется хотя бы один из взаимоисключающих аргументов:14671468```python1469>>> parser = argparse.ArgumentParser(prog='PROG')1470>>> group = parser.add_mutually_exclusive_group(required=True)1471>>> group.add_argument('--foo', action='store_true')1472>>> group.add_argument('--bar', action='store_false')1473>>> parser.parse_args([])1474usage: PROG [-h] (--foo | --bar)1475PROG: error: one of the arguments --foo --bar is required1476```14771478Обратите внимание: в настоящее время взаимоисключающие группы аргументов не поддерживают аргументы *title* и *description* метода [`add_argument_group()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.add_argument_group). Однако взаимоисключающую группу можно добавить к группе аргументов, у которой есть заголовок и описание. Например:14791480```python1481>>> parser = argparse.ArgumentParser(prog='PROG')1482>>> group = parser.add_argument_group('Group title', 'Group description')1483>>> exclusive_group = group.add_mutually_exclusive_group(required=True)1484>>> exclusive_group.add_argument('--foo', help='foo help')1485>>> exclusive_group.add_argument('--bar', help='bar help')1486>>> parser.print_help()1487usage: PROG [-h] (--foo FOO | --bar BAR)14881489options:1490  -h, --help  show this help message and exit14911492Group title:1493  Group description14941495  --foo FOO   foo help1496  --bar BAR   bar help1497```14981499Изменено в версии 3.11: Вызов [`add_argument_group()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.add_argument_group) или `add_mutually_exclusive_group()` для взаимоисключающей группы устарел. Эти возможности никогда не поддерживались и не всегда работают корректно. Функции присутствуют в API случайно, из-за наследования, и будут удалены в будущем.15001501### Умолчания парсера15021503#### `ArgumentParser.set_defaults(**kwargs)`15041505В большинстве случаев атрибуты объекта, возвращаемого [`parse_args()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.parse_args), полностью определяются путём анализа аргументов командной строки и действий аргументов. `set_defaults()` позволяет добавить некоторые дополнительные атрибуты, которые определяются без какого-либо анализа командной строки:15061507```python1508>>> parser = argparse.ArgumentParser()1509>>> parser.add_argument('foo', type=int)1510>>> parser.set_defaults(bar=42, baz='badger')1511>>> parser.parse_args(['736'])1512Namespace(bar=42, baz='badger', foo=736)1513```15141515Обратите внимание: умолчания можно задать как на уровне парсера с помощью `set_defaults()`, так и на уровне аргумента с помощью [`add_argument()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.add_argument). Если оба метода вызываются для одного и того же аргумента, используется последнее установленное умолчание:15161517```python1518>>> parser = argparse.ArgumentParser()1519>>> parser.add_argument('--foo', default='bar')1520>>> parser.set_defaults(foo='spam')1521>>> parser.parse_args([])1522Namespace(foo='spam')1523```15241525Умолчания на уровне парсера могут быть особенно полезны при работе с несколькими парсерами. См. пример этого типа в методе [`add_subparsers()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.add_subparsers).15261527#### `ArgumentParser.get_default(dest)`15281529Возвращает значение по умолчанию для атрибута пространства имён, заданное либо [`add_argument()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.add_argument), либо [`set_defaults()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.set_defaults):15301531```python1532>>> parser = argparse.ArgumentParser()1533>>> parser.add_argument('--foo', default='badger')1534>>> parser.get_default('foo')1535'badger'1536```15371538### Вывод справки15391540В большинстве типичных приложений [`parse_args()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.parse_args) берёт на себя форматирование и вывод всех сообщений об использовании и ошибок. Однако доступно несколько методов форматирования:15411542#### `ArgumentParser.print_usage(file=None)`15431544Выводит краткое описание того, как [`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser) должен вызываться в командной строке. Если *file* равен `None`, предполагается [`sys.stdout`](https://python-all.ru/3.13/library/sys.html#sys.stdout).15451546#### `ArgumentParser.print_help(file=None)`15471548Выводит справочное сообщение, включая использование программы и информацию об аргументах, зарегистрированных в [`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser). Если *file* равен `None`, предполагается [`sys.stdout`](https://python-all.ru/3.13/library/sys.html#sys.stdout).15491550Существуют также варианты этих методов, которые просто возвращают строку вместо её вывода:15511552#### `ArgumentParser.format_usage()`15531554Возвращает строку с кратким описанием того, как [`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser) должен вызываться в командной строке.15551556#### `ArgumentParser.format_help()`15571558Возвращает строку со справочным сообщением, включая использование программы и информацию об аргументах, зарегистрированных в [`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser).15591560### Частичный разбор15611562#### `ArgumentParser.parse_known_args(args=None, namespace=None)`15631564Иногда скрипту нужно обрабатывать только определённый набор аргументов командной строки, оставляя нераспознанные аргументы для другого скрипта или программы. В таких случаях может быть полезен метод `parse_known_args()`.15651566Этот метод работает аналогично [`parse_args()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.parse_args), но не вызывает ошибку для лишних нераспознанных аргументов. Вместо этого он разбирает известные аргументы и возвращает кортеж из двух элементов, содержащий заполненное пространство имён и список всех нераспознанных аргументов.15671568```python1569>>> parser = argparse.ArgumentParser()1570>>> parser.add_argument('--foo', action='store_true')1571>>> parser.add_argument('bar')1572>>> parser.parse_known_args(['--foo', '--badger', 'BAR', 'spam'])1573(Namespace(bar='BAR', foo=True), ['--badger', 'spam'])1574```15751576> **Предупреждение**1577>1578> Правила [совпадения по префиксу](https://python-all.ru/3.13/library/argparse.html#prefix-matching) применяются к [`parse_known_args()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.parse_known_args). Парсер может поглотить параметр, даже если он является всего лишь префиксом одного из известных параметров, вместо того чтобы оставить его в списке оставшихся аргументов.15791580### Настройка разбора файлов15811582#### `ArgumentParser.convert_arg_line_to_args(arg_line)`15831584Аргументы, читаемые из файла (см. именованный аргумент *fromfile\_prefix\_chars* конструктора [`ArgumentParser`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser)), читаются по одному аргументу на строку. `convert_arg_line_to_args()` можно переопределить для более сложного чтения.15851586Этот метод принимает один аргумент *arg\_line* – строку, прочитанную из файла аргументов. Он возвращает список аргументов, разобранных из этой строки. Метод вызывается по одному разу для каждой строки из файла аргументов, по порядку.15871588Полезным переопределением этого метода будет то, которое рассматривает каждое отделённое пробелом слово как аргумент. Следующий пример показывает, как это сделать:15891590```python1591class MyArgumentParser(argparse.ArgumentParser):1592    def convert_arg_line_to_args(self, arg_line):1593        return arg_line.split()1594```15951596Обратите внимание: при таком переопределении аргумент больше не может содержать пробелы, поскольку каждое отделённое пробелом слово становится отдельным аргументом.15971598### Методы завершения15991600#### `ArgumentParser.exit(status=0, message=None)`16011602Этот метод завершает программу с указанным *status* и, если задано, выводит *message* в [`sys.stderr`](https://python-all.ru/3.13/library/sys.html#sys.stderr) перед этим. Пользователь может переопределить этот метод, чтобы выполнять эти действия иначе:16031604```python1605class ErrorCatchingArgumentParser(argparse.ArgumentParser):1606    def exit(self, status=0, message=None):1607        if status:1608            raise Exception(f'Exiting because of an error: {message}')1609        exit(status)1610```16111612#### `ArgumentParser.error(message)`16131614Этот метод выводит сообщение об использовании, включая *message*, в [`sys.stderr`](https://python-all.ru/3.13/library/sys.html#sys.stderr) и завершает программу с кодом возврата 2.16151616### Смешанный разбор16171618#### `ArgumentParser.parse_intermixed_args(args=None, namespace=None)`16191620#### `ArgumentParser.parse_known_intermixed_args(args=None, namespace=None)`16211622Многие команды Unix позволяют пользователю смешивать опциональные аргументы с позиционными. Методы [`parse_intermixed_args()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.parse_intermixed_args) и `parse_known_intermixed_args()` поддерживают такой стиль разбора.16231624Эти анализаторы не поддерживают все возможности `argparse` и будут вызывать исключения при использовании неподдерживаемых возможностей. В частности, не поддерживаются подпарсеры и взаимоисключающие группы, содержащие как опциональные, так и позиционные аргументы.16251626Следующий пример показывает разницу между [`parse_known_args()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.parse_known_args) и [`parse_intermixed_args()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.parse_intermixed_args): первый возвращает `['2', '3']` как неразобранные аргументы, в то время как второй собирает все позиционные аргументы в `rest`.16271628```python1629>>> parser = argparse.ArgumentParser()1630>>> parser.add_argument('--foo')1631>>> parser.add_argument('cmd')1632>>> parser.add_argument('rest', nargs='*', type=int)1633>>> parser.parse_known_args('doit 1 --foo bar 2 3'.split())1634(Namespace(cmd='doit', foo='bar', rest=[1]), ['2', '3'])1635>>> parser.parse_intermixed_args('doit 1 --foo bar 2 3'.split())1636Namespace(cmd='doit', foo='bar', rest=[1, 2, 3])1637```16381639`parse_known_intermixed_args()` возвращает кортеж из двух элементов, содержащий заполненное пространство имён и список оставшихся строк аргументов. [`parse_intermixed_args()`](https://python-all.ru/3.13/library/argparse.html#argparse.ArgumentParser.parse_intermixed_args) вызывает ошибку, если остаются какие-либо неразобранные строки аргументов.16401641Добавлено в версии 3.7.16421643### Регистрация пользовательских типов или действий16441645#### `ArgumentParser.register(registry_name, value, object)`16461647Иногда бывает удобно использовать произвольную строку в сообщениях об ошибках, чтобы сделать вывод более понятным для пользователя. В таких случаях `register()` можно использовать для регистрации пользовательских действий или типов в анализаторе и ссылаться на тип по его зарегистрированному имени, а не по имени вызываемого объекта.16481649Метод `register()` принимает три аргумента: *registry\_name*, указывающий внутренний реестр, в котором будет сохранён объект (например, `action`, `type`); *value* – ключ, под которым объект будет зарегистрирован; и object – вызываемый объект, который нужно зарегистрировать.16501651Следующий пример показывает, как зарегистрировать пользовательский тип в анализаторе:16521653```python1654>>> import argparse1655>>> parser = argparse.ArgumentParser()1656>>> parser.register('type', 'hexadecimal integer', lambda s: int(s, 16))1657>>> parser.add_argument('--foo', type='hexadecimal integer')1658_StoreAction(option_strings=['--foo'], dest='foo', nargs=None, const=None, default=None, type='hexadecimal integer', choices=None, required=False, help=None, metavar=None, deprecated=False)1659>>> parser.parse_args(['--foo', '0xFA'])1660Namespace(foo=250)1661>>> parser.parse_args(['--foo', '1.2'])1662usage: PROG [-h] [--foo FOO]1663PROG: error: argument --foo: invalid 'hexadecimal integer' value: '1.2'1664```16651666## Исключения16671668#### `exception argparse.ArgumentError`16691670Ошибка при создании или использовании аргумента (опционального или позиционного).16711672Строковое значение этого исключения – это сообщение, дополненное информацией об аргументе, который его вызвал.16731674#### `exception argparse.ArgumentTypeError`16751676Вызывается, когда что-то идёт не так при преобразовании строки командной строки в тип.16771678Руководства и учебные пособия16791680- [Учебное пособие по argparse](https://python-all.ru/3.13/howto/argparse.html)1681- [Перенос кода `optparse` на `argparse`](https://python-all.ru/3.13/howto/argparse-optparse.html)1682