argparse.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2020, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
# 
# Translators:
# Arihiro TAKASE, 2017
# shirou - しろう <shirou.faw@gmail.com>, 2017
# Nozomu Kaneko <nozom.kaneko@gmail.com>, 2017
# Shun Sakurai, 2017
# Masato HASHIMOTO <cabezon.hashimoto@gmail.com>, 2017
# Osamu NAKAMURA, 2017
# E. Kawashima, 2017
# 秘湯 <xwhhsprings@gmail.com>, 2018
# Naoki Nakamura <agent@sohzoh.com>, 2020
# tomo, 2020
# 
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.8\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2020-02-09 12:40+0000\n"
"PO-Revision-Date: 2017-02-16 17:48+0000\n"
"Last-Translator: tomo, 2020\n"
"Language-Team: Japanese (https://www.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 sub-"
"commands"
msgstr ":mod:`argparse` --- コマンドラインオプション、引数、サブコマンドのパーサー"

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

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

#: ../../library/argparse.rst:18
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:22
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 and issues errors when users give the program invalid arguments."
msgstr ""
":mod:`argparse` "
"モジュールはユーザーフレンドリなコマンドラインインターフェースの作成を簡単にします。プログラムがどんな引数を必要としているのかを定義すると、:mod:`argparse`"
" が :data:`sys.argv` からそのオプションを解析する方法を見つけ出します。:mod:`argparse` "
"モジュールは自動的にヘルプと使用方法メッセージを生成し、ユーザーが不正な引数をプログラムに指定したときにエラーを発生させます。"

#: ../../library/argparse.rst:30
msgid "Example"
msgstr "使用例"

#: ../../library/argparse.rst:32
msgid ""
"The following code is a Python program that takes a list of integers and "
"produces either the sum or the max::"
msgstr "次のコードは、整数のリストを受け取って合計か最大値を返す Python プログラムです::"

#: ../../library/argparse.rst:47
msgid ""
"Assuming the Python code above is saved into a file called ``prog.py``, it "
"can be run at the command line and provides useful help messages:"
msgstr ""
"上の Python コードが ``prog.py`` "
"という名前のファイルに保存されたと仮定します。コマンドラインから便利なヘルプメッセージを表示できます:"

#: ../../library/argparse.rst:64
msgid ""
"When run with the appropriate arguments, it prints either the sum or the max"
" of the command-line integers:"
msgstr "適切な引数を与えて実行した場合、このプログラムはコマンドライン引数の整数列の合計か最大値を表示します:"

#: ../../library/argparse.rst:75
msgid "If invalid arguments are passed in, it will issue an error:"
msgstr "不正な引数が与えられた場合、エラーを発生させます:"

#: ../../library/argparse.rst:83
msgid "The following sections walk you through this example."
msgstr "以降の節では、この例をひと通り説明して行きます。"

#: ../../library/argparse.rst:87
msgid "Creating a parser"
msgstr "パーサーを作る"

#: ../../library/argparse.rst:89
msgid ""
"The first step in using the :mod:`argparse` is creating an "
":class:`ArgumentParser` object::"
msgstr ""
":mod:`argparse` を使うときの最初のステップは、:class:`ArgumentParser` オブジェクトを生成することです::"

#: ../../library/argparse.rst:94
msgid ""
"The :class:`ArgumentParser` object will hold all the information necessary "
"to parse the command line into Python data types."
msgstr ""
":class:`ArgumentParser` オブジェクトはコマンドラインを解析して Python "
"データ型にするために必要なすべての情報を保持します。"

#: ../../library/argparse.rst:99
msgid "Adding arguments"
msgstr "引数を追加する"

#: ../../library/argparse.rst:101
msgid ""
"Filling an :class:`ArgumentParser` with information about program arguments "
"is done by making calls to the :meth:`~ArgumentParser.add_argument` method. "
"Generally, these calls tell the :class:`ArgumentParser` how to take the "
"strings on the command line and turn them into objects.  This information is"
" stored and used when :meth:`~ArgumentParser.parse_args` is called. For "
"example::"
msgstr ""
":class:`ArgumentParser` "
"にプログラム引数の情報を与えるために、:meth:`~ArgumentParser.add_argument` "
"メソッドを呼び出します。一般的に、このメソッドの呼び出しは :class:`ArgumentParser` "
"に、コマンドラインの文字列を受け取ってそれをオブジェクトにする方法を教えます。この情報は保存され、:meth:`~ArgumentParser.parse_args`"
" が呼び出されたときに利用されます。例えば::"

#: ../../library/argparse.rst:113
msgid ""
"Later, calling :meth:`~ArgumentParser.parse_args` will return an object with"
" two attributes, ``integers`` and ``accumulate``.  The ``integers`` "
"attribute will be a list of one or more ints, and the ``accumulate`` "
"attribute will be either the :func:`sum` function, if ``--sum`` was "
"specified at the command line, or the :func:`max` function if it was not."
msgstr ""
"あとで :meth:`~ArgumentParser.parse_args` を呼び出すと、``integers`` と ``accumulate`` "
"という2つの属性を持ったオブジェクトを返します。``integers`` 属性は1つ以上の整数のリストで、``accumulate`` "
"属性はコマンドラインから ``--sum`` が指定された場合は :func:`sum` 関数に、それ以外の場合は :func:`max` "
"関数になります。"

#: ../../library/argparse.rst:121
msgid "Parsing arguments"
msgstr "引数を解析する"

#: ../../library/argparse.rst:123
msgid ""
":class:`ArgumentParser` parses arguments through the "
":meth:`~ArgumentParser.parse_args` method.  This will inspect the command "
"line, convert each argument to the appropriate type and then invoke the "
"appropriate action. In most cases, this means a simple :class:`Namespace` "
"object will be built up from attributes parsed out of the command line::"
msgstr ""
":class:`ArgumentParser` は引数を :meth:`~ArgumentParser.parse_args` "
"メソッドで解析します。このメソッドはコマンドラインを調べ、各引数を正しい型に変換して、適切なアクションを実行します。ほとんどの場合、これはコマンドラインの解析結果から、シンプルな"
" :class:`Namespace` オブジェクトを構築することを意味します::"

#: ../../library/argparse.rst:132
msgid ""
"In a script, :meth:`~ArgumentParser.parse_args` will typically be called "
"with no arguments, and the :class:`ArgumentParser` will automatically "
"determine the command-line arguments from :data:`sys.argv`."
msgstr ""
"スクリプト内では、:meth:`~ArgumentParser.parse_args` "
"は通常引数なしで呼び出され、:class:`ArgumentParser` は自動的に :data:`sys.argv` "
"からコマンドライン引数を取得します。"

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

#: ../../library/argparse.rst:147
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:151
msgid "prog_ - The name of the program (default: ``sys.argv[0]``)"
msgstr "prog_ - プログラム名 (デフォルト: ``sys.argv[0]``)"

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

#: ../../library/argparse.rst:156
msgid ""
"description_ - Text to display before the argument help (default: none)"
msgstr "description_ - 引数のヘルプの前に表示されるテキスト (デフォルト: none)"

#: ../../library/argparse.rst:158
msgid "epilog_ - Text to display after the argument help (default: none)"
msgstr "epilog_ - 引数のヘルプの後で表示されるテキスト (デフォルト: none)"

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

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

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

#: ../../library/argparse.rst:168
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:171
msgid ""
"argument_default_ - The global default value for arguments (default: "
"``None``)"
msgstr "argument_default_ - 引数のグローバルなデフォルト値 (デフォルト: ``None``)"

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

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

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

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

#: ../../library/argparse.rst:185
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:189 ../../library/argparse.rst:687
msgid "The following sections describe how each of these are used."
msgstr "以下の節では各オプションの利用方法を説明します。"

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

#: ../../library/argparse.rst:195
msgid ""
"By default, :class:`ArgumentParser` objects use ``sys.argv[0]`` to determine"
" how to display the name of the program in help messages.  This default is "
"almost always desirable because it will make the help messages match how the"
" program was invoked on the command line.  For example, consider a file "
"named ``myprogram.py`` with the following code::"
msgstr ""
"デフォルトでは、:class:`ArgumentParser` オブジェクトはヘルプメッセージ中に表示するプログラム名を ``sys.argv[0]`` から取得します。\n"
"このデフォルトの動作は、プログラムがコマンドライン上の起動方法に合わせてヘルプメッセージを作成するため、ほとんどの場合望ましい挙動になります。\n"
"例えば、``myprogram.py`` という名前のファイルに次のコードがあるとします::"

#: ../../library/argparse.rst:206
msgid ""
"The help for this program will display ``myprogram.py`` as the program name "
"(regardless of where the program was invoked from):"
msgstr ""
"このプログラムのヘルプは、プログラム名として (プログラムがどこから起動されたのかに関わらず) ``myprogram.py`` を表示します:"

#: ../../library/argparse.rst:225
msgid ""
"To change this default behavior, another value can be supplied using the "
"``prog=`` argument to :class:`ArgumentParser`::"
msgstr "このデフォルトの動作を変更するには、:class:`ArgumentParser` の ``prog=`` 引数に他の値を指定します::"

#: ../../library/argparse.rst:235
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:252
msgid "usage"
msgstr "usage"

#: ../../library/argparse.rst:254
msgid ""
"By default, :class:`ArgumentParser` calculates the usage message from the "
"arguments it contains::"
msgstr "デフォルトでは、 :class:`ArgumentParser` は使用法メッセージを、保持している引数から生成します::"

#: ../../library/argparse.rst:270
msgid ""
"The default message can be overridden with the ``usage=`` keyword argument::"
msgstr "デフォルトのメッセージは ``usage=`` キーワード引数で変更できます::"

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

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

#: ../../library/argparse.rst:292
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 ""
"多くの場合、:class:`ArgumentParser` のコンストラクターを呼び出すときに ``description=`` "
"キーワード引数が使用されます。この引数はプログラムが何をしてどう動くのかについての短い説明になります。ヘルプメッセージで、この説明がコマンドラインの利用法と引数のヘルプメッセージの間に表示されます::"

#: ../../library/argparse.rst:307
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:312
msgid "epilog"
msgstr "epilog"

#: ../../library/argparse.rst:314
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:331
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:337
msgid "parents"
msgstr "parents"

#: ../../library/argparse.rst:339
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:359
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:364
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:370
msgid "formatter_class"
msgstr "formatter_class"

#: ../../library/argparse.rst:372
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:381
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:406
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:432
msgid ""
":class:`RawTextHelpFormatter` maintains whitespace for all sorts of help "
"text, including argument descriptions. However, multiple new lines are "
"replaced with one. If you wish to preserve multiple blank lines, add spaces "
"between the newlines."
msgstr ""
":class:`RawTextHelpFormatter` "
"は引数の説明を含めてすべての種類のヘルプテキストで空白を維持します。例外として、複数の空行はひとつにまとめられます。複数の空白行を保ちたい場合には、行に空白を含めるようにして下さい。"

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

#: ../../library/argparse.rst:455
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:476
msgid "prefix_chars"
msgstr "prefix_chars"

#: ../../library/argparse.rst:478
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 ArgumentParser constructor::"
msgstr ""
"ほとんどのコマンドラインオプションは、``-f/--foo`` のように接頭辞に ``-`` を使います。``+f`` や ``/foo`` "
"のような、他の、あるいは追加の接頭辞文字をサポートしなければならない場合、ArgumentParser のコンストラクターに "
"``prefix_chars=`` 引数を使って指定します::"

#: ../../library/argparse.rst:490
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:496
msgid "fromfile_prefix_chars"
msgstr "fromfile_prefix_chars"

#: ../../library/argparse.rst:498
msgid ""
"Sometimes, for example when dealing with a particularly long argument lists,"
" 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:512
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:518
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:523
msgid "argument_default"
msgstr "argument_default"

#: ../../library/argparse.rst:525
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:545
msgid "allow_abbrev"
msgstr "allow_abbrev"

#: ../../library/argparse.rst:547
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:551
msgid ""
"This feature can be disabled by setting ``allow_abbrev`` to ``False``::"
msgstr "この機能は、``allow_abbrev`` に ``False`` を指定することで無効にできます::"

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

#: ../../library/argparse.rst:566
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:578
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:594
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:601
msgid "add_help"
msgstr "add_help"

#: ../../library/argparse.rst:603
msgid ""
"By default, ArgumentParser objects add an option which simply displays the "
"parser's help message. For example, consider a file named ``myprogram.py`` "
"containing the following code::"
msgstr ""
"デフォルトでは、ArgumentParser "
"オブジェクトはシンプルにパーサーのヘルプメッセージを表示するオプションを自動的に追加します。例えば、以下のコードを含む ``myprogram.py``"
" ファイルについて考えてください::"

#: ../../library/argparse.rst:612
msgid ""
"If ``-h`` or ``--help`` is supplied at the command line, the ArgumentParser "
"help will be printed:"
msgstr "コマンドラインに ``-h`` か ``--help`` が指定された場合、ArgumentParser の help が表示されます:"

#: ../../library/argparse.rst:624
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:636
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:651
msgid "The add_argument() method"
msgstr "add_argument() メソッド"

#: ../../library/argparse.rst:657
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:660
msgid ""
"`name or flags`_ - Either a name or a list of option strings, e.g. ``foo`` "
"or ``-f, --foo``."
msgstr ""
"`name または flags`_ - 名前か、あるいはオプション文字列のリスト (例: ``foo`` や ``-f, --foo``)。"

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

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

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

#: ../../library/argparse.rst:670
msgid ""
"default_ - The value produced if the argument is absent from the command "
"line."
msgstr "default_ - コマンドラインに引数がなかった場合に生成される値。"

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

#: ../../library/argparse.rst:675
msgid "choices_ - A container of the allowable values for the argument."
msgstr "choices_ - 引数として許される値のコンテナー。"

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

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

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

#: ../../library/argparse.rst:684
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:691
msgid "name or flags"
msgstr "name または flags"

#: ../../library/argparse.rst:693
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.  For example, an optional argument could "
"be created like::"
msgstr ""
":meth:`~ArgumentParser.add_argument` メソッドは、指定されている引数が ``-f`` や ``--foo`` "
"のようなオプション引数なのか、ファイル名リストなどの位置引数なのかを知る必要があります。そのため、:meth:`~ArgumentParser.add_argument`"
" の第1引数は、フラグのリストか、シンプルな引数名のどちらかになります。例えば、オプション引数は次のようにして作成します::"

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

#: ../../library/argparse.rst:706
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:723
msgid "action"
msgstr "action"

#: ../../library/argparse.rst:725
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:731
msgid ""
"``'store'`` - This just stores the argument's value.  This is the default "
"action. For example::"
msgstr "``'store'`` - これは単に引数の値を格納します。これはデフォルトのアクションです。例えば::"

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

#: ../../library/argparse.rst:748
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.  For example::"
msgstr ""
"``'store_true'``, ``'store_false'`` - これらは ``'store_const'`` の、それぞれ ``True``"
" と ``False`` を格納する特別版になります。加えて、これらはそれぞれデフォルト値を順に ``False`` と ``True`` "
"にします。例えば::"

#: ../../library/argparse.rst:760
msgid ""
"``'append'`` - This stores a list, and appends each argument value to the "
"list.  This is useful to allow an option to be specified multiple times. "
"Example usage::"
msgstr ""
"``'append'`` - "
"このアクションはリストを格納して、各引数の値をそのリストに追加します。このアクションは複数回指定を許可したいオプションに便利です。利用例::"

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

#: ../../library/argparse.rst:791
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:796
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:806
msgid ""
"``'extend'`` - This stores a list, and extends each argument value to the "
"list. Example usage::"
msgstr "``'extend'`` - このアクションはリストを格納して、各引数の値でそのリストを拡張します。利用例::"

#: ../../library/argparse.rst:817
msgid ""
"You may also specify an arbitrary action by passing an Action subclass or "
"other object that implements the same interface.  The recommended way to do "
"this is to extend :class:`Action`, overriding the ``__call__`` method and "
"optionally the ``__init__`` method."
msgstr ""
"Action "
"のサブクラスまたは同じインターフェイスを実装したほかのオブジェクト渡すことで、任意のアクションを指定することもできます。これをするお奨めの方法は、 "
":class:`argparse.Action` を継承して、 ``__call__`` と、必要であれば ``__init__`` "
"をオーバライドすることです。"

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

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

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

#: ../../library/argparse.rst:847
msgid ""
"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.  The "
"supported values are:"
msgstr ""
"ArgumentParser オブジェクトは通常1つのコマンドライン引数を1つのアクションに渡します。``nargs`` "
"キーワード引数は1つのアクションにそれ以外の数のコマンドライン引数を割り当てます。指定できる値は:"

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

#: ../../library/argparse.rst:900
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:914
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:928
msgid ""
"``argparse.REMAINDER``.  All the remaining command-line arguments are "
"gathered into a list.  This is commonly useful for command line utilities "
"that dispatch to other command line utilities::"
msgstr ""
"``argparse.REMAINDER`` -- "
"コマンドライン引数の残りすべてをリストとして集めます。これは他のコマンドラインツールに対して処理を渡すようなツールによく使われます。例えば::"

#: ../../library/argparse.rst:939
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."
msgstr ""
"``nargs`` キーワード引数が指定されない場合、受け取る引数の数は action_ "
"によって決定されます。通常これは、1つのコマンドライン引数は1つのアイテムになる (リストにはならない) ことを意味します。"

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

#: ../../library/argparse.rst:947
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:951
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."
msgstr ""
":meth:`~ArgumentParser.add_argument` が ``action='store_const'`` か "
"``action='append_const'`` で呼び出されたとき、これらのアクションは ``const`` の値を "
":meth:`~ArgumentParser.parse_args` が返すオブジェクトの属性に追加します。サンプルは action_ "
"の説明を参照してください。"

#: ../../library/argparse.rst:956
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 "
"instead. See the nargs_ description for examples."
msgstr ""
":meth:`~ArgumentParser.add_argument` がオプション文字列 (``-f`` や ``--foo``) と "
"``nargs='?'`` "
"で呼び出された場合。この場合0個か1つのコマンドライン引数を取るオプション引数が作られます。オプション引数にコマンドライン引数が続かなかった場合、 "
"``const`` の値が代わりに利用されます。サンプルは nargs_ の説明を参照してください。"

#: ../../library/argparse.rst:963
msgid ""
"With the ``'store_const'`` and ``'append_const'`` actions, the ``const`` "
"keyword argument must be given.  For other actions, it defaults to ``None``."
msgstr ""
"``'store_const'`` と ``'append_const'`` アクションでは、 ``const`` "
"キーワード引数を与える必要があります。他のアクションでは、デフォルトは ``None`` になります。"

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

#: ../../library/argparse.rst:970
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:984
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:995
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:1006
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:1018
msgid "type"
msgstr "type"

#: ../../library/argparse.rst:1020
msgid ""
"By default, :class:`ArgumentParser` objects read command-line arguments in "
"as simple strings. However, quite often the command-line string should "
"instead be interpreted as another type, like a :class:`float` or "
":class:`int`.  The ``type`` keyword argument of "
":meth:`~ArgumentParser.add_argument` allows any necessary type-checking and "
"type conversions to be performed.  Common built-in types and functions can "
"be used directly as the value of the ``type`` argument::"
msgstr ""
"デフォルトでは、:class:`ArgumentParser` "
"オブジェクトはコマンドライン引数を単なる文字列として読み込みます。しかし、コマンドラインの文字列は :class:`float`, "
":class:`int` など別の型として扱うべき事がよくあります。:meth:`~ArgumentParser.add_argument` の "
"``type`` キーワード引数により型チェックと型変換を行うことができます。一般的なビルトインデータ型や関数を ``type`` "
"引数の値として直接指定できます::"

#: ../../library/argparse.rst:1033
msgid ""
"See the section on the default_ keyword argument for information on when the"
" ``type`` argument is applied to default arguments."
msgstr "``type`` 引数がデフォルト引数に適用されている場合の情報は、default_ キーワード引数の節を参照してください。"

#: ../../library/argparse.rst:1036
msgid ""
"To ease the use of various types of files, the argparse module provides the "
"factory FileType which takes the ``mode=``, ``bufsize=``, ``encoding=`` and "
"``errors=`` arguments of the :func:`open` function.  For example, "
"``FileType('w')`` can be used to create a writable file::"
msgstr ""
"いろいろな種類のファイルを簡単に扱うために、 argparse モジュールは :func:`open` 関数の ``mode=``, "
"``bufsize=``, ``encoding=`` および ``errors=`` 引数を取る FileType "
"ファクトリを提供しています。例えば、書き込み可能なファイルを作るために ``FileType('w')`` を利用できます::"

#: ../../library/argparse.rst:1046
msgid ""
"``type=`` can take any callable that takes a single string argument and "
"returns the converted value::"
msgstr "``type=`` には1つの文字列を引数に受け取って変換結果を返すような任意の呼び出し可能オブジェクトを渡すことができます::"

#: ../../library/argparse.rst:1065
msgid ""
"The choices_ keyword argument may be more convenient for type checkers that "
"simply check against a range of values::"
msgstr "さらに、choices_ キーワード引数を使って、値の範囲をチェックすることもできます::"

#: ../../library/argparse.rst:1076
msgid "See the choices_ section for more details."
msgstr "詳細は choices_ 節を参照してください。"

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

#: ../../library/argparse.rst:1082
msgid ""
"Some command-line arguments should be selected from a restricted set of "
"values. These can be handled by passing a container 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:1097
msgid ""
"Note that inclusion in the *choices* container is checked after any type_ "
"conversions have been performed, so the type of the objects in the *choices*"
" container should match the type_ specified::"
msgstr ""
"*choices* コンテナーに含まれているかどうかのチェックは、type_ "
"による型変換が実行された後であることに注意してください。このため、*choices* に格納するオブジェクトの型は指定された type_ "
"にマッチしている必要があります::"

#: ../../library/argparse.rst:1109
msgid ""
"Any container can be passed as the *choices* value, so :class:`list` "
"objects, :class:`set` objects, and custom containers are all supported."
msgstr ""
"任意のコンテナを *choices* に渡すことができます。すなわち、:class:`list` 、 "
":class:`set`、カスタムコンテナなどはすべてサポートされています。"

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

#: ../../library/argparse.rst:1116
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 ""
"通常 :mod:`argparse` モジュールは、``-f`` や ``--bar`` といったフラグは *任意* の引数 (オプション引数) "
"だと仮定し、コマンドライン上になくても良いものとして扱います。フラグの指定を *必須* "
"にするには、:meth:`~ArgumentParser.add_argument` の ``required=`` キーワード引数に ``True``"
" を指定します::"

#: ../../library/argparse.rst:1129
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:1135
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:1140
msgid "help"
msgstr "help"

#: ../../library/argparse.rst:1142
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 ""
"``help`` の値はその引数の簡潔な説明を含む文字列です。ユーザーが (コマンドライン上で ``-h`` か ``--help`` "
"を指定するなどして) ヘルプを要求したとき、この ``help`` の説明が各引数に表示されます::"

#: ../../library/argparse.rst:1162
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:1179
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:1182
msgid ""
":mod:`argparse` supports silencing the help entry for certain options, by "
"setting the ``help`` value to ``argparse.SUPPRESS``::"
msgstr ""
":mod:`argparse` は ``help`` に ``argparse.SUPPRESS`` "
"を設定することで、特定のオプションをヘルプに表示させないことができます::"

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

#: ../../library/argparse.rst:1197
msgid ""
"When :class:`ArgumentParser` generates help messages, it needs some way to "
"refer to each expected argument.  By default, 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 ""
":class:`ArgumentParser` がヘルプメッセージを出力するとき、各引数に対してなんらかの参照方法が必要です。デフォルトでは、 "
"ArgumentParser オブジェクトは各オブジェクトの \"名前\" として dest_ を利用します。デフォルトでは、位置引数には dest_ "
"の値をそのまま 利用し、オプション引数については dest_ の値を大文字に変換して利用します。このため、1つの ``dest='bar'`` "
"である位置引数は ``bar`` として参照されます。 1つのオプション引数 ``--foo`` が1つのコマンドライン引数を要求するときは、その引数は"
" ``FOO`` として参照されます。以下に例を示します::"

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

#: ../../library/argparse.rst:1238
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:1242
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:1259
msgid "dest"
msgstr "dest"

#: ../../library/argparse.rst:1261
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:1273
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:1290
msgid "``dest`` allows a custom attribute name to be provided::"
msgstr "``dest`` にカスタムの属性名を与えることも可能です::"

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

#: ../../library/argparse.rst:1300
msgid ""
"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:`add_argument`."
msgstr ""
"Acrtion クラスは Action "
"API、すなわちコマンドラインからの引数を処理する呼び出し可能オブジェクトを返す呼び出し可能オブジェクトを実装します。この API "
"に従うあらゆるオブジェクトは ``action`` 引数として :meth:`add_argument` に渡すことができます。"

#: ../../library/argparse.rst:1309
msgid ""
"Action objects are used by an ArgumentParser to represent the information "
"needed to parse a single argument from one or more strings from the command "
"line. The Action class must accept the two positional arguments plus any "
"keyword arguments passed to :meth:`ArgumentParser.add_argument` except for "
"the ``action`` itself."
msgstr ""
"Action オブジェクトは、コマンドラインからの一つ以上の文字列から単一の引数を解析するのに必要とされる情報を表現するために "
"ArgumentParser によって使われます。Action クラス 2 つの位置引数と、``action`` それ自身を除く "
":meth:`ArgumentParser.add_argument` に渡されるすべてのキーワード引数を受け付けなければなりません。"

#: ../../library/argparse.rst:1315
msgid ""
"Instances of Action (or return value of any callable to the ``action`` "
"parameter) should have attributes \"dest\", \"option_strings\", \"default\","
" \"type\", \"required\", \"help\", etc. defined. The easiest way to ensure "
"these attributes are defined is to call ``Action.__init__``."
msgstr ""
"Action のインスタンス (あるいは ``action`` 引数に渡す任意の呼び出し可能オブジェクトの返り値) は、属性 \"dest\", "
"\"option_strings\", \"default\", \"type\", \"required\", \"help\", "
"などを定義しなければなりません。これらの属性を定義するのを確実にするためにもっとも簡単な方法は、``Action.__init__`` "
"を呼び出すことです。"

#: ../../library/argparse.rst:1320
msgid ""
"Action instances should be callable, so subclasses must override the "
"``__call__`` method, which should accept four parameters:"
msgstr ""
"Action インスタンスは呼び出し可能でなければならず、したがって、サブクラスは 4 つの引数を受け取る ``__call__`` "
"メソッドをオーバライドしなければなりません:"

#: ../../library/argparse.rst:1323
msgid "``parser`` - The ArgumentParser object which contains this action."
msgstr "``parser`` - このアクションを持っている ArgumentParser オブジェクト。"

#: ../../library/argparse.rst:1325
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 ""
"``namespace`` - :meth:`~ArgumentParser.parse_args` が返す :class:`Namespace` "
"オブジェクト。ほとんどのアクションはこのオブジェクトに属性を :func:`setattr` を使って追加します。"

#: ../../library/argparse.rst:1329
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 ""
"``values`` - 型変換が適用された後の、関連付けられたコマンドライン引数。型変換は "
":meth:`~ArgumentParser.add_argument` メソッドの type_ キーワード引数で指定されます。"

#: ../../library/argparse.rst:1333
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 ""
"``option_string`` - このアクションを実行したオプション文字列。``option_string`` "
"引数はオプションで、アクションが位置引数に関連付けられた場合は渡されません。"

#: ../../library/argparse.rst:1337
msgid ""
"The ``__call__`` method may perform arbitrary actions, but will typically "
"set attributes on the ``namespace`` based on ``dest`` and ``values``."
msgstr ""
"``__call__`` メソッドでは任意のアクションを行えますが、 典型的にはそれは ``dest``, ``values`` に基づく "
"``namespace`` に属性をセットすることでしょう。"

#: ../../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 ""
"事前の :meth:`add_argument` メソッドの呼び出しにより、どのオブジェクトが生成されてどう代入されるかが決定されます。詳細は "
":meth:`add_argument` のドキュメントを参照してください。"

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

#: ../../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: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: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: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:1479
msgid "Argument abbreviations (prefix matching)"
msgstr "引数の短縮形 (先頭文字でのマッチング)"

#: ../../library/argparse.rst:1481
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:1496
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:1502
msgid "Beyond ``sys.argv``"
msgstr "``sys.argv`` 以外"

#: ../../library/argparse.rst:1504
msgid ""
"Sometimes it may be useful to have an 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 ""
"ArgumentParser が :data:`sys.argv` 以外の引数を解析できると役に立つ場合があります。その場合は文字列のリストを "
":meth:`~ArgumentParser.parse_args` に渡します。これはインタラクティブプロンプトからテストするときに便利です::"

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

#: ../../library/argparse.rst:1528
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:1531
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 ""
"デフォルトでは、 :meth:`~ArgumentParser.parse_args` は :class:`Namespace` "
"の新しいオブジェクトに必要な属性を設定して返します。このクラスはシンプルに設計されており、単に読みやすい文字列表現を持った "
":class:`object` のサブクラスです。もし属性を辞書のように扱える方が良ければ、標準的な Python のイディオム "
":func:`vars` を利用できます::"

#: ../../library/argparse.rst:1541
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:1557
msgid "Other utilities"
msgstr "その他のユーティリティ"

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

#: ../../library/argparse.rst:1567
msgid ""
"Many programs split up their functionality into a number of sub-commands, "
"for example, the ``svn`` program can invoke sub-commands 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 sub-commands 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:`~ArgumentParser.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 ""
"多くのプログラムは、その機能をサブコマンドへと分割します。 例えば ``svn`` プログラムは ``svn checkout``, ``svn "
"update``, ``svn commit`` などのサブコマンドを利用できます。 "
"機能をサブコマンドに分割するのは、プログラムがいくつかの異なった機能を持っていて、 "
"それぞれが異なるコマンドライン引数を必要とする場合には良いアイデアです。 :class:`ArgumentParser` は "
":meth:`add_subparsers` メソッドによりサブコマンドを サポートしています。 :meth:`add_subparsers` "
"メソッドは通常引数なしに呼び出され、 特殊なアクションオブジェクトを返します。このオブジェクトには1つのメソッド "
":meth:`~ArgumentParser.add_parser` があり、コマンド名と :class:`ArgumentParser` "
"コンストラクターの任意の引数を受け取り、通常の方法で操作できる :class:`ArgumentParser` オブジェクトを返します。"

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

#: ../../library/argparse.rst:1581
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 ""
"title - ヘルプ出力でのサブパーサーグループのタイトルです。デフォルトは、description が指定されている場合は "
"\"subcommands\" に、指定されていない場合は位置引数のタイトルになります"

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

#: ../../library/argparse.rst:1588
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 ""
"prog - サブコマンドのヘルプに表示される使用方法の説明です。デフォルトではプログラム名と位置引数の後ろに、サブパーサーの引数が続きます"

#: ../../library/argparse.rst:1592
msgid ""
"parser_class - class which will be used to create sub-parser instances, by "
"default the class of the current parser (e.g. ArgumentParser)"
msgstr ""
"parser_class - サブパーサーのインスタンスを作成するときに使用されるクラスです。デフォルトでは現在のパーサーのクラス (例: "
"ArgumentParser) になります"

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

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

#: ../../library/argparse.rst:1606
msgid ""
"metavar_ - string presenting available sub-commands in help; by default it "
"is ``None`` and presents sub-commands in form {cmd1, cmd2, ..}"
msgstr ""
"metavar_ - 利用可能なサブコマンドをヘルプ内で表示するための文字列です。デフォルトは ``None`` で、サブコマンドを {cmd1, "
"cmd2, ..} のような形式で表します"

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

#: ../../library/argparse.rst:1630
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:1637
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:`add_parser` as above.)"
msgstr ""
"同じように、サブパーサーにヘルプメッセージが要求された場合は、そのパーサーに対するヘルプだけが表示されます。ヘルプメッセージには親パーサーや兄弟パーサーのヘルプメッセージを表示しません。"
" (ただし、各サブパーサーコマンドのヘルプメッセージは、上の例にもあるように :meth:`add_parser` の ``help=`` "
"引数によって指定できます)"

#: ../../library/argparse.rst:1673
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:1694
msgid ""
"Furthermore, ``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 ""
"さらに、``add_parser`` は ``aliases`` "
"引数もサポートしており、同じサブパーサーに対して複数の文字列で参照することもできます。以下の例では ``svn`` のように ``checkout`` "
"の短縮形として ``co`` を使用できるようにしています::"

#: ../../library/argparse.rst:1705
msgid ""
"One particularly effective way of handling sub-commands 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 ""
"サブコマンドを扱う1つの便利な方法は :meth:`add_subparsers` メソッドと :meth:`set_defaults` "
"を組み合わせて、各サブパーサーにどの Python 関数を実行するかを教えることです。例えば::"

#: ../../library/argparse.rst:1742
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:1758
msgid "New *required* keyword argument."
msgstr "新しい *required* キーワード引数。"

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

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

#: ../../library/argparse.rst:1788
msgid "The *encodings* and *errors* keyword arguments."
msgstr "*encoding* および *errors* キーワードが追加されました。"

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

#: ../../library/argparse.rst:1797
msgid ""
"By default, :class:`ArgumentParser` groups command-line arguments into "
"\"positional arguments\" and \"optional arguments\" 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 ""
"デフォルトでは、 :class:`ArgumentParser` はヘルプメッセージを表示するときに、コマンドライン引数を \"位置引数\" と "
"\"オプション引数\" にグループ化します。このデフォルトの動作よりも良い引数のグループ化方法がある場合、 "
":meth:`add_argument_group` メソッドで適切なグループを作成できます::"

#: ../../library/argparse.rst:1814
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 ""
":meth:`add_argument_group` メソッドは、通常の :class:`ArgumentParser` と同じような "
":meth:`~ArgumentParser.add_argument` "
"メソッドを持つ引数グループオブジェクトを返します。引数がグループに追加された時、パーサーはその引数を通常の引数のように扱いますが、ヘルプメッセージではその引数を分離されたグループの中に表示します。"
" :meth:`add_argument_group` メソッドには、この表示をカスタマイズするための *title* と *description* "
"引数があります::"

#: ../../library/argparse.rst:1840
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:1845
msgid "Mutual exclusion"
msgstr "相互排他"

#: ../../library/argparse.rst:1849
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 "相互排他グループを作ります。:mod:`argparse` は相互排他グループの中でただ1つの引数のみが存在することを確認します::"

#: ../../library/argparse.rst:1865
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:1877
msgid ""
"Note that currently mutually exclusive argument groups do not support the "
"*title* and *description* arguments of "
":meth:`~ArgumentParser.add_argument_group`."
msgstr ""
"現在のところ、相互排他引数グループは :meth:`~ArgumentParser.add_argument_group` の *title* と "
"*description* 引数をサポートしていません。"

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

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

#: ../../library/argparse.rst:1907
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:1913
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:1924
msgid "Printing help"
msgstr "ヘルプの表示"

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

#: ../../library/argparse.rst:1947
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:1952
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:1957
msgid "Partial parsing"
msgstr "部分解析"

#: ../../library/argparse.rst:1961
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:1977
msgid ""
":ref:`Prefix matching <prefix-matching>` rules apply to "
":meth:`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:`parse_known_args` "
"にも適用されます。たとえ既知のオプションの先頭文字に過ぎない場合でも、パーサは引数リストに残さずに、オプションを受け取る場合があります。"

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

#: ../../library/argparse.rst:1988
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:1993
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:1997
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 つの引数として扱えます。次の例でその方法を示します::"

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

#: ../../library/argparse.rst:2010
msgid ""
"This method terminates the program, exiting with the specified *status* and,"
" if given, it prints a *message* before that. The user can override this "
"method to handle these steps differently::"
msgstr ""
"このメソッドはプログラムを、*status* のステータスで終了させ、指定された場合は *message* "
"を終了前に表示します。ユーザは、この振る舞いを違うものにするために、メソッドをオーバーライドすることができます。"

#: ../../library/argparse.rst:2022
msgid ""
"This method prints a usage message including the *message* to the standard "
"error and terminates the program with a status code of 2."
msgstr "このメソッドは *message* を含む使用法メッセージを標準エラーに表示して、終了ステータス 2 でプログラムを終了します。"

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

#: ../../library/argparse.rst:2032
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:2037
msgid ""
"These parsers do not support all the argparse features, and will raise "
"exceptions if unsupported features are used.  In particular, subparsers, "
"``argparse.REMAINDER``, and mutually exclusive groups that include both "
"optionals and positionals are not supported."
msgstr ""
"このパーサーは、argparse のすべての機能をサポートしておらず、対応しない機能が使われた場合、例外を送出します。特に、サブパーサーや "
"``argparse.REMAINDER``、位置引数とオプション引数を両方含むような相互排他的なグループは、サポートされていません。"

#: ../../library/argparse.rst:2042
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:2057
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:2067
msgid "Upgrading optparse code"
msgstr "optparse からのアップグレード"

#: ../../library/argparse.rst:2069
msgid ""
"Originally, the :mod:`argparse` module had attempted to maintain "
"compatibility with :mod:`optparse`.  However, :mod:`optparse` was difficult "
"to extend transparently, particularly with the changes required to support "
"the new ``nargs=`` specifiers and better usage messages.  When most "
"everything in :mod:`optparse` had either been copy-pasted over or monkey-"
"patched, it no longer seemed practical to try to maintain the backwards "
"compatibility."
msgstr ""
"もともと、:mod:`argparse` モジュールは :mod:`optparse` "
"モジュールとの互換性を保って開発しようと試みられました。しかし、特に新しい ``nargs=`` "
"指定子とより良い使用法メッセージのために必要な変更のために、:mod:`optparse` "
"を透過的に拡張することは難しかったのです。:mod:`optparse` "
"のほとんどすべてがコピーアンドペーストされたりモンキーパッチを当てられたりしたとき、もはや後方互換性を保とうとすることは現実的ではありませんでした。"

#: ../../library/argparse.rst:2076
msgid ""
"The :mod:`argparse` module improves on the standard library :mod:`optparse` "
"module in a number of ways including:"
msgstr ""
":mod:`argparse` モジュールは標準ライブラリ :mod:`optparse` モジュールを、以下を含むたくさんの方法で改善しています:"

#: ../../library/argparse.rst:2079
msgid "Handling positional arguments."
msgstr "位置引数を扱う"

#: ../../library/argparse.rst:2080
msgid "Supporting sub-commands."
msgstr "サブコマンドのサポート"

#: ../../library/argparse.rst:2081
msgid "Allowing alternative option prefixes like ``+`` and ``/``."
msgstr "``+``, ``/`` のような代替オプションプレフィクスを許容する"

#: ../../library/argparse.rst:2082
msgid "Handling zero-or-more and one-or-more style arguments."
msgstr "zero-or-more スタイル、one-or-more スタイルの引数を扱う"

#: ../../library/argparse.rst:2083
msgid "Producing more informative usage messages."
msgstr "より有益な使用方法メッセージの生成"

#: ../../library/argparse.rst:2084
msgid "Providing a much simpler interface for custom ``type`` and ``action``."
msgstr "カスタム ``type``, カスタム ``action`` のために遥かに簡単なインターフェイスを提供する"

#: ../../library/argparse.rst:2086
msgid "A partial upgrade path from :mod:`optparse` to :mod:`argparse`:"
msgstr ":mod:`optparse` から :mod:`argparse` への現実的なアップグレードパス:"

#: ../../library/argparse.rst:2088
msgid ""
"Replace all :meth:`optparse.OptionParser.add_option` calls with "
":meth:`ArgumentParser.add_argument` calls."
msgstr ""
"すべての :meth:`optparse.OptionParser.add_option` "
"の呼び出しを、:meth:`ArgumentParser.add_argument` の呼び出しに置き換える。"

#: ../../library/argparse.rst:2091
msgid ""
"Replace ``(options, args) = parser.parse_args()`` with ``args = "
"parser.parse_args()`` and add additional :meth:`ArgumentParser.add_argument`"
" calls for the positional arguments. Keep in mind that what was previously "
"called ``options``, now in the :mod:`argparse` context is called ``args``."
msgstr ""
"``(options, args) = parser.parse_args()`` を ``args = parser.parse_args()`` "
"に置き換え、位置引数のために必要に応じて :meth:`ArgumentParser.add_argument` の呼び出しを追加する。これまで "
"``options`` と呼ばれていたものが、:mod:`argparse` では ``args`` と呼ばれていることに留意してください。"

#: ../../library/argparse.rst:2096
msgid ""
"Replace :meth:`optparse.OptionParser.disable_interspersed_args` by using "
":meth:`~ArgumentParser.parse_intermixed_args` instead of "
":meth:`~ArgumentParser.parse_args`."
msgstr ""
":meth:`optparse.OptionParser.disable_interspersed_args` "
"を、:meth:`~ArgumentParser.parse_args` ではなく "
":meth:`~ArgumentParser.parse_intermixed_args` で置き換える。"

#: ../../library/argparse.rst:2100
msgid ""
"Replace callback actions and the ``callback_*`` keyword arguments with "
"``type`` or ``action`` arguments."
msgstr "コールバック・アクションと ``callback_*`` キーワード引数を ``type`` や ``action`` 引数に置き換える。"

#: ../../library/argparse.rst:2103
msgid ""
"Replace string names for ``type`` keyword arguments with the corresponding "
"type objects (e.g. int, float, complex, etc)."
msgstr ""
"``type`` キーワード引数に渡していた文字列の名前を、それに応じたオブジェクト (例: int, float, complex, ...) "
"に置き換える。"

#: ../../library/argparse.rst:2106
msgid ""
"Replace :class:`optparse.Values` with :class:`Namespace` and "
":exc:`optparse.OptionError` and :exc:`optparse.OptionValueError` with "
":exc:`ArgumentError`."
msgstr ""
":class:`optparse.Values` を :class:`Namespace` "
"に置き換え、:exc:`optparse.OptionError` と :exc:`optparse.OptionValueError` を "
":exc:`ArgumentError` に置き換える。"

#: ../../library/argparse.rst:2110
msgid ""
"Replace strings with implicit arguments such as ``%default`` or ``%prog`` "
"with the standard Python syntax to use dictionaries to format strings, that "
"is, ``%(default)s`` and ``%(prog)s``."
msgstr ""
"``%default`` や ``%prog`` などの暗黙の引数を含む文字列を、``%(default)s`` や ``%(prog)s`` "
"などの、通常の Python で辞書を使う場合のフォーマット文字列に置き換える。"

#: ../../library/argparse.rst:2114
msgid ""
"Replace the OptionParser constructor ``version`` argument with a call to "
"``parser.add_argument('--version', action='version', version='<the "
"version>')``."
msgstr ""
"OptionParser のコンストラクターの ``version`` 引数を、``parser.add_argument('--version', "
"action='version', version='<the version>')`` に置き換える"