argparse.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2025, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# mollinaca, 2021
# Shin Saito, 2021
# Atsuo Ishimoto <atsuoishimoto@gmail.com>, 2022
# Takeshi Nakazato, 2023
# Takanori Suzuki <takanori@takanory.net>, 2024
# Arihiro TAKASE, 2024
# tomo, 2024
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.13\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2025-03-28 14:18+0000\n"
"PO-Revision-Date: 2021-06-28 00:54+0000\n"
"Last-Translator: tomo, 2024\n"
"Language-Team: Japanese (https://app.transifex.com/python-doc/teams/5390/"
"ja/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: ja\n"
"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../library/argparse.rst:2
msgid ""
":mod:`!argparse` --- Parser for command-line options, arguments and "
"subcommands"
msgstr ""

#: ../../library/argparse.rst:12
msgid "**Source code:** :source:`Lib/argparse.py`"
msgstr "**ソースコード:** :source:`Lib/argparse.py`"

#: ../../library/argparse.rst:16
msgid ""
"While :mod:`argparse` is the default recommended standard library module for "
"implementing basic command line applications, authors with more exacting "
"requirements for exactly how their command line applications behave may find "
"it doesn't provide the necessary level of control. Refer to :ref:`choosing-"
"an-argument-parser` for alternatives to consider when ``argparse`` doesn't "
"support behaviors that the application requires (such as entirely disabling "
"support for interspersed options and positional arguments, or accepting "
"option parameter values that start with ``-`` even when they correspond to "
"another defined option)."
msgstr ""

#: ../../library/argparse.rst-1
msgid "Tutorial"
msgstr "チュートリアル"

#: ../../library/argparse.rst:30
msgid ""
"This page contains the API reference information. For a more gentle "
"introduction to Python command-line parsing, have a look at the :ref:"
"`argparse tutorial <argparse-tutorial>`."
msgstr ""
"このページは API のリファレンス情報が記載しています。:ref:`argparse チュート"
"リアル <argparse-tutorial>` では、コマンドラインの解析についてより優しく説明"
"しています。"

#: ../../library/argparse.rst:34
msgid ""
"The :mod:`!argparse` module makes it easy to write user-friendly command-"
"line interfaces. The program defines what arguments it requires, and :mod:`!"
"argparse` will figure out how to parse those out of :data:`sys.argv`.  The :"
"mod:`!argparse` module also automatically generates help and usage "
"messages.  The module will also issue errors when users give the program "
"invalid arguments."
msgstr ""

#: ../../library/argparse.rst:40
msgid ""
"The :mod:`!argparse` module's support for command-line interfaces is built "
"around an instance of :class:`argparse.ArgumentParser`.  It is a container "
"for argument specifications and has options that apply to the parser as "
"whole::"
msgstr ""

#: ../../library/argparse.rst:44
msgid ""
"parser = argparse.ArgumentParser(\n"
"                    prog='ProgramName',\n"
"                    description='What the program does',\n"
"                    epilog='Text at the bottom of help')"
msgstr ""

#: ../../library/argparse.rst:49
msgid ""
"The :meth:`ArgumentParser.add_argument` method attaches individual argument "
"specifications to the parser.  It supports positional arguments, options "
"that accept values, and on/off flags::"
msgstr ""
":meth:`ArgumentParser.add_argument` メソッドは各引数の仕様をパーサーに付属さ"
"せます。このメソッドは位置引数、値を受け取るオプション、機能のオン／オフを切"
"り替えるフラグをサポートします::"

#: ../../library/argparse.rst:53
msgid ""
"parser.add_argument('filename')           # positional argument\n"
"parser.add_argument('-c', '--count')      # option that takes a value\n"
"parser.add_argument('-v', '--verbose',\n"
"                    action='store_true')  # on/off flag"
msgstr ""

#: ../../library/argparse.rst:58
msgid ""
"The :meth:`ArgumentParser.parse_args` method runs the parser and places the "
"extracted data in a :class:`argparse.Namespace` object::"
msgstr ""
":meth:`ArgumentParser.parse_args` メソッドはパーサーを実行し、抽出したデータ"
"を :class:`argparse.Namespace` オブジェクト内に配置します::"

#: ../../library/argparse.rst:61
msgid ""
"args = parser.parse_args()\n"
"print(args.filename, args.count, args.verbose)"
msgstr ""

#: ../../library/argparse.rst:65
msgid ""
"If you're looking for a guide about how to upgrade :mod:`optparse` code to :"
"mod:`!argparse`, see :ref:`Upgrading Optparse Code <upgrading-optparse-"
"code>`."
msgstr ""

#: ../../library/argparse.rst:69
msgid "ArgumentParser objects"
msgstr "ArgumentParser オブジェクト"

#: ../../library/argparse.rst:78
msgid ""
"Create a new :class:`ArgumentParser` object. All parameters should be passed "
"as keyword arguments. Each parameter has its own more detailed description "
"below, but in short they are:"
msgstr ""
"新しい :class:`ArgumentParser` オブジェクトを生成します。すべての引数はキー"
"ワード引数として渡すべきです。各引数についてはあとで詳しく説明しますが、簡単"
"に言うと:"

#: ../../library/argparse.rst:82
msgid ""
"prog_ - The name of the program (default: ``os.path.basename(sys.argv[0])``)"
msgstr "prog_ - プログラム名(デフォルト: ``os.path.basename(sys.argv[0])``)"

#: ../../library/argparse.rst:85
msgid ""
"usage_ - The string describing the program usage (default: generated from "
"arguments added to parser)"
msgstr ""
"usage_ - プログラムの利用方法を記述する文字列 (デフォルト: パーサーに追加され"
"た引数から生成されます)"

#: ../../library/argparse.rst:88
msgid ""
"description_ - Text to display before the argument help (by default, no text)"
msgstr ""
"description_ - 引数のヘルプの前に表示されるテキスト (デフォルトはテキストなし"
"です)"

#: ../../library/argparse.rst:91
msgid "epilog_ - Text to display after the argument help (by default, no text)"
msgstr ""
"epilog_ - 引数のヘルプの後に表示されるテキスト (デフォルトはテキストなしです)"

#: ../../library/argparse.rst:93
msgid ""
"parents_ - A list of :class:`ArgumentParser` objects whose arguments should "
"also be included"
msgstr ""
"parents_ - :class:`ArgumentParser` オブジェクトのリストで、このオブジェクトの"
"引数が追加されます"

#: ../../library/argparse.rst:96
msgid "formatter_class_ - A class for customizing the help output"
msgstr "formatter_class_ - ヘルプ出力をカスタマイズするためのクラス"

#: ../../library/argparse.rst:98
msgid ""
"prefix_chars_ - The set of characters that prefix optional arguments "
"(default: '-')"
msgstr ""
"prefix_chars_ - オプションの引数の prefix になる文字集合 (デフォルト: '-')"

#: ../../library/argparse.rst:101
msgid ""
"fromfile_prefix_chars_ - The set of characters that prefix files from which "
"additional arguments should be read (default: ``None``)"
msgstr ""
"fromfile_prefix_chars_ - 追加の引数を読み込むファイルの prefix になる文字集"
"合 (デフォルト: ``None``)"

#: ../../library/argparse.rst:104
msgid ""
"argument_default_ - The global default value for arguments (default: "
"``None``)"
msgstr ""
"argument_default_ - 引数のグローバルなデフォルト値 (デフォルト: ``None``)"

#: ../../library/argparse.rst:107
msgid ""
"conflict_handler_ - The strategy for resolving conflicting optionals "
"(usually unnecessary)"
msgstr "conflict_handler_ - 衝突するオプションを解決する方法 (通常は不要)"

#: ../../library/argparse.rst:110
msgid ""
"add_help_ - Add a ``-h/--help`` option to the parser (default: ``True``)"
msgstr ""
"add_help_ - ``-h/--help`` オプションをパーサーに追加する (デフォルト: "
"``True``)"

#: ../../library/argparse.rst:112
msgid ""
"allow_abbrev_ - Allows long options to be abbreviated if the abbreviation is "
"unambiguous. (default: ``True``)"
msgstr ""
"allow_abbrev_ - 長いオプションが先頭文字列に短縮可能 (先頭の文字が一意) であ"
"る場合に短縮指定を許可する。(デフォルト: ``True``)"

#: ../../library/argparse.rst:115
msgid ""
"exit_on_error_ - Determines whether or not :class:`!ArgumentParser` exits "
"with error info when an error occurs. (default: ``True``)"
msgstr ""

#: ../../library/argparse.rst:118
msgid "*allow_abbrev* parameter was added."
msgstr "*allow_abbrev* 引数が追加されました。"

#: ../../library/argparse.rst:121
msgid ""
"In previous versions, *allow_abbrev* also disabled grouping of short flags "
"such as ``-vv`` to mean ``-v -v``."
msgstr ""
"以前のバージョンでは、 *allow_abbrev* は、``-vv`` が ``-v -v`` と等価になるよ"
"うな、短いフラグのグループ化を無効にしていました。"

#: ../../library/argparse.rst:125
msgid "*exit_on_error* parameter was added."
msgstr "*exit_on_error* 引数が追加されました。"

#: ../../library/argparse.rst:128 ../../library/argparse.rst:610
msgid "The following sections describe how each of these are used."
msgstr "以下の節では各オプションの利用方法を説明します。"

#: ../../library/argparse.rst:134
msgid "prog"
msgstr "``prog``"

#: ../../library/argparse.rst:137
msgid ""
"By default, :class:`ArgumentParser` calculates the name of the program to "
"display in help messages depending on the way the Python interpreter was run:"
msgstr ""

#: ../../library/argparse.rst:140
msgid ""
"The :func:`base name <os.path.basename>` of ``sys.argv[0]`` if a file was "
"passed as argument."
msgstr ""

#: ../../library/argparse.rst:142
msgid ""
"The Python interpreter name followed by ``sys.argv[0]`` if a directory or a "
"zipfile was passed as argument."
msgstr ""

#: ../../library/argparse.rst:144
msgid ""
"The Python interpreter name followed by ``-m`` followed by the module or "
"package name if the :option:`-m` option was used."
msgstr ""

#: ../../library/argparse.rst:147
msgid ""
"This default is almost always desirable because it will make the help "
"messages match the string that was used to invoke the program on the command "
"line. However, to change this default behavior, another value can be "
"supplied using the ``prog=`` argument to :class:`ArgumentParser`::"
msgstr ""

#: ../../library/argparse.rst:152
msgid ""
">>> parser = argparse.ArgumentParser(prog='myprogram')\n"
">>> parser.print_help()\n"
"usage: myprogram [-h]\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit"
msgstr ""

#: ../../library/argparse.rst:159
msgid ""
"Note that the program name, whether determined from ``sys.argv[0]`` or from "
"the ``prog=`` argument, is available to help messages using the ``%(prog)s`` "
"format specifier."
msgstr ""
"プログラム名は、``sys.argv[0]`` から取られた場合でも ``prog=`` 引数で与えられ"
"た場合でも、ヘルプメッセージ中では ``%(prog)s`` フォーマット指定子で利用でき"
"ます。"

#: ../../library/argparse.rst:165
msgid ""
">>> parser = argparse.ArgumentParser(prog='myprogram')\n"
">>> parser.add_argument('--foo', help='foo of the %(prog)s program')\n"
">>> parser.print_help()\n"
"usage: myprogram [-h] [--foo FOO]\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit\n"
" --foo FOO   foo of the myprogram program"
msgstr ""

#: ../../library/argparse.rst:176
msgid "usage"
msgstr "usage"

#: ../../library/argparse.rst:178
msgid ""
"By default, :class:`ArgumentParser` calculates the usage message from the "
"arguments it contains. The default message can be overridden with the "
"``usage=`` keyword argument::"
msgstr ""

#: ../../library/argparse.rst:182
msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG', usage='%(prog)s "
"[options]')\n"
">>> parser.add_argument('--foo', nargs='?', help='foo help')\n"
">>> parser.add_argument('bar', nargs='+', help='bar help')\n"
">>> parser.print_help()\n"
"usage: PROG [options]\n"
"\n"
"positional arguments:\n"
" bar          bar help\n"
"\n"
"options:\n"
" -h, --help   show this help message and exit\n"
" --foo [FOO]  foo help"
msgstr ""

#: ../../library/argparse.rst:195
msgid ""
"The ``%(prog)s`` format specifier is available to fill in the program name "
"in your usage messages."
msgstr ""
"``%(prog)s`` フォーマット指定子を、使用法メッセージ内でプログラム名として利用"
"できます。"

#: ../../library/argparse.rst:202
msgid "description"
msgstr "description"

#: ../../library/argparse.rst:204
msgid ""
"Most calls to the :class:`ArgumentParser` constructor will use the "
"``description=`` keyword argument.  This argument gives a brief description "
"of what the program does and how it works.  In help messages, the "
"description is displayed between the command-line usage string and the help "
"messages for the various arguments."
msgstr ""

#: ../../library/argparse.rst:210
msgid ""
"By default, the description will be line-wrapped so that it fits within the "
"given space.  To change this behavior, see the formatter_class_ argument."
msgstr ""
"デフォルトでは、説明は与えられたスペースに合わせて折り返されます。この挙動を"
"変更するには、formatter_class_ 引数を参照してください。"

#: ../../library/argparse.rst:215
msgid "epilog"
msgstr "epilog"

#: ../../library/argparse.rst:217
msgid ""
"Some programs like to display additional description of the program after "
"the description of the arguments.  Such text can be specified using the "
"``epilog=`` argument to :class:`ArgumentParser`::"
msgstr ""
"いくつかのプログラムは、プログラムについての追加の説明を引数の説明の後に表示"
"します。このテキストは :class:`ArgumentParser` の ``epilog=`` 引数に指定でき"
"ます::"

#: ../../library/argparse.rst:221
msgid ""
">>> parser = argparse.ArgumentParser(\n"
"...     description='A foo that bars',\n"
"...     epilog=\"And that's how you'd foo a bar\")\n"
">>> parser.print_help()\n"
"usage: argparse.py [-h]\n"
"\n"
"A foo that bars\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit\n"
"\n"
"And that's how you'd foo a bar"
msgstr ""

#: ../../library/argparse.rst:234
msgid ""
"As with the description_ argument, the ``epilog=`` text is by default line-"
"wrapped, but this behavior can be adjusted with the formatter_class_ "
"argument to :class:`ArgumentParser`."
msgstr ""
"description_ 引数と同じく、``epilog=`` テキストもデフォルトで折り返され、:"
"class:`ArgumentParser` の formatter_class_ 引数で動作を調整できます。"

#: ../../library/argparse.rst:240
msgid "parents"
msgstr "parents"

#: ../../library/argparse.rst:242
msgid ""
"Sometimes, several parsers share a common set of arguments. Rather than "
"repeating the definitions of these arguments, a single parser with all the "
"shared arguments and passed to ``parents=`` argument to :class:"
"`ArgumentParser` can be used.  The ``parents=`` argument takes a list of :"
"class:`ArgumentParser` objects, collects all the positional and optional "
"actions from them, and adds these actions to the :class:`ArgumentParser` "
"object being constructed::"
msgstr ""
"ときどき、いくつかのパーサーが共通の引数セットを共有することがあります。それ"
"らの引数を繰り返し定義する代わりに、すべての共通引数を持ったパーサーを :"
"class:`ArgumentParser` の ``parents=`` 引数に渡すことができます。 "
"``parents=`` 引数は :class:`ArgumentParser` オブジェクトのリストを受け取り、"
"すべての位置アクションとオプションのアクションをそれらから集め、そのアクショ"
"ンを構築中の :class:`ArgumentParser` オブジェクトに追加します::"

#: ../../library/argparse.rst:249
msgid ""
">>> parent_parser = argparse.ArgumentParser(add_help=False)\n"
">>> parent_parser.add_argument('--parent', type=int)\n"
"\n"
">>> foo_parser = argparse.ArgumentParser(parents=[parent_parser])\n"
">>> foo_parser.add_argument('foo')\n"
">>> foo_parser.parse_args(['--parent', '2', 'XXX'])\n"
"Namespace(foo='XXX', parent=2)\n"
"\n"
">>> bar_parser = argparse.ArgumentParser(parents=[parent_parser])\n"
">>> bar_parser.add_argument('--bar')\n"
">>> bar_parser.parse_args(['--bar', 'YYY'])\n"
"Namespace(bar='YYY', parent=None)"
msgstr ""

#: ../../library/argparse.rst:262
msgid ""
"Note that most parent parsers will specify ``add_help=False``.  Otherwise, "
"the :class:`ArgumentParser` will see two ``-h/--help`` options (one in the "
"parent and one in the child) and raise an error."
msgstr ""
"一番親になるパーサーに ``add_help=False`` を指定していることに注目してくださ"
"い。こうしないと、:class:`ArgumentParser` は2つの ``-h/--help`` オプションを"
"与えられる (1つは親から、もうひとつは子から) ことになり、エラーを発生します。"

#: ../../library/argparse.rst:267
msgid ""
"You must fully initialize the parsers before passing them via ``parents=``. "
"If you change the parent parsers after the child parser, those changes will "
"not be reflected in the child."
msgstr ""
"``parents=`` に渡す前にパーサーを完全に初期化する必要があります。子パーサーを"
"作成してから親パーサーを変更した場合、その変更は子パーサーに反映されません。"

#: ../../library/argparse.rst:275
msgid "formatter_class"
msgstr "formatter_class"

#: ../../library/argparse.rst:277
msgid ""
":class:`ArgumentParser` objects allow the help formatting to be customized "
"by specifying an alternate formatting class.  Currently, there are four such "
"classes:"
msgstr ""
":class:`ArgumentParser` オブジェクトは代わりのフォーマットクラスを指定するこ"
"とでヘルプのフォーマットをカスタマイズできます。現在、4つのフォーマットクラス"
"があります:"

#: ../../library/argparse.rst:286
msgid ""
":class:`RawDescriptionHelpFormatter` and :class:`RawTextHelpFormatter` give "
"more control over how textual descriptions are displayed. By default, :class:"
"`ArgumentParser` objects line-wrap the description_ and epilog_ texts in "
"command-line help messages::"
msgstr ""
":class:`RawDescriptionHelpFormatter` と :class:`RawTextHelpFormatter` はどの"
"ようにテキストの説明を表示するかを指定できます。デフォルトでは :class:"
"`ArgumentParser` オブジェクトはコマンドラインヘルプの中の description_ と "
"epilog_ を折り返して表示します::"

#: ../../library/argparse.rst:291
msgid ""
">>> parser = argparse.ArgumentParser(\n"
"...     prog='PROG',\n"
"...     description='''this description\n"
"...         was indented weird\n"
"...             but that is okay''',\n"
"...     epilog='''\n"
"...             likewise for this epilog whose whitespace will\n"
"...         be cleaned up and whose words will be wrapped\n"
"...         across a couple lines''')\n"
">>> parser.print_help()\n"
"usage: PROG [-h]\n"
"\n"
"this description was indented weird but that is okay\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit\n"
"\n"
"likewise for this epilog whose whitespace will be cleaned up and whose "
"words\n"
"will be wrapped across a couple lines"
msgstr ""

#: ../../library/argparse.rst:311
msgid ""
"Passing :class:`RawDescriptionHelpFormatter` as ``formatter_class=`` "
"indicates that description_ and epilog_ are already correctly formatted and "
"should not be line-wrapped::"
msgstr ""
"``formatter_class=`` に :class:`RawDescriptionHelpFormatter` を渡した場合、 "
"description_ と epilog_ は整形済みとされ改行されません::"

#: ../../library/argparse.rst:315
msgid ""
">>> parser = argparse.ArgumentParser(\n"
"...     prog='PROG',\n"
"...     formatter_class=argparse.RawDescriptionHelpFormatter,\n"
"...     description=textwrap.dedent('''\\\n"
"...         Please do not mess up this text!\n"
"...         --------------------------------\n"
"...             I have indented it\n"
"...             exactly the way\n"
"...             I want it\n"
"...         '''))\n"
">>> parser.print_help()\n"
"usage: PROG [-h]\n"
"\n"
"Please do not mess up this text!\n"
"--------------------------------\n"
"   I have indented it\n"
"   exactly the way\n"
"   I want it\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit"
msgstr ""

#: ../../library/argparse.rst:337
msgid ""
":class:`RawTextHelpFormatter` maintains whitespace for all sorts of help "
"text, including argument descriptions. However, multiple newlines are "
"replaced with one. If you wish to preserve multiple blank lines, add spaces "
"between the newlines."
msgstr ""

#: ../../library/argparse.rst:342
msgid ""
":class:`ArgumentDefaultsHelpFormatter` automatically adds information about "
"default values to each of the argument help messages::"
msgstr ""
":class:`ArgumentDefaultsHelpFormatter` は各引数のデフォルト値を自動的にヘルプ"
"に追加します::"

#: ../../library/argparse.rst:345
msgid ""
">>> parser = argparse.ArgumentParser(\n"
"...     prog='PROG',\n"
"...     formatter_class=argparse.ArgumentDefaultsHelpFormatter)\n"
">>> parser.add_argument('--foo', type=int, default=42, help='FOO!')\n"
">>> parser.add_argument('bar', nargs='*', default=[1, 2, 3], help='BAR!')\n"
">>> parser.print_help()\n"
"usage: PROG [-h] [--foo FOO] [bar ...]\n"
"\n"
"positional arguments:\n"
" bar         BAR! (default: [1, 2, 3])\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit\n"
" --foo FOO   FOO! (default: 42)"
msgstr ""

#: ../../library/argparse.rst:360
msgid ""
":class:`MetavarTypeHelpFormatter` uses the name of the type_ argument for "
"each argument as the display name for its values (rather than using the "
"dest_ as the regular formatter does)::"
msgstr ""
":class:`MetavarTypeHelpFormatter` は、各引数の値の表示名に type_ 引数の値を使"
"用します (通常は dest_ の値が使用されます)::"

#: ../../library/argparse.rst:364
msgid ""
">>> parser = argparse.ArgumentParser(\n"
"...     prog='PROG',\n"
"...     formatter_class=argparse.MetavarTypeHelpFormatter)\n"
">>> parser.add_argument('--foo', type=int)\n"
">>> parser.add_argument('bar', type=float)\n"
">>> parser.print_help()\n"
"usage: PROG [-h] [--foo int] float\n"
"\n"
"positional arguments:\n"
"  float\n"
"\n"
"options:\n"
"  -h, --help  show this help message and exit\n"
"  --foo int"
msgstr ""

#: ../../library/argparse.rst:381
msgid "prefix_chars"
msgstr "prefix_chars"

#: ../../library/argparse.rst:383
msgid ""
"Most command-line options will use ``-`` as the prefix, e.g. ``-f/--foo``. "
"Parsers that need to support different or additional prefix characters, e.g. "
"for options like ``+f`` or ``/foo``, may specify them using the "
"``prefix_chars=`` argument to the :class:`ArgumentParser` constructor::"
msgstr ""

#: ../../library/argparse.rst:389
msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG', prefix_chars='-+')\n"
">>> parser.add_argument('+f')\n"
">>> parser.add_argument('++bar')\n"
">>> parser.parse_args('+f X ++bar Y'.split())\n"
"Namespace(bar='Y', f='X')"
msgstr ""

#: ../../library/argparse.rst:395
msgid ""
"The ``prefix_chars=`` argument defaults to ``'-'``. Supplying a set of "
"characters that does not include ``-`` will cause ``-f/--foo`` options to be "
"disallowed."
msgstr ""
"``prefix_chars=`` 引数のデフォルトは ``'-'`` です。``-`` を含まない文字セット"
"を指定すると、``-f/--foo`` オプションが使用できなくなります。"

#: ../../library/argparse.rst:401
msgid "fromfile_prefix_chars"
msgstr "fromfile_prefix_chars"

#: ../../library/argparse.rst:403
msgid ""
"Sometimes, when dealing with a particularly long argument list, it may make "
"sense to keep the list of arguments in a file rather than typing it out at "
"the command line.  If the ``fromfile_prefix_chars=`` argument is given to "
"the :class:`ArgumentParser` constructor, then arguments that start with any "
"of the specified characters will be treated as files, and will be replaced "
"by the arguments they contain.  For example::"
msgstr ""
"ときどき、非常に長い引数リストを扱う場合に、その引数リストを毎回コマンドライ"
"ンにタイプする代わりにファイルに置いておきたい場合があります。:class:"
"`ArgumentParser` のコンストラクターに ``fromfile_prefix_chars=`` 引数が渡され"
"た場合、指定された文字のいずれかで始まる引数はファイルとして扱われ、そのファ"
"イルに含まれる引数リストに置換されます。例えば::"

#: ../../library/argparse.rst:410
msgid ""
">>> with open('args.txt', 'w', encoding=sys.getfilesystemencoding()) as fp:\n"
"...     fp.write('-f\\nbar')\n"
"...\n"
">>> parser = argparse.ArgumentParser(fromfile_prefix_chars='@')\n"
">>> parser.add_argument('-f')\n"
">>> parser.parse_args(['-f', 'foo', '@args.txt'])\n"
"Namespace(f='bar')"
msgstr ""

#: ../../library/argparse.rst:418
msgid ""
"Arguments read from a file must by default be one per line (but see also :"
"meth:`~ArgumentParser.convert_arg_line_to_args`) and are treated as if they "
"were in the same place as the original file referencing argument on the "
"command line.  So in the example above, the expression ``['-f', 'foo', "
"'@args.txt']`` is considered equivalent to the expression ``['-f', 'foo', '-"
"f', 'bar']``."
msgstr ""
"ファイルから読み込まれる引数は、デフォルトでは1行に1つ (ただし、:meth:"
"`~ArgumentParser.convert_arg_line_to_args` も参照してください) で、コマンドラ"
"イン上でファイルを参照する引数があった場所にその引数があったものとして扱われ"
"ます。このため、上の例では、``['-f', 'foo', '@args.txt']`` は ``['-f', "
"'foo', '-f', 'bar']`` と等価になります。"

#: ../../library/argparse.rst:424
msgid ""
":class:`ArgumentParser` uses :term:`filesystem encoding and error handler` "
"to read the file containing arguments."
msgstr ""

#: ../../library/argparse.rst:427
msgid ""
"The ``fromfile_prefix_chars=`` argument defaults to ``None``, meaning that "
"arguments will never be treated as file references."
msgstr ""
"``fromfile_prefix_chars=`` 引数のデフォルト値は ``None`` で、引数がファイル参"
"照として扱われることがないことを意味しています。"

#: ../../library/argparse.rst:430
msgid ""
":class:`ArgumentParser` changed encoding and errors to read arguments files "
"from default (e.g. :func:`locale.getpreferredencoding(False) <locale."
"getpreferredencoding>` and ``\"strict\"``) to the :term:`filesystem encoding "
"and error handler`. Arguments file should be encoded in UTF-8 instead of "
"ANSI Codepage on Windows."
msgstr ""

#: ../../library/argparse.rst:438
msgid "argument_default"
msgstr "argument_default"

#: ../../library/argparse.rst:440
msgid ""
"Generally, argument defaults are specified either by passing a default to :"
"meth:`~ArgumentParser.add_argument` or by calling the :meth:`~ArgumentParser."
"set_defaults` methods with a specific set of name-value pairs.  Sometimes "
"however, it may be useful to specify a single parser-wide default for "
"arguments.  This can be accomplished by passing the ``argument_default=`` "
"keyword argument to :class:`ArgumentParser`.  For example, to globally "
"suppress attribute creation on :meth:`~ArgumentParser.parse_args` calls, we "
"supply ``argument_default=SUPPRESS``::"
msgstr ""
"一般的には、引数のデフォルト値は :meth:`~ArgumentParser.add_argument` メソッ"
"ドにデフォルト値を渡すか、:meth:`~ArgumentParser.set_defaults` メソッドに名前"
"と値のペアを渡すことで指定します。しかしまれに、1つのパーサー全体に適用される"
"デフォルト引数が便利なことがあります。これを行うには、 :class:"
"`ArgumentParser` に ``argument_default=`` キーワード引数を渡します。例えば、"
"全体で :meth:`~ArgumentParser.parse_args` メソッド呼び出しの属性の生成を抑制"
"するには、``argument_default=SUPPRESS`` を指定します::"

#: ../../library/argparse.rst:449
msgid ""
">>> parser = argparse.ArgumentParser(argument_default=argparse.SUPPRESS)\n"
">>> parser.add_argument('--foo')\n"
">>> parser.add_argument('bar', nargs='?')\n"
">>> parser.parse_args(['--foo', '1', 'BAR'])\n"
"Namespace(bar='BAR', foo='1')\n"
">>> parser.parse_args([])\n"
"Namespace()"
msgstr ""

#: ../../library/argparse.rst:460
msgid "allow_abbrev"
msgstr "allow_abbrev"

#: ../../library/argparse.rst:462
msgid ""
"Normally, when you pass an argument list to the :meth:`~ArgumentParser."
"parse_args` method of an :class:`ArgumentParser`, it :ref:`recognizes "
"abbreviations <prefix-matching>` of long options."
msgstr ""
"通常、:class:`ArgumentParser` の :meth:`~ArgumentParser.parse_args` に引数の"
"リストを渡すとき、長いオプションは :ref:`短縮しても認識されます <prefix-"
"matching>`。"

#: ../../library/argparse.rst:466
msgid "This feature can be disabled by setting ``allow_abbrev`` to ``False``::"
msgstr ""
"この機能は、``allow_abbrev`` に ``False`` を指定することで無効にできます::"

#: ../../library/argparse.rst:468
msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG', allow_abbrev=False)\n"
">>> parser.add_argument('--foobar', action='store_true')\n"
">>> parser.add_argument('--foonley', action='store_false')\n"
">>> parser.parse_args(['--foon'])\n"
"usage: PROG [-h] [--foobar] [--foonley]\n"
"PROG: error: unrecognized arguments: --foon"
msgstr ""

#: ../../library/argparse.rst:479
msgid "conflict_handler"
msgstr "conflict_handler"

#: ../../library/argparse.rst:481
msgid ""
":class:`ArgumentParser` objects do not allow two actions with the same "
"option string.  By default, :class:`ArgumentParser` objects raise an "
"exception if an attempt is made to create an argument with an option string "
"that is already in use::"
msgstr ""
":class:`ArgumentParser` オブジェクトは同じオプション文字列に対して複数のアク"
"ションを許可していません。\n"
"デフォルトでは、:class:`ArgumentParser` オブジェクトは、すでに利用されている"
"オプション文字列を使って新しい引数をつくろうとしたときに例外を送出します::"

#: ../../library/argparse.rst:486
msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('-f', '--foo', help='old foo help')\n"
">>> parser.add_argument('--foo', help='new foo help')\n"
"Traceback (most recent call last):\n"
" ..\n"
"ArgumentError: argument --foo: conflicting option string(s): --foo"
msgstr ""

#: ../../library/argparse.rst:493
msgid ""
"Sometimes (e.g. when using parents_) it may be useful to simply override any "
"older arguments with the same option string.  To get this behavior, the "
"value ``'resolve'`` can be supplied to the ``conflict_handler=`` argument "
"of :class:`ArgumentParser`::"
msgstr ""
"ときどき (例えば parents_ を利用する場合など)、古い引数を同じオプション文字列"
"で上書きするほうが便利な場合があります。この動作をするには、:class:"
"`ArgumentParser` の ``conflict_handler=`` 引数に ``'resolve'`` を渡します::"

#: ../../library/argparse.rst:498
msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG', "
"conflict_handler='resolve')\n"
">>> parser.add_argument('-f', '--foo', help='old foo help')\n"
">>> parser.add_argument('--foo', help='new foo help')\n"
">>> parser.print_help()\n"
"usage: PROG [-h] [-f FOO] [--foo FOO]\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit\n"
" -f FOO      old foo help\n"
" --foo FOO   new foo help"
msgstr ""

#: ../../library/argparse.rst:509
msgid ""
"Note that :class:`ArgumentParser` objects only remove an action if all of "
"its option strings are overridden.  So, in the example above, the old ``-f/--"
"foo`` action is retained as the ``-f`` action, because only the ``--foo`` "
"option string was overridden."
msgstr ""
":class:`ArgumentParser` オブジェクトは、すべてのオプション文字列が上書きされ"
"た場合にだけアクションを削除することに注目してください。上の例では、 ``--"
"foo`` オプション文字列だけが上書きされているので、古い ``-f/--foo`` アクショ"
"ンは ``-f`` アクションとして残っています。"

#: ../../library/argparse.rst:516
msgid "add_help"
msgstr "add_help"

#: ../../library/argparse.rst:518
msgid ""
"By default, :class:`ArgumentParser` objects add an option which simply "
"displays the parser's help message. If ``-h`` or ``--help`` is supplied at "
"the command line, the :class:`!ArgumentParser` help will be printed."
msgstr ""

#: ../../library/argparse.rst:522
msgid ""
"Occasionally, it may be useful to disable the addition of this help option. "
"This can be achieved by passing ``False`` as the ``add_help=`` argument to :"
"class:`ArgumentParser`::"
msgstr ""
"必要に応じて、この help オプションを無効にする場合があります。これは :class:"
"`ArgumentParser` の ``add_help=`` 引数に ``False`` を渡すことで可能です::"

#: ../../library/argparse.rst:526
msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG', add_help=False)\n"
">>> parser.add_argument('--foo', help='foo help')\n"
">>> parser.print_help()\n"
"usage: PROG [--foo FOO]\n"
"\n"
"options:\n"
" --foo FOO  foo help"
msgstr ""

#: ../../library/argparse.rst:534
msgid ""
"The help option is typically ``-h/--help``. The exception to this is if the "
"``prefix_chars=`` is specified and does not include ``-``, in which case ``-"
"h`` and ``--help`` are not valid options.  In this case, the first character "
"in ``prefix_chars`` is used to prefix the help options::"
msgstr ""
"ヘルプオプションは通常 ``-h/--help`` です。例外は ``prefix_chars=`` が指定さ"
"れてその中に ``-`` が無かった場合で、その場合は ``-h`` と ``--help`` は有効な"
"オプションではありません。この場合、``prefix_chars`` の最初の文字がヘルプオプ"
"ションの接頭辞として利用されます::"

#: ../../library/argparse.rst:540
msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG', prefix_chars='+/')\n"
">>> parser.print_help()\n"
"usage: PROG [+h]\n"
"\n"
"options:\n"
"  +h, ++help  show this help message and exit"
msgstr ""

#: ../../library/argparse.rst:549
msgid "exit_on_error"
msgstr "exit_on_error"

#: ../../library/argparse.rst:551
msgid ""
"Normally, when you pass an invalid argument list to the :meth:"
"`~ArgumentParser.parse_args` method of an :class:`ArgumentParser`, it will "
"print a *message* to :data:`sys.stderr` and exit with a status code of 2."
msgstr ""

#: ../../library/argparse.rst:555
msgid ""
"If the user would like to catch errors manually, the feature can be enabled "
"by setting ``exit_on_error`` to ``False``::"
msgstr ""
"もしエラーを例外としてプログラム内でキャッチしたい場合は、``exit_on_error`` "
"を ``False`` に設定してください::"

#: ../../library/argparse.rst:558
msgid ""
">>> parser = argparse.ArgumentParser(exit_on_error=False)\n"
">>> parser.add_argument('--integers', type=int)\n"
"_StoreAction(option_strings=['--integers'], dest='integers', nargs=None, "
"const=None, default=None, type=<class 'int'>, choices=None, help=None, "
"metavar=None)\n"
">>> try:\n"
"...     parser.parse_args('--integers a'.split())\n"
"... except argparse.ArgumentError:\n"
"...     print('Catching an argumentError')\n"
"...\n"
"Catching an argumentError"
msgstr ""

#: ../../library/argparse.rst:572
msgid "The add_argument() method"
msgstr "add_argument() メソッド"

#: ../../library/argparse.rst:578
msgid ""
"Define how a single command-line argument should be parsed.  Each parameter "
"has its own more detailed description below, but in short they are:"
msgstr ""
"1つのコマンドライン引数がどう解析されるかを定義します。各引数についての詳細は"
"後述しますが、簡単に言うと:"

#: ../../library/argparse.rst:581
msgid ""
"`name or flags`_ - Either a name or a list of option strings, e.g. ``'foo'`` "
"or ``'-f', '--foo'``."
msgstr ""

#: ../../library/argparse.rst:584
msgid ""
"action_ - The basic type of action to be taken when this argument is "
"encountered at the command line."
msgstr "action_ - コマンドラインにこの引数があったときのアクション。"

#: ../../library/argparse.rst:587
msgid "nargs_ - The number of command-line arguments that should be consumed."
msgstr "nargs_ - 受け取るべきコマンドライン引数の数。"

#: ../../library/argparse.rst:589
msgid ""
"const_ - A constant value required by some action_ and nargs_ selections."
msgstr "const_ - 一部の action_ と nargs_ の組み合わせで利用される定数。"

#: ../../library/argparse.rst:591
msgid ""
"default_ - The value produced if the argument is absent from the command "
"line and if it is absent from the namespace object."
msgstr ""
"default_ - コマンドラインに対応する引数が存在せず、さらに namespace オブジェ"
"クトにも存在しない場合に利用される値。 "

#: ../../library/argparse.rst:594
msgid ""
"type_ - The type to which the command-line argument should be converted."
msgstr "type_ - コマンドライン引数が変換されるべき型。"

#: ../../library/argparse.rst:596
msgid "choices_ - A sequence of the allowable values for the argument."
msgstr "choices_ - 引数として許される値のシーケンス。"

#: ../../library/argparse.rst:598
msgid ""
"required_ - Whether or not the command-line option may be omitted (optionals "
"only)."
msgstr ""
"required_ - コマンドラインオプションが省略可能かどうか (オプション引数のみ)。"

#: ../../library/argparse.rst:601
msgid "help_ - A brief description of what the argument does."
msgstr "help_ - 引数が何なのかを示す簡潔な説明。"

#: ../../library/argparse.rst:603
msgid "metavar_ - A name for the argument in usage messages."
msgstr "metavar_ - 使用法メッセージの中で使われる引数の名前。"

#: ../../library/argparse.rst:605
msgid ""
"dest_ - The name of the attribute to be added to the object returned by :"
"meth:`parse_args`."
msgstr "dest_ - :meth:`parse_args` が返すオブジェクトに追加される属性名。"

#: ../../library/argparse.rst:608
msgid "deprecated_ - Whether or not use of the argument is deprecated."
msgstr ""

#: ../../library/argparse.rst:616
msgid "name or flags"
msgstr "name または flags"

#: ../../library/argparse.rst:618
msgid ""
"The :meth:`~ArgumentParser.add_argument` method must know whether an "
"optional argument, like ``-f`` or ``--foo``, or a positional argument, like "
"a list of filenames, is expected.  The first arguments passed to :meth:"
"`~ArgumentParser.add_argument` must therefore be either a series of flags, "
"or a simple argument name."
msgstr ""
":meth:`~ArgumentParser.add_argument` メソッドは、指定されている引数が ``-f`` "
"や ``--foo`` のようなオプション引数なのか、ファイル名リストなどの位置引数なの"
"かを知る必要があります。\n"
"そのため、 :meth:`~ArgumentParser.add_argument` に初めに渡される引数は、一連"
"のフラグか、単一の引数名のどちらかになります。"

#: ../../library/argparse.rst:624
msgid "For example, an optional argument could be created like::"
msgstr "たとえば、オプション引数は次のように作成します::"

#: ../../library/argparse.rst:626
msgid ">>> parser.add_argument('-f', '--foo')"
msgstr ""

#: ../../library/argparse.rst:628
msgid "while a positional argument could be created like::"
msgstr "一方、位置引数は次のように作成します::"

#: ../../library/argparse.rst:630
msgid ">>> parser.add_argument('bar')"
msgstr ""

#: ../../library/argparse.rst:632
msgid ""
"When :meth:`~ArgumentParser.parse_args` is called, optional arguments will "
"be identified by the ``-`` prefix, and the remaining arguments will be "
"assumed to be positional::"
msgstr ""
":meth:`~ArgumentParser.parse_args` が呼ばれたとき、オプション引数は接頭辞 ``-"
"`` により識別され、それ以外の引数は位置引数として扱われます::"

#: ../../library/argparse.rst:636
msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('-f', '--foo')\n"
">>> parser.add_argument('bar')\n"
">>> parser.parse_args(['BAR'])\n"
"Namespace(bar='BAR', foo=None)\n"
">>> parser.parse_args(['BAR', '--foo', 'FOO'])\n"
"Namespace(bar='BAR', foo='FOO')\n"
">>> parser.parse_args(['--foo', 'FOO'])\n"
"usage: PROG [-h] [-f FOO] bar\n"
"PROG: error: the following arguments are required: bar"
msgstr ""

#: ../../library/argparse.rst:651
msgid "action"
msgstr "action"

#: ../../library/argparse.rst:653
msgid ""
":class:`ArgumentParser` objects associate command-line arguments with "
"actions.  These actions can do just about anything with the command-line "
"arguments associated with them, though most actions simply add an attribute "
"to the object returned by :meth:`~ArgumentParser.parse_args`.  The "
"``action`` keyword argument specifies how the command-line arguments should "
"be handled. The supplied actions are:"
msgstr ""
":class:`ArgumentParser` オブジェクトはコマンドライン引数にアクションを割り当"
"てます。このアクションは、割り当てられたコマンドライン引数に関してどんな処理"
"でもできますが、ほとんどのアクションは単に :meth:`~ArgumentParser."
"parse_args` が返すオブジェクトに属性を追加するだけです。``action`` キーワード"
"引数は、コマンドライン引数がどう処理されるかを指定します。提供されているアク"
"ションは:"

#: ../../library/argparse.rst:659
msgid ""
"``'store'`` - This just stores the argument's value.  This is the default "
"action."
msgstr ""

#: ../../library/argparse.rst:662
msgid ""
"``'store_const'`` - This stores the value specified by the const_ keyword "
"argument; note that the const_ keyword argument defaults to ``None``.  The "
"``'store_const'`` action is most commonly used with optional arguments that "
"specify some sort of flag.  For example::"
msgstr ""
"``'store_const'`` - このアクションは const_ キーワード引数で指定された値を格"
"納します。const_ キーワード引数のデフォルト値は ``None`` であることに注意して"
"ください。``'store_const'`` アクションは、何かの種類のフラグを指定するオプ"
"ション引数によく使われます。例えば::"

#: ../../library/argparse.rst:667
msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', action='store_const', const=42)\n"
">>> parser.parse_args(['--foo'])\n"
"Namespace(foo=42)"
msgstr ""

#: ../../library/argparse.rst:672
msgid ""
"``'store_true'`` and ``'store_false'`` - These are special cases of "
"``'store_const'`` used for storing the values ``True`` and ``False`` "
"respectively.  In addition, they create default values of ``False`` and "
"``True`` respectively::"
msgstr ""

#: ../../library/argparse.rst:677
msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', action='store_true')\n"
">>> parser.add_argument('--bar', action='store_false')\n"
">>> parser.add_argument('--baz', action='store_false')\n"
">>> parser.parse_args('--foo --bar'.split())\n"
"Namespace(foo=True, bar=False, baz=True)"
msgstr ""

#: ../../library/argparse.rst:684
msgid ""
"``'append'`` - This stores a list, and appends each argument value to the "
"list. It is useful to allow an option to be specified multiple times. If the "
"default value is non-empty, the default elements will be present in the "
"parsed value for the option, with any values from the command line appended "
"after those default values. Example usage::"
msgstr ""
"``'append'`` - このアクションはリストを格納し、それぞれの引数として与えられた"
"値をリストに追加します。これは複数回指定可能なオプション引数に対して有用で"
"す。デフォルト値が空でない場合、デフォルト値は常にパースされたリストに含ま"
"れ、コマンドラインで指定した値はデフォルト値の後に追加されます。使用例::"

#: ../../library/argparse.rst:690
msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', action='append')\n"
">>> parser.parse_args('--foo 1 --foo 2'.split())\n"
"Namespace(foo=['1', '2'])"
msgstr ""

#: ../../library/argparse.rst:695
msgid ""
"``'append_const'`` - This stores a list, and appends the value specified by "
"the const_ keyword argument to the list; note that the const_ keyword "
"argument defaults to ``None``. The ``'append_const'`` action is typically "
"useful when multiple arguments need to store constants to the same list. For "
"example::"
msgstr ""
"``'append_const'`` - このアクションはリストを格納して、const_ キーワード引数"
"に与えられた値をそのリストに追加します。const_ キーワード引数のデフォルト値"
"は ``None`` であることに注意してください。``'append_const'`` アクションは、定"
"数を同じリストに複数回格納する場合に便利です。例えば::"

#: ../../library/argparse.rst:701
msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--str', dest='types', action='append_const', "
"const=str)\n"
">>> parser.add_argument('--int', dest='types', action='append_const', "
"const=int)\n"
">>> parser.parse_args('--str --int'.split())\n"
"Namespace(types=[<class 'str'>, <class 'int'>])"
msgstr ""

#: ../../library/argparse.rst:707
msgid ""
"``'extend'`` - This stores a list and appends each item from the multi-value "
"argument list to it. The ``'extend'`` action is typically used with the "
"nargs_ keyword argument value ``'+'`` or ``'*'``. Note that when nargs_ is "
"``None`` (the default) or ``'?'``, each character of the argument string "
"will be appended to the list. Example usage::"
msgstr ""

#: ../../library/argparse.rst:715
msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument(\"--foo\", action=\"extend\", nargs=\"+\", "
"type=str)\n"
">>> parser.parse_args([\"--foo\", \"f1\", \"--foo\", \"f2\", \"f3\", "
"\"f4\"])\n"
"Namespace(foo=['f1', 'f2', 'f3', 'f4'])"
msgstr ""

#: ../../library/argparse.rst:722
msgid ""
"``'count'`` - This counts the number of times a keyword argument occurs. For "
"example, this is useful for increasing verbosity levels::"
msgstr ""
"``'count'`` - このアクションはキーワード引数の数を数えます。例えば、verboseレ"
"ベルを上げるのに役立ちます::"

#: ../../library/argparse.rst:725
msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--verbose', '-v', action='count', default=0)\n"
">>> parser.parse_args(['-vvv'])\n"
"Namespace(verbose=3)"
msgstr ""

#: ../../library/argparse.rst:730
msgid "Note, the *default* will be ``None`` unless explicitly set to *0*."
msgstr ""
"*default* は明示的に *0* と指定されない場合は ``None`` であることに注意してく"
"ださい。"

#: ../../library/argparse.rst:732
msgid ""
"``'help'`` - This prints a complete help message for all the options in the "
"current parser and then exits. By default a help action is automatically "
"added to the parser. See :class:`ArgumentParser` for details of how the "
"output is created."
msgstr ""
"``'help'`` - このアクションは現在のパーサー中のすべてのオプションのヘルプメッ"
"セージを表示し、終了します。出力の生成方法の詳細については :class:"
"`ArgumentParser` を参照してください。"

#: ../../library/argparse.rst:737
msgid ""
"``'version'`` - This expects a ``version=`` keyword argument in the :meth:"
"`~ArgumentParser.add_argument` call, and prints version information and "
"exits when invoked::"
msgstr ""
"``'version'`` - このアクションは :meth:`~ArgumentParser.add_argument` の呼び"
"出しに ``version=`` キーワード引数を期待します。指定されたときはバージョン情"
"報を表示して終了します::"

#: ../../library/argparse.rst:741
msgid ""
">>> import argparse\n"
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('--version', action='version', version='%(prog)s "
"2.0')\n"
">>> parser.parse_args(['--version'])\n"
"PROG 2.0"
msgstr ""

#: ../../library/argparse.rst:747
msgid ""
"Only actions that consume command-line arguments (e.g. ``'store'``, "
"``'append'`` or ``'extend'``) can be used with positional arguments."
msgstr ""

#: ../../library/argparse.rst:752
msgid ""
"You may also specify an arbitrary action by passing an :class:`Action` "
"subclass or other object that implements the same interface. The :class:`!"
"BooleanOptionalAction` is available in :mod:`!argparse` and adds support for "
"boolean actions such as ``--foo`` and ``--no-foo``::"
msgstr ""

#: ../../library/argparse.rst:757
msgid ""
">>> import argparse\n"
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', action=argparse.BooleanOptionalAction)\n"
">>> parser.parse_args(['--no-foo'])\n"
"Namespace(foo=False)"
msgstr ""

#: ../../library/argparse.rst:765
msgid ""
"The recommended way to create a custom action is to extend :class:`Action`, "
"overriding the :meth:`!__call__` method and optionally the :meth:`!__init__` "
"and :meth:`!format_usage` methods. You can also register custom actions "
"using the :meth:`~ArgumentParser.register` method and reference them by "
"their registered name."
msgstr ""

#: ../../library/argparse.rst:770
msgid "An example of a custom action::"
msgstr "カスタムアクションの例です::"

#: ../../library/argparse.rst:772
msgid ""
">>> class FooAction(argparse.Action):\n"
"...     def __init__(self, option_strings, dest, nargs=None, **kwargs):\n"
"...         if nargs is not None:\n"
"...             raise ValueError(\"nargs not allowed\")\n"
"...         super().__init__(option_strings, dest, **kwargs)\n"
"...     def __call__(self, parser, namespace, values, option_string=None):\n"
"...         print('%r %r %r' % (namespace, values, option_string))\n"
"...         setattr(namespace, self.dest, values)\n"
"...\n"
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', action=FooAction)\n"
">>> parser.add_argument('bar', action=FooAction)\n"
">>> args = parser.parse_args('1 --foo 2'.split())\n"
"Namespace(bar=None, foo=None) '1' None\n"
"Namespace(bar='1', foo=None) '2' '--foo'\n"
">>> args\n"
"Namespace(bar='1', foo='2')"
msgstr ""

#: ../../library/argparse.rst:790
msgid "For more details, see :class:`Action`."
msgstr "詳細は :class:`Action` を参照してください。"

#: ../../library/argparse.rst:796
msgid "nargs"
msgstr "nargs"

#: ../../library/argparse.rst:798
msgid ""
":class:`ArgumentParser` objects usually associate a single command-line "
"argument with a single action to be taken.  The ``nargs`` keyword argument "
"associates a different number of command-line arguments with a single "
"action. See also :ref:`specifying-ambiguous-arguments`. The supported values "
"are:"
msgstr ""

#: ../../library/argparse.rst:803
msgid ""
"``N`` (an integer).  ``N`` arguments from the command line will be gathered "
"together into a list.  For example::"
msgstr ""
"``N`` (整数) -- ``N`` 個の引数がコマンドラインから集められ、リストに格納され"
"ます。例えば::"

#: ../../library/argparse.rst:806
msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', nargs=2)\n"
">>> parser.add_argument('bar', nargs=1)\n"
">>> parser.parse_args('c --foo a b'.split())\n"
"Namespace(bar=['c'], foo=['a', 'b'])"
msgstr ""

#: ../../library/argparse.rst:812
msgid ""
"Note that ``nargs=1`` produces a list of one item.  This is different from "
"the default, in which the item is produced by itself."
msgstr ""
"``nargs=1`` は1要素のリストを作ることに注意してください。これはデフォルトの、"
"要素がそのまま属性になる動作とは異なります。"

#: ../../library/argparse.rst:817
msgid ""
"``'?'``. One argument will be consumed from the command line if possible, "
"and produced as a single item.  If no command-line argument is present, the "
"value from default_ will be produced.  Note that for optional arguments, "
"there is an additional case - the option string is present but not followed "
"by a command-line argument.  In this case the value from const_ will be "
"produced.  Some examples to illustrate this::"
msgstr ""
"``'?'`` -- 可能なら1つの引数がコマンドラインから取られ、1つのアイテムを作りま"
"す。コマンドライン引数が存在しない場合、default_ の値が生成されます。オプショ"
"ン引数の場合、さらにオプション引数が指定され、その後にコマンドライン引数がな"
"いというケースもありえます。この場合は const_ の値が生成されます。この動作の"
"例です::"

#: ../../library/argparse.rst:824
msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', nargs='?', const='c', default='d')\n"
">>> parser.add_argument('bar', nargs='?', default='d')\n"
">>> parser.parse_args(['XX', '--foo', 'YY'])\n"
"Namespace(bar='XX', foo='YY')\n"
">>> parser.parse_args(['XX', '--foo'])\n"
"Namespace(bar='XX', foo='c')\n"
">>> parser.parse_args([])\n"
"Namespace(bar='d', foo='d')"
msgstr ""

#: ../../library/argparse.rst:834
msgid ""
"One of the more common uses of ``nargs='?'`` is to allow optional input and "
"output files::"
msgstr ""
"``nargs='?'`` のよくある利用例の1つは、入出力ファイルの指定オプションです::"

#: ../../library/argparse.rst:837
msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('infile', nargs='?', type=argparse.FileType('r'),\n"
"...                     default=sys.stdin)\n"
">>> parser.add_argument('outfile', nargs='?', type=argparse.FileType('w'),\n"
"...                     default=sys.stdout)\n"
">>> parser.parse_args(['input.txt', 'output.txt'])\n"
"Namespace(infile=<_io.TextIOWrapper name='input.txt' encoding='UTF-8'>,\n"
"          outfile=<_io.TextIOWrapper name='output.txt' encoding='UTF-8'>)\n"
">>> parser.parse_args([])\n"
"Namespace(infile=<_io.TextIOWrapper name='<stdin>' encoding='UTF-8'>,\n"
"          outfile=<_io.TextIOWrapper name='<stdout>' encoding='UTF-8'>)"
msgstr ""

#: ../../library/argparse.rst:851
msgid ""
"``'*'``.  All command-line arguments present are gathered into a list.  Note "
"that it generally doesn't make much sense to have more than one positional "
"argument with ``nargs='*'``, but multiple optional arguments with "
"``nargs='*'`` is possible.  For example::"
msgstr ""
"``'*'`` -- すべてのコマンドライン引数がリストに集められます。複数の位置引数"
"が ``nargs='*'`` を持つことにあまり意味はありませんが、複数のオプション引数"
"が ``nargs='*'`` を持つことはありえます。例えば::"

#: ../../library/argparse.rst:856
msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', nargs='*')\n"
">>> parser.add_argument('--bar', nargs='*')\n"
">>> parser.add_argument('baz', nargs='*')\n"
">>> parser.parse_args('a b --foo x y --bar 1 2'.split())\n"
"Namespace(bar=['1', '2'], baz=['a', 'b'], foo=['x', 'y'])"
msgstr ""

#: ../../library/argparse.rst:865
msgid ""
"``'+'``. Just like ``'*'``, all command-line args present are gathered into "
"a list.  Additionally, an error message will be generated if there wasn't at "
"least one command-line argument present.  For example::"
msgstr ""
"``'+'`` -- ``'*'`` と同じように、すべてのコマンドライン引数をリストに集めま"
"す。加えて、最低でも1つのコマンドライン引数が存在しない場合にエラーメッセージ"
"を生成します。例えば::"

#: ../../library/argparse.rst:869
msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('foo', nargs='+')\n"
">>> parser.parse_args(['a', 'b'])\n"
"Namespace(foo=['a', 'b'])\n"
">>> parser.parse_args([])\n"
"usage: PROG [-h] foo [foo ...]\n"
"PROG: error: the following arguments are required: foo"
msgstr ""

#: ../../library/argparse.rst:877
msgid ""
"If the ``nargs`` keyword argument is not provided, the number of arguments "
"consumed is determined by the action_.  Generally this means a single "
"command-line argument will be consumed and a single item (not a list) will "
"be produced. Actions that do not consume command-line arguments (e.g. "
"``'store_const'``) set ``nargs=0``."
msgstr ""

#: ../../library/argparse.rst:887
msgid "const"
msgstr "const"

#: ../../library/argparse.rst:889
msgid ""
"The ``const`` argument of :meth:`~ArgumentParser.add_argument` is used to "
"hold constant values that are not read from the command line but are "
"required for the various :class:`ArgumentParser` actions.  The two most "
"common uses of it are:"
msgstr ""
":meth:`~ArgumentParser.add_argument` の ``const`` 引数は、コマンドライン引数"
"から読み込まれないけれども :class:`ArgumentParser` のいくつかのアクションで必"
"要とされる値のために使われます。この引数のよくある2つの使用法は:"

#: ../../library/argparse.rst:893
msgid ""
"When :meth:`~ArgumentParser.add_argument` is called with "
"``action='store_const'`` or ``action='append_const'``.  These actions add "
"the ``const`` value to one of the attributes of the object returned by :meth:"
"`~ArgumentParser.parse_args`. See the action_ description for examples. If "
"``const`` is not provided to :meth:`~ArgumentParser.add_argument`, it will "
"receive a default value of ``None``."
msgstr ""
":meth:`~ArgumentParser.add_argument` が ``action='store_const'`` か "
"``action='append_const'`` で呼び出されたとき、これらのアクションは ``const`` "
"の値を :meth:`~ArgumentParser.parse_args` が返すオブジェクトの属性に追加しま"
"す。サンプルは action_ の説明を参照してください。``const`` が :meth:"
"`~ArgumentParser.add_argument` に与えられなければ、``None`` のデフォルト値を"
"受け取ります。"

#: ../../library/argparse.rst:901
msgid ""
"When :meth:`~ArgumentParser.add_argument` is called with option strings "
"(like ``-f`` or ``--foo``) and ``nargs='?'``.  This creates an optional "
"argument that can be followed by zero or one command-line arguments. When "
"parsing the command line, if the option string is encountered with no "
"command-line argument following it, the value of ``const`` will be assumed "
"to be ``None`` instead.  See the nargs_ description for examples."
msgstr ""
":meth:`~ArgumentParser.add_argument` がオプション文字列 (``-f`` や ``--"
"foo``) と ``nargs='?'`` で呼び出された場合。この場合0個か1つのコマンドライン"
"引数を取るオプション引数が作られます。オプション引数にコマンドライン引数が続"
"かなかった場合、代わりに ``const`` の値が ``None`` であると見なされます。サン"
"プルは nargs_ の説明を参照してください。"

#: ../../library/argparse.rst:908
msgid ""
"``const=None`` by default, including when ``action='append_const'`` or "
"``action='store_const'``."
msgstr ""
"``action='append_const'`` や ``action='store_const'`` の場合も含め、デフォル"
"トでは ``const=None`` です。"

#: ../../library/argparse.rst:915
msgid "default"
msgstr "default"

#: ../../library/argparse.rst:917
msgid ""
"All optional arguments and some positional arguments may be omitted at the "
"command line.  The ``default`` keyword argument of :meth:`~ArgumentParser."
"add_argument`, whose value defaults to ``None``, specifies what value should "
"be used if the command-line argument is not present. For optional arguments, "
"the ``default`` value is used when the option string was not present at the "
"command line::"
msgstr ""
"すべてのオプション引数といくつかの位置引数はコマンドライン上で省略されること"
"があります。 :meth:`~ArgumentParser.add_argument` の ``default`` キーワード引"
"数 (デフォルト: ``None``) は、コマンドライン引数が存在しなかった場合に利用す"
"る値を指定します。オプション引数では、オプション文字列がコマンドライン上に存"
"在しなかったときに ``default`` の値が利用されます::"

#: ../../library/argparse.rst:924
msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', default=42)\n"
">>> parser.parse_args(['--foo', '2'])\n"
"Namespace(foo='2')\n"
">>> parser.parse_args([])\n"
"Namespace(foo=42)"
msgstr ""

#: ../../library/argparse.rst:931
msgid ""
"If the target namespace already has an attribute set, the action *default* "
"will not overwrite it::"
msgstr ""

#: ../../library/argparse.rst:934
msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', default=42)\n"
">>> parser.parse_args([], namespace=argparse.Namespace(foo=101))\n"
"Namespace(foo=101)"
msgstr ""

#: ../../library/argparse.rst:939
msgid ""
"If the ``default`` value is a string, the parser parses the value as if it "
"were a command-line argument.  In particular, the parser applies any type_ "
"conversion argument, if provided, before setting the attribute on the :class:"
"`Namespace` return value.  Otherwise, the parser uses the value as is::"
msgstr ""
"``default`` の値が文字列の場合、パーサーは値をコマンドライン引数のように解析"
"します。具体的には、パーサーは返り値 :class:`Namespace` の属性を設定する前"
"に、type_ 変換引数が与えられていればそれらを適用します。そうでない場合、パー"
"サーは値をそのまま使用します::"

#: ../../library/argparse.rst:944
msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--length', default='10', type=int)\n"
">>> parser.add_argument('--width', default=10.5, type=int)\n"
">>> parser.parse_args()\n"
"Namespace(length=10, width=10.5)"
msgstr ""

#: ../../library/argparse.rst:950
msgid ""
"For positional arguments with nargs_ equal to ``?`` or ``*``, the "
"``default`` value is used when no command-line argument was present::"
msgstr ""
"nargs_ が ``?`` か ``*`` である位置引数では、コマンドライン引数が指定されな"
"かった場合 ``default`` の値が使われます。例えば::"

#: ../../library/argparse.rst:953
msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('foo', nargs='?', default=42)\n"
">>> parser.parse_args(['a'])\n"
"Namespace(foo='a')\n"
">>> parser.parse_args([])\n"
"Namespace(foo=42)"
msgstr ""

#: ../../library/argparse.rst:960
msgid ""
"For required_ arguments, the ``default`` value is ignored. For example, this "
"applies to positional arguments with nargs_ values other than ``?`` or "
"``*``, or optional arguments marked as ``required=True``."
msgstr ""

#: ../../library/argparse.rst:964
msgid ""
"Providing ``default=argparse.SUPPRESS`` causes no attribute to be added if "
"the command-line argument was not present::"
msgstr ""
"``default=argparse.SUPPRESS`` を渡すと、コマンドライン引数が存在しないときに"
"属性の追加をしなくなります::"

#: ../../library/argparse.rst:967
msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', default=argparse.SUPPRESS)\n"
">>> parser.parse_args([])\n"
"Namespace()\n"
">>> parser.parse_args(['--foo', '1'])\n"
"Namespace(foo='1')"
msgstr ""

#: ../../library/argparse.rst:978
msgid "type"
msgstr "type"

#: ../../library/argparse.rst:980
msgid ""
"By default, the parser reads command-line arguments in as simple strings. "
"However, quite often the command-line string should instead be interpreted "
"as another type, such as a :class:`float` or :class:`int`.  The ``type`` "
"keyword for :meth:`~ArgumentParser.add_argument` allows any necessary type-"
"checking and type conversions to be performed."
msgstr ""
"デフォルトでは、パーサーはコマンドライン引数を単なる文字列として読み込みま"
"す。しかし、それらの文字列を :class:`float`, :class:`int` など別の型として扱"
"うべき事がよくあります。:meth:`~ArgumentParser.add_argument` の ``type`` キー"
"ワード引数に指定する type converter により、必要な型チェックと型変換を行うこ"
"とができます。"

#: ../../library/argparse.rst:986
msgid ""
"If the type_ keyword is used with the default_ keyword, the type converter "
"is only applied if the default is a string."
msgstr ""
"もし type_ キーワードが default_ キーワードとともに使用された場合、default_  "
"の値が文字列のときのみ、type converter による変換などが行われます。"

#: ../../library/argparse.rst:989
msgid ""
"The argument to ``type`` can be a callable that accepts a single string or "
"the name of a registered type (see :meth:`~ArgumentParser.register`) If the "
"function raises :exc:`ArgumentTypeError`, :exc:`TypeError`, or :exc:"
"`ValueError`, the exception is caught and a nicely formatted error message "
"is displayed. Other exception types are not handled."
msgstr ""

#: ../../library/argparse.rst:995
msgid "Common built-in types and functions can be used as type converters:"
msgstr ""
"一般的なビルトインデータ型や関数を ``type`` 引数の値として直接指定できます::"

#: ../../library/argparse.rst:997
msgid ""
"import argparse\n"
"import pathlib\n"
"\n"
"parser = argparse.ArgumentParser()\n"
"parser.add_argument('count', type=int)\n"
"parser.add_argument('distance', type=float)\n"
"parser.add_argument('street', type=ascii)\n"
"parser.add_argument('code_point', type=ord)\n"
"parser.add_argument('dest_file', type=argparse.FileType('w', "
"encoding='latin-1'))\n"
"parser.add_argument('datapath', type=pathlib.Path)"
msgstr ""

#: ../../library/argparse.rst:1010
msgid "User defined functions can be used as well:"
msgstr "ユーザが定義した関数も使用できます::"

#: ../../library/argparse.rst:1012
msgid ""
">>> def hyphenated(string):\n"
"...     return '-'.join([word[:4] for word in string.casefold().split()])\n"
"...\n"
">>> parser = argparse.ArgumentParser()\n"
">>> _ = parser.add_argument('short_title', type=hyphenated)\n"
">>> parser.parse_args(['\"The Tale of Two Cities\"'])\n"
"Namespace(short_title='\"the-tale-of-two-citi')"
msgstr ""

#: ../../library/argparse.rst:1022
msgid ""
"The :func:`bool` function is not recommended as a type converter.  All it "
"does is convert empty strings to ``False`` and non-empty strings to "
"``True``. This is usually not what is desired."
msgstr ""
"Type converter として :func:`bool` 関数を使用することは推奨されません。なぜな"
"ら、これは空文字列を ``False`` に、それ以外の全てを ``True`` に変換しますが、"
"これはおそらく望まれる動作ではないからです (訳注: 文字列 ``'false'`` を "
"``False`` に変換してくれたりはしません)。"

#: ../../library/argparse.rst:1026
msgid ""
"In general, the ``type`` keyword is a convenience that should only be used "
"for simple conversions that can only raise one of the three supported "
"exceptions. Anything with more interesting error-handling or resource "
"management should be done downstream after the arguments are parsed."
msgstr ""
"一般論として、``type`` キーワードに指定するものは、せいぜい上記の3種類の例外"
"を発生するくらいの、お手軽な変換に限るべきです。より複雑な (interesting) エ"
"ラー処理、またはリソース管理を伴うものは、引数を解析したあとに別個の処理とし"
"て行うべきです。"

#: ../../library/argparse.rst:1031
msgid ""
"For example, JSON or YAML conversions have complex error cases that require "
"better reporting than can be given by the ``type`` keyword.  A :exc:`~json."
"JSONDecodeError` would not be well formatted and a :exc:`FileNotFoundError` "
"exception would not be handled at all."
msgstr ""
"たとえば、JSON または YAML からの変換は複雑なエラーケースを持つので、"
"``type`` がサポートする以上のエラー表示を必要とするでしょう。(JSON デコーダが"
"発生しうる) :exc:`~json.JSONDecodeError` は適切に整形されて表示されません。ま"
"た、:exc:`FileNotFoundError` が発生しても parser は何も処理しません。"

#: ../../library/argparse.rst:1036
msgid ""
"Even :class:`~argparse.FileType` has its limitations for use with the "
"``type`` keyword.  If one argument uses :class:`~argparse.FileType` and then "
"a subsequent argument fails, an error is reported but the file is not "
"automatically closed.  In this case, it would be better to wait until after "
"the parser has run and then use the :keyword:`with`-statement to manage the "
"files."
msgstr ""

#: ../../library/argparse.rst:1043
msgid ""
"For type checkers that simply check against a fixed set of values, consider "
"using the choices_ keyword instead."
msgstr ""
"なお、引数が、あらかじめ決められた値の候補のいずれかに一致するかをチェックし"
"たいだけの場合には、代わりに choices_ キーワードの使用を検討してください。"

#: ../../library/argparse.rst:1050
msgid "choices"
msgstr "choices"

#: ../../library/argparse.rst:1052
msgid ""
"Some command-line arguments should be selected from a restricted set of "
"values. These can be handled by passing a sequence object as the *choices* "
"keyword argument to :meth:`~ArgumentParser.add_argument`.  When the command "
"line is parsed, argument values will be checked, and an error message will "
"be displayed if the argument was not one of the acceptable values::"
msgstr ""
"コマンドライン引数をいくつかの選択肢の中から選ばせたい場合があります。 これ"
"は :meth:`~ArgumentParser.add_argument` に シーケンスオブジェクトを "
"*choices* キーワード引数として渡すことで可能です。コマンドラインを解析すると"
"き、引数の値がチェックされ、その値が選択肢の中に含まれていない場合はエラー"
"メッセージを表示します::"

#: ../../library/argparse.rst:1058
msgid ""
">>> parser = argparse.ArgumentParser(prog='game.py')\n"
">>> parser.add_argument('move', choices=['rock', 'paper', 'scissors'])\n"
">>> parser.parse_args(['rock'])\n"
"Namespace(move='rock')\n"
">>> parser.parse_args(['fire'])\n"
"usage: game.py [-h] {rock,paper,scissors}\n"
"game.py: error: argument move: invalid choice: 'fire' (choose from 'rock',\n"
"'paper', 'scissors')"
msgstr ""

#: ../../library/argparse.rst:1067
msgid ""
"Note that inclusion in the *choices* sequence is checked after any type_ "
"conversions have been performed, so the type of the objects in the *choices* "
"sequence should match the type_ specified."
msgstr ""

#: ../../library/argparse.rst:1071
msgid ""
"Any sequence can be passed as the *choices* value, so :class:`list` "
"objects, :class:`tuple` objects, and custom sequences are all supported."
msgstr ""
"任意のシーケンスを *choices* に渡すことができます。すなわち、:class:`list` オ"
"ブジェクト、 :class:`tuple` オブジェクト、カスタムシーケンスはすべてサポート"
"されています。"

#: ../../library/argparse.rst:1074
msgid ""
"Use of :class:`enum.Enum` is not recommended because it is difficult to "
"control its appearance in usage, help, and error messages."
msgstr ""
"ただし、:class:`enum.Enum` を渡すことは推奨されません。使用方法、ヘルプ、エ"
"ラーメッセージなどでどのように表示されるかを制御することが難いからです。"

#: ../../library/argparse.rst:1077
msgid ""
"Formatted choices override the default *metavar* which is normally derived "
"from *dest*.  This is usually what you want because the user never sees the "
"*dest* parameter.  If this display isn't desirable (perhaps because there "
"are many choices), just specify an explicit metavar_."
msgstr ""
"ヘルプテキストにおいて整形された choices の値は、通常 *dest* から生成されるデ"
"フォルトの *metavar* に優先します。ユーザーは *dest* パラメータを目にすること"
"がないため、この振る舞いは基本的には望ましいものです。もしこの表示方法が望ま"
"しくない場合 (おそらく多くの選択肢がある場合など) は、 metavar_ を明示的に指"
"定してください。"

#: ../../library/argparse.rst:1086
msgid "required"
msgstr "required"

#: ../../library/argparse.rst:1088
msgid ""
"In general, the :mod:`!argparse` module assumes that flags like ``-f`` and "
"``--bar`` indicate *optional* arguments, which can always be omitted at the "
"command line. To make an option *required*, ``True`` can be specified for "
"the ``required=`` keyword argument to :meth:`~ArgumentParser.add_argument`::"
msgstr ""

#: ../../library/argparse.rst:1093
msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', required=True)\n"
">>> parser.parse_args(['--foo', 'BAR'])\n"
"Namespace(foo='BAR')\n"
">>> parser.parse_args([])\n"
"usage: [-h] --foo FOO\n"
": error: the following arguments are required: --foo"
msgstr ""

#: ../../library/argparse.rst:1101
msgid ""
"As the example shows, if an option is marked as ``required``, :meth:"
"`~ArgumentParser.parse_args` will report an error if that option is not "
"present at the command line."
msgstr ""
"上の例のように、引数が ``required`` と指定されると、:meth:`~ArgumentParser."
"parse_args` はそのフラグがコマンドラインに存在しないときにエラーを表示しま"
"す。"

#: ../../library/argparse.rst:1107
msgid ""
"Required options are generally considered bad form because users expect "
"*options* to be *optional*, and thus they should be avoided when possible."
msgstr ""
"ユーザーは、通常 *フラグ* の指定は *任意* であると認識しているため、必須にす"
"るのは一般的には悪いやり方で、できる限り避けるべきです。"

#: ../../library/argparse.rst:1114
msgid "help"
msgstr "help"

#: ../../library/argparse.rst:1116
msgid ""
"The ``help`` value is a string containing a brief description of the "
"argument. When a user requests help (usually by using ``-h`` or ``--help`` "
"at the command line), these ``help`` descriptions will be displayed with "
"each argument."
msgstr ""

#: ../../library/argparse.rst:1121
msgid ""
"The ``help`` strings can include various format specifiers to avoid "
"repetition of things like the program name or the argument default_.  The "
"available specifiers include the program name, ``%(prog)s`` and most keyword "
"arguments to :meth:`~ArgumentParser.add_argument`, e.g. ``%(default)s``, "
"``%(type)s``, etc.::"
msgstr ""
"``help`` 文字列には、プログラム名や引数の default_ などを繰り返し記述するのを"
"避けるためのフォーマット指定子を含めることができます。利用できる指定子には、"
"プログラム名 ``%(prog)s`` と、 ``%(default)s`` や ``%(type)s`` など :meth:"
"`~ArgumentParser.add_argument` のキーワード引数の多くが含まれます::"

#: ../../library/argparse.rst:1126
msgid ""
">>> parser = argparse.ArgumentParser(prog='frobble')\n"
">>> parser.add_argument('bar', nargs='?', type=int, default=42,\n"
"...                     help='the bar to %(prog)s (default: %(default)s)')\n"
">>> parser.print_help()\n"
"usage: frobble [-h] [bar]\n"
"\n"
"positional arguments:\n"
" bar     the bar to frobble (default: 42)\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit"
msgstr ""

#: ../../library/argparse.rst:1138
msgid ""
"As the help string supports %-formatting, if you want a literal ``%`` to "
"appear in the help string, you must escape it as ``%%``."
msgstr ""
"ヘルプ文字列は %-フォーマットをサポートしているので、ヘルプ文字列内にリテラ"
"ル ``%`` を表示したい場合は ``%%`` のようにエスケープしなければなりません。"

#: ../../library/argparse.rst:1141
msgid ""
":mod:`!argparse` supports silencing the help entry for certain options, by "
"setting the ``help`` value to ``argparse.SUPPRESS``::"
msgstr ""

#: ../../library/argparse.rst:1144
msgid ""
">>> parser = argparse.ArgumentParser(prog='frobble')\n"
">>> parser.add_argument('--foo', help=argparse.SUPPRESS)\n"
">>> parser.print_help()\n"
"usage: frobble [-h]\n"
"\n"
"options:\n"
"  -h, --help  show this help message and exit"
msgstr ""

#: ../../library/argparse.rst:1156
msgid "metavar"
msgstr "metavar"

#: ../../library/argparse.rst:1158
msgid ""
"When :class:`ArgumentParser` generates help messages, it needs some way to "
"refer to each expected argument.  By default, :class:`!ArgumentParser` "
"objects use the dest_ value as the \"name\" of each object.  By default, for "
"positional argument actions, the dest_ value is used directly, and for "
"optional argument actions, the dest_ value is uppercased.  So, a single "
"positional argument with ``dest='bar'`` will be referred to as ``bar``. A "
"single optional argument ``--foo`` that should be followed by a single "
"command-line argument will be referred to as ``FOO``.  An example::"
msgstr ""

#: ../../library/argparse.rst:1167
msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo')\n"
">>> parser.add_argument('bar')\n"
">>> parser.parse_args('X --foo Y'.split())\n"
"Namespace(bar='X', foo='Y')\n"
">>> parser.print_help()\n"
"usage:  [-h] [--foo FOO] bar\n"
"\n"
"positional arguments:\n"
" bar\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit\n"
" --foo FOO"
msgstr ""

#: ../../library/argparse.rst:1182
msgid "An alternative name can be specified with ``metavar``::"
msgstr "代わりの名前を、``metavar`` として指定できます::"

#: ../../library/argparse.rst:1184
msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', metavar='YYY')\n"
">>> parser.add_argument('bar', metavar='XXX')\n"
">>> parser.parse_args('X --foo Y'.split())\n"
"Namespace(bar='X', foo='Y')\n"
">>> parser.print_help()\n"
"usage:  [-h] [--foo YYY] XXX\n"
"\n"
"positional arguments:\n"
" XXX\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit\n"
" --foo YYY"
msgstr ""

#: ../../library/argparse.rst:1199
msgid ""
"Note that ``metavar`` only changes the *displayed* name - the name of the "
"attribute on the :meth:`~ArgumentParser.parse_args` object is still "
"determined by the dest_ value."
msgstr ""
"``metavar`` は *表示される* 名前だけを変更することに注意してください。:meth:"
"`~ArgumentParser.parse_args` の返すオブジェクトの属性名は dest_ の値のままで"
"す。"

#: ../../library/argparse.rst:1203
msgid ""
"Different values of ``nargs`` may cause the metavar to be used multiple "
"times. Providing a tuple to ``metavar`` specifies a different display for "
"each of the arguments::"
msgstr ""
"``nargs`` を指定した場合、metavar が複数回利用されるかもしれません。"
"``metavar`` にタプルを渡すと、各引数に対して異なる名前を指定できます::"

#: ../../library/argparse.rst:1207
msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('-x', nargs=2)\n"
">>> parser.add_argument('--foo', nargs=2, metavar=('bar', 'baz'))\n"
">>> parser.print_help()\n"
"usage: PROG [-h] [-x X X] [--foo bar baz]\n"
"\n"
"options:\n"
" -h, --help     show this help message and exit\n"
" -x X X\n"
" --foo bar baz"
msgstr ""

#: ../../library/argparse.rst:1222
msgid "dest"
msgstr "dest"

#: ../../library/argparse.rst:1224
msgid ""
"Most :class:`ArgumentParser` actions add some value as an attribute of the "
"object returned by :meth:`~ArgumentParser.parse_args`.  The name of this "
"attribute is determined by the ``dest`` keyword argument of :meth:"
"`~ArgumentParser.add_argument`.  For positional argument actions, ``dest`` "
"is normally supplied as the first argument to :meth:`~ArgumentParser."
"add_argument`::"
msgstr ""
"ほとんどの :class:`ArgumentParser` のアクションは :meth:`~ArgumentParser."
"parse_args` が返すオブジェクトに対する属性として値を追加します。この属性の名"
"前は :meth:`~ArgumentParser.add_argument` の ``dest`` キーワード引数によって"
"決定されます。位置引数のアクションについては、 ``dest`` は通常 :meth:"
"`~ArgumentParser.add_argument` の第一引数として渡します::"

#: ../../library/argparse.rst:1231
msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('bar')\n"
">>> parser.parse_args(['XXX'])\n"
"Namespace(bar='XXX')"
msgstr ""

#: ../../library/argparse.rst:1236
msgid ""
"For optional argument actions, the value of ``dest`` is normally inferred "
"from the option strings.  :class:`ArgumentParser` generates the value of "
"``dest`` by taking the first long option string and stripping away the "
"initial ``--`` string.  If no long option strings were supplied, ``dest`` "
"will be derived from the first short option string by stripping the initial "
"``-`` character.  Any internal ``-`` characters will be converted to ``_`` "
"characters to make sure the string is a valid attribute name.  The examples "
"below illustrate this behavior::"
msgstr ""
"オプション引数のアクションについては、 ``dest`` の値は通常オプション文字列か"
"ら生成されます。 :class:`ArgumentParser` は最初の長いオプション文字列を選択"
"し、先頭の ``--`` を除去することで ``dest`` の値を生成します。長いオプション"
"文字列が指定されていない場合、最初の短いオプション文字列から先頭の ``-`` 文字"
"を除去することで ``dest`` を生成します。先頭以外のすべての ``-`` 文字は、妥当"
"な属性名になるように ``_`` 文字へ変換されます。次の例はこの動作を示していま"
"す::"

#: ../../library/argparse.rst:1245
msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('-f', '--foo-bar', '--foo')\n"
">>> parser.add_argument('-x', '-y')\n"
">>> parser.parse_args('-f 1 -x 2'.split())\n"
"Namespace(foo_bar='1', x='2')\n"
">>> parser.parse_args('--foo 1 -y 2'.split())\n"
"Namespace(foo_bar='1', x='2')"
msgstr ""

#: ../../library/argparse.rst:1253
msgid "``dest`` allows a custom attribute name to be provided::"
msgstr "``dest`` にカスタムの属性名を与えることも可能です::"

#: ../../library/argparse.rst:1255
msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', dest='bar')\n"
">>> parser.parse_args('--foo XXX'.split())\n"
"Namespace(bar='XXX')"
msgstr ""

#: ../../library/argparse.rst:1264
msgid "deprecated"
msgstr ""

#: ../../library/argparse.rst:1266
msgid ""
"During a project's lifetime, some arguments may need to be removed from the "
"command line. Before removing them, you should inform your users that the "
"arguments are deprecated and will be removed. The ``deprecated`` keyword "
"argument of :meth:`~ArgumentParser.add_argument`, which defaults to "
"``False``, specifies if the argument is deprecated and will be removed in "
"the future. For arguments, if ``deprecated`` is ``True``, then a warning "
"will be printed to :data:`sys.stderr` when the argument is used::"
msgstr ""

#: ../../library/argparse.rst:1276
msgid ""
">>> import argparse\n"
">>> parser = argparse.ArgumentParser(prog='snake.py')\n"
">>> parser.add_argument('--legs', default=0, type=int, deprecated=True)\n"
">>> parser.parse_args([])\n"
"Namespace(legs=0)\n"
">>> parser.parse_args(['--legs', '4'])\n"
"snake.py: warning: option '--legs' is deprecated\n"
"Namespace(legs=4)"
msgstr ""

#: ../../library/argparse.rst:1289
msgid "Action classes"
msgstr "Action クラス"

#: ../../library/argparse.rst:1291
msgid ""
":class:`!Action` classes implement the Action API, a callable which returns "
"a callable which processes arguments from the command-line. Any object which "
"follows this API may be passed as the ``action`` parameter to :meth:"
"`~ArgumentParser.add_argument`."
msgstr ""

#: ../../library/argparse.rst:1300
msgid ""
":class:`!Action` objects are used by an :class:`ArgumentParser` to represent "
"the information needed to parse a single argument from one or more strings "
"from the command line. The :class:`!Action` class must accept the two "
"positional arguments plus any keyword arguments passed to :meth:"
"`ArgumentParser.add_argument` except for the ``action`` itself."
msgstr ""

#: ../../library/argparse.rst:1306
msgid ""
"Instances of :class:`!Action` (or return value of any callable to the "
"``action`` parameter) should have attributes :attr:`!dest`, :attr:`!"
"option_strings`, :attr:`!default`, :attr:`!type`, :attr:`!required`, :attr:`!"
"help`, etc. defined. The easiest way to ensure these attributes are defined "
"is to call :meth:`!Action.__init__`."
msgstr ""

#: ../../library/argparse.rst:1314
msgid ""
":class:`!Action` instances should be callable, so subclasses must override "
"the :meth:`!__call__` method, which should accept four parameters:"
msgstr ""

#: ../../library/argparse.rst:1317
msgid ""
"*parser* - The :class:`ArgumentParser` object which contains this action."
msgstr ""

#: ../../library/argparse.rst:1319
msgid ""
"*namespace* - The :class:`Namespace` object that will be returned by :meth:"
"`~ArgumentParser.parse_args`.  Most actions add an attribute to this object "
"using :func:`setattr`."
msgstr ""

#: ../../library/argparse.rst:1323
msgid ""
"*values* - The associated command-line arguments, with any type conversions "
"applied.  Type conversions are specified with the type_ keyword argument to :"
"meth:`~ArgumentParser.add_argument`."
msgstr ""

#: ../../library/argparse.rst:1327
msgid ""
"*option_string* - The option string that was used to invoke this action. The "
"``option_string`` argument is optional, and will be absent if the action is "
"associated with a positional argument."
msgstr ""

#: ../../library/argparse.rst:1331
msgid ""
"The :meth:`!__call__` method may perform arbitrary actions, but will "
"typically set attributes on the ``namespace`` based on ``dest`` and "
"``values``."
msgstr ""

#: ../../library/argparse.rst:1336
msgid ""
":class:`!Action` subclasses can define a :meth:`!format_usage` method that "
"takes no argument and return a string which will be used when printing the "
"usage of the program. If such method is not provided, a sensible default "
"will be used."
msgstr ""

#: ../../library/argparse.rst:1342
msgid "The parse_args() method"
msgstr "parse_args() メソッド"

#: ../../library/argparse.rst:1346
msgid ""
"Convert argument strings to objects and assign them as attributes of the "
"namespace.  Return the populated namespace."
msgstr ""
"引数の文字列をオブジェクトに変換し、namespace オブジェクトの属性に代入しま"
"す。結果の namespace オブジェクトを返します。"

#: ../../library/argparse.rst:1349
msgid ""
"Previous calls to :meth:`add_argument` determine exactly what objects are "
"created and how they are assigned. See the documentation for :meth:`!"
"add_argument` for details."
msgstr ""

#: ../../library/argparse.rst:1353
msgid ""
"args_ - List of strings to parse.  The default is taken from :data:`sys."
"argv`."
msgstr ""
"args_ - 解析する文字列のリスト。デフォルトでは :data:`sys.argv` から取得され"
"ます。"

#: ../../library/argparse.rst:1356
msgid ""
"namespace_ - An object to take the attributes.  The default is a new empty :"
"class:`Namespace` object."
msgstr ""
"namespace_ - 属性を代入するオブジェクト。デフォルトでは、新しい空の :class:"
"`Namespace` オブジェクトです。"

#: ../../library/argparse.rst:1361
msgid "Option value syntax"
msgstr "オプション値の文法"

#: ../../library/argparse.rst:1363
msgid ""
"The :meth:`~ArgumentParser.parse_args` method supports several ways of "
"specifying the value of an option (if it takes one).  In the simplest case, "
"the option and its value are passed as two separate arguments::"
msgstr ""
":meth:`~ArgumentParser.parse_args` メソッドは、オプションの値がある場合、その"
"オプションの値の指定に複数の方法をサポートしています。もっとも単純な場合に"
"は、オプションとその値は次のように2つの別々の引数として渡されます::"

#: ../../library/argparse.rst:1367
msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('-x')\n"
">>> parser.add_argument('--foo')\n"
">>> parser.parse_args(['-x', 'X'])\n"
"Namespace(foo=None, x='X')\n"
">>> parser.parse_args(['--foo', 'FOO'])\n"
"Namespace(foo='FOO', x=None)"
msgstr ""

#: ../../library/argparse.rst:1375
msgid ""
"For long options (options with names longer than a single character), the "
"option and value can also be passed as a single command-line argument, using "
"``=`` to separate them::"
msgstr ""
"長いオプション (1文字よりも長い名前を持ったオプション) では、オプションとその"
"値は次のように ``=`` で区切られた1つのコマンドライン引数として渡すこともでき"
"ます::"

#: ../../library/argparse.rst:1379
msgid ""
">>> parser.parse_args(['--foo=FOO'])\n"
"Namespace(foo='FOO', x=None)"
msgstr ""

#: ../../library/argparse.rst:1382
msgid ""
"For short options (options only one character long), the option and its "
"value can be concatenated::"
msgstr ""
"短いオプション (1文字のオプション) では、オプションとその値は次のように連結し"
"て渡すことができます::"

#: ../../library/argparse.rst:1385
msgid ""
">>> parser.parse_args(['-xX'])\n"
"Namespace(foo=None, x='X')"
msgstr ""

#: ../../library/argparse.rst:1388
msgid ""
"Several short options can be joined together, using only a single ``-`` "
"prefix, as long as only the last option (or none of them) requires a value::"
msgstr ""
"最後の1つのオプションだけが値を要求する場合、または値を要求するオプションがな"
"い場合、複数の短いオプションは次のように1つの接頭辞 ``-`` だけで連結できま"
"す::"

#: ../../library/argparse.rst:1391
msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('-x', action='store_true')\n"
">>> parser.add_argument('-y', action='store_true')\n"
">>> parser.add_argument('-z')\n"
">>> parser.parse_args(['-xyzZ'])\n"
"Namespace(x=True, y=True, z='Z')"
msgstr ""

#: ../../library/argparse.rst:1400
msgid "Invalid arguments"
msgstr "不正な引数"

#: ../../library/argparse.rst:1402
msgid ""
"While parsing the command line, :meth:`~ArgumentParser.parse_args` checks "
"for a variety of errors, including ambiguous options, invalid types, invalid "
"options, wrong number of positional arguments, etc.  When it encounters such "
"an error, it exits and prints the error along with a usage message::"
msgstr ""
":meth:`~ArgumentParser.parse_args` は、コマンドラインの解析中に、曖昧なオプ"
"ション、不正な型、不正なオプション、位置引数の数の不一致などのエラーを検証し"
"ます。それらのエラーが発生した場合、エラーメッセージと使用法メッセージを表示"
"して終了します::"

#: ../../library/argparse.rst:1407
msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('--foo', type=int)\n"
">>> parser.add_argument('bar', nargs='?')\n"
"\n"
">>> # invalid type\n"
">>> parser.parse_args(['--foo', 'spam'])\n"
"usage: PROG [-h] [--foo FOO] [bar]\n"
"PROG: error: argument --foo: invalid int value: 'spam'\n"
"\n"
">>> # invalid option\n"
">>> parser.parse_args(['--bar'])\n"
"usage: PROG [-h] [--foo FOO] [bar]\n"
"PROG: error: no such option: --bar\n"
"\n"
">>> # wrong number of arguments\n"
">>> parser.parse_args(['spam', 'badger'])\n"
"usage: PROG [-h] [--foo FOO] [bar]\n"
"PROG: error: extra arguments found: badger"
msgstr ""

#: ../../library/argparse.rst:1428
msgid "Arguments containing ``-``"
msgstr "``-`` を含む引数"

#: ../../library/argparse.rst:1430
msgid ""
"The :meth:`~ArgumentParser.parse_args` method attempts to give errors "
"whenever the user has clearly made a mistake, but some situations are "
"inherently ambiguous.  For example, the command-line argument ``-1`` could "
"either be an attempt to specify an option or an attempt to provide a "
"positional argument. The :meth:`~ArgumentParser.parse_args` method is "
"cautious here: positional arguments may only begin with ``-`` if they look "
"like negative numbers and there are no options in the parser that look like "
"negative numbers::"
msgstr ""
":meth:`~ArgumentParser.parse_args` メソッドは、ユーザーが明らかなミスをした場"
"合はエラーを表示しますが、いくつか本質的に曖昧な場面があります。例えば、コマ"
"ンドライン引数 ``-1`` は、オプションの指定かもしれませんし位置引数かもしれま"
"せん。:meth:`~ArgumentParser.parse_args` メソッドはこれを次のように扱います: "
"負の数として解釈でき、パーサーに負の数のように解釈できるオプションが存在しな"
"い場合にのみ、``-`` で始まる位置引数になりえます::"

#: ../../library/argparse.rst:1438
msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('-x')\n"
">>> parser.add_argument('foo', nargs='?')\n"
"\n"
">>> # no negative number options, so -1 is a positional argument\n"
">>> parser.parse_args(['-x', '-1'])\n"
"Namespace(foo=None, x='-1')\n"
"\n"
">>> # no negative number options, so -1 and -5 are positional arguments\n"
">>> parser.parse_args(['-x', '-1', '-5'])\n"
"Namespace(foo='-5', x='-1')\n"
"\n"
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('-1', dest='one')\n"
">>> parser.add_argument('foo', nargs='?')\n"
"\n"
">>> # negative number options present, so -1 is an option\n"
">>> parser.parse_args(['-1', 'X'])\n"
"Namespace(foo=None, one='X')\n"
"\n"
">>> # negative number options present, so -2 is an option\n"
">>> parser.parse_args(['-2'])\n"
"usage: PROG [-h] [-1 ONE] [foo]\n"
"PROG: error: no such option: -2\n"
"\n"
">>> # negative number options present, so both -1s are options\n"
">>> parser.parse_args(['-1', '-1'])\n"
"usage: PROG [-h] [-1 ONE] [foo]\n"
"PROG: error: argument -1: expected one argument"
msgstr ""

#: ../../library/argparse.rst:1468
msgid ""
"If you have positional arguments that must begin with ``-`` and don't look "
"like negative numbers, you can insert the pseudo-argument ``'--'`` which "
"tells :meth:`~ArgumentParser.parse_args` that everything after that is a "
"positional argument::"
msgstr ""
"``-`` で始まる位置引数があって、それが負の数として解釈できない場合、ダミーの"
"引数 ``'--'`` を挿入して、:meth:`~ArgumentParser.parse_args` にそれ以降のすべ"
"てが位置引数だと教えることができます::"

#: ../../library/argparse.rst:1473
msgid ""
">>> parser.parse_args(['--', '-f'])\n"
"Namespace(foo='-f', one=None)"
msgstr ""

#: ../../library/argparse.rst:1476
msgid ""
"See also :ref:`the argparse howto on ambiguous arguments <specifying-"
"ambiguous-arguments>` for more details."
msgstr ""

#: ../../library/argparse.rst:1482
msgid "Argument abbreviations (prefix matching)"
msgstr "引数の短縮形 (先頭文字でのマッチング)"

#: ../../library/argparse.rst:1484
msgid ""
"The :meth:`~ArgumentParser.parse_args` method :ref:`by default "
"<allow_abbrev>` allows long options to be abbreviated to a prefix, if the "
"abbreviation is unambiguous (the prefix matches a unique option)::"
msgstr ""
":meth:`~ArgumentParser.parse_args` メソッドは、:ref:`デフォルトで "
"<allow_abbrev>`、長いオプションに曖昧さがない (先頭文字列が一意である) かぎ"
"り、先頭文字列に短縮して指定できます::"

#: ../../library/argparse.rst:1488
msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('-bacon')\n"
">>> parser.add_argument('-badger')\n"
">>> parser.parse_args('-bac MMM'.split())\n"
"Namespace(bacon='MMM', badger=None)\n"
">>> parser.parse_args('-bad WOOD'.split())\n"
"Namespace(bacon=None, badger='WOOD')\n"
">>> parser.parse_args('-ba BA'.split())\n"
"usage: PROG [-h] [-bacon BACON] [-badger BADGER]\n"
"PROG: error: ambiguous option: -ba could match -badger, -bacon"
msgstr ""

#: ../../library/argparse.rst:1499
msgid ""
"An error is produced for arguments that could produce more than one options. "
"This feature can be disabled by setting :ref:`allow_abbrev` to ``False``."
msgstr ""
"先頭の文字が同じ引数が複数ある場合に短縮指定を行うとエラーを発生させます。こ"
"の機能は :ref:`allow_abbrev` に ``False`` を指定することで無効にできます。"

#: ../../library/argparse.rst:1505
msgid "Beyond ``sys.argv``"
msgstr "``sys.argv`` 以外"

#: ../../library/argparse.rst:1507
msgid ""
"Sometimes it may be useful to have an :class:`ArgumentParser` parse "
"arguments other than those of :data:`sys.argv`.  This can be accomplished by "
"passing a list of strings to :meth:`~ArgumentParser.parse_args`.  This is "
"useful for testing at the interactive prompt::"
msgstr ""

#: ../../library/argparse.rst:1512
msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument(\n"
"...     'integers', metavar='int', type=int, choices=range(10),\n"
"...     nargs='+', help='an integer in the range 0..9')\n"
">>> parser.add_argument(\n"
"...     '--sum', dest='accumulate', action='store_const', const=sum,\n"
"...     default=max, help='sum the integers (default: find the max)')\n"
">>> parser.parse_args(['1', '2', '3', '4'])\n"
"Namespace(accumulate=<built-in function max>, integers=[1, 2, 3, 4])\n"
">>> parser.parse_args(['1', '2', '3', '4', '--sum'])\n"
"Namespace(accumulate=<built-in function sum>, integers=[1, 2, 3, 4])"
msgstr ""

#: ../../library/argparse.rst:1527
msgid "The Namespace object"
msgstr "Namespace オブジェクト"

#: ../../library/argparse.rst:1531
msgid ""
"Simple class used by default by :meth:`~ArgumentParser.parse_args` to create "
"an object holding attributes and return it."
msgstr ""
":meth:`~ArgumentParser.parse_args` が属性を格納して返すためのオブジェクトにデ"
"フォルトで使用されるシンプルなクラスです。"

#: ../../library/argparse.rst:1534
msgid ""
"This class is deliberately simple, just an :class:`object` subclass with a "
"readable string representation. If you prefer to have dict-like view of the "
"attributes, you can use the standard Python idiom, :func:`vars`::"
msgstr ""
"このクラスはシンプルに設計されており、単に読みやすい文字列表現を持った :"
"class:`object` のサブクラスです。もし属性を辞書のように扱える方が良ければ、標"
"準的な Python のイディオム :func:`vars` を利用できます::"

#: ../../library/argparse.rst:1538
msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo')\n"
">>> args = parser.parse_args(['--foo', 'BAR'])\n"
">>> vars(args)\n"
"{'foo': 'BAR'}"
msgstr ""

#: ../../library/argparse.rst:1544
msgid ""
"It may also be useful to have an :class:`ArgumentParser` assign attributes "
"to an already existing object, rather than a new :class:`Namespace` object.  "
"This can be achieved by specifying the ``namespace=`` keyword argument::"
msgstr ""
":class:`ArgumentParser` が、新しい :class:`Namespace` オブジェクトではなく、"
"既存のオブジェクトに属性を設定する方が良い場合があります。これは "
"``namespace=`` キーワード引数を指定することで可能です::"

#: ../../library/argparse.rst:1548
msgid ""
">>> class C:\n"
"...     pass\n"
"...\n"
">>> c = C()\n"
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo')\n"
">>> parser.parse_args(args=['--foo', 'BAR'], namespace=c)\n"
">>> c.foo\n"
"'BAR'"
msgstr ""

#: ../../library/argparse.rst:1560
msgid "Other utilities"
msgstr "その他のユーティリティ"

#: ../../library/argparse.rst:1563
msgid "Sub-commands"
msgstr "サブコマンド"

#: ../../library/argparse.rst:1570
msgid ""
"Many programs split up their functionality into a number of subcommands, for "
"example, the ``svn`` program can invoke subcommands like ``svn checkout``, "
"``svn update``, and ``svn commit``.  Splitting up functionality this way can "
"be a particularly good idea when a program performs several different "
"functions which require different kinds of command-line arguments. :class:"
"`ArgumentParser` supports the creation of such subcommands with the :meth:`!"
"add_subparsers` method.  The :meth:`!add_subparsers` method is normally "
"called with no arguments and returns a special action object.  This object "
"has a single method, :meth:`~_SubParsersAction.add_parser`, which takes a "
"command name and any :class:`!ArgumentParser` constructor arguments, and "
"returns an :class:`!ArgumentParser` object that can be modified as usual."
msgstr ""

#: ../../library/argparse.rst:1582
msgid "Description of parameters:"
msgstr "引数の説明:"

#: ../../library/argparse.rst:1584
msgid ""
"*title* - title for the sub-parser group in help output; by default "
"\"subcommands\" if description is provided, otherwise uses title for "
"positional arguments"
msgstr ""

#: ../../library/argparse.rst:1588
msgid ""
"*description* - description for the sub-parser group in help output, by "
"default ``None``"
msgstr ""

#: ../../library/argparse.rst:1591
msgid ""
"*prog* - usage information that will be displayed with sub-command help, by "
"default the name of the program and any positional arguments before the "
"subparser argument"
msgstr ""

#: ../../library/argparse.rst:1595
msgid ""
"*parser_class* - class which will be used to create sub-parser instances, by "
"default the class of the current parser (e.g. :class:`ArgumentParser`)"
msgstr ""

#: ../../library/argparse.rst:1598
msgid ""
"action_ - the basic type of action to be taken when this argument is "
"encountered at the command line"
msgstr "action_ - コマンドラインにこの引数があったときの基本のアクション。"

#: ../../library/argparse.rst:1601
msgid ""
"dest_ - name of the attribute under which sub-command name will be stored; "
"by default ``None`` and no value is stored"
msgstr ""
"dest_ - サブコマンド名を格納する属性の名前です。デフォルトは ``None`` で値は"
"格納されません"

#: ../../library/argparse.rst:1604
msgid ""
"required_ - Whether or not a subcommand must be provided, by default "
"``False`` (added in 3.7)"
msgstr ""
"required_ - サブコマンドが必須であるかどうかを指定し、デフォルトは ``False`` "
"です。(3.7 より追加)"

#: ../../library/argparse.rst:1607
msgid "help_ - help for sub-parser group in help output, by default ``None``"
msgstr ""
"help_ - ヘルプ出力に表示されるサブパーサーグループのヘルプです。デフォルトは "
"``None`` です"

#: ../../library/argparse.rst:1609
msgid ""
"metavar_ - string presenting available subcommands in help; by default it is "
"``None`` and presents subcommands in form {cmd1, cmd2, ..}"
msgstr ""

#: ../../library/argparse.rst:1612
msgid "Some example usage::"
msgstr "いくつかの使用例::"

#: ../../library/argparse.rst:1614
msgid ""
">>> # create the top-level parser\n"
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('--foo', action='store_true', help='foo help')\n"
">>> subparsers = parser.add_subparsers(help='subcommand help')\n"
">>>\n"
">>> # create the parser for the \"a\" command\n"
">>> parser_a = subparsers.add_parser('a', help='a help')\n"
">>> parser_a.add_argument('bar', type=int, help='bar help')\n"
">>>\n"
">>> # create the parser for the \"b\" command\n"
">>> parser_b = subparsers.add_parser('b', help='b help')\n"
">>> parser_b.add_argument('--baz', choices=('X', 'Y', 'Z'), help='baz "
"help')\n"
">>>\n"
">>> # parse some argument lists\n"
">>> parser.parse_args(['a', '12'])\n"
"Namespace(bar=12, foo=False)\n"
">>> parser.parse_args(['--foo', 'b', '--baz', 'Z'])\n"
"Namespace(baz='Z', foo=True)"
msgstr ""

#: ../../library/argparse.rst:1633
msgid ""
"Note that the object returned by :meth:`parse_args` will only contain "
"attributes for the main parser and the subparser that was selected by the "
"command line (and not any other subparsers).  So in the example above, when "
"the ``a`` command is specified, only the ``foo`` and ``bar`` attributes are "
"present, and when the ``b`` command is specified, only the ``foo`` and "
"``baz`` attributes are present."
msgstr ""
":meth:`parse_args` が返すオブジェクトにはメインパーサーとコマンドラインで選択"
"されたサブパーサーによる属性だけが設定されており、選択されなかったサブコマン"
"ドのパーサーの属性が設定されていないことに注意してください。このため、上の例"
"では、``a`` コマンドが指定されたときは ``foo``, ``bar`` 属性だけが存在し、"
"``b`` コマンドが指定されたときは ``foo``, ``baz`` 属性だけが存在しています。"

#: ../../library/argparse.rst:1640
msgid ""
"Similarly, when a help message is requested from a subparser, only the help "
"for that particular parser will be printed.  The help message will not "
"include parent parser or sibling parser messages.  (A help message for each "
"subparser command, however, can be given by supplying the ``help=`` argument "
"to :meth:`~_SubParsersAction.add_parser` as above.)"
msgstr ""
"同じように、サブパーサーにヘルプメッセージが要求された場合は、そのパーサーに"
"対するヘルプだけが表示されます。ヘルプメッセージには親パーサーや兄弟パーサー"
"のヘルプメッセージを表示しません。 (ただし、各サブパーサーコマンドのヘルプ"
"メッセージは、上の例にもあるように :meth:`~_SubParsersAction.add_parser` の "
"``help=`` 引数によって指定できます)"

#: ../../library/argparse.rst:1648
msgid ""
">>> parser.parse_args(['--help'])\n"
"usage: PROG [-h] [--foo] {a,b} ...\n"
"\n"
"positional arguments:\n"
"  {a,b}   subcommand help\n"
"    a     a help\n"
"    b     b help\n"
"\n"
"options:\n"
"  -h, --help  show this help message and exit\n"
"  --foo   foo help\n"
"\n"
">>> parser.parse_args(['a', '--help'])\n"
"usage: PROG a [-h] bar\n"
"\n"
"positional arguments:\n"
"  bar     bar help\n"
"\n"
"options:\n"
"  -h, --help  show this help message and exit\n"
"\n"
">>> parser.parse_args(['b', '--help'])\n"
"usage: PROG b [-h] [--baz {X,Y,Z}]\n"
"\n"
"options:\n"
"  -h, --help     show this help message and exit\n"
"  --baz {X,Y,Z}  baz help"
msgstr ""

#: ../../library/argparse.rst:1676
msgid ""
"The :meth:`add_subparsers` method also supports ``title`` and "
"``description`` keyword arguments.  When either is present, the subparser's "
"commands will appear in their own group in the help output.  For example::"
msgstr ""
":meth:`add_subparsers` メソッドは ``title`` と ``description`` キーワード引数"
"もサポートしています。どちらかが存在する場合、サブパーサーのコマンドはヘルプ"
"出力でそれぞれのグループの中に表示されます。例えば::"

#: ../../library/argparse.rst:1680
msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> subparsers = parser.add_subparsers(title='subcommands',\n"
"...                                    description='valid subcommands',\n"
"...                                    help='additional help')\n"
">>> subparsers.add_parser('foo')\n"
">>> subparsers.add_parser('bar')\n"
">>> parser.parse_args(['-h'])\n"
"usage:  [-h] {foo,bar} ...\n"
"\n"
"options:\n"
"  -h, --help  show this help message and exit\n"
"\n"
"subcommands:\n"
"  valid subcommands\n"
"\n"
"  {foo,bar}   additional help"
msgstr ""

#: ../../library/argparse.rst:1697
msgid ""
"Furthermore, :meth:`~_SubParsersAction.add_parser` supports an additional "
"*aliases* argument, which allows multiple strings to refer to the same "
"subparser. This example, like ``svn``, aliases ``co`` as a shorthand for "
"``checkout``::"
msgstr ""

#: ../../library/argparse.rst:1702
msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> subparsers = parser.add_subparsers()\n"
">>> checkout = subparsers.add_parser('checkout', aliases=['co'])\n"
">>> checkout.add_argument('foo')\n"
">>> parser.parse_args(['co', 'bar'])\n"
"Namespace(foo='bar')"
msgstr ""

#: ../../library/argparse.rst:1709
msgid ""
":meth:`~_SubParsersAction.add_parser` supports also an additional "
"*deprecated* argument, which allows to deprecate the subparser."
msgstr ""

#: ../../library/argparse.rst:1723
msgid ""
"One particularly effective way of handling subcommands is to combine the use "
"of the :meth:`add_subparsers` method with calls to :meth:`set_defaults` so "
"that each subparser knows which Python function it should execute.  For "
"example::"
msgstr ""

#: ../../library/argparse.rst:1728
msgid ""
">>> # subcommand functions\n"
">>> def foo(args):\n"
"...     print(args.x * args.y)\n"
"...\n"
">>> def bar(args):\n"
"...     print('((%s))' % args.z)\n"
"...\n"
">>> # create the top-level parser\n"
">>> parser = argparse.ArgumentParser()\n"
">>> subparsers = parser.add_subparsers(required=True)\n"
">>>\n"
">>> # create the parser for the \"foo\" command\n"
">>> parser_foo = subparsers.add_parser('foo')\n"
">>> parser_foo.add_argument('-x', type=int, default=1)\n"
">>> parser_foo.add_argument('y', type=float)\n"
">>> parser_foo.set_defaults(func=foo)\n"
">>>\n"
">>> # create the parser for the \"bar\" command\n"
">>> parser_bar = subparsers.add_parser('bar')\n"
">>> parser_bar.add_argument('z')\n"
">>> parser_bar.set_defaults(func=bar)\n"
">>>\n"
">>> # parse the args and call whatever function was selected\n"
">>> args = parser.parse_args('foo 1 -x 2'.split())\n"
">>> args.func(args)\n"
"2.0\n"
">>>\n"
">>> # parse the args and call whatever function was selected\n"
">>> args = parser.parse_args('bar XYZYX'.split())\n"
">>> args.func(args)\n"
"((XYZYX))"
msgstr ""

#: ../../library/argparse.rst:1760
msgid ""
"This way, you can let :meth:`parse_args` do the job of calling the "
"appropriate function after argument parsing is complete.  Associating "
"functions with actions like this is typically the easiest way to handle the "
"different actions for each of your subparsers.  However, if it is necessary "
"to check the name of the subparser that was invoked, the ``dest`` keyword "
"argument to the :meth:`add_subparsers` call will work::"
msgstr ""
"こうすると、:meth:`parse_args` が引数の解析が終わってから適切な関数を呼び出す"
"ようになります。このように関数をアクションに関連付けるのは一般的にサブパー"
"サーごとに異なるアクションを扱うもっとも簡単な方法です。ただし、実行されたサ"
"ブパーサーの名前を確認する必要がある場合は、:meth:`add_subparsers` を呼び出す"
"ときに ``dest`` キーワードを指定できます::"

#: ../../library/argparse.rst:1767
msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> subparsers = parser.add_subparsers(dest='subparser_name')\n"
">>> subparser1 = subparsers.add_parser('1')\n"
">>> subparser1.add_argument('-x')\n"
">>> subparser2 = subparsers.add_parser('2')\n"
">>> subparser2.add_argument('y')\n"
">>> parser.parse_args(['2', 'frobble'])\n"
"Namespace(subparser_name='2', y='frobble')"
msgstr ""

#: ../../library/argparse.rst:1776
msgid "New *required* keyword-only parameter."
msgstr ""

#: ../../library/argparse.rst:1781
msgid "FileType objects"
msgstr "FileType オブジェクト"

#: ../../library/argparse.rst:1785
msgid ""
"The :class:`FileType` factory creates objects that can be passed to the type "
"argument of :meth:`ArgumentParser.add_argument`.  Arguments that have :class:"
"`FileType` objects as their type will open command-line arguments as files "
"with the requested modes, buffer sizes, encodings and error handling (see "
"the :func:`open` function for more details)::"
msgstr ""
":class:`FileType` ファクトリは :meth:`ArgumentParser.add_argument` の type 引"
"数に渡すことができるオブジェクトを生成します。 type が :class:`FileType` オブ"
"ジェクトである引数はコマンドライン引数を、指定されたモード、バッファーサイ"
"ズ、エンコーディング、エラー処理でファイルとして開きます (詳細は :func:"
"`open` 関数を参照してください。)::"

#: ../../library/argparse.rst:1791
msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--raw', type=argparse.FileType('wb', 0))\n"
">>> parser.add_argument('out', type=argparse.FileType('w', "
"encoding='UTF-8'))\n"
">>> parser.parse_args(['--raw', 'raw.dat', 'file.txt'])\n"
"Namespace(out=<_io.TextIOWrapper name='file.txt' mode='w' encoding='UTF-8'>, "
"raw=<_io.FileIO name='raw.dat' mode='wb'>)"
msgstr ""

#: ../../library/argparse.rst:1797
msgid ""
"FileType objects understand the pseudo-argument ``'-'`` and automatically "
"convert this into :data:`sys.stdin` for readable :class:`FileType` objects "
"and :data:`sys.stdout` for writable :class:`FileType` objects::"
msgstr ""
"FileType オブジェクトは擬似引数 ``'-'`` を識別し、読み込み用の :class:"
"`FileType` であれば :data:`sys.stdin` を、書き込み用の :class:`FileType` であ"
"れば :data:`sys.stdout` に変換します::"

#: ../../library/argparse.rst:1801
msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('infile', type=argparse.FileType('r'))\n"
">>> parser.parse_args(['-'])\n"
"Namespace(infile=<_io.TextIOWrapper name='<stdin>' encoding='UTF-8'>)"
msgstr ""

#: ../../library/argparse.rst:1806
msgid "Added the *encodings* and *errors* parameters."
msgstr "*encodings* と *errors* がパラメータに追加されました。"

#: ../../library/argparse.rst:1811
msgid "Argument groups"
msgstr "引数グループ"

#: ../../library/argparse.rst:1816
msgid ""
"By default, :class:`ArgumentParser` groups command-line arguments into "
"\"positional arguments\" and \"options\" when displaying help messages. When "
"there is a better conceptual grouping of arguments than this default one, "
"appropriate groups can be created using the :meth:`!add_argument_group` "
"method::"
msgstr ""

#: ../../library/argparse.rst:1822
msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG', add_help=False)\n"
">>> group = parser.add_argument_group('group')\n"
">>> group.add_argument('--foo', help='foo help')\n"
">>> group.add_argument('bar', help='bar help')\n"
">>> parser.print_help()\n"
"usage: PROG [--foo FOO] bar\n"
"\n"
"group:\n"
"  bar    bar help\n"
"  --foo FOO  foo help"
msgstr ""

#: ../../library/argparse.rst:1833
msgid ""
"The :meth:`add_argument_group` method returns an argument group object which "
"has an :meth:`~ArgumentParser.add_argument` method just like a regular :"
"class:`ArgumentParser`.  When an argument is added to the group, the parser "
"treats it just like a normal argument, but displays the argument in a "
"separate group for help messages.  The :meth:`!add_argument_group` method "
"accepts *title* and *description* arguments which can be used to customize "
"this display::"
msgstr ""

#: ../../library/argparse.rst:1841
msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG', add_help=False)\n"
">>> group1 = parser.add_argument_group('group1', 'group1 description')\n"
">>> group1.add_argument('foo', help='foo help')\n"
">>> group2 = parser.add_argument_group('group2', 'group2 description')\n"
">>> group2.add_argument('--bar', help='bar help')\n"
">>> parser.print_help()\n"
"usage: PROG [--bar BAR] foo\n"
"\n"
"group1:\n"
"  group1 description\n"
"\n"
"  foo    foo help\n"
"\n"
"group2:\n"
"  group2 description\n"
"\n"
"  --bar BAR  bar help"
msgstr ""

#: ../../library/argparse.rst:1859
msgid ""
"The optional, keyword-only parameters argument_default_ and "
"conflict_handler_ allow for finer-grained control of the behavior of the "
"argument group. These parameters have the same meaning as in the :class:"
"`ArgumentParser` constructor, but apply specifically to the argument group "
"rather than the entire parser."
msgstr ""

#: ../../library/argparse.rst:1864
msgid ""
"Note that any arguments not in your user-defined groups will end up back in "
"the usual \"positional arguments\" and \"optional arguments\" sections."
msgstr ""
"ユーザー定義グループにないすべての引数は通常の \"位置引数\" と \"オプション引"
"数\" セクションに表示されます。"

#: ../../library/argparse.rst:1867
msgid ""
"Calling :meth:`add_argument_group` on an argument group is deprecated. This "
"feature was never supported and does not always work correctly. The function "
"exists on the API by accident through inheritance and will be removed in the "
"future."
msgstr ""
"引数グループについて :meth:`add_argument_group` を呼び出すことは非推奨です。"
"この機能はこれまでサポートされたことはなく、常に正しく動作するとは限りませ"
"ん。この関数は継承を通じて思いがけず API に存在することになったもので、将来削"
"除される予定です。"

#: ../../library/argparse.rst:1875
msgid "Mutual exclusion"
msgstr "相互排他"

#: ../../library/argparse.rst:1879
msgid ""
"Create a mutually exclusive group. :mod:`!argparse` will make sure that only "
"one of the arguments in the mutually exclusive group was present on the "
"command line::"
msgstr ""

#: ../../library/argparse.rst:1883
msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> group = parser.add_mutually_exclusive_group()\n"
">>> group.add_argument('--foo', action='store_true')\n"
">>> group.add_argument('--bar', action='store_false')\n"
">>> parser.parse_args(['--foo'])\n"
"Namespace(bar=True, foo=True)\n"
">>> parser.parse_args(['--bar'])\n"
"Namespace(bar=False, foo=False)\n"
">>> parser.parse_args(['--foo', '--bar'])\n"
"usage: PROG [-h] [--foo | --bar]\n"
"PROG: error: argument --bar: not allowed with argument --foo"
msgstr ""

#: ../../library/argparse.rst:1895
msgid ""
"The :meth:`add_mutually_exclusive_group` method also accepts a *required* "
"argument, to indicate that at least one of the mutually exclusive arguments "
"is required::"
msgstr ""
":meth:`add_mutually_exclusive_group` メソッドの引数 *required* に True 値を指"
"定すると、その相互排他引数のどれか1つを選ぶことが要求されます::"

#: ../../library/argparse.rst:1899
msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> group = parser.add_mutually_exclusive_group(required=True)\n"
">>> group.add_argument('--foo', action='store_true')\n"
">>> group.add_argument('--bar', action='store_false')\n"
">>> parser.parse_args([])\n"
"usage: PROG [-h] (--foo | --bar)\n"
"PROG: error: one of the arguments --foo --bar is required"
msgstr ""

#: ../../library/argparse.rst:1907
msgid ""
"Note that currently mutually exclusive argument groups do not support the "
"*title* and *description* arguments of :meth:`~ArgumentParser."
"add_argument_group`. However, a mutually exclusive group can be added to an "
"argument group that has a title and description. For example::"
msgstr ""

#: ../../library/argparse.rst:1913
msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> group = parser.add_argument_group('Group title', 'Group description')\n"
">>> exclusive_group = group.add_mutually_exclusive_group(required=True)\n"
">>> exclusive_group.add_argument('--foo', help='foo help')\n"
">>> exclusive_group.add_argument('--bar', help='bar help')\n"
">>> parser.print_help()\n"
"usage: PROG [-h] (--foo FOO | --bar BAR)\n"
"\n"
"options:\n"
"  -h, --help  show this help message and exit\n"
"\n"
"Group title:\n"
"  Group description\n"
"\n"
"  --foo FOO   foo help\n"
"  --bar BAR   bar help"
msgstr ""

#: ../../library/argparse.rst:1930
msgid ""
"Calling :meth:`add_argument_group` or :meth:`add_mutually_exclusive_group` "
"on a mutually exclusive group is deprecated. These features were never "
"supported and do not always work correctly. The functions exist on the API "
"by accident through inheritance and will be removed in the future."
msgstr ""
"相互排他グループについて :meth:`add_argument_group` や :meth:"
"`add_mutually_exclusive_group` を呼び出すことは非推奨です。これらの機能はこれ"
"まで一度もサポートされたことがなく、常に正しく動作するとは限りません。これら"
"の関数は継承により偶然 API に存在することになったもので、将来削除される予定で"
"す。"

#: ../../library/argparse.rst:1938
msgid "Parser defaults"
msgstr "パーサーのデフォルト値"

#: ../../library/argparse.rst:1942
msgid ""
"Most of the time, the attributes of the object returned by :meth:"
"`parse_args` will be fully determined by inspecting the command-line "
"arguments and the argument actions.  :meth:`set_defaults` allows some "
"additional attributes that are determined without any inspection of the "
"command line to be added::"
msgstr ""
"ほとんどの場合、 :meth:`parse_args` が返すオブジェクトの属性はコマンドライン"
"引数の内容と引数のアクションによってのみ決定されます。 :meth:`set_defaults` "
"を使うと与えられたコマンドライン引数の内容によらず追加の属性を決定することが"
"可能です::"

#: ../../library/argparse.rst:1948
msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('foo', type=int)\n"
">>> parser.set_defaults(bar=42, baz='badger')\n"
">>> parser.parse_args(['736'])\n"
"Namespace(bar=42, baz='badger', foo=736)"
msgstr ""

#: ../../library/argparse.rst:1954
msgid ""
"Note that parser-level defaults always override argument-level defaults::"
msgstr ""
"パーサーレベルのデフォルト値は常に引数レベルのデフォルト値を上書きします::"

#: ../../library/argparse.rst:1956
msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', default='bar')\n"
">>> parser.set_defaults(foo='spam')\n"
">>> parser.parse_args([])\n"
"Namespace(foo='spam')"
msgstr ""

#: ../../library/argparse.rst:1962
msgid ""
"Parser-level defaults can be particularly useful when working with multiple "
"parsers.  See the :meth:`~ArgumentParser.add_subparsers` method for an "
"example of this type."
msgstr ""
"パーサーレベルの default は、複数のパーサーを扱うときに特に便利です。このタイ"
"プの例については :meth:`~ArgumentParser.add_subparsers` メソッドを参照してく"
"ださい。"

#: ../../library/argparse.rst:1968
msgid ""
"Get the default value for a namespace attribute, as set by either :meth:"
"`~ArgumentParser.add_argument` or by :meth:`~ArgumentParser.set_defaults`::"
msgstr ""
":meth:`~ArgumentParser.add_argument` か :meth:`~ArgumentParser.set_defaults` "
"によって指定された、 namespace の属性のデフォルト値を取得します::"

#: ../../library/argparse.rst:1972
msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', default='badger')\n"
">>> parser.get_default('foo')\n"
"'badger'"
msgstr ""

#: ../../library/argparse.rst:1979
msgid "Printing help"
msgstr "ヘルプの表示"

#: ../../library/argparse.rst:1981
msgid ""
"In most typical applications, :meth:`~ArgumentParser.parse_args` will take "
"care of formatting and printing any usage or error messages.  However, "
"several formatting methods are available:"
msgstr ""
"ほとんどの典型的なアプリケーションでは、:meth:`~ArgumentParser.parse_args` が"
"使用法やエラーメッセージのフォーマットと表示について面倒を見ます。しかし、い"
"くつかのフォーマットメソッドが利用できます:"

#: ../../library/argparse.rst:1987
msgid ""
"Print a brief description of how the :class:`ArgumentParser` should be "
"invoked on the command line.  If *file* is ``None``, :data:`sys.stdout` is "
"assumed."
msgstr ""
":class:`ArgumentParser` がコマンドラインからどう実行されるべきかの短い説明を"
"表示します。 *file* が ``None`` の時は、 :data:`sys.stdout` に出力されます。"

#: ../../library/argparse.rst:1993
msgid ""
"Print a help message, including the program usage and information about the "
"arguments registered with the :class:`ArgumentParser`.  If *file* is "
"``None``, :data:`sys.stdout` is assumed."
msgstr ""
"プログラムの使用法と :class:`ArgumentParser` に登録された引数についての情報を"
"含むヘルプメッセージを表示します。 *file* が ``None`` の時は、 :data:`sys."
"stdout` に出力されます。"

#: ../../library/argparse.rst:1997
msgid ""
"There are also variants of these methods that simply return a string instead "
"of printing it:"
msgstr ""
"これらのメソッドの、表示する代わりにシンプルに文字列を返すバージョンもありま"
"す:"

#: ../../library/argparse.rst:2002
msgid ""
"Return a string containing a brief description of how the :class:"
"`ArgumentParser` should be invoked on the command line."
msgstr ""
":class:`ArgumentParser` がコマンドラインからどう実行されるべきかの短い説明を"
"格納した文字列を返します。"

#: ../../library/argparse.rst:2007
msgid ""
"Return a string containing a help message, including the program usage and "
"information about the arguments registered with the :class:`ArgumentParser`."
msgstr ""
"プログラムの使用法と :class:`ArgumentParser` に登録された引数についての情報を"
"含むヘルプメッセージを格納した文字列を返します。"

#: ../../library/argparse.rst:2012
msgid "Partial parsing"
msgstr "部分解析"

#: ../../library/argparse.rst:2016
msgid ""
"Sometimes a script may only parse a few of the command-line arguments, "
"passing the remaining arguments on to another script or program. In these "
"cases, the :meth:`~ArgumentParser.parse_known_args` method can be useful.  "
"It works much like :meth:`~ArgumentParser.parse_args` except that it does "
"not produce an error when extra arguments are present.  Instead, it returns "
"a two item tuple containing the populated namespace and the list of "
"remaining argument strings."
msgstr ""
"ときどき、スクリプトがコマンドライン引数のいくつかだけを解析し、残りの引数は"
"別のスクリプトやプログラムに渡すことがあります。こういった場合、 :meth:"
"`~ArgumentParser.parse_known_args` メソッドが便利です。これは :meth:"
"`~ArgumentParser.parse_args` と同じように動作しますが、余分な引数が存在しても"
"エラーを生成しません。代わりに、評価された namespace オブジェクトと、残りの引"
"数文字列のリストからなる2要素タプルを返します。"

#: ../../library/argparse.rst:2025
msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', action='store_true')\n"
">>> parser.add_argument('bar')\n"
">>> parser.parse_known_args(['--foo', '--badger', 'BAR', 'spam'])\n"
"(Namespace(bar='BAR', foo=True), ['--badger', 'spam'])"
msgstr ""

#: ../../library/argparse.rst:2032
msgid ""
":ref:`Prefix matching <prefix-matching>` rules apply to :meth:"
"`~ArgumentParser.parse_known_args`. The parser may consume an option even if "
"it's just a prefix of one of its known options, instead of leaving it in the "
"remaining arguments list."
msgstr ""
":ref:`先頭文字でのマッチング <prefix-matching>` ルールは :meth:"
"`~ArgumentParser.parse_known_args` にも適用されます。たとえ既知のオプションの"
"先頭文字に過ぎない場合でも、パーサは引数リストに残さずに、オプションを受け取"
"る場合があります。"

#: ../../library/argparse.rst:2039
msgid "Customizing file parsing"
msgstr "ファイル解析のカスタマイズ"

#: ../../library/argparse.rst:2043
msgid ""
"Arguments that are read from a file (see the *fromfile_prefix_chars* keyword "
"argument to the :class:`ArgumentParser` constructor) are read one argument "
"per line. :meth:`convert_arg_line_to_args` can be overridden for fancier "
"reading."
msgstr ""
"ファイルから引数を読み込む場合 (:class:`ArgumentParser` コンストラクターの "
"*fromfile_prefix_chars* キーワード引数を参照)、1行につき1つの引数を読み込みま"
"す。 :meth:`convert_arg_line_to_args` を変更することでこの動作をカスタマイズ"
"できます。"

#: ../../library/argparse.rst:2048
msgid ""
"This method takes a single argument *arg_line* which is a string read from "
"the argument file.  It returns a list of arguments parsed from this string. "
"The method is called once per line read from the argument file, in order."
msgstr ""
"このメソッドは、引数ファイルから読まれた文字列である1つの引数 *arg_line* を受"
"け取ります。そしてその文字列を解析した結果の引数のリストを返します。このメ"
"ソッドはファイルから1行読みこむごとに、順番に呼ばれます。"

#: ../../library/argparse.rst:2052
msgid ""
"A useful override of this method is one that treats each space-separated "
"word as an argument.  The following example demonstrates how to do this::"
msgstr ""
"このメソッドをオーバーライドすると便利なこととして、スペースで区切られた行の"
"単語1つ1つを別々の引数として扱えます。次の例でその方法を示します::"

#: ../../library/argparse.rst:2055
msgid ""
"class MyArgumentParser(argparse.ArgumentParser):\n"
"    def convert_arg_line_to_args(self, arg_line):\n"
"        return arg_line.split()"
msgstr ""

#: ../../library/argparse.rst:2061
msgid "Exiting methods"
msgstr "終了メソッド"

#: ../../library/argparse.rst:2065
msgid ""
"This method terminates the program, exiting with the specified *status* and, "
"if given, it prints a *message* to :data:`sys.stderr` before that. The user "
"can override this method to handle these steps differently::"
msgstr ""

#: ../../library/argparse.rst:2069
msgid ""
"class ErrorCatchingArgumentParser(argparse.ArgumentParser):\n"
"    def exit(self, status=0, message=None):\n"
"        if status:\n"
"            raise Exception(f'Exiting because of an error: {message}')\n"
"        exit(status)"
msgstr ""

#: ../../library/argparse.rst:2077
msgid ""
"This method prints a usage message, including the *message*, to :data:`sys."
"stderr` and terminates the program with a status code of 2."
msgstr ""

#: ../../library/argparse.rst:2082
msgid "Intermixed parsing"
msgstr "混在した引数の解析"

#: ../../library/argparse.rst:2087
msgid ""
"A number of Unix commands allow the user to intermix optional arguments with "
"positional arguments.  The :meth:`~ArgumentParser.parse_intermixed_args` "
"and :meth:`~ArgumentParser.parse_known_intermixed_args` methods support this "
"parsing style."
msgstr ""
"多くの Unix コマンドは、オプション引数と位置引数を混在させることを許していま"
"す。 :meth:`~ArgumentParser.parse_intermixed_args` と :meth:`~ArgumentParser."
"parse_known_intermixed_args` メソッドは、このような方法での解析をサポートして"
"います。"

#: ../../library/argparse.rst:2092
msgid ""
"These parsers do not support all the :mod:`!argparse` features, and will "
"raise exceptions if unsupported features are used.  In particular, "
"subparsers, and mutually exclusive groups that include both optionals and "
"positionals are not supported."
msgstr ""

#: ../../library/argparse.rst:2097
msgid ""
"The following example shows the difference between :meth:`~ArgumentParser."
"parse_known_args` and :meth:`~ArgumentParser.parse_intermixed_args`: the "
"former returns ``['2', '3']`` as unparsed arguments, while the latter "
"collects all the positionals into ``rest``.  ::"
msgstr ""
"この例は、:meth:`~ArgumentParser.parse_known_args` と :meth:`~ArgumentParser."
"parse_intermixed_args` の違いを表しています: 前者は ``['2', '3']`` を、解析さ"
"れない引数として返し、後者は全ての位置引数を ``rest`` に入れて返しています::"

#: ../../library/argparse.rst:2103
msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo')\n"
">>> parser.add_argument('cmd')\n"
">>> parser.add_argument('rest', nargs='*', type=int)\n"
">>> parser.parse_known_args('doit 1 --foo bar 2 3'.split())\n"
"(Namespace(cmd='doit', foo='bar', rest=[1]), ['2', '3'])\n"
">>> parser.parse_intermixed_args('doit 1 --foo bar 2 3'.split())\n"
"Namespace(cmd='doit', foo='bar', rest=[1, 2, 3])"
msgstr ""

#: ../../library/argparse.rst:2112
msgid ""
":meth:`~ArgumentParser.parse_known_intermixed_args` returns a two item tuple "
"containing the populated namespace and the list of remaining argument "
"strings. :meth:`~ArgumentParser.parse_intermixed_args` raises an error if "
"there are any remaining unparsed argument strings."
msgstr ""
":meth:`~ArgumentParser.parse_known_intermixed_args` は、解析した内容を含む名"
"前空間と、残りの引数を含んだリストの、2つの要素を持つタプルを返します。\n"
":meth:`~ArgumentParser.parse_intermixed_args` は、解析されない引数が残された"
"場合にはエラーを送出します。"

#: ../../library/argparse.rst:2121
msgid "Registering custom types or actions"
msgstr ""

#: ../../library/argparse.rst:2125
msgid ""
"Sometimes it's desirable to use a custom string in error messages to provide "
"more user-friendly output. In these cases, :meth:`!register` can be used to "
"register custom actions or types with a parser and allow you to reference "
"the type by their registered name instead of their callable name."
msgstr ""

#: ../../library/argparse.rst:2130
msgid ""
"The :meth:`!register` method accepts three arguments - a *registry_name*, "
"specifying the internal registry where the object will be stored (e.g., "
"``action``, ``type``), *value*, which is the key under which the object will "
"be registered, and object, the callable to be registered."
msgstr ""

#: ../../library/argparse.rst:2135
msgid ""
"The following example shows how to register a custom type with a parser::"
msgstr ""

#: ../../library/argparse.rst:2137
msgid ""
">>> import argparse\n"
">>> parser = argparse.ArgumentParser()\n"
">>> parser.register('type', 'hexadecimal integer', lambda s: int(s, 16))\n"
">>> parser.add_argument('--foo', type='hexadecimal integer')\n"
"_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)\n"
">>> parser.parse_args(['--foo', '0xFA'])\n"
"Namespace(foo=250)\n"
">>> parser.parse_args(['--foo', '1.2'])\n"
"usage: PROG [-h] [--foo FOO]\n"
"PROG: error: argument --foo: invalid 'hexadecimal integer' value: '1.2'"
msgstr ""

#: ../../library/argparse.rst:2149
msgid "Exceptions"
msgstr "例外"

#: ../../library/argparse.rst:2153
msgid "An error from creating or using an argument (optional or positional)."
msgstr "引数 (オプション引数または位置引数) の生成時または利用時のエラーです。"

#: ../../library/argparse.rst:2155
msgid ""
"The string value of this exception is the message, augmented with "
"information about the argument that caused it."
msgstr ""
"この例外の文字列表現は、エラーの原因となった引数についての情報を補足するメッ"
"セージです。"

#: ../../library/argparse.rst:2160
msgid ""
"Raised when something goes wrong converting a command line string to a type."
msgstr ""
"コマンドラインの文字列を、指定された型に変換するのに失敗した時に送出されま"
"す。"

#: ../../library/argparse.rst:2164
msgid "Guides and Tutorials"
msgstr "ガイドとチュートリアル"

#: ../../library/argparse.rst:815
msgid "? (question mark)"
msgstr "? (クエスチョンマーク)"

#: ../../library/argparse.rst:815 ../../library/argparse.rst:849
#: ../../library/argparse.rst:863
msgid "in argparse module"
msgstr "argparse モジュール内"

#: ../../library/argparse.rst:849
msgid "* (asterisk)"
msgstr "* (アスタリスク)"

#: ../../library/argparse.rst:863
msgid "+ (plus)"
msgstr "+ (プラス記号)"