optparse.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001 Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# python-doc bot, 2025
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.15\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-09-29 18:58+0000\n"
"PO-Revision-Date: 2025-09-16 00:01+0000\n"
"Last-Translator: python-doc bot, 2025\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/optparse.rst:2
msgid ":mod:`!optparse` --- Parser for command line options"
msgstr ""

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

#: ../../library/optparse.rst:14
msgid "Choosing an argument parsing library"
msgstr ""

#: ../../library/optparse.rst:16
msgid "The standard library includes three argument parsing libraries:"
msgstr ""

#: ../../library/optparse.rst:18
msgid ""
":mod:`getopt`: a module that closely mirrors the procedural C ``getopt`` API."
msgstr ""

#: ../../library/optparse.rst:19
msgid ""
":mod:`!optparse`: a declarative replacement for ``getopt`` that provides "
"equivalent functionality without requiring each application to implement its "
"own procedural option parsing logic."
msgstr ""

#: ../../library/optparse.rst:22
msgid ""
":mod:`argparse`: a more opinionated alternative to ``optparse`` that "
"provides more functionality by default, at the expense of reduced "
"application flexibility in controlling exactly how arguments are processed."
msgstr ""

#: ../../library/optparse.rst:26
msgid ""
"In the absence of more specific argument parsing design constraints, :mod:"
"`argparse` is the recommended choice for implementing command line "
"applications, as it offers the highest level of baseline functionality with "
"the least application level code."
msgstr ""

#: ../../library/optparse.rst:30
msgid ""
":mod:`getopt` is retained almost entirely for backwards compatibility "
"reasons. However, it also serves a niche use case as a tool for prototyping "
"and testing command line argument handling in ``getopt``-based C "
"applications."
msgstr ""

#: ../../library/optparse.rst:34
msgid ""
":mod:`!optparse` should be considered as an alternative to :mod:`argparse` "
"in the following cases:"
msgstr ""

#: ../../library/optparse.rst:37
msgid ""
"an application is already using :mod:`!optparse` and doesn't want to risk "
"the subtle behavioural changes that may arise when migrating to :mod:"
"`argparse`"
msgstr ""

#: ../../library/optparse.rst:39
msgid ""
"the application requires additional control over the way options and "
"positional parameters are interleaved on the command line (including the "
"ability to disable the interleaving feature completely)"
msgstr ""

#: ../../library/optparse.rst:42
msgid ""
"the application requires additional control over the incremental parsing of "
"command line elements (while ``argparse`` does support this, the exact way "
"it works in practice is undesirable for some use cases)"
msgstr ""

#: ../../library/optparse.rst:45
msgid ""
"the application requires additional control over the handling of options "
"which accept parameter values that may start with ``-`` (such as delegated "
"options to be passed to invoked subprocesses)"
msgstr ""

#: ../../library/optparse.rst:48
msgid ""
"the application requires some other command line parameter processing "
"behavior which ``argparse`` does not support, but which can be implemented "
"in terms of the lower level interface offered by ``optparse``"
msgstr ""

#: ../../library/optparse.rst:52
msgid ""
"These considerations also mean that :mod:`!optparse` is likely to provide a "
"better foundation for library authors writing third party command line "
"argument processing libraries."
msgstr ""

#: ../../library/optparse.rst:56
msgid ""
"As a concrete example, consider the following two command line argument "
"parsing configurations, the first using ``optparse``, and the second using "
"``argparse``:"
msgstr ""

#: ../../library/optparse.rst:60
msgid ""
"import optparse\n"
"\n"
"if __name__ == '__main__':\n"
"    parser = optparse.OptionParser()\n"
"    parser.add_option('-o', '--output')\n"
"    parser.add_option('-v', dest='verbose', action='store_true')\n"
"    opts, args = parser.parse_args()\n"
"    process(args, output=opts.output, verbose=opts.verbose)"
msgstr ""

#: ../../library/optparse.rst:71
msgid ""
"import argparse\n"
"\n"
"if __name__ == '__main__':\n"
"    parser = argparse.ArgumentParser()\n"
"    parser.add_argument('-o', '--output')\n"
"    parser.add_argument('-v', dest='verbose', action='store_true')\n"
"    parser.add_argument('rest', nargs='*')\n"
"    args = parser.parse_args()\n"
"    process(args.rest, output=args.output, verbose=args.verbose)"
msgstr ""

#: ../../library/optparse.rst:83
msgid ""
"The most obvious difference is that in the ``optparse`` version, the non-"
"option arguments are processed separately by the application after the "
"option processing is complete. In the ``argparse`` version, positional "
"arguments are declared and processed in the same way as the named options."
msgstr ""

#: ../../library/optparse.rst:88
msgid ""
"However, the ``argparse`` version will also handle some parameter "
"combination differently from the way the ``optparse`` version would handle "
"them. For example (amongst other differences):"
msgstr ""

#: ../../library/optparse.rst:92
msgid ""
"supplying ``-o -v`` gives ``output=\"-v\"`` and ``verbose=False`` when using "
"``optparse``, but a usage error with ``argparse`` (complaining that no value "
"has been supplied for ``-o/--output``, since ``-v`` is interpreted as "
"meaning the verbosity flag)"
msgstr ""

#: ../../library/optparse.rst:96
msgid ""
"similarly, supplying ``-o --`` gives ``output=\"--\"`` and ``args=()`` when "
"using ``optparse``, but a usage error with ``argparse`` (also complaining "
"that no value has been supplied for ``-o/--output``, since ``--`` is "
"interpreted as terminating the option processing and treating all remaining "
"values as positional arguments)"
msgstr ""

#: ../../library/optparse.rst:101
msgid ""
"supplying ``-o=foo`` gives ``output=\"=foo\"`` when using ``optparse``, but "
"gives ``output=\"foo\"`` with ``argparse`` (since ``=`` is special cased as "
"an alternative separator for option parameter values)"
msgstr ""

#: ../../library/optparse.rst:105
msgid ""
"Whether these differing behaviors in the ``argparse`` version are considered "
"desirable or a problem will depend on the specific command line application "
"use case."
msgstr ""

#: ../../library/optparse.rst:111
msgid ""
":pypi:`click` is a third party argument processing library (originally based "
"on ``optparse``), which allows command line applications to be developed as "
"a set of decorated command implementation functions."
msgstr ""

#: ../../library/optparse.rst:115
msgid ""
"Other third party libraries, such as :pypi:`typer` or :pypi:`msgspec-click`, "
"allow command line interfaces to be specified in ways that more effectively "
"integrate with static checking of Python type annotations."
msgstr ""

#: ../../library/optparse.rst:121
msgid "Introduction"
msgstr "はじめに"

#: ../../library/optparse.rst:123
msgid ""
":mod:`!optparse` is a more convenient, flexible, and powerful library for "
"parsing command-line options than the minimalist :mod:`getopt` module. :mod:"
"`!optparse` uses a more declarative style of command-line parsing: you "
"create an instance of :class:`OptionParser`, populate it with options, and "
"parse the command line. :mod:`!optparse` allows users to specify options in "
"the conventional GNU/POSIX syntax, and additionally generates usage and help "
"messages for you."
msgstr ""

#: ../../library/optparse.rst:131
msgid "Here's an example of using :mod:`!optparse` in a simple script::"
msgstr ""

#: ../../library/optparse.rst:133
msgid ""
"from optparse import OptionParser\n"
"...\n"
"parser = OptionParser()\n"
"parser.add_option(\"-f\", \"--file\", dest=\"filename\",\n"
"                  help=\"write report to FILE\", metavar=\"FILE\")\n"
"parser.add_option(\"-q\", \"--quiet\",\n"
"                  action=\"store_false\", dest=\"verbose\", default=True,\n"
"                  help=\"don't print status messages to stdout\")\n"
"\n"
"(options, args) = parser.parse_args()"
msgstr ""

#: ../../library/optparse.rst:144
msgid ""
"With these few lines of code, users of your script can now do the \"usual "
"thing\" on the command-line, for example::"
msgstr ""
"このようにわずかな行数のコードによって、スクリプトのユーザはコマンドライン上"
"で例えば以下のような「よくある使い方」を実行できるようになります::"

#: ../../library/optparse.rst:147
msgid "<yourscript> --file=outfile -q"
msgstr ""

#: ../../library/optparse.rst:149
msgid ""
"As it parses the command line, :mod:`!optparse` sets attributes of the "
"``options`` object returned by :meth:`~OptionParser.parse_args` based on "
"user-supplied command-line values.  When :meth:`~OptionParser.parse_args` "
"returns from parsing this command line, ``options.filename`` will be "
"``\"outfile\"`` and ``options.verbose`` will be ``False``.  :mod:`!optparse` "
"supports both long and short options, allows short options to be merged "
"together, and allows options to be associated with their arguments in a "
"variety of ways.  Thus, the following command lines are all equivalent to "
"the above example::"
msgstr ""

#: ../../library/optparse.rst:158
msgid ""
"<yourscript> -f outfile --quiet\n"
"<yourscript> --quiet --file outfile\n"
"<yourscript> -q -foutfile\n"
"<yourscript> -qfoutfile"
msgstr ""

#: ../../library/optparse.rst:163
msgid "Additionally, users can run one of the following ::"
msgstr "さらに、ユーザが以下のいずれかを実行すると ::"

#: ../../library/optparse.rst:165
msgid ""
"<yourscript> -h\n"
"<yourscript> --help"
msgstr ""

#: ../../library/optparse.rst:168
msgid ""
"and :mod:`!optparse` will print out a brief summary of your script's options:"
msgstr ""

#: ../../library/optparse.rst:170
msgid ""
"Usage: <yourscript> [options]\n"
"\n"
"Options:\n"
"  -h, --help            show this help message and exit\n"
"  -f FILE, --file=FILE  write report to FILE\n"
"  -q, --quiet           don't print status messages to stdout"
msgstr ""

#: ../../library/optparse.rst:179
msgid ""
"where the value of *yourscript* is determined at runtime (normally from "
"``sys.argv[0]``)."
msgstr ""
"*yourscript* の中身は実行時に決まります (通常は ``sys.argv[0]`` になります)。"

#: ../../library/optparse.rst:186
msgid "Background"
msgstr "背景"

#: ../../library/optparse.rst:188
msgid ""
":mod:`!optparse` was explicitly designed to encourage the creation of "
"programs with straightforward command-line interfaces that follow the "
"conventions established by the :c:func:`!getopt` family of functions "
"available to C developers. To that end, it supports only the most common "
"command-line syntax and semantics conventionally used under Unix.  If you "
"are unfamiliar with these conventions, reading this section will allow you "
"to acquaint yourself with them."
msgstr ""

#: ../../library/optparse.rst:199
msgid "Terminology"
msgstr "用語集"

#: ../../library/optparse.rst:201
msgid "argument"
msgstr "引数 (argument)"

#: ../../library/optparse.rst:202
msgid ""
"a string entered on the command-line, and passed by the shell to ``execl()`` "
"or ``execv()``.  In Python, arguments are elements of ``sys.argv[1:]`` "
"(``sys.argv[0]`` is the name of the program being executed).  Unix shells "
"also use the term \"word\"."
msgstr ""
"コマンドラインでユーザが入力するテキストの塊で、シェルが ``execl`` や "
"``execv`` に引き渡すものです。Python では、引数は ``sys.argv[1:]`` の要素とな"
"ります。(``sys.argv[0]`` は実行しようとしているプログラムの名前です。引数解析"
"に関しては、この要素はあまり重要ではありません。) Unix シェルでは、「語 "
"(word)」という用語も使います。"

#: ../../library/optparse.rst:207
msgid ""
"It is occasionally desirable to substitute an argument list other than ``sys."
"argv[1:]``, so you should read \"argument\" as \"an element of ``sys."
"argv[1:]``, or of some other list provided as a substitute for ``sys."
"argv[1:]``\"."
msgstr ""
"場合によっては ``sys.argv[1:]`` 以外の引数リストを代入する方が望ましいことが"
"あるので、「引数」は「 ``sys.argv[1:]`` または ``sys.argv[1:]`` の代替として"
"提供される別のリストの要素」と読むべきでしょう。"

#: ../../library/optparse.rst:212
msgid "option"
msgstr "オプション (option)"

#: ../../library/optparse.rst:213
msgid ""
"an argument used to supply extra information to guide or customize the "
"execution of a program.  There are many different syntaxes for options; the "
"traditional Unix syntax is a hyphen (\"-\") followed by a single letter, e."
"g. ``-x`` or ``-F``.  Also, traditional Unix syntax allows multiple options "
"to be merged into a single argument, e.g. ``-x -F`` is equivalent to ``-"
"xF``.  The GNU project introduced ``--`` followed by a series of hyphen-"
"separated words, e.g. ``--file`` or ``--dry-run``.  These are the only two "
"option syntaxes provided by :mod:`!optparse`."
msgstr ""

#: ../../library/optparse.rst:222
msgid "Some other option syntaxes that the world has seen include:"
msgstr "他に見られる他のオプション書法には以下のようなものがあります:"

#: ../../library/optparse.rst:224
msgid ""
"a hyphen followed by a few letters, e.g. ``-pf`` (this is *not* the same as "
"multiple options merged into a single argument)"
msgstr ""
"ハイフンの後ろに数個の文字が続くもので、例えば ``-pf`` (このオプションは複数"
"のオプションを一つにまとめたものとは *違います*)"

#: ../../library/optparse.rst:227
msgid ""
"a hyphen followed by a whole word, e.g. ``-file`` (this is technically "
"equivalent to the previous syntax, but they aren't usually seen in the same "
"program)"
msgstr ""
"ハイフンの後ろに語が続くもので、例えば ``-file`` (これは技術的には上の書式と"
"同じですが、通常同じプログラム上で一緒に使うことはありません)"

#: ../../library/optparse.rst:231
msgid ""
"a plus sign followed by a single letter, or a few letters, or a word, e.g. "
"``+f``, ``+rgb``"
msgstr ""
"プラス記号の後ろに一文字、数個の文字、または語を続けたもので、例えば ``+f``, "
"``+rgb``"

#: ../../library/optparse.rst:234
msgid ""
"a slash followed by a letter, or a few letters, or a word, e.g. ``/f``, ``/"
"file``"
msgstr ""
"スラッシュ記号の後ろに一文字、数個の文字、または語を続けたもので、例えば ``/"
"f``, ``/file``"

#: ../../library/optparse.rst:237
msgid ""
"These option syntaxes are not supported by :mod:`!optparse`, and they never "
"will be.  This is deliberate: the first three are non-standard on any "
"environment, and the last only makes sense if you're exclusively targeting "
"Windows or certain legacy platforms (e.g. VMS, MS-DOS)."
msgstr ""

#: ../../library/optparse.rst:242
msgid "option argument"
msgstr "オプション引数 (option argument)"

#: ../../library/optparse.rst:243
msgid ""
"an argument that follows an option, is closely associated with that option, "
"and is consumed from the argument list when that option is. With :mod:`!"
"optparse`, option arguments may either be in a separate argument from their "
"option:"
msgstr ""

#: ../../library/optparse.rst:248
msgid ""
"-f foo\n"
"--file foo"
msgstr ""

#: ../../library/optparse.rst:253
msgid "or included in the same argument:"
msgstr "また、一つの引数中にも入れられます:"

#: ../../library/optparse.rst:255
msgid ""
"-ffoo\n"
"--file=foo"
msgstr ""

#: ../../library/optparse.rst:260
msgid ""
"Typically, a given option either takes an argument or it doesn't. Lots of "
"people want an \"optional option arguments\" feature, meaning that some "
"options will take an argument if they see it, and won't if they don't.  This "
"is somewhat controversial, because it makes parsing ambiguous: if ``-a`` "
"takes an optional argument and ``-b`` is another option entirely, how do we "
"interpret ``-ab``?  Because of this ambiguity, :mod:`!optparse` does not "
"support this feature."
msgstr ""

#: ../../library/optparse.rst:268
msgid "positional argument"
msgstr "位置引数 (positional argument)"

#: ../../library/optparse.rst:269
msgid ""
"something leftover in the argument list after options have been parsed, i.e. "
"after options and their arguments have been parsed and removed from the "
"argument list."
msgstr ""
"他のオプションが解析される、すなわち他のオプションとその引数が解析されて引数"
"リストから除去された後に引数リストに置かれているものです。"

#: ../../library/optparse.rst:273
msgid "required option"
msgstr "必須のオプション (required option)"

#: ../../library/optparse.rst:274
msgid ""
"an option that must be supplied on the command-line; note that the phrase "
"\"required option\" is self-contradictory in English.  :mod:`!optparse` "
"doesn't prevent you from implementing required options, but doesn't give you "
"much help at it either."
msgstr ""

#: ../../library/optparse.rst:279
msgid "For example, consider this hypothetical command-line::"
msgstr "例えば、下記のような架空のコマンドラインを考えてみましょう::"

#: ../../library/optparse.rst:281
msgid "prog -v --report report.txt foo bar"
msgstr ""

#: ../../library/optparse.rst:283
msgid ""
"``-v`` and ``--report`` are both options.  Assuming that ``--report`` takes "
"one argument, ``report.txt`` is an option argument.  ``foo`` and ``bar`` are "
"positional arguments."
msgstr ""
"``-v`` と ``--report`` はどちらもオプションです。``--report`` オプションが引"
"数をとるとすれば、``report.txt`` はオプションの引数です。``foo`` と ``bar`` "
"は位置引数になります。"

#: ../../library/optparse.rst:291
msgid "What are options for?"
msgstr "オプションとは何か"

#: ../../library/optparse.rst:293
msgid ""
"Options are used to provide extra information to tune or customize the "
"execution of a program.  In case it wasn't clear, options are usually "
"*optional*.  A program should be able to run just fine with no options "
"whatsoever.  (Pick a random program from the Unix or GNU toolsets.  Can it "
"run without any options at all and still make sense?  The main exceptions "
"are ``find``, ``tar``, and ``dd``\\ ---all of which are mutant oddballs that "
"have been rightly criticized for their non-standard syntax and confusing "
"interfaces.)"
msgstr ""
"オプションはプログラムの実行を調整したり、カスタマイズしたりするための補助的"
"な情報を与えるために使います。もっとはっきりいうと、オプションはあくまでもオ"
"プション (省略可能)であるということです。本来、プログラムはともかくもオプショ"
"ンなしでうまく実行できてしかるべきです。(Unix やGNU ツールセットのプログラム"
"をランダムにピックアップしてみてください。オプションを全く指定しなくてもちゃ"
"んと動くでしょう？例外は ``find``, ``tar``, ``dd`` くらいです---これらの例外"
"は、オプション文法が標準的でなく、インターフェースが混乱を招くと酷評されてき"
"た変種のはみ出しものなのです)"

#: ../../library/optparse.rst:301
msgid ""
"Lots of people want their programs to have \"required options\".  Think "
"about it. If it's required, then it's *not optional*!  If there is a piece "
"of information that your program absolutely requires in order to run "
"successfully, that's what positional arguments are for."
msgstr ""
"多くの人が自分のプログラムに「必須のオプション」を持たせたいと考えます。しか"
"しよく考えてください。必須なら、それは *オプション(省略可能) ではないのです！"
"* プログラムを正しく動作させるのに絶対的に必要な情報があるとすれば、そこには"
"位置引数を割り当てるべきなのです。"

#: ../../library/optparse.rst:306
msgid ""
"As an example of good command-line interface design, consider the humble "
"``cp`` utility, for copying files.  It doesn't make much sense to try to "
"copy files without supplying a destination and at least one source. Hence, "
"``cp`` fails if you run it with no arguments.  However, it has a flexible, "
"useful syntax that does not require any options at all::"
msgstr ""
"良くできたコマンドライン インターフェース設計として、ファイルのコピーに使われ"
"る ``cp`` ユーティリティのことを考えてみましょう。ファイルのコピーでは、コ"
"ピー先を指定せずにファイルをコピーするのは無意味な操作ですし、少なくとも一つ"
"のコピー元が必要です。従って、``cp`` は引数無しで実行すると失敗します。とはい"
"え、``cp`` はオプションを全く必要としない柔軟で便利なコマンドライン文法を備え"
"ています::"

#: ../../library/optparse.rst:312
msgid ""
"cp SOURCE DEST\n"
"cp SOURCE ... DEST-DIR"
msgstr ""

#: ../../library/optparse.rst:315
msgid ""
"You can get pretty far with just that.  Most ``cp`` implementations provide "
"a bunch of options to tweak exactly how the files are copied: you can "
"preserve mode and modification time, avoid following symlinks, ask before "
"clobbering existing files, etc.  But none of this distracts from the core "
"mission of ``cp``, which is to copy either one file to another, or several "
"files to another directory."
msgstr ""
"まだあります。ほとんどの ``cp`` の実装では、ファイルモードや変更時刻を変えず"
"にコピーする、シンボリックリンクの追跡を行わない、すでにあるファイルを上書き"
"する前にユーザに尋ねる、など、ファイルをコピーする方法をいじるための一連のオ"
"プションを実装しています。しかし、こうしたオプションは、一つのファイルを別の"
"場所にコピーする、または複数のファイルを別のディレクトリにコピーするという、"
"``cp`` の中心的な処理を乱すことはないのです。"

#: ../../library/optparse.rst:326
msgid "What are positional arguments for?"
msgstr "位置引数とは何か"

#: ../../library/optparse.rst:328
msgid ""
"Positional arguments are for those pieces of information that your program "
"absolutely, positively requires to run."
msgstr ""
"位置引数とは、プログラムを動作させる上で絶対的に必要な情報となる引数です。"

#: ../../library/optparse.rst:331
msgid ""
"A good user interface should have as few absolute requirements as possible.  "
"If your program requires 17 distinct pieces of information in order to run "
"successfully, it doesn't much matter *how* you get that information from the "
"user---most people will give up and walk away before they successfully run "
"the program.  This applies whether the user interface is a command-line, a "
"configuration file, or a GUI: if you make that many demands on your users, "
"most of them will simply give up."
msgstr ""
"よいユーザインターフェースとは、絶対に必要だとされるものが可能な限り少ないも"
"のです。プログラムを正しく動作させるために 17 個もの別個の情報が必要だとした"
"ら、その *方法* はさして問題にはなりません ---ユーザはプログラムを正しく動作"
"させられないうちに諦め、立ち去ってしまうからです。ユーザインターフェースがコ"
"マンドラインでも、設定ファイルでも、GUI やその他の何であっても同じです: 多く"
"の要求をユーザに押し付ければ、ほとんどのユーザはただ音をあげてしまうだけなの"
"です。"

#: ../../library/optparse.rst:339
msgid ""
"In short, try to minimize the amount of information that users are "
"absolutely required to supply---use sensible defaults whenever possible.  Of "
"course, you also want to make your programs reasonably flexible.  That's "
"what options are for.  Again, it doesn't matter if they are entries in a "
"config file, widgets in the \"Preferences\" dialog of a GUI, or command-line "
"options---the more options you implement, the more flexible your program is, "
"and the more complicated its implementation becomes.  Too much flexibility "
"has drawbacks as well, of course; too many options can overwhelm users and "
"make your code much harder to maintain."
msgstr ""
"要するに、ユーザが絶対に提供しなければならない情報だけに制限する --- そして可"
"能な限りよく練られたデフォルト設定を使うよう試みてください。もちろん、プログ"
"ラムには適度な柔軟性を持たせたいとも望むはずですが、それこそがオプションの果"
"たす役割です。繰り返しますが、設定ファイルのエントリであろうが、GUI でできた"
"「環境設定」ダイアログ上のウィジェットであろうが、コマンドラインオプションで"
"あろうが関係ありません --- より多くのオプションを実装すればプログラムはより柔"
"軟性を持ちますが、実装はより難解になるのです。高すぎる柔軟性はユーザを閉口さ"
"せ、コードの維持をより難しくするのです。"

#: ../../library/optparse.rst:352
msgid "Tutorial"
msgstr "チュートリアル"

#: ../../library/optparse.rst:354
msgid ""
"While :mod:`!optparse` is quite flexible and powerful, it's also "
"straightforward to use in most cases.  This section covers the code patterns "
"that are common to any :mod:`!optparse`\\ -based program."
msgstr ""

#: ../../library/optparse.rst:358
msgid ""
"First, you need to import the OptionParser class; then, early in the main "
"program, create an OptionParser instance::"
msgstr ""
"まず、:class:`OptionParser` クラスを import しておかなければなりません。次"
"に、プログラムの冒頭で :class:`OptionParser` インスタンスを生成しておきます::"

#: ../../library/optparse.rst:361
msgid ""
"from optparse import OptionParser\n"
"...\n"
"parser = OptionParser()"
msgstr ""

#: ../../library/optparse.rst:365
msgid "Then you can start defining options.  The basic syntax is::"
msgstr ""
"これでオプションを定義できるようになりました。基本的な構文は以下の通りです::"

#: ../../library/optparse.rst:367
msgid ""
"parser.add_option(opt_str, ...,\n"
"                  attr=value, ...)"
msgstr ""

#: ../../library/optparse.rst:370
msgid ""
"Each option has one or more option strings, such as ``-f`` or ``--file``, "
"and several option attributes that tell :mod:`!optparse` what to expect and "
"what to do when it encounters that option on the command line."
msgstr ""

#: ../../library/optparse.rst:374
msgid ""
"Typically, each option will have one short option string and one long option "
"string, e.g.::"
msgstr ""
"通常、各オプションには短いオプション文字列と長いオプション文字列があります。"
"例えば::"

#: ../../library/optparse.rst:377
msgid "parser.add_option(\"-f\", \"--file\", ...)"
msgstr ""

#: ../../library/optparse.rst:379
msgid ""
"You're free to define as many short option strings and as many long option "
"strings as you like (including zero), as long as there is at least one "
"option string overall."
msgstr ""
"オプション文字列は、(ゼロ文字の場合も含め)いくらでも短く、またいくらでも長く"
"できます。ただしオプション文字列は少なくとも一つなければなりません。"

#: ../../library/optparse.rst:383
msgid ""
"The option strings passed to :meth:`OptionParser.add_option` are effectively "
"labels for the option defined by that call.  For brevity, we will frequently "
"refer to *encountering an option* on the command line; in reality, :mod:`!"
"optparse` encounters *option strings* and looks up options from them."
msgstr ""

#: ../../library/optparse.rst:389
msgid ""
"Once all of your options are defined, instruct :mod:`!optparse` to parse "
"your program's command line::"
msgstr ""

#: ../../library/optparse.rst:392
msgid "(options, args) = parser.parse_args()"
msgstr ""

#: ../../library/optparse.rst:394
msgid ""
"(If you like, you can pass a custom argument list to :meth:`~OptionParser."
"parse_args`, but that's rarely necessary: by default it uses ``sys."
"argv[1:]``.)"
msgstr ""
"(お望みなら、 :meth:`~OptionParser.parse_args` に自作の引数リストを渡してもか"
"まいません。とはいえ、実際にはそうした必要はほとんどないでしょう: :mod:"
"`optionparser` はデフォルトで ``sys.argv[1:]`` を使うからです。)"

#: ../../library/optparse.rst:397
msgid ":meth:`~OptionParser.parse_args` returns two values:"
msgstr ":meth:`~OptionParser.parse_args` は二つの値を返します:"

#: ../../library/optparse.rst:399
msgid ""
"``options``, an object containing values for all of your options---e.g. if "
"``--file`` takes a single string argument, then ``options.file`` will be the "
"filename supplied by the user, or ``None`` if the user did not supply that "
"option"
msgstr ""
"全てのオプションに対する値の入ったオブジェクト ``options`` --- 例えば、``--"
"file`` が単一の文字列引数をとる場合、``options.file`` はユーザが指定したファ"
"イル名になります。オプションを指定しなかった場合には ``None`` になります"

#: ../../library/optparse.rst:404
msgid ""
"``args``, the list of positional arguments leftover after parsing options"
msgstr "オプションの解析後に残った位置引数からなるリスト ``args``"

#: ../../library/optparse.rst:406
msgid ""
"This tutorial section only covers the four most important option "
"attributes: :attr:`~Option.action`, :attr:`~Option.type`, :attr:`~Option."
"dest` (destination), and :attr:`~Option.help`. Of these, :attr:`~Option."
"action` is the most fundamental."
msgstr ""
"このチュートリアルの節では、最も重要な四つのオプション属性: :attr:`~Option."
"action`, :attr:`~Option.type`, :attr:`~Option.dest` (destination), :attr:"
"`~Option.help` についてしか触れません。このうち最も重要なのは :attr:`~Option."
"action` です。"

#: ../../library/optparse.rst:415
msgid "Understanding option actions"
msgstr "オプション・アクションを理解する"

#: ../../library/optparse.rst:417
msgid ""
"Actions tell :mod:`!optparse` what to do when it encounters an option on the "
"command line.  There is a fixed set of actions hard-coded into :mod:`!"
"optparse`; adding new actions is an advanced topic covered in section :ref:"
"`optparse-extending-optparse`.  Most actions tell :mod:`!optparse` to store "
"a value in some variable---for example, take a string from the command line "
"and store it in an attribute of ``options``."
msgstr ""

#: ../../library/optparse.rst:424
msgid ""
"If you don't specify an option action, :mod:`!optparse` defaults to "
"``store``."
msgstr ""

#: ../../library/optparse.rst:430
msgid "The store action"
msgstr "store アクション"

#: ../../library/optparse.rst:432
msgid ""
"The most common option action is ``store``, which tells :mod:`!optparse` to "
"take the next argument (or the remainder of the current argument), ensure "
"that it is of the correct type, and store it to your chosen destination."
msgstr ""

#: ../../library/optparse.rst:436
msgid "For example::"
msgstr "例えば::"

#: ../../library/optparse.rst:438
msgid ""
"parser.add_option(\"-f\", \"--file\",\n"
"                  action=\"store\", type=\"string\", dest=\"filename\")"
msgstr ""

#: ../../library/optparse.rst:441
msgid ""
"Now let's make up a fake command line and ask :mod:`!optparse` to parse it::"
msgstr ""

#: ../../library/optparse.rst:443
msgid ""
"args = [\"-f\", \"foo.txt\"]\n"
"(options, args) = parser.parse_args(args)"
msgstr ""

#: ../../library/optparse.rst:446
msgid ""
"When :mod:`!optparse` sees the option string ``-f``, it consumes the next "
"argument, ``foo.txt``, and stores it in ``options.filename``.  So, after "
"this call to :meth:`~OptionParser.parse_args`, ``options.filename`` is "
"``\"foo.txt\"``."
msgstr ""

#: ../../library/optparse.rst:450
msgid ""
"Some other option types supported by :mod:`!optparse` are ``int`` and "
"``float``. Here's an option that expects an integer argument::"
msgstr ""

#: ../../library/optparse.rst:453
msgid "parser.add_option(\"-n\", type=\"int\", dest=\"num\")"
msgstr ""

#: ../../library/optparse.rst:455
msgid ""
"Note that this option has no long option string, which is perfectly "
"acceptable. Also, there's no explicit action, since the default is ``store``."
msgstr ""
"このオプションには長い形式のオプション文字列がないため、設定に問題がないとい"
"うことに注意してください。また、デフォルトのアクションは ``store`` なので、こ"
"こでは action を明示的に指定していません。"

#: ../../library/optparse.rst:458
msgid ""
"Let's parse another fake command-line.  This time, we'll jam the option "
"argument right up against the option: since ``-n42`` (one argument) is "
"equivalent to ``-n 42`` (two arguments), the code ::"
msgstr ""
"架空のコマンドラインをもう一つ解析してみましょう。今度は、オプション引数をオ"
"プションの右側にぴったりくっつけて一緒くたにします: ``-n42`` (一つの引数の"
"み) は ``-n 42`` (二つの引数からなる) と等価になるので ::"

#: ../../library/optparse.rst:462
msgid ""
"(options, args) = parser.parse_args([\"-n42\"])\n"
"print(options.num)"
msgstr ""

#: ../../library/optparse.rst:465
msgid "will print ``42``."
msgstr "は ``42`` を出力します。"

#: ../../library/optparse.rst:467
msgid ""
"If you don't specify a type, :mod:`!optparse` assumes ``string``.  Combined "
"with the fact that the default action is ``store``, that means our first "
"example can be a lot shorter::"
msgstr ""

#: ../../library/optparse.rst:471
msgid "parser.add_option(\"-f\", \"--file\", dest=\"filename\")"
msgstr ""

#: ../../library/optparse.rst:473
msgid ""
"If you don't supply a destination, :mod:`!optparse` figures out a sensible "
"default from the option strings: if the first long option string is ``--foo-"
"bar``, then the default destination is ``foo_bar``.  If there are no long "
"option strings, :mod:`!optparse` looks at the first short option string: the "
"default destination for ``-f`` is ``f``."
msgstr ""

#: ../../library/optparse.rst:479
msgid ""
":mod:`!optparse` also includes the built-in ``complex`` type.  Adding types "
"is covered in section :ref:`optparse-extending-optparse`."
msgstr ""

#: ../../library/optparse.rst:486
msgid "Handling boolean (flag) options"
msgstr "ブール値 (フラグ) オプションの処理"

#: ../../library/optparse.rst:488
msgid ""
"Flag options---set a variable to true or false when a particular option is "
"seen---are quite common.  :mod:`!optparse` supports them with two separate "
"actions, ``store_true`` and ``store_false``.  For example, you might have a "
"``verbose`` flag that is turned on with ``-v`` and off with ``-q``::"
msgstr ""

#: ../../library/optparse.rst:493
msgid ""
"parser.add_option(\"-v\", action=\"store_true\", dest=\"verbose\")\n"
"parser.add_option(\"-q\", action=\"store_false\", dest=\"verbose\")"
msgstr ""

#: ../../library/optparse.rst:496
msgid ""
"Here we have two different options with the same destination, which is "
"perfectly OK.  (It just means you have to be a bit careful when setting "
"default values---see below.)"
msgstr ""
"ここでは二つのオプションに同じ保存先を指定していますが、全く問題ありません。"
"(下記のように、デフォルト値の設定を少し注意深く行わなければならないだけで"
"す。)"

#: ../../library/optparse.rst:500
msgid ""
"When :mod:`!optparse` encounters ``-v`` on the command line, it sets "
"``options.verbose`` to ``True``; when it encounters ``-q``, ``options."
"verbose`` is set to ``False``."
msgstr ""

#: ../../library/optparse.rst:508
msgid "Other actions"
msgstr "その他のアクション"

#: ../../library/optparse.rst:510
msgid "Some other actions supported by :mod:`!optparse` are:"
msgstr ""

#: ../../library/optparse.rst:512 ../../library/optparse.rst:1034
msgid "``\"store_const\"``"
msgstr "``\"store_const\"``"

#: ../../library/optparse.rst:513 ../../library/optparse.rst:1035
msgid "store a constant value, pre-set via :attr:`Option.const`"
msgstr ""

#: ../../library/optparse.rst:515 ../../library/optparse.rst:1043
msgid "``\"append\"``"
msgstr "``\"append\"``"

#: ../../library/optparse.rst:516 ../../library/optparse.rst:1044
msgid "append this option's argument to a list"
msgstr "オプションの引数を指定のリストに追加します"

#: ../../library/optparse.rst:518 ../../library/optparse.rst:1049
msgid "``\"count\"``"
msgstr "``\"count\"``"

#: ../../library/optparse.rst:519 ../../library/optparse.rst:1050
msgid "increment a counter by one"
msgstr "指定のカウンタを 1 増やします"

#: ../../library/optparse.rst:521 ../../library/optparse.rst:1052
msgid "``\"callback\"``"
msgstr "``\"callback\"``"

#: ../../library/optparse.rst:522 ../../library/optparse.rst:1053
msgid "call a specified function"
msgstr "指定の関数を呼び出します"

#: ../../library/optparse.rst:524
msgid ""
"These are covered in section :ref:`optparse-reference-guide`, and section :"
"ref:`optparse-option-callbacks`."
msgstr ""
"これらのアクションについては、 :ref:`optparse-reference-guide` 節および :ref:"
"`optparse-option-callbacks` 節で触れます。"

#: ../../library/optparse.rst:531
msgid "Default values"
msgstr "デフォルト値"

#: ../../library/optparse.rst:533
msgid ""
"All of the above examples involve setting some variable (the "
"\"destination\") when certain command-line options are seen.  What happens "
"if those options are never seen?  Since we didn't supply any defaults, they "
"are all set to ``None``.  This is usually fine, but sometimes you want more "
"control.  :mod:`!optparse` lets you supply a default value for each "
"destination, which is assigned before the command line is parsed."
msgstr ""

#: ../../library/optparse.rst:540
msgid ""
"First, consider the verbose/quiet example.  If we want :mod:`!optparse` to "
"set ``verbose`` to ``True`` unless ``-q`` is seen, then we can do this::"
msgstr ""

#: ../../library/optparse.rst:543
msgid ""
"parser.add_option(\"-v\", action=\"store_true\", dest=\"verbose\", "
"default=True)\n"
"parser.add_option(\"-q\", action=\"store_false\", dest=\"verbose\")"
msgstr ""

#: ../../library/optparse.rst:546
msgid ""
"Since default values apply to the *destination* rather than to any "
"particular option, and these two options happen to have the same "
"destination, this is exactly equivalent::"
msgstr ""
"デフォルトの値は特定のオプションではなく *保存先* に対して適用されます。ま"
"た、これら二つのオプションはたまたま同じ保存先を持っているにすぎないため、上"
"のコードは下のコードと全く等価になります::"

#: ../../library/optparse.rst:550
msgid ""
"parser.add_option(\"-v\", action=\"store_true\", dest=\"verbose\")\n"
"parser.add_option(\"-q\", action=\"store_false\", dest=\"verbose\", "
"default=True)"
msgstr ""

#: ../../library/optparse.rst:553
msgid "Consider this::"
msgstr "下のような場合を考えてみましょう::"

#: ../../library/optparse.rst:555
msgid ""
"parser.add_option(\"-v\", action=\"store_true\", dest=\"verbose\", "
"default=False)\n"
"parser.add_option(\"-q\", action=\"store_false\", dest=\"verbose\", "
"default=True)"
msgstr ""

#: ../../library/optparse.rst:558
msgid ""
"Again, the default value for ``verbose`` will be ``True``: the last default "
"value supplied for any particular destination is the one that counts."
msgstr ""
"やはり ``verbose`` のデフォルト値は ``True`` になります; 特定の目的変数に対す"
"るデフォルト値として有効なのは、最後に指定した値だからです。"

#: ../../library/optparse.rst:561
msgid ""
"A clearer way to specify default values is the :meth:`set_defaults` method "
"of OptionParser, which you can call at any time before calling :meth:"
"`~OptionParser.parse_args`::"
msgstr ""
"デフォルト値をすっきりと指定するには、 :class:`OptionParser` の :meth:"
"`set_defaults` メソッドを使います。このメソッドは :meth:`~OptionParser."
"parse_args` を呼び出す前ならいつでも使えます::"

#: ../../library/optparse.rst:565
msgid ""
"parser.set_defaults(verbose=True)\n"
"parser.add_option(...)\n"
"(options, args) = parser.parse_args()"
msgstr ""

#: ../../library/optparse.rst:569
msgid ""
"As before, the last value specified for a given option destination is the "
"one that counts.  For clarity, try to use one method or the other of setting "
"default values, not both."
msgstr ""
"前の例と同様、あるオプションの値の保存先に対するデフォルトの値は最後に指定し"
"た値になります。コードを読みやすくするため、デフォルト値を設定するときには両"
"方のやり方を混ぜるのではなく、片方だけを使うようにしましょう。"

#: ../../library/optparse.rst:577
msgid "Generating help"
msgstr "ヘルプの生成"

#: ../../library/optparse.rst:579
msgid ""
":mod:`!optparse`'s ability to generate help and usage text automatically is "
"useful for creating user-friendly command-line interfaces.  All you have to "
"do is supply a :attr:`~Option.help` value for each option, and optionally a "
"short usage message for your whole program.  Here's an OptionParser "
"populated with user-friendly (documented) options::"
msgstr ""

#: ../../library/optparse.rst:585
msgid ""
"usage = \"usage: %prog [options] arg1 arg2\"\n"
"parser = OptionParser(usage=usage)\n"
"parser.add_option(\"-v\", \"--verbose\",\n"
"                  action=\"store_true\", dest=\"verbose\", default=True,\n"
"                  help=\"make lots of noise [default]\")\n"
"parser.add_option(\"-q\", \"--quiet\",\n"
"                  action=\"store_false\", dest=\"verbose\",\n"
"                  help=\"be vewwy quiet (I'm hunting wabbits)\")\n"
"parser.add_option(\"-f\", \"--filename\",\n"
"                  metavar=\"FILE\", help=\"write output to FILE\")\n"
"parser.add_option(\"-m\", \"--mode\",\n"
"                  default=\"intermediate\",\n"
"                  help=\"interaction mode: novice, intermediate, \"\n"
"                       \"or expert [default: %default]\")"
msgstr ""

#: ../../library/optparse.rst:600
msgid ""
"If :mod:`!optparse` encounters either ``-h`` or ``--help`` on the command-"
"line, or if you just call :meth:`parser.print_help`, it prints the following "
"to standard output:"
msgstr ""

#: ../../library/optparse.rst:604
msgid ""
"Usage: <yourscript> [options] arg1 arg2\n"
"\n"
"Options:\n"
"  -h, --help            show this help message and exit\n"
"  -v, --verbose         make lots of noise [default]\n"
"  -q, --quiet           be vewwy quiet (I'm hunting wabbits)\n"
"  -f FILE, --filename=FILE\n"
"                        write output to FILE\n"
"  -m MODE, --mode=MODE  interaction mode: novice, intermediate, or\n"
"                        expert [default: intermediate]"
msgstr ""

#: ../../library/optparse.rst:617
msgid ""
"(If the help output is triggered by a help option, :mod:`!optparse` exits "
"after printing the help text.)"
msgstr ""

#: ../../library/optparse.rst:620
msgid ""
"There's a lot going on here to help :mod:`!optparse` generate the best "
"possible help message:"
msgstr ""

#: ../../library/optparse.rst:623
msgid "the script defines its own usage message::"
msgstr "スクリプト自体の利用法を表すメッセージを定義します::"

#: ../../library/optparse.rst:625
msgid "usage = \"usage: %prog [options] arg1 arg2\""
msgstr ""

#: ../../library/optparse.rst:627
msgid ""
":mod:`!optparse` expands ``%prog`` in the usage string to the name of the "
"current program, i.e. ``os.path.basename(sys.argv[0])``.  The expanded "
"string is then printed before the detailed option help."
msgstr ""

#: ../../library/optparse.rst:631
msgid ""
"If you don't supply a usage string, :mod:`!optparse` uses a bland but "
"sensible default: ``\"Usage: %prog [options]\"``, which is fine if your "
"script doesn't take any positional arguments."
msgstr ""

#: ../../library/optparse.rst:635
msgid ""
"every option defines a help string, and doesn't worry about line-wrapping---"
"\\ :mod:`!optparse` takes care of wrapping lines and making the help output "
"look good."
msgstr ""

#: ../../library/optparse.rst:639
msgid ""
"options that take a value indicate this fact in their automatically "
"generated help message, e.g. for the \"mode\" option::"
msgstr ""
"オプションが値をとるということは自動的に生成されるヘルプメッセージの中で分か"
"ります。例えば、\"mode\" option の場合にはこのようになります::"

#: ../../library/optparse.rst:642
msgid "-m MODE, --mode=MODE"
msgstr ""

#: ../../library/optparse.rst:644
msgid ""
"Here, \"MODE\" is called the meta-variable: it stands for the argument that "
"the user is expected to supply to ``-m``/``--mode``.  By default, :mod:`!"
"optparse` converts the destination variable name to uppercase and uses that "
"for the meta-variable.  Sometimes, that's not what you want---for example, "
"the ``--filename`` option explicitly sets ``metavar=\"FILE\"``, resulting in "
"this automatically generated option description::"
msgstr ""

#: ../../library/optparse.rst:651
msgid "-f FILE, --filename=FILE"
msgstr ""

#: ../../library/optparse.rst:653
msgid ""
"This is important for more than just saving space, though: the manually "
"written help text uses the meta-variable ``FILE`` to clue the user in that "
"there's a connection between the semi-formal syntax ``-f FILE`` and the "
"informal semantic description \"write output to FILE\". This is a simple but "
"effective way to make your help text a lot clearer and more useful for end "
"users."
msgstr ""
"この機能の重要さは、単に表示スペースを節約するといった理由にとどまりません: "
"上の例では、手作業で書いたヘルプテキストの中でメタ変数として ``FILE`` を使っ"
"ています。その結果、ユーザに対してやや堅苦しい表現の書法 ``-f FILE`` と、より"
"平易に意味付けを説明した \"write output to FILE\" との間に対応があるというヒ"
"ントを与えています。これは、エンドユーザにとってより明解で便利なヘルプテキス"
"トを作成する単純でありながら効果的な手法なのです。"

#: ../../library/optparse.rst:659
msgid ""
"options that have a default value can include ``%default`` in the help "
"string---\\ :mod:`!optparse` will replace it with :func:`str` of the "
"option's default value.  If an option has no default value (or the default "
"value is ``None``), ``%default`` expands to ``none``."
msgstr ""

#: ../../library/optparse.rst:665
msgid "Grouping Options"
msgstr "オプションをグループ化する"

#: ../../library/optparse.rst:667
msgid ""
"When dealing with many options, it is convenient to group these options for "
"better help output.  An :class:`OptionParser` can contain several option "
"groups, each of which can contain several options."
msgstr ""
"たくさんのオプションを扱う場合、オプションをグループ分けするとヘルプ出力が見"
"やすくなります。 :class:`OptionParser` は、複数のオプションをまとめたオプショ"
"ングループを複数持つことができます。"

#: ../../library/optparse.rst:671
msgid "An option group is obtained using the class :class:`OptionGroup`:"
msgstr "オプションのグループは、 :class:`OptionGroup` を使って作成します:"

#: ../../library/optparse.rst:675 ../../library/optparse.rst:1746
msgid "where"
msgstr "ここでは:"

#: ../../library/optparse.rst:677
msgid ""
"parser is the :class:`OptionParser` instance the group will be inserted in to"
msgstr ""
"*parser* は、このグループが属する :class:`OptionParser` のインスタンスです"

#: ../../library/optparse.rst:679
msgid "title is the group title"
msgstr "*title* はグループのタイトルです"

#: ../../library/optparse.rst:680
msgid "description, optional, is a long description of the group"
msgstr "*description* はオプションで、グループの長い説明です"

#: ../../library/optparse.rst:682
msgid ""
":class:`OptionGroup` inherits from :class:`OptionContainer` (like :class:"
"`OptionParser`) and so the :meth:`add_option` method can be used to add an "
"option to the group."
msgstr ""
":class:`OptionGroup` は (:class:`OptionParser` のように) :class:"
"`OptionContainer` を継承していて、オプションをグループに追加するために :meth:"
"`add_option` メソッドを利用できます。"

#: ../../library/optparse.rst:686
msgid ""
"Once all the options are declared, using the :class:`OptionParser` method :"
"meth:`add_option_group` the group is added to the previously defined parser."
msgstr ""
"全てのオプションを定義したら、 :class:`OptionParser` の :meth:"
"`add_option_group` メソッドを使ってグループを定義済みのパーサーに追加します。"

#: ../../library/optparse.rst:689
msgid ""
"Continuing with the parser defined in the previous section, adding an :class:"
"`OptionGroup` to a parser is easy::"
msgstr ""
"前のセクションで定義したパーサーに、続けて :class:`OptionGroup` を追加しま"
"す::"

#: ../../library/optparse.rst:692
msgid ""
"group = OptionGroup(parser, \"Dangerous Options\",\n"
"                    \"Caution: use these options at your own risk.  \"\n"
"                    \"It is believed that some of them bite.\")\n"
"group.add_option(\"-g\", action=\"store_true\", help=\"Group option.\")\n"
"parser.add_option_group(group)"
msgstr ""

#: ../../library/optparse.rst:698
msgid "This would result in the following help output:"
msgstr "この結果のヘルプ出力は次のようになります:"

#: ../../library/optparse.rst:700
msgid ""
"Usage: <yourscript> [options] arg1 arg2\n"
"\n"
"Options:\n"
"  -h, --help            show this help message and exit\n"
"  -v, --verbose         make lots of noise [default]\n"
"  -q, --quiet           be vewwy quiet (I'm hunting wabbits)\n"
"  -f FILE, --filename=FILE\n"
"                        write output to FILE\n"
"  -m MODE, --mode=MODE  interaction mode: novice, intermediate, or\n"
"                        expert [default: intermediate]\n"
"\n"
"  Dangerous Options:\n"
"    Caution: use these options at your own risk.  It is believed that some\n"
"    of them bite.\n"
"\n"
"    -g                  Group option."
msgstr ""

#: ../../library/optparse.rst:719
msgid ""
"A bit more complete example might involve using more than one group: still "
"extending the previous example::"
msgstr "さらにサンプルを拡張して、複数のグループを使うようにしてみます::"

#: ../../library/optparse.rst:722
msgid ""
"group = OptionGroup(parser, \"Dangerous Options\",\n"
"                    \"Caution: use these options at your own risk.  \"\n"
"                    \"It is believed that some of them bite.\")\n"
"group.add_option(\"-g\", action=\"store_true\", help=\"Group option.\")\n"
"parser.add_option_group(group)\n"
"\n"
"group = OptionGroup(parser, \"Debug Options\")\n"
"group.add_option(\"-d\", \"--debug\", action=\"store_true\",\n"
"                 help=\"Print debug information\")\n"
"group.add_option(\"-s\", \"--sql\", action=\"store_true\",\n"
"                 help=\"Print all SQL statements executed\")\n"
"group.add_option(\"-e\", action=\"store_true\", help=\"Print every action "
"done\")\n"
"parser.add_option_group(group)"
msgstr ""

#: ../../library/optparse.rst:736
msgid "that results in the following output:"
msgstr "出力結果は次のようになります:"

#: ../../library/optparse.rst:738
msgid ""
"Usage: <yourscript> [options] arg1 arg2\n"
"\n"
"Options:\n"
"  -h, --help            show this help message and exit\n"
"  -v, --verbose         make lots of noise [default]\n"
"  -q, --quiet           be vewwy quiet (I'm hunting wabbits)\n"
"  -f FILE, --filename=FILE\n"
"                        write output to FILE\n"
"  -m MODE, --mode=MODE  interaction mode: novice, intermediate, or expert\n"
"                        [default: intermediate]\n"
"\n"
"  Dangerous Options:\n"
"    Caution: use these options at your own risk.  It is believed that some\n"
"    of them bite.\n"
"\n"
"    -g                  Group option.\n"
"\n"
"  Debug Options:\n"
"    -d, --debug         Print debug information\n"
"    -s, --sql           Print all SQL statements executed\n"
"    -e                  Print every action done"
msgstr ""

#: ../../library/optparse.rst:762
msgid ""
"Another interesting method, in particular when working programmatically with "
"option groups is:"
msgstr ""
"もう1つの、特にオプショングループをプログラムから操作するときに利用できるメ"
"ソッドがあります:"

#: ../../library/optparse.rst:767
msgid ""
"Return the :class:`OptionGroup` to which the short or long option string "
"*opt_str* (e.g. ``'-o'`` or ``'--option'``) belongs. If there's no such :"
"class:`OptionGroup`, return ``None``."
msgstr ""
"短いオプション文字列もしくは長いオプション文字列 *opt_str* (例。 ``'-o'`` 、 "
"``'--option'``) が属する :class:`OptionGroup` を返します。そのような :class:"
"`OptionGroup` が無い場合は、 ``None`` を返します。"

#: ../../library/optparse.rst:774
msgid "Printing a version string"
msgstr "バージョン番号の出力"

#: ../../library/optparse.rst:776
msgid ""
"Similar to the brief usage string, :mod:`!optparse` can also print a version "
"string for your program.  You have to supply the string as the ``version`` "
"argument to OptionParser::"
msgstr ""

#: ../../library/optparse.rst:780
msgid "parser = OptionParser(usage=\"%prog [-f] [-q]\", version=\"%prog 1.0\")"
msgstr ""

#: ../../library/optparse.rst:782
msgid ""
"``%prog`` is expanded just like it is in ``usage``.  Apart from that, "
"``version`` can contain anything you like.  When you supply it, :mod:`!"
"optparse` automatically adds a ``--version`` option to your parser. If it "
"encounters this option on the command line, it expands your ``version`` "
"string (by replacing ``%prog``), prints it to stdout, and exits."
msgstr ""

#: ../../library/optparse.rst:788
msgid "For example, if your script is called ``/usr/bin/foo``:"
msgstr "例えば、``/usr/bin/foo`` という名前のスクリプトなら:"

#: ../../library/optparse.rst:790
msgid ""
"$ /usr/bin/foo --version\n"
"foo 1.0"
msgstr ""

#: ../../library/optparse.rst:795
msgid ""
"The following two methods can be used to print and get the ``version`` "
"string:"
msgstr "以下の2つのメソッドを、``version`` 文字列を表示するために利用できます:"

#: ../../library/optparse.rst:799
msgid ""
"Print the version message for the current program (``self.version``) to "
"*file* (default stdout).  As with :meth:`print_usage`, any occurrence of "
"``%prog`` in ``self.version`` is replaced with the name of the current "
"program.  Does nothing if ``self.version`` is empty or undefined."
msgstr ""
"現在のプログラムのバージョン (``self.version``) を *file* (デフォルト: "
"stdout) へ表示します。 :meth:`print_usage` と同じく、 ``self.version`` の中の"
"全ての ``%prog`` が現在のプログラム名に置き換えられます。 ``self.version`` が"
"空文字列だだったり未定義だったときは何もしません。"

#: ../../library/optparse.rst:806
msgid ""
"Same as :meth:`print_version` but returns the version string instead of "
"printing it."
msgstr ""
":meth:`print_version` と同じですが、バージョン文字列を表示する代わりに返しま"
"す。"

#: ../../library/optparse.rst:813
msgid "How :mod:`!optparse` handles errors"
msgstr ""

#: ../../library/optparse.rst:815
msgid ""
"There are two broad classes of errors that :mod:`!optparse` has to worry "
"about: programmer errors and user errors.  Programmer errors are usually "
"erroneous calls to :func:`OptionParser.add_option`, e.g. invalid option "
"strings, unknown option attributes, missing option attributes, etc.  These "
"are dealt with in the usual way: raise an exception (either :exc:`optparse."
"OptionError` or :exc:`TypeError`) and let the program crash."
msgstr ""

#: ../../library/optparse.rst:822
msgid ""
"Handling user errors is much more important, since they are guaranteed to "
"happen no matter how stable your code is.  :mod:`!optparse` can "
"automatically detect some user errors, such as bad option arguments (passing "
"``-n 4x`` where ``-n`` takes an integer argument), missing arguments (``-n`` "
"at the end of the command line, where ``-n`` takes an argument of any "
"type).  Also, you can call :func:`OptionParser.error` to signal an "
"application-defined error condition::"
msgstr ""

#: ../../library/optparse.rst:830
msgid ""
"(options, args) = parser.parse_args()\n"
"...\n"
"if options.a and options.b:\n"
"    parser.error(\"options -a and -b are mutually exclusive\")"
msgstr ""

#: ../../library/optparse.rst:835
msgid ""
"In either case, :mod:`!optparse` handles the error the same way: it prints "
"the program's usage message and an error message to standard error and exits "
"with error status 2."
msgstr ""

#: ../../library/optparse.rst:839
msgid ""
"Consider the first example above, where the user passes ``4x`` to an option "
"that takes an integer:"
msgstr ""
"上に挙げた最初の例、すなわち整数を引数にとるオプションにユーザが ``4x`` を指"
"定した場合を考えてみましょう:"

#: ../../library/optparse.rst:842
msgid ""
"$ /usr/bin/foo -n 4x\n"
"Usage: foo [options]\n"
"\n"
"foo: error: option -n: invalid integer value: '4x'"
msgstr ""

#: ../../library/optparse.rst:849
msgid "Or, where the user fails to pass a value at all:"
msgstr "値を全く指定しない場合には、以下のようになります:"

#: ../../library/optparse.rst:851
msgid ""
"$ /usr/bin/foo -n\n"
"Usage: foo [options]\n"
"\n"
"foo: error: -n option requires an argument"
msgstr ""

#: ../../library/optparse.rst:858
msgid ""
":mod:`!optparse`\\ -generated error messages take care always to mention the "
"option involved in the error; be sure to do the same when calling :func:"
"`OptionParser.error` from your application code."
msgstr ""

#: ../../library/optparse.rst:862
msgid ""
"If :mod:`!optparse`'s default error-handling behaviour does not suit your "
"needs, you'll need to subclass OptionParser and override its :meth:"
"`~OptionParser.exit` and/or :meth:`~OptionParser.error` methods."
msgstr ""

#: ../../library/optparse.rst:870
msgid "Putting it all together"
msgstr "全てをつなぎ合わせる"

#: ../../library/optparse.rst:872
msgid "Here's what :mod:`!optparse`\\ -based scripts usually look like::"
msgstr ""

#: ../../library/optparse.rst:874
msgid ""
"from optparse import OptionParser\n"
"...\n"
"def main():\n"
"    usage = \"usage: %prog [options] arg\"\n"
"    parser = OptionParser(usage)\n"
"    parser.add_option(\"-f\", \"--file\", dest=\"filename\",\n"
"                      help=\"read data from FILENAME\")\n"
"    parser.add_option(\"-v\", \"--verbose\",\n"
"                      action=\"store_true\", dest=\"verbose\")\n"
"    parser.add_option(\"-q\", \"--quiet\",\n"
"                      action=\"store_false\", dest=\"verbose\")\n"
"    ...\n"
"    (options, args) = parser.parse_args()\n"
"    if len(args) != 1:\n"
"        parser.error(\"incorrect number of arguments\")\n"
"    if options.verbose:\n"
"        print(\"reading %s...\" % options.filename)\n"
"    ...\n"
"\n"
"if __name__ == \"__main__\":\n"
"    main()"
msgstr ""

#: ../../library/optparse.rst:900
msgid "Reference Guide"
msgstr "リファレンスガイド"

#: ../../library/optparse.rst:906
msgid "Creating the parser"
msgstr "parserを作る"

#: ../../library/optparse.rst:908
msgid ""
"The first step in using :mod:`!optparse` is to create an OptionParser "
"instance."
msgstr ""

#: ../../library/optparse.rst:912
msgid ""
"The OptionParser constructor has no required arguments, but a number of "
"optional keyword arguments.  You should always pass them as keyword "
"arguments, i.e. do not rely on the order in which the arguments are declared."
msgstr ""
"OptionParser のコンストラクタの引数はどれも必須ではありませんが、いくつもの"
"キーワード引数がオプションとして使えます。これらはキーワード引数として渡さな"
"ければなりません。すなわち、引数が宣言されている順番に頼ってはいけません。"

#: ../../library/optparse.rst:916
msgid "``usage`` (default: ``\"%prog [options]\"``)"
msgstr "``usage`` (デフォルト: ``\"%prog [options]\"``)"

#: ../../library/optparse.rst:917
msgid ""
"The usage summary to print when your program is run incorrectly or with a "
"help option.  When :mod:`!optparse` prints the usage string, it expands "
"``%prog`` to ``os.path.basename(sys.argv[0])`` (or to ``prog`` if you passed "
"that keyword argument).  To suppress a usage message, pass the special "
"value :const:`optparse.SUPPRESS_USAGE`."
msgstr ""

#: ../../library/optparse.rst:923
msgid "``option_list`` (default: ``[]``)"
msgstr "``option_list`` (デフォルト: ``[]``)"

#: ../../library/optparse.rst:924
msgid ""
"A list of Option objects to populate the parser with.  The options in "
"``option_list`` are added after any options in ``standard_option_list`` (a "
"class attribute that may be set by OptionParser subclasses), but before any "
"version or help options. Deprecated; use :meth:`add_option` after creating "
"the parser instead."
msgstr ""
"パーザに追加する Option オブジェクトのリストです。 ``option_list`` の中のオプ"
"ションは ``standard_option_list`` (OptionParser のサブクラスでセットされる可"
"能性のあるクラス属性) の後に追加されますが、バージョンやヘルプのオプションよ"
"りは前になります。このオプションの使用は推奨されません。パーザを作成した後"
"で、 :meth:`add_option` を使って追加してください。"

#: ../../library/optparse.rst:930
msgid "``option_class`` (default: optparse.Option)"
msgstr "``option_class`` (デフォルト: optparse.Option)"

#: ../../library/optparse.rst:931
msgid "Class to use when adding options to the parser in :meth:`add_option`."
msgstr ""
":meth:`add_option` でパーザにオプションを追加するときに使用されるクラス。"

#: ../../library/optparse.rst:933
msgid "``version`` (default: ``None``)"
msgstr "``version`` (デフォルト: ``None``)"

#: ../../library/optparse.rst:934
msgid ""
"A version string to print when the user supplies a version option. If you "
"supply a true value for ``version``, :mod:`!optparse` automatically adds a "
"version option with the single option string ``--version``.  The substring "
"``%prog`` is expanded the same as for ``usage``."
msgstr ""

#: ../../library/optparse.rst:939
msgid "``conflict_handler`` (default: ``\"error\"``)"
msgstr "``conflict_handler`` (デフォルト: ``\"error\"``)"

#: ../../library/optparse.rst:940
msgid ""
"Specifies what to do when options with conflicting option strings are added "
"to the parser; see section :ref:`optparse-conflicts-between-options`."
msgstr ""
"オプション文字列が衝突するようなオプションがパーザに追加されたときにどうする"
"かを指定します。 :ref:`optparse-conflicts-between-options` 節を参照して下さ"
"い。"

#: ../../library/optparse.rst:944
msgid "``description`` (default: ``None``)"
msgstr "``description`` (デフォルト: ``None``)"

#: ../../library/optparse.rst:945
msgid ""
"A paragraph of text giving a brief overview of your program. :mod:`!"
"optparse` reformats this paragraph to fit the current terminal width and "
"prints it when the user requests help (after ``usage``, but before the list "
"of options)."
msgstr ""

#: ../../library/optparse.rst:950
msgid "``formatter`` (default: a new :class:`IndentedHelpFormatter`)"
msgstr "``formatter`` (デフォルト: 新しい :class:`IndentedHelpFormatter`)"

#: ../../library/optparse.rst:951
msgid ""
"An instance of optparse.HelpFormatter that will be used for printing help "
"text.  :mod:`!optparse` provides two concrete classes for this purpose: "
"IndentedHelpFormatter and TitledHelpFormatter."
msgstr ""

#: ../../library/optparse.rst:955
msgid "``add_help_option`` (default: ``True``)"
msgstr "``add_help_option`` (デフォルト: ``True``)"

#: ../../library/optparse.rst:956
msgid ""
"If true, :mod:`!optparse` will add a help option (with option strings ``-h`` "
"and ``--help``) to the parser."
msgstr ""

#: ../../library/optparse.rst:959
msgid "``prog``"
msgstr "``prog``"

#: ../../library/optparse.rst:960
msgid ""
"The string to use when expanding ``%prog`` in ``usage`` and ``version`` "
"instead of ``os.path.basename(sys.argv[0])``."
msgstr ""
"``usage`` や ``version`` の中の ``%prog`` を展開するときに ``os.path."
"basename(sys.argv[0])`` の代わりに使われる文字列です。"

#: ../../library/optparse.rst:963
msgid "``epilog`` (default: ``None``)"
msgstr "``epilog`` (デフォルト: ``None``)"

#: ../../library/optparse.rst:964
msgid "A paragraph of help text to print after the option help."
msgstr "オプションのヘルプの後に表示されるヘルプテキスト."

#: ../../library/optparse.rst:969
msgid "Populating the parser"
msgstr "パーザへのオプション追加"

#: ../../library/optparse.rst:971
msgid ""
"There are several ways to populate the parser with options.  The preferred "
"way is by using :meth:`OptionParser.add_option`, as shown in section :ref:"
"`optparse-tutorial`.  :meth:`add_option` can be called in one of two ways:"
msgstr ""
"パーザにオプションを加えていくにはいくつか方法があります。推奨するのは :ref:"
"`optparse-tutorial` 節で示したような :meth:`OptionParser.add_option` を使う方"
"法です。 :meth:`add_option` は以下の二つのうちいずれかの方法で呼び出せます:"

#: ../../library/optparse.rst:975
msgid "pass it an Option instance (as returned by :func:`make_option`)"
msgstr ""
"(:func:`make_option` などが返す) :class:`Option` インスタンスを渡します"

#: ../../library/optparse.rst:977
msgid ""
"pass it any combination of positional and keyword arguments that are "
"acceptable to :func:`make_option` (i.e., to the Option constructor), and it "
"will create the Option instance for you"
msgstr ""
":func:`make_option` に (すなわち :class:`Option` のコンストラクタに) 位置引数"
"とキーワード引数の組み合わせを渡して、 :class:`Option` インスタンスを生成させ"
"ます"

#: ../../library/optparse.rst:981
msgid ""
"The other alternative is to pass a list of pre-constructed Option instances "
"to the OptionParser constructor, as in::"
msgstr ""
"もう一つの方法は、あらかじめ作成しておいた :class:`Option` インスタンスからな"
"るリストを、以下のようにして :class:`OptionParser` のコンストラクタに渡すとい"
"うものです::"

#: ../../library/optparse.rst:984
msgid ""
"option_list = [\n"
"    make_option(\"-f\", \"--filename\",\n"
"                action=\"store\", type=\"string\", dest=\"filename\"),\n"
"    make_option(\"-q\", \"--quiet\",\n"
"                action=\"store_false\", dest=\"verbose\"),\n"
"    ]\n"
"parser = OptionParser(option_list=option_list)"
msgstr ""

#: ../../library/optparse.rst:992
msgid ""
"(:func:`make_option` is a factory function for creating Option instances; "
"currently it is an alias for the Option constructor.  A future version of :"
"mod:`!optparse` may split Option into several classes, and :func:"
"`make_option` will pick the right class to instantiate.  Do not instantiate "
"Option directly.)"
msgstr ""

#: ../../library/optparse.rst:1001
msgid "Defining options"
msgstr "オプションの定義"

#: ../../library/optparse.rst:1003
msgid ""
"Each Option instance represents a set of synonymous command-line option "
"strings, e.g. ``-f`` and ``--file``.  You can specify any number of short or "
"long option strings, but you must specify at least one overall option string."
msgstr ""
"各々の :class:`Option` インスタンス、は ``-f`` や ``--file`` といった同義のコ"
"マンドラインオプションからなる集合を表現しています。一つの :class:`Option` に"
"は任意の数のオプションを短い形式でも長い形式でも指定できます。ただし、少なく"
"とも一つは指定しなければなりません。"

#: ../../library/optparse.rst:1007
msgid ""
"The canonical way to create an :class:`Option` instance is with the :meth:"
"`add_option` method of :class:`OptionParser`."
msgstr ""
"正しい方法で :class:`Option` インスタンスを生成するには、 :class:"
"`OptionParser` の :meth:`add_option` を使います。"

#: ../../library/optparse.rst:1013
msgid "To define an option with only a short option string::"
msgstr ""
"短い形式のオプション文字列を一つだけ持つようなオプションを生成するには次のよ"
"うにします::"

#: ../../library/optparse.rst:1015
msgid "parser.add_option(\"-f\", attr=value, ...)"
msgstr ""

#: ../../library/optparse.rst:1017
msgid "And to define an option with only a long option string::"
msgstr ""
"また、長い形式のオプション文字列を一つだけ持つようなオプションの定義は次のよ"
"うになります::"

#: ../../library/optparse.rst:1019
msgid "parser.add_option(\"--foo\", attr=value, ...)"
msgstr ""

#: ../../library/optparse.rst:1021
msgid ""
"The keyword arguments define attributes of the new Option object.  The most "
"important option attribute is :attr:`~Option.action`, and it largely "
"determines which other attributes are relevant or required.  If you pass "
"irrelevant option attributes, or fail to pass required ones, :mod:`!"
"optparse` raises an :exc:`OptionError` exception explaining your mistake."
msgstr ""

#: ../../library/optparse.rst:1027
msgid ""
"An option's *action* determines what :mod:`!optparse` does when it "
"encounters this option on the command-line.  The standard option actions "
"hard-coded into :mod:`!optparse` are:"
msgstr ""

#: ../../library/optparse.rst:1031
msgid "``\"store\"``"
msgstr "``\"store\"``"

#: ../../library/optparse.rst:1032
msgid "store this option's argument (default)"
msgstr "オプションの引数を保存します (デフォルトの動作です)"

#: ../../library/optparse.rst:1037
msgid "``\"store_true\"``"
msgstr "``\"store_true\"``"

#: ../../library/optparse.rst:1038
msgid "store ``True``"
msgstr ""

#: ../../library/optparse.rst:1040
msgid "``\"store_false\"``"
msgstr "``\"store_false\"``"

#: ../../library/optparse.rst:1041
msgid "store ``False``"
msgstr ""

#: ../../library/optparse.rst:1046
msgid "``\"append_const\"``"
msgstr "``\"append_const\"``"

#: ../../library/optparse.rst:1047
msgid "append a constant value to a list, pre-set via :attr:`Option.const`"
msgstr ""

#: ../../library/optparse.rst:1055 ../../library/optparse.rst:1350
msgid "``\"help\"``"
msgstr "``\"help\"``"

#: ../../library/optparse.rst:1056
msgid ""
"print a usage message including all options and the documentation for them"
msgstr "全てのオプションとそのドキュメントの入った使用法メッセージを出力します"

#: ../../library/optparse.rst:1058
msgid ""
"(If you don't supply an action, the default is ``\"store\"``.  For this "
"action, you may also supply :attr:`~Option.type` and :attr:`~Option.dest` "
"option attributes; see :ref:`optparse-standard-option-actions`.)"
msgstr ""
"(アクションを指定しない場合、デフォルトは ``\"store\"`` になります。このアク"
"ションでは、 :attr:`~Option.type` および :attr:`~Option.dest` オプション属性"
"を指定できます。 :ref:`optparse-standard-option-actions` を参照してくださ"
"い。)"

#: ../../library/optparse.rst:1062
msgid ""
"As you can see, most actions involve storing or updating a value somewhere. :"
"mod:`!optparse` always creates a special object for this, conventionally "
"called ``options``, which is an instance of :class:`optparse.Values`."
msgstr ""

#: ../../library/optparse.rst:1068
msgid ""
"An object holding parsed argument names and values as attributes. Normally "
"created by calling when calling :meth:`OptionParser.parse_args`, and can be "
"overridden by a custom subclass passed to the *values* argument of :meth:"
"`OptionParser.parse_args` (as described in :ref:`optparse-parsing-"
"arguments`)."
msgstr ""

#: ../../library/optparse.rst:1073
msgid ""
"Option arguments (and various other values) are stored as attributes of this "
"object, according to the :attr:`~Option.dest` (destination) option attribute."
msgstr ""

#: ../../library/optparse.rst:1077
msgid "For example, when you call ::"
msgstr "例えばこれを呼び出した場合 ::"

#: ../../library/optparse.rst:1079
msgid "parser.parse_args()"
msgstr ""

#: ../../library/optparse.rst:1081
msgid ""
"one of the first things :mod:`!optparse` does is create the ``options`` "
"object::"
msgstr ""

#: ../../library/optparse.rst:1083
msgid "options = Values()"
msgstr ""

#: ../../library/optparse.rst:1085
msgid "If one of the options in this parser is defined with ::"
msgstr "パーザ中で以下のようなオプションが定義されていて ::"

#: ../../library/optparse.rst:1087
msgid ""
"parser.add_option(\"-f\", \"--file\", action=\"store\", type=\"string\", "
"dest=\"filename\")"
msgstr ""

#: ../../library/optparse.rst:1089
msgid "and the command-line being parsed includes any of the following::"
msgstr "パーズしたコマンドラインに以下のいずれかが入っていた場合::"

#: ../../library/optparse.rst:1091
msgid ""
"-ffoo\n"
"-f foo\n"
"--file=foo\n"
"--file foo"
msgstr ""

#: ../../library/optparse.rst:1096
msgid ""
"then :mod:`!optparse`, on seeing this option, will do the equivalent of ::"
msgstr ""

#: ../../library/optparse.rst:1098
msgid "options.filename = \"foo\""
msgstr ""

#: ../../library/optparse.rst:1100
msgid ""
"The :attr:`~Option.type` and :attr:`~Option.dest` option attributes are "
"almost as important as :attr:`~Option.action`, but :attr:`~Option.action` is "
"the only one that makes sense for *all* options."
msgstr ""
":attr:`~Option.type` および :attr:`~Option.dest` オプション属性は :attr:"
"`~Option.action` と同じくらい重要ですが、 *全ての* オプションで意味をなすの"
"は :attr:`~Option.action` だけなのです。"

#: ../../library/optparse.rst:1108
msgid "Option attributes"
msgstr "オプション属性"

#: ../../library/optparse.rst:1112
msgid ""
"A single command line argument, with various attributes passed by keyword to "
"the constructor. Normally created with :meth:`OptionParser.add_option` "
"rather than directly, and can be overridden by a custom class via the "
"*option_class* argument to :class:`OptionParser`."
msgstr ""

#: ../../library/optparse.rst:1118
msgid ""
"The following option attributes may be passed as keyword arguments to :meth:"
"`OptionParser.add_option`.  If you pass an option attribute that is not "
"relevant to a particular option, or fail to pass a required option "
"attribute, :mod:`!optparse` raises :exc:`OptionError`."
msgstr ""

#: ../../library/optparse.rst:1125
msgid "(default: ``\"store\"``)"
msgstr "(デフォルト: ``\"store\"``)"

#: ../../library/optparse.rst:1127
msgid ""
"Determines :mod:`!optparse`'s behaviour when this option is seen on the "
"command line; the available options are documented :ref:`here <optparse-"
"standard-option-actions>`."
msgstr ""

#: ../../library/optparse.rst:1133
msgid "(default: ``\"string\"``)"
msgstr "(デフォルト: ``\"string\"``)"

#: ../../library/optparse.rst:1135
msgid ""
"The argument type expected by this option (e.g., ``\"string\"`` or "
"``\"int\"``); the available option types are documented :ref:`here <optparse-"
"standard-option-types>`."
msgstr ""
"このオプションに与えられる引数の型 (たとえば ``\"string\"`` や ``\"int\"``) "
"です。取りうるオプションについては :ref:`こちら <optparse-standard-option-"
"types>` を参照してください。"

#: ../../library/optparse.rst:1141 ../../library/optparse.rst:1191
msgid "(default: derived from option strings)"
msgstr "(デフォルト: オプション文字列を使う)"

#: ../../library/optparse.rst:1143
msgid ""
"If the option's action implies writing or modifying a value somewhere, this "
"tells :mod:`!optparse` where to write it: :attr:`~Option.dest` names an "
"attribute of the ``options`` object that :mod:`!optparse` builds as it "
"parses the command line."
msgstr ""

#: ../../library/optparse.rst:1150
msgid ""
"The value to use for this option's destination if the option is not seen on "
"the command line.  See also :meth:`OptionParser.set_defaults`."
msgstr ""
"コマンドラインに指定がなかったときにこのオプションの対象に使われる値です。 :"
"meth:`OptionParser.set_defaults` も参照してください。"

#: ../../library/optparse.rst:1155
msgid "(default: 1)"
msgstr "(デフォルト: 1)"

#: ../../library/optparse.rst:1157
msgid ""
"How many arguments of type :attr:`~Option.type` should be consumed when this "
"option is seen.  If > 1, :mod:`!optparse` will store a tuple of values to :"
"attr:`~Option.dest`."
msgstr ""

#: ../../library/optparse.rst:1163
msgid "For actions that store a constant value, the constant value to store."
msgstr "定数を格納する動作のための、その定数です。"

#: ../../library/optparse.rst:1167
msgid ""
"For options of type ``\"choice\"``, the list of strings the user may choose "
"from."
msgstr ""
"``\"choice\"`` 型オプションに対してユーザが選べる選択肢となる文字列のリストで"
"す。"

#: ../../library/optparse.rst:1172
msgid ""
"For options with action ``\"callback\"``, the callable to call when this "
"option is seen.  See section :ref:`optparse-option-callbacks` for detail on "
"the arguments passed to the callable."
msgstr ""
"アクションが ``\"callback\"`` であるオプションに対し、このオプションがあった"
"ときに呼ばれる呼び出し可能オブジェクトです。呼び出し時に渡される引数の詳細に"
"ついては、 :ref:`optparse-option-callbacks` を参照してください。"

#: ../../library/optparse.rst:1179
msgid ""
"Additional positional and keyword arguments to pass to ``callback`` after "
"the four standard callback arguments."
msgstr ""
"``callback`` に渡される標準的な4つのコールバック引数の後ろに追加する、位置引"
"数とキーワード引数。"

#: ../../library/optparse.rst:1184
msgid ""
"Help text to print for this option when listing all available options after "
"the user supplies a :attr:`~Option.help` option (such as ``--help``).  If no "
"help text is supplied, the option will be listed without help text.  To hide "
"this option, use the special value :const:`optparse.SUPPRESS_HELP`."
msgstr ""
"ユーザが :attr:`~Option.help` オプション(``--help`` のような)を指定したときに"
"表示される、使用可能な全オプションのリストの中のこのオプションに関する説明文"
"です。説明文を提供しておかなければ、オプションは説明文なしで表示されます。オ"
"プションを隠すには特殊な値 :const:`optparse.SUPPRESS_HELP` を使います。"

#: ../../library/optparse.rst:1193
msgid ""
"Stand-in for the option argument(s) to use when printing help text.  See "
"section :ref:`optparse-tutorial` for an example."
msgstr ""
"説明文を表示する際にオプションの引数の身代わりになるものです。例は :ref:"
"`optparse-tutorial` 節を参照してください。"

#: ../../library/optparse.rst:1200
msgid "Standard option actions"
msgstr "標準的なオプション・アクション"

#: ../../library/optparse.rst:1202
msgid ""
"The various option actions all have slightly different requirements and "
"effects. Most actions have several relevant option attributes which you may "
"specify to guide :mod:`!optparse`'s behaviour; a few have required "
"attributes, which you must specify for any option using that action."
msgstr ""

#: ../../library/optparse.rst:1207
msgid ""
"``\"store\"`` [relevant: :attr:`~Option.type`, :attr:`~Option.dest`, :attr:"
"`~Option.nargs`, :attr:`~Option.choices`]"
msgstr ""
"``\"store\"`` [関連: :attr:`~Option.type`, :attr:`~Option.dest`, :attr:"
"`~Option.nargs`, :attr:`~Option.choices`]"

#: ../../library/optparse.rst:1210
msgid ""
"The option must be followed by an argument, which is converted to a value "
"according to :attr:`~Option.type` and stored in :attr:`~Option.dest`.  If :"
"attr:`~Option.nargs` > 1, multiple arguments will be consumed from the "
"command line; all will be converted according to :attr:`~Option.type` and "
"stored to :attr:`~Option.dest` as a tuple.  See the :ref:`optparse-standard-"
"option-types` section."
msgstr ""
"オプションの後には必ず引数が続きます。引数は :attr:`~Option.type` に従って値"
"に変換されて :attr:`~Option.dest` に保存されます。 :attr:`~Option.nargs` > 1 "
"の場合、複数の引数をコマンドラインから取り出します。引数は全て :attr:"
"`~Option.type` に従って変換され、 :attr:`~Option.dest` にタプルとして保存され"
"ます。 :ref:`optparse-standard-option-types` 節を参照してください。"

#: ../../library/optparse.rst:1217
msgid ""
"If :attr:`~Option.choices` is supplied (a list or tuple of strings), the "
"type defaults to ``\"choice\"``."
msgstr ""
":attr:`~Option.choices` を(文字列のリストかタプルで) 指定した場合、型のデフォ"
"ルト値は ``\"choice\"`` になります。"

#: ../../library/optparse.rst:1220
msgid "If :attr:`~Option.type` is not supplied, it defaults to ``\"string\"``."
msgstr ""
":attr:`~Option.type` を指定しない場合、デフォルトの値は ``\"string\"`` です。"

#: ../../library/optparse.rst:1222
msgid ""
"If :attr:`~Option.dest` is not supplied, :mod:`!optparse` derives a "
"destination from the first long option string (e.g., ``--foo-bar`` implies "
"``foo_bar``). If there are no long option strings, :mod:`!optparse` derives "
"a destination from the first short option string (e.g., ``-f`` implies "
"``f``)."
msgstr ""

#: ../../library/optparse.rst:1227 ../../library/optparse.rst:1247
#: ../../library/optparse.rst:1269 ../../library/optparse.rst:1287
#: ../../library/optparse.rst:1326 ../../library/optparse.rst:1364
msgid "Example::"
msgstr "以下はプログラム例です::"

#: ../../library/optparse.rst:1229
msgid ""
"parser.add_option(\"-f\")\n"
"parser.add_option(\"-p\", type=\"float\", nargs=3, dest=\"point\")"
msgstr ""

#: ../../library/optparse.rst:1232
msgid "As it parses the command line ::"
msgstr "とすると、以下のようなコマンドライン ::"

#: ../../library/optparse.rst:1234
msgid "-f foo.txt -p 1 -3.5 4 -fbar.txt"
msgstr ""

#: ../../library/optparse.rst:1236
msgid ":mod:`!optparse` will set ::"
msgstr ""

#: ../../library/optparse.rst:1238
msgid ""
"options.f = \"foo.txt\"\n"
"options.point = (1.0, -3.5, 4.0)\n"
"options.f = \"bar.txt\""
msgstr ""

#: ../../library/optparse.rst:1242
msgid ""
"``\"store_const\"`` [required: :attr:`~Option.const`; relevant: :attr:"
"`~Option.dest`]"
msgstr ""
"``\"store_const\"`` [関連: :attr:`~Option.const`; 関連: :attr:`~Option.dest`]"

#: ../../library/optparse.rst:1245
msgid "The value :attr:`~Option.const` is stored in :attr:`~Option.dest`."
msgstr "値 :attr:`~Option.const` を :attr:`~Option.dest` に保存します。"

#: ../../library/optparse.rst:1249
msgid ""
"parser.add_option(\"-q\", \"--quiet\",\n"
"                  action=\"store_const\", const=0, dest=\"verbose\")\n"
"parser.add_option(\"-v\", \"--verbose\",\n"
"                  action=\"store_const\", const=1, dest=\"verbose\")\n"
"parser.add_option(\"--noisy\",\n"
"                  action=\"store_const\", const=2, dest=\"verbose\")"
msgstr ""

#: ../../library/optparse.rst:1256
msgid "If ``--noisy`` is seen, :mod:`!optparse` will set  ::"
msgstr ""

#: ../../library/optparse.rst:1258
msgid "options.verbose = 2"
msgstr ""

#: ../../library/optparse.rst:1260
msgid "``\"store_true\"`` [relevant: :attr:`~Option.dest`]"
msgstr "``\"store_true\"`` [関連: :attr:`~Option.dest`]"

#: ../../library/optparse.rst:1262
msgid ""
"A special case of ``\"store_const\"`` that stores ``True`` to :attr:`~Option."
"dest`."
msgstr ""

#: ../../library/optparse.rst:1265
msgid "``\"store_false\"`` [relevant: :attr:`~Option.dest`]"
msgstr "``\"store_false\"`` [関連: :attr:`~Option.dest`]"

#: ../../library/optparse.rst:1267
msgid "Like ``\"store_true\"``, but stores ``False``."
msgstr ""

#: ../../library/optparse.rst:1271
msgid ""
"parser.add_option(\"--clobber\", action=\"store_true\", dest=\"clobber\")\n"
"parser.add_option(\"--no-clobber\", action=\"store_false\", dest=\"clobber\")"
msgstr ""

#: ../../library/optparse.rst:1274
msgid ""
"``\"append\"`` [relevant: :attr:`~Option.type`, :attr:`~Option.dest`, :attr:"
"`~Option.nargs`, :attr:`~Option.choices`]"
msgstr ""
"``\"append\"`` [関連: :attr:`~Option.type`, :attr:`~Option.dest`, :attr:"
"`~Option.nargs`, :attr:`~Option.choices`]"

#: ../../library/optparse.rst:1277
msgid ""
"The option must be followed by an argument, which is appended to the list "
"in :attr:`~Option.dest`.  If no default value for :attr:`~Option.dest` is "
"supplied, an empty list is automatically created when :mod:`!optparse` first "
"encounters this option on the command-line.  If :attr:`~Option.nargs` > 1, "
"multiple arguments are consumed, and a tuple of length :attr:`~Option.nargs` "
"is appended to :attr:`~Option.dest`."
msgstr ""

#: ../../library/optparse.rst:1284
msgid ""
"The defaults for :attr:`~Option.type` and :attr:`~Option.dest` are the same "
"as for the ``\"store\"`` action."
msgstr ""
":attr:`~Option.type` および :attr:`~Option.dest` のデフォルト値は "
"``\"store\"`` アクションと同じです。"

#: ../../library/optparse.rst:1289
msgid ""
"parser.add_option(\"-t\", \"--tracks\", action=\"append\", type=\"int\")"
msgstr ""

#: ../../library/optparse.rst:1291
msgid ""
"If ``-t3`` is seen on the command-line, :mod:`!optparse` does the equivalent "
"of::"
msgstr ""

#: ../../library/optparse.rst:1294
msgid ""
"options.tracks = []\n"
"options.tracks.append(int(\"3\"))"
msgstr ""

#: ../../library/optparse.rst:1297
msgid "If, a little later on, ``--tracks=4`` is seen, it does::"
msgstr "その後、``--tracks=4`` が見つかると以下を実行します::"

#: ../../library/optparse.rst:1299
msgid "options.tracks.append(int(\"4\"))"
msgstr ""

#: ../../library/optparse.rst:1301
msgid ""
"The ``append`` action calls the ``append`` method on the current value of "
"the option.  This means that any default value specified must have an "
"``append`` method.  It also means that 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::"
msgstr ""
"``append`` アクションは、オプションの現在の値の ``append`` メソッドを呼び出し"
"ます。これは、どのデフォルト値も ``append`` メソッドを持っていなければならな"
"いことを意味します。また、デフォルト値が空でない場合、オプションの解析結果"
"は、そのデフォルトの要素の後ろにコマンドラインからの値が追加されたものにな"
"る、ということも意味します::"

#: ../../library/optparse.rst:1307
msgid ""
">>> parser.add_option(\"--files\", action=\"append\", default=['~/.mypkg/"
"defaults'])\n"
">>> opts, args = parser.parse_args(['--files', 'overrides.mypkg'])\n"
">>> opts.files\n"
"['~/.mypkg/defaults', 'overrides.mypkg']"
msgstr ""

#: ../../library/optparse.rst:1312
msgid ""
"``\"append_const\"`` [required: :attr:`~Option.const`; relevant: :attr:"
"`~Option.dest`]"
msgstr ""
"``\"append_const\"`` [関連: :attr:`~Option.const`; 関連: :attr:`~Option."
"dest`]"

#: ../../library/optparse.rst:1315
msgid ""
"Like ``\"store_const\"``, but the value :attr:`~Option.const` is appended "
"to :attr:`~Option.dest`; as with ``\"append\"``, :attr:`~Option.dest` "
"defaults to ``None``, and an empty list is automatically created the first "
"time the option is encountered."
msgstr ""
"``\"store_const\"`` と同様ですが、 :attr:`~Option.const` の値は :attr:"
"`~Option.dest` に追加(append)されます。 ``\"append\"`` の場合と同じように :"
"attr:`~Option.dest` のデフォルトは ``None`` ですがこのオプションを最初にみつ"
"けた時点で空のリストを自動的に生成します。"

#: ../../library/optparse.rst:1320
msgid "``\"count\"`` [relevant: :attr:`~Option.dest`]"
msgstr "``\"count\"`` [関連: :attr:`~Option.dest`]"

#: ../../library/optparse.rst:1322
msgid ""
"Increment the integer stored at :attr:`~Option.dest`.  If no default value "
"is supplied, :attr:`~Option.dest` is set to zero before being incremented "
"the first time."
msgstr ""
":attr:`~Option.dest` に保存されている整数値をインクリメントします。 :attr:"
"`~Option.dest` は (デフォルトの値を指定しない限り) 最初にインクリメントを行う"
"前にゼロに設定されます。"

#: ../../library/optparse.rst:1328
msgid "parser.add_option(\"-v\", action=\"count\", dest=\"verbosity\")"
msgstr ""

#: ../../library/optparse.rst:1330
msgid ""
"The first time ``-v`` is seen on the command line, :mod:`!optparse` does the "
"equivalent of::"
msgstr ""

#: ../../library/optparse.rst:1333
msgid ""
"options.verbosity = 0\n"
"options.verbosity += 1"
msgstr ""

#: ../../library/optparse.rst:1336
msgid "Every subsequent occurrence of ``-v`` results in  ::"
msgstr "以後、``-v`` が見つかるたびに ::"

#: ../../library/optparse.rst:1338
msgid "options.verbosity += 1"
msgstr ""

#: ../../library/optparse.rst:1340
msgid ""
"``\"callback\"`` [required: :attr:`~Option.callback`; relevant: :attr:"
"`~Option.type`, :attr:`~Option.nargs`, :attr:`~Option.callback_args`, :attr:"
"`~Option.callback_kwargs`]"
msgstr ""
"``\"callback\"`` [必須: :attr:`~Option.callback`; 関連: :attr:`~Option."
"type`, :attr:`~Option.nargs`, :attr:`~Option.callback_args`, :attr:`~Option."
"callback_kwargs`]"

#: ../../library/optparse.rst:1344
msgid ""
"Call the function specified by :attr:`~Option.callback`, which is called "
"as ::"
msgstr ":attr:`~Option.callback` に指定された関数を次のように呼び出します ::"

#: ../../library/optparse.rst:1346 ../../library/optparse.rst:1744
msgid "func(option, opt_str, value, parser, *args, **kwargs)"
msgstr ""

#: ../../library/optparse.rst:1348
msgid "See section :ref:`optparse-option-callbacks` for more detail."
msgstr "詳細は、 :ref:`optparse-option-callbacks` 節を参照してください。"

#: ../../library/optparse.rst:1352
msgid ""
"Prints a complete help message for all the options in the current option "
"parser.  The help message is constructed from the ``usage`` string passed to "
"OptionParser's constructor and the :attr:`~Option.help` string passed to "
"every option."
msgstr ""
"現在のオプションパーザ内の全てのオプションに対する完全なヘルプメッセージを出"
"力します。ヘルプメッセージは :class:`OptionParser` のコンストラクタに渡した "
"``usage``  文字列と、各オプションに渡した :attr:`~Option.help` 文字列から生成"
"します。"

#: ../../library/optparse.rst:1357
msgid ""
"If no :attr:`~Option.help` string is supplied for an option, it will still "
"be listed in the help message.  To omit an option entirely, use the special "
"value :const:`optparse.SUPPRESS_HELP`."
msgstr ""
"オプションに :attr:`~Option.help` 文字列が指定されていなくても、オプションは"
"ヘルプメッセージ中に列挙されます。オプションを完全に表示させないようにするに"
"は、特殊な値 :const:`optparse.SUPPRESS_HELP` を使ってください。"

#: ../../library/optparse.rst:1361
msgid ""
":mod:`!optparse` automatically adds a :attr:`~Option.help` option to all "
"OptionParsers, so you do not normally need to create one."
msgstr ""

#: ../../library/optparse.rst:1366
msgid ""
"from optparse import OptionParser, SUPPRESS_HELP\n"
"\n"
"# usually, a help option is added automatically, but that can\n"
"# be suppressed using the add_help_option argument\n"
"parser = OptionParser(add_help_option=False)\n"
"\n"
"parser.add_option(\"-h\", \"--help\", action=\"help\")\n"
"parser.add_option(\"-v\", action=\"store_true\", dest=\"verbose\",\n"
"                  help=\"Be moderately verbose\")\n"
"parser.add_option(\"--file\", dest=\"filename\",\n"
"                  help=\"Input file to read data from\")\n"
"parser.add_option(\"--secret\", help=SUPPRESS_HELP)"
msgstr ""

#: ../../library/optparse.rst:1379
msgid ""
"If :mod:`!optparse` sees either ``-h`` or ``--help`` on the command line, it "
"will print something like the following help message to stdout (assuming "
"``sys.argv[0]`` is ``\"foo.py\"``):"
msgstr ""

#: ../../library/optparse.rst:1383
msgid ""
"Usage: foo.py [options]\n"
"\n"
"Options:\n"
"  -h, --help        Show this help message and exit\n"
"  -v                Be moderately verbose\n"
"  --file=FILENAME   Input file to read data from"
msgstr ""

#: ../../library/optparse.rst:1392
msgid ""
"After printing the help message, :mod:`!optparse` terminates your process "
"with ``sys.exit(0)``."
msgstr ""

#: ../../library/optparse.rst:1395
msgid "``\"version\"``"
msgstr "``\"version\"``"

#: ../../library/optparse.rst:1397
msgid ""
"Prints the version number supplied to the OptionParser to stdout and exits. "
"The version number is actually formatted and printed by the "
"``print_version()`` method of OptionParser.  Generally only relevant if the "
"``version`` argument is supplied to the OptionParser constructor.  As with :"
"attr:`~Option.help` options, you will rarely create ``version`` options, "
"since :mod:`!optparse` automatically adds them when needed."
msgstr ""

#: ../../library/optparse.rst:1408
msgid "Standard option types"
msgstr "標準のオプション型"

#: ../../library/optparse.rst:1410
msgid ""
":mod:`!optparse` has five built-in option types: ``\"string\"``, "
"``\"int\"``, ``\"choice\"``, ``\"float\"`` and ``\"complex\"``.  If you need "
"to add new option types, see section :ref:`optparse-extending-optparse`."
msgstr ""

#: ../../library/optparse.rst:1414
msgid ""
"Arguments to string options are not checked or converted in any way: the "
"text on the command line is stored in the destination (or passed to the "
"callback) as-is."
msgstr ""
"文字列オプションの引数はチェックや変換を一切受けません: コマンドライン上のテ"
"キストは保存先にそのまま保存されます (またはコールバックに渡されます)。"

#: ../../library/optparse.rst:1417
msgid "Integer arguments (type ``\"int\"``) are parsed as follows:"
msgstr "整数引数 (``\"int\"`` 型) は次のように解析されます:"

#: ../../library/optparse.rst:1419
msgid "if the number starts with ``0x``, it is parsed as a hexadecimal number"
msgstr "数が ``0x`` から始まるならば、16進数として読み取られます"

#: ../../library/optparse.rst:1421
msgid "if the number starts with ``0``, it is parsed as an octal number"
msgstr "数が ``0`` から始まるならば、8進数として読み取られます"

#: ../../library/optparse.rst:1423
msgid "if the number starts with ``0b``, it is parsed as a binary number"
msgstr "数が ``0b`` から始まるならば、2進数として読み取られます"

#: ../../library/optparse.rst:1425
msgid "otherwise, the number is parsed as a decimal number"
msgstr "それ以外の場合、数は10進数として読み取られます"

#: ../../library/optparse.rst:1428
msgid ""
"The conversion is done by calling :func:`int` with the appropriate base (2, "
"8, 10, or 16).  If this fails, so will :mod:`!optparse`, although with a "
"more useful error message."
msgstr ""

#: ../../library/optparse.rst:1432
msgid ""
"``\"float\"`` and ``\"complex\"`` option arguments are converted directly "
"with :func:`float` and :func:`complex`, with similar error-handling."
msgstr ""
"``\"float\"`` および ``\"complex\"`` のオプション引数は直接 :func:`float` "
"や :func:`complex` で変換されます。エラーは同様の扱いです。"

#: ../../library/optparse.rst:1435
msgid ""
"``\"choice\"`` options are a subtype of ``\"string\"`` options.  The :attr:"
"`~Option.choices` option attribute (a sequence of strings) defines the set "
"of allowed option arguments.  :func:`optparse.check_choice` compares user-"
"supplied option arguments against this master list and raises :exc:"
"`OptionValueError` if an invalid string is given."
msgstr ""
"``\"choice\"`` オプションは ``\"string\"`` オプションのサブタイプです。 :"
"attr:`~Option.choices` オプションの属性 (文字列からなるシーケンス) には、利用"
"できるオプション引数のセットを指定します。 :func:`optparse.check_choice` は"
"ユーザの指定したオプション引数とマスタリストを比較して、無効な文字列が指定さ"
"れた場合には :exc:`OptionValueError` を送出します。"

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

#: ../../library/optparse.rst:1447
msgid ""
"The whole point of creating and populating an OptionParser is to call its :"
"meth:`~OptionParser.parse_args` method."
msgstr ""
"OptionParser を作成してオプションを追加していく上で大事なポイントは、 :meth:"
"`~OptionParser.parse_args` メソッドの呼び出しです。"

#: ../../library/optparse.rst:1452
msgid "Parse the command-line options found in *args*."
msgstr ""

#: ../../library/optparse.rst:1454
msgid "The input parameters are"
msgstr ""

#: ../../library/optparse.rst:1456 ../../library/optparse.rst:1470
#: ../../library/optparse.rst:1788
msgid "``args``"
msgstr "``args``"

#: ../../library/optparse.rst:1457
msgid "the list of arguments to process (default: ``sys.argv[1:]``)"
msgstr "処理する引数のリスト (デフォルト: ``sys.argv[1:]``)"

#: ../../library/optparse.rst:1459
msgid "``values``"
msgstr "``values``"

#: ../../library/optparse.rst:1460
msgid ""
"a :class:`Values` object to store option arguments in (default: a new "
"instance of :class:`Values`) -- if you give an existing object, the option "
"defaults will not be initialized on it"
msgstr ""
"オプション引数を格納する :class:`Values` のオブジェクト (デフォルト: 新しい :"
"class:`Values` のインスタンス) -- 既存のオブジェクトを指定した場合、オプショ"
"ンのデフォルトは初期化されません"

#: ../../library/optparse.rst:1464
msgid "and the return value is a pair ``(options, args)`` where"
msgstr ""

#: ../../library/optparse.rst:1466
msgid "``options``"
msgstr "``options``"

#: ../../library/optparse.rst:1467
msgid ""
"the same object that was passed in as *values*, or the ``optparse.Values`` "
"instance created by :mod:`!optparse`"
msgstr ""

#: ../../library/optparse.rst:1471
msgid "the leftover positional arguments after all options have been processed"
msgstr "全てのオプションの処理が終わった後で残った位置引数"

#: ../../library/optparse.rst:1473
msgid ""
"The most common usage is to supply neither keyword argument.  If you supply "
"``values``, it will be modified with repeated :func:`setattr` calls (roughly "
"one for every option argument stored to an option destination) and returned "
"by :meth:`~OptionParser.parse_args`."
msgstr ""
"一番普通の使い方は一切キーワード引数を使わないというものです。 ``values`` を"
"指定した場合、それは繰り返される :func:`setattr` の呼び出し (大雑把に言うと保"
"存される各オプション引数につき一回ずつ) で更新されていき、 :meth:"
"`~OptionParser.parse_args` で返されます。"

#: ../../library/optparse.rst:1478
msgid ""
"If :meth:`~OptionParser.parse_args` encounters any errors in the argument "
"list, it calls the OptionParser's :meth:`error` method with an appropriate "
"end-user error message. This ultimately terminates your process with an exit "
"status of 2 (the traditional Unix exit status for command-line errors)."
msgstr ""
":meth:`~OptionParser.parse_args` が引数リストでエラーに遭遇した場合、 "
"OptionParser の :meth:`error` メソッドを適切なエンドユーザ向けのエラーメッ"
"セージとともに呼び出します。この呼び出しにより、最終的に終了ステータス 2 (伝"
"統的な Unix におけるコマンドラインエラーの終了ステータス) でプロセスを終了さ"
"せることになります。"

#: ../../library/optparse.rst:1487
msgid "Querying and manipulating your option parser"
msgstr "オプション解析器への問い合わせと操作"

#: ../../library/optparse.rst:1489
msgid ""
"The default behavior of the option parser can be customized slightly, and "
"you can also poke around your option parser and see what's there.  "
"OptionParser provides several methods to help you out:"
msgstr ""
"オプションパーザのデフォルトの振る舞いは、ある程度カスタマイズすることができ"
"ます。また、オプションパーザの中を調べることもできます。:class:"
"`OptionParser` は幾つかのヘルパーメソッドを提供しています:"

#: ../../library/optparse.rst:1495
msgid ""
"Set parsing to stop on the first non-option.  For example, if ``-a`` and ``-"
"b`` are both simple options that take no arguments, :mod:`!optparse` "
"normally accepts this syntax::"
msgstr ""

#: ../../library/optparse.rst:1499
msgid "prog -a arg1 -b arg2"
msgstr ""

#: ../../library/optparse.rst:1501
msgid "and treats it as equivalent to  ::"
msgstr "それを次と同じように扱います ::"

#: ../../library/optparse.rst:1503
msgid "prog -a -b arg1 arg2"
msgstr ""

#: ../../library/optparse.rst:1505
msgid ""
"To disable this feature, call :meth:`disable_interspersed_args`.  This "
"restores traditional Unix syntax, where option parsing stops with the first "
"non-option argument."
msgstr ""
"この機能を無効にしたいときは、 :meth:`disable_interspersed_args` メソッドを呼"
"び出してください。古典的な Unix システムのように、最初のオプションでない引数"
"を見つけたときにオプションの解析を止めるようになります。"

#: ../../library/optparse.rst:1509
msgid ""
"Use this if you have a command processor which runs another command which "
"has options of its own and you want to make sure these options don't get "
"confused.  For example, each command might have a different set of options."
msgstr ""
"別のコマンドを実行するコマンドをプロセッサを作成する際、別のコマンドのオプ"
"ションと自身のオプションが混ざるのを防ぐために利用することができます。例え"
"ば、各コマンドがそれぞれ異なるオプションのセットを持つ場合などに有効です。"

#: ../../library/optparse.rst:1515
msgid ""
"Set parsing to not stop on the first non-option, allowing interspersing "
"switches with command arguments.  This is the default behavior."
msgstr ""
"オプションで無い最初の引数を見つけてもパースを止めないように設定します。オプ"
"ションとコマンド引数の順序が混ざっても良いようになります。これはデフォルトの"
"動作です。"

#: ../../library/optparse.rst:1520
msgid ""
"Returns the Option instance with the option string *opt_str*, or ``None`` if "
"no options have that option string."
msgstr ""
"オプション文字列 *opt_str* に対する :class:`Option` インスタンスを返します。"
"該当するオプションがなければ ``None`` を返します。"

#: ../../library/optparse.rst:1525
msgid ""
"Return ``True`` if the OptionParser has an option with option string "
"*opt_str* (e.g., ``-q`` or ``--verbose``)."
msgstr ""
":class:`OptionParser` に(``-q`` や ``--verbose`` のような) オプション "
"*opt_str* がある場合、``True`` を返します。"

#: ../../library/optparse.rst:1530
msgid ""
"If the :class:`OptionParser` has an option corresponding to *opt_str*, that "
"option is removed.  If that option provided any other option strings, all of "
"those option strings become invalid. If *opt_str* does not occur in any "
"option belonging to this :class:`OptionParser`, raises :exc:`ValueError`."
msgstr ""
":class:`OptionParser` に *opt_str* に対応するオプションがある場合、そのオプ"
"ションを削除します。該当するオプションに他のオプション文字列が指定されていた"
"場合、それらのオプション文字列は全て無効になります。 *opt_str* がこの :class:"
"`OptionParser` オブジェクトのどのオプションにも属さない場合、 :exc:"
"`ValueError` を送出します。"

#: ../../library/optparse.rst:1539
msgid "Conflicts between options"
msgstr "オプション間の衝突"

#: ../../library/optparse.rst:1541
msgid ""
"If you're not careful, it's easy to define options with conflicting option "
"strings::"
msgstr "注意が足りないと、衝突するオプションを定義してしまうことがあります::"

#: ../../library/optparse.rst:1544
msgid ""
"parser.add_option(\"-n\", \"--dry-run\", ...)\n"
"...\n"
"parser.add_option(\"-n\", \"--noisy\", ...)"
msgstr ""

#: ../../library/optparse.rst:1548
msgid ""
"(This is particularly true if you've defined your own OptionParser subclass "
"with some standard options.)"
msgstr ""
"(とりわけ、:class:`OptionParser` から標準的なオプションを備えた自前のサブクラ"
"スを定義してしまった場合にはよく起きます。)"

#: ../../library/optparse.rst:1551
msgid ""
"Every time you add an option, :mod:`!optparse` checks for conflicts with "
"existing options.  If it finds any, it invokes the current conflict-handling "
"mechanism. You can set the conflict-handling mechanism either in the "
"constructor::"
msgstr ""

#: ../../library/optparse.rst:1555
msgid "parser = OptionParser(..., conflict_handler=handler)"
msgstr ""

#: ../../library/optparse.rst:1557
msgid "or with a separate call::"
msgstr "個別にも呼び出せます::"

#: ../../library/optparse.rst:1559
msgid "parser.set_conflict_handler(handler)"
msgstr ""

#: ../../library/optparse.rst:1561
msgid "The available conflict handlers are:"
msgstr "衝突時の処理をおこなうハンドラ(handler)には、以下のものが利用できます:"

#: ../../library/optparse.rst:1563
msgid "``\"error\"`` (default)"
msgstr "``\"error\"`` (デフォルト)"

#: ../../library/optparse.rst:1564
msgid ""
"assume option conflicts are a programming error and raise :exc:"
"`OptionConflictError`"
msgstr ""
"オプション間の衝突をプログラム上のエラーとみなし、 :exc:"
"`OptionConflictError` を送出します"

#: ../../library/optparse.rst:1567
msgid "``\"resolve\"``"
msgstr "``\"resolve\"``"

#: ../../library/optparse.rst:1568
msgid "resolve option conflicts intelligently (see below)"
msgstr "オプション間の衝突をインテリジェントに解決します (下記参照)"

#: ../../library/optparse.rst:1571
msgid ""
"As an example, let's define an :class:`OptionParser` that resolves conflicts "
"intelligently and add conflicting options to it::"
msgstr ""
"一例として、衝突をインテリジェントに解決する :class:`OptionParser` を定義し、"
"衝突を起こすようなオプションを追加してみましょう::"

#: ../../library/optparse.rst:1574
msgid ""
"parser = OptionParser(conflict_handler=\"resolve\")\n"
"parser.add_option(\"-n\", \"--dry-run\", ..., help=\"do no harm\")\n"
"parser.add_option(\"-n\", \"--noisy\", ..., help=\"be noisy\")"
msgstr ""

#: ../../library/optparse.rst:1578
msgid ""
"At this point, :mod:`!optparse` detects that a previously added option is "
"already using the ``-n`` option string.  Since ``conflict_handler`` is "
"``\"resolve\"``, it resolves the situation by removing ``-n`` from the "
"earlier option's list of option strings.  Now ``--dry-run`` is the only way "
"for the user to activate that option.  If the user asks for help, the help "
"message will reflect that::"
msgstr ""

#: ../../library/optparse.rst:1584
msgid ""
"Options:\n"
"  --dry-run     do no harm\n"
"  ...\n"
"  -n, --noisy   be noisy"
msgstr ""

#: ../../library/optparse.rst:1589
msgid ""
"It's possible to whittle away the option strings for a previously added "
"option until there are none left, and the user has no way of invoking that "
"option from the command-line.  In that case, :mod:`!optparse` removes that "
"option completely, so it doesn't show up in help text or anywhere else. "
"Carrying on with our existing OptionParser::"
msgstr ""

#: ../../library/optparse.rst:1595
msgid "parser.add_option(\"--dry-run\", ..., help=\"new dry-run option\")"
msgstr ""

#: ../../library/optparse.rst:1597
msgid ""
"At this point, the original ``-n``/``--dry-run`` option is no longer "
"accessible, so :mod:`!optparse` removes it, leaving this help text::"
msgstr ""

#: ../../library/optparse.rst:1600
msgid ""
"Options:\n"
"  ...\n"
"  -n, --noisy   be noisy\n"
"  --dry-run     new dry-run option"
msgstr ""

#: ../../library/optparse.rst:1609
msgid "Cleanup"
msgstr "クリーンアップ"

#: ../../library/optparse.rst:1611
msgid ""
"OptionParser instances have several cyclic references.  This should not be a "
"problem for Python's garbage collector, but you may wish to break the cyclic "
"references explicitly by calling :meth:`~OptionParser.destroy` on your "
"OptionParser once you are done with it.  This is particularly useful in long-"
"running applications where large object graphs are reachable from your "
"OptionParser."
msgstr ""
"OptionParser インスタンスはいくつかの循環参照を抱えています。このことは "
"Python のガーベジコレクタにとって問題になるわけではありませんが、使い終わっ"
"た OptionParser に対して :meth:`~OptionParser.destroy` を呼び出すことでこの循"
"環参照を意図的に断ち切るという方法を選ぶこともできます。この方法は特に長時間"
"実行するアプリケーションで OptionParser から大きなオブジェクトグラフが到達可"
"能になっているような場合に有用です。"

#: ../../library/optparse.rst:1622
msgid "Other methods"
msgstr "その他のメソッド"

#: ../../library/optparse.rst:1624
msgid "OptionParser supports several other public methods:"
msgstr "OptionParser にはその他にも幾つかの公開されたメソッドがあります:"

#: ../../library/optparse.rst:1628
msgid ""
"Set the usage string according to the rules described above for the "
"``usage`` constructor keyword argument.  Passing ``None`` sets the default "
"usage string; use :const:`optparse.SUPPRESS_USAGE` to suppress a usage "
"message."
msgstr ""
"上で説明したコンストラクタの ``usage`` キーワード引数での規則に従った使用法の"
"文字列をセットします。 ``None`` を渡すとデフォルトの使用法文字列が使われるよ"
"うになり、 :const:`optparse.SUPPRESS_USAGE` によって使用法メッセージを抑制で"
"きます。"

#: ../../library/optparse.rst:1634
msgid ""
"Print the usage message for the current program (``self.usage``) to *file* "
"(default stdout).  Any occurrence of the string ``%prog`` in ``self.usage`` "
"is replaced with the name of the current program.  Does nothing if ``self."
"usage`` is empty or not defined."
msgstr ""
"現在のプログラムの使用法メッセージ (``self.usage``) を *file* (デフォルト: "
"stdout) に表示します。``self.usage`` 内にある全ての ``%prog`` という文字列は"
"現在のプログラム名に置換されます。``self.usage`` が空もしくは未定義の時は何も"
"しません。"

#: ../../library/optparse.rst:1641
msgid ""
"Same as :meth:`print_usage` but returns the usage string instead of printing "
"it."
msgstr ""
":meth:`print_usage` と同じですが、使用法メッセージを表示する代わりに文字列と"
"して返します。"

#: ../../library/optparse.rst:1646
msgid ""
"Set default values for several option destinations at once.  Using :meth:"
"`set_defaults` is the preferred way to set default values for options, since "
"multiple options can share the same destination.  For example, if several "
"\"mode\" options all set the same destination, any one of them can set the "
"default, and the last one wins::"
msgstr ""
"幾つかの保存先に対してデフォルト値をまとめてセットします。 :meth:"
"`set_defaults` を使うのは複数のオプションにデフォルト値をセットする好ましいや"
"り方です。複数のオプションが同じ保存先を共有することがあり得るからです。たと"
"えば幾つかの \"mode\" オプションが全て同じ保存先をセットするものだったとする"
"と、どのオプションもデフォルトをセットすることができ、しかし最後に指定したも"
"のだけが有効になります::"

#: ../../library/optparse.rst:1652
msgid ""
"parser.add_option(\"--advanced\", action=\"store_const\",\n"
"                  dest=\"mode\", const=\"advanced\",\n"
"                  default=\"novice\")    # overridden below\n"
"parser.add_option(\"--novice\", action=\"store_const\",\n"
"                  dest=\"mode\", const=\"novice\",\n"
"                  default=\"advanced\")  # overrides above setting"
msgstr ""

#: ../../library/optparse.rst:1659
msgid "To avoid this confusion, use :meth:`set_defaults`::"
msgstr "こうした混乱を避けるために :meth:`set_defaults` を使います::"

#: ../../library/optparse.rst:1661
msgid ""
"parser.set_defaults(mode=\"advanced\")\n"
"parser.add_option(\"--advanced\", action=\"store_const\",\n"
"                  dest=\"mode\", const=\"advanced\")\n"
"parser.add_option(\"--novice\", action=\"store_const\",\n"
"                  dest=\"mode\", const=\"novice\")"
msgstr ""

#: ../../library/optparse.rst:1671
msgid "Option Callbacks"
msgstr "オプション処理コールバック"

#: ../../library/optparse.rst:1673
msgid ""
"When :mod:`!optparse`'s built-in actions and types aren't quite enough for "
"your needs, you have two choices: extend :mod:`!optparse` or define a "
"callback option. Extending :mod:`!optparse` is more general, but overkill "
"for a lot of simple cases.  Quite often a simple callback is all you need."
msgstr ""

#: ../../library/optparse.rst:1678
msgid "There are two steps to defining a callback option:"
msgstr "``callback`` オプションの定義は二つのステップからなります:"

#: ../../library/optparse.rst:1680
msgid "define the option itself using the ``\"callback\"`` action"
msgstr "``\"callback\"`` アクションを使ってオプション自体を定義する"

#: ../../library/optparse.rst:1682
msgid ""
"write the callback; this is a function (or method) that takes at least four "
"arguments, as described below"
msgstr ""
"コールバックを書く。コールバックは少なくとも後で説明する 4 つの引数をとる関"
"数 (またはメソッド) でなければなりません"

#: ../../library/optparse.rst:1689
msgid "Defining a callback option"
msgstr "callbackオプションの定義"

#: ../../library/optparse.rst:1691
msgid ""
"As always, the easiest way to define a callback option is by using the :meth:"
"`OptionParser.add_option` method.  Apart from :attr:`~Option.action`, the "
"only option attribute you must specify is ``callback``, the function to "
"call::"
msgstr ""
"callback オプションを最も簡単に定義するには、 :meth:`OptionParser."
"add_option` メソッドを使います。 :attr:`~Option.action` の他に指定しなければ"
"ならない属性は ``callback`` すなわちコールバックする関数自体です::"

#: ../../library/optparse.rst:1695
msgid "parser.add_option(\"-c\", action=\"callback\", callback=my_callback)"
msgstr ""

#: ../../library/optparse.rst:1697
msgid ""
"``callback`` is a function (or other callable object), so you must have "
"already defined ``my_callback()`` when you create this callback option. In "
"this simple case, :mod:`!optparse` doesn't even know if ``-c`` takes any "
"arguments, which usually means that the option takes no arguments---the mere "
"presence of ``-c`` on the command-line is all it needs to know.  In some "
"circumstances, though, you might want your callback to consume an arbitrary "
"number of command-line arguments.  This is where writing callbacks gets "
"tricky; it's covered later in this section."
msgstr ""

#: ../../library/optparse.rst:1706
msgid ""
":mod:`!optparse` always passes four particular arguments to your callback, "
"and it will only pass additional arguments if you specify them via :attr:"
"`~Option.callback_args` and :attr:`~Option.callback_kwargs`.  Thus, the "
"minimal callback function signature is::"
msgstr ""

#: ../../library/optparse.rst:1711
msgid "def my_callback(option, opt, value, parser):"
msgstr ""

#: ../../library/optparse.rst:1713
msgid "The four arguments to a callback are described below."
msgstr "コールバックの四つの引数については後で説明します。"

#: ../../library/optparse.rst:1715
msgid ""
"There are several other option attributes that you can supply when you "
"define a callback option:"
msgstr ""
"callback オプションを定義する場合には、他にもいくつかオプション属性を指定でき"
"ます:"

#: ../../library/optparse.rst:1718
msgid ":attr:`~Option.type`"
msgstr ":attr:`~Option.type`"

#: ../../library/optparse.rst:1719
msgid ""
"has its usual meaning: as with the ``\"store\"`` or ``\"append\"`` actions, "
"it instructs :mod:`!optparse` to consume one argument and convert it to :"
"attr:`~Option.type`.  Rather than storing the converted value(s) anywhere, "
"though, :mod:`!optparse` passes it to your callback function."
msgstr ""

#: ../../library/optparse.rst:1724
msgid ":attr:`~Option.nargs`"
msgstr ":attr:`~Option.nargs`"

#: ../../library/optparse.rst:1725
msgid ""
"also has its usual meaning: if it is supplied and > 1, :mod:`!optparse` will "
"consume :attr:`~Option.nargs` arguments, each of which must be convertible "
"to :attr:`~Option.type`.  It then passes a tuple of converted values to your "
"callback."
msgstr ""

#: ../../library/optparse.rst:1730
msgid ":attr:`~Option.callback_args`"
msgstr ":attr:`~Option.callback_args`"

#: ../../library/optparse.rst:1731
msgid "a tuple of extra positional arguments to pass to the callback"
msgstr "その他の位置引数からなるタプルで、コールバックに渡されます"

#: ../../library/optparse.rst:1733
msgid ":attr:`~Option.callback_kwargs`"
msgstr ":attr:`~Option.callback_kwargs`"

#: ../../library/optparse.rst:1734
msgid "a dictionary of extra keyword arguments to pass to the callback"
msgstr "その他のキーワード引数からなる辞書で、コールバックに渡されます"

#: ../../library/optparse.rst:1740
msgid "How callbacks are called"
msgstr "コールバック関数はどのように呼び出されるか"

#: ../../library/optparse.rst:1742
msgid "All callbacks are called as follows::"
msgstr "コールバックは全て以下の形式で呼び出されます::"

#: ../../library/optparse.rst:1748
msgid "``option``"
msgstr "``option``"

#: ../../library/optparse.rst:1749
msgid "is the Option instance that's calling the callback"
msgstr "コールバックを呼び出している :class:`Option` のインスタンスです"

#: ../../library/optparse.rst:1751
msgid "``opt_str``"
msgstr "``opt_str``"

#: ../../library/optparse.rst:1752
msgid ""
"is the option string seen on the command-line that's triggering the "
"callback. (If an abbreviated long option was used, ``opt_str`` will be the "
"full, canonical option string---e.g. if the user puts ``--foo`` on the "
"command-line as an abbreviation for ``--foobar``, then ``opt_str`` will be "
"``\"--foobar\"``.)"
msgstr ""
"は、コールバック呼び出しのきっかけとなったコマンドライン上のオプション文字列"
"です。(長い形式のオプションに対する省略形が使われている場合、``opt_str`` は完"
"全な、正式な形のオプション文字列となります --- 例えば、ユーザが ``--foobar`` "
"の短縮形として ``--foo`` をコマンドラインに入力した時には、``opt_str`` は "
"``\"--foobar\"`` となります。)"

#: ../../library/optparse.rst:1758
msgid "``value``"
msgstr "``value``"

#: ../../library/optparse.rst:1759
msgid ""
"is the argument to this option seen on the command-line.  :mod:`!optparse` "
"will only expect an argument if :attr:`~Option.type` is set; the type of "
"``value`` will be the type implied by the option's type.  If :attr:`~Option."
"type` for this option is ``None`` (no argument expected), then ``value`` "
"will be ``None``.  If :attr:`~Option.nargs` > 1, ``value`` will be a tuple "
"of values of the appropriate type."
msgstr ""

#: ../../library/optparse.rst:1765
msgid "``parser``"
msgstr "``parser``"

#: ../../library/optparse.rst:1766
msgid ""
"is the OptionParser instance driving the whole thing, mainly useful because "
"you can access some other interesting data through its instance attributes:"
msgstr ""
"現在のオプション解析の全てを駆動している :class:`OptionParser` インスタンスで"
"す。この変数が有用なのは、この値を介してインスタンス属性としていくつかの興味"
"深いデータにアクセスできるからです:"

#: ../../library/optparse.rst:1769
msgid "``parser.largs``"
msgstr "``parser.largs``"

#: ../../library/optparse.rst:1770
msgid ""
"the current list of leftover arguments, ie. arguments that have been "
"consumed but are neither options nor option arguments. Feel free to modify "
"``parser.largs``, e.g. by adding more arguments to it.  (This list will "
"become ``args``, the second return value of :meth:`~OptionParser."
"parse_args`.)"
msgstr ""
"現在放置されている引数、すなわち、すでに消費されたものの、オプションでもオプ"
"ション引数でもない引数からなるリストです。 ``parser.largs`` は自由に変更で"
"き、たとえば引数を追加したりできます (このリストは ``args`` 、すなわち :meth:"
"`~OptionParser.parse_args` の二つ目の戻り値になります)"

#: ../../library/optparse.rst:1775
msgid "``parser.rargs``"
msgstr "``parser.rargs``"

#: ../../library/optparse.rst:1776
msgid ""
"the current list of remaining arguments, ie. with ``opt_str`` and ``value`` "
"(if applicable) removed, and only the arguments following them still there.  "
"Feel free to modify ``parser.rargs``, e.g. by consuming more arguments."
msgstr ""
"現在残っている引数、すなわち、``opt_str`` および ``value`` があれば除き、それ"
"以外の引数が残っているリストです。``parser.rargs`` は自由に変更でき、例えばさ"
"らに引数を消費したりできます。"

#: ../../library/optparse.rst:1781
msgid "``parser.values``"
msgstr "``parser.values``"

#: ../../library/optparse.rst:1782
msgid ""
"the object where option values are by default stored (an instance of "
"optparse.OptionValues).  This lets callbacks use the same mechanism as the "
"rest of :mod:`!optparse` for storing option values; you don't need to mess "
"around with globals or closures.  You can also access or modify the value(s) "
"of any options already encountered on the command-line."
msgstr ""

#: ../../library/optparse.rst:1789
msgid ""
"is a tuple of arbitrary positional arguments supplied via the :attr:`~Option."
"callback_args` option attribute."
msgstr ""
":attr:`~Option.callback_args` オプション属性で与えられた任意の位置引数からな"
"るタプルです。"

#: ../../library/optparse.rst:1792
msgid "``kwargs``"
msgstr "``kwargs``"

#: ../../library/optparse.rst:1793
msgid ""
"is a dictionary of arbitrary keyword arguments supplied via :attr:`~Option."
"callback_kwargs`."
msgstr ""
":attr:`~Option.callback_kwargs` オプション属性で与えられた任意のキーワード引"
"数からなるタプルです。"

#: ../../library/optparse.rst:1800
msgid "Raising errors in a callback"
msgstr "コールバック中で例外を送出する"

#: ../../library/optparse.rst:1802
msgid ""
"The callback function should raise :exc:`OptionValueError` if there are any "
"problems with the option or its argument(s).  :mod:`!optparse` catches this "
"and terminates the program, printing the error message you supply to "
"stderr.  Your message should be clear, concise, accurate, and mention the "
"option at fault. Otherwise, the user will have a hard time figuring out what "
"they did wrong."
msgstr ""

#: ../../library/optparse.rst:1812
msgid "Callback example 1: trivial callback"
msgstr "コールバックの例 1: ありふれたコールバック"

#: ../../library/optparse.rst:1814
msgid ""
"Here's an example of a callback option that takes no arguments, and simply "
"records that the option was seen::"
msgstr ""
"引数をとらず、発見したオプションを単に記録するだけのコールバックオプションの"
"例を以下に示します::"

#: ../../library/optparse.rst:1817
msgid ""
"def record_foo_seen(option, opt_str, value, parser):\n"
"    parser.values.saw_foo = True\n"
"\n"
"parser.add_option(\"--foo\", action=\"callback\", callback=record_foo_seen)"
msgstr ""

#: ../../library/optparse.rst:1822
msgid "Of course, you could do that with the ``\"store_true\"`` action."
msgstr "もちろん、``\"store_true\"`` アクションを使っても実現できます。"

#: ../../library/optparse.rst:1828
msgid "Callback example 2: check option order"
msgstr "コールバックの例 2: オプションの順番をチェックする"

#: ../../library/optparse.rst:1830
msgid ""
"Here's a slightly more interesting example: record the fact that ``-a`` is "
"seen, but blow up if it comes after ``-b`` in the command-line.  ::"
msgstr ""
"もう少し面白みのある例を示します: この例では、``-b`` を発見して、その後で ``-"
"a`` がコマンドライン中に現れた場合にはエラーになります。 ::"

#: ../../library/optparse.rst:1833
msgid ""
"def check_order(option, opt_str, value, parser):\n"
"    if parser.values.b:\n"
"        raise OptionValueError(\"can't use -a after -b\")\n"
"    parser.values.a = 1\n"
"...\n"
"parser.add_option(\"-a\", action=\"callback\", callback=check_order)\n"
"parser.add_option(\"-b\", action=\"store_true\", dest=\"b\")"
msgstr ""

#: ../../library/optparse.rst:1845
msgid "Callback example 3: check option order (generalized)"
msgstr "コールバックの例 3: オプションの順番をチェックする (汎用的)"

#: ../../library/optparse.rst:1847
msgid ""
"If you want to reuse this callback for several similar options (set a flag, "
"but blow up if ``-b`` has already been seen), it needs a bit of work: the "
"error message and the flag that it sets must be generalized.  ::"
msgstr ""
"このコールバック (フラグを立てるが、``-b`` が既に指定されていればエラーにな"
"る) を同様の複数のオプションに対して再利用したければ、もう少し作業する必要が"
"あります: エラーメッセージとセットされるフラグを一般化しなければなりませ"
"ん。 ::"

#: ../../library/optparse.rst:1851
msgid ""
"def check_order(option, opt_str, value, parser):\n"
"    if parser.values.b:\n"
"        raise OptionValueError(\"can't use %s after -b\" % opt_str)\n"
"    setattr(parser.values, option.dest, 1)\n"
"...\n"
"parser.add_option(\"-a\", action=\"callback\", callback=check_order, "
"dest='a')\n"
"parser.add_option(\"-b\", action=\"store_true\", dest=\"b\")\n"
"parser.add_option(\"-c\", action=\"callback\", callback=check_order, "
"dest='c')"
msgstr ""

#: ../../library/optparse.rst:1864
msgid "Callback example 4: check arbitrary condition"
msgstr "コールバックの例 4: 任意の条件をチェックする"

#: ../../library/optparse.rst:1866
msgid ""
"Of course, you could put any condition in there---you're not limited to "
"checking the values of already-defined options.  For example, if you have "
"options that should not be called when the moon is full, all you have to do "
"is this::"
msgstr ""
"もちろん、単に定義済みのオプションの値を調べるだけにとどまらず、コールバック"
"には任意の条件を入れられます。例えば、満月でなければ呼び出してはならないオプ"
"ションがあるとしましょう。やらなければならないことはこれだけです::"

#: ../../library/optparse.rst:1870
msgid ""
"def check_moon(option, opt_str, value, parser):\n"
"    if is_moon_full():\n"
"        raise OptionValueError(\"%s option invalid when moon is full\"\n"
"                               % opt_str)\n"
"    setattr(parser.values, option.dest, 1)\n"
"...\n"
"parser.add_option(\"--foo\",\n"
"                  action=\"callback\", callback=check_moon, dest=\"foo\")"
msgstr ""

#: ../../library/optparse.rst:1879
msgid ""
"(The definition of ``is_moon_full()`` is left as an exercise for the reader.)"
msgstr "(``is_moon_full()`` の定義は読者への課題としましょう。)"

#: ../../library/optparse.rst:1885
msgid "Callback example 5: fixed arguments"
msgstr "コールバックの例5: 固定引数"

#: ../../library/optparse.rst:1887
msgid ""
"Things get slightly more interesting when you define callback options that "
"take a fixed number of arguments.  Specifying that a callback option takes "
"arguments is similar to defining a ``\"store\"`` or ``\"append\"`` option: "
"if you define :attr:`~Option.type`, then the option takes one argument that "
"must be convertible to that type; if you further define :attr:`~Option."
"nargs`, then the option takes :attr:`~Option.nargs` arguments."
msgstr ""
"決まった数の引数をとるようなコールパックオプションを定義するなら、問題はやや"
"興味深くなってきます。引数をとるようコールバックに指定するのは、 "
"``\"store\"`` や ``\"append\"`` オプションの定義に似ています。 :attr:"
"`~Option.type` を定義していれば、そのオプションは引数を受け取ったときに該当す"
"る型に変換できなければなりません。さらに :attr:`~Option.nargs` を指定すれば、"
"オプションは :attr:`~Option.nargs` 個の引数を受け取ります。"

#: ../../library/optparse.rst:1894
msgid ""
"Here's an example that just emulates the standard ``\"store\"`` action::"
msgstr "標準の ``\"store\"`` アクションをエミュレートする例を以下に示します::"

#: ../../library/optparse.rst:1896
msgid ""
"def store_value(option, opt_str, value, parser):\n"
"    setattr(parser.values, option.dest, value)\n"
"...\n"
"parser.add_option(\"--foo\",\n"
"                  action=\"callback\", callback=store_value,\n"
"                  type=\"int\", nargs=3, dest=\"foo\")"
msgstr ""

#: ../../library/optparse.rst:1903
msgid ""
"Note that :mod:`!optparse` takes care of consuming 3 arguments and "
"converting them to integers for you; all you have to do is store them.  (Or "
"whatever; obviously you don't need a callback for this example.)"
msgstr ""

#: ../../library/optparse.rst:1911
msgid "Callback example 6: variable arguments"
msgstr "コールバックの例6: 可変個の引数"

#: ../../library/optparse.rst:1913
msgid ""
"Things get hairy when you want an option to take a variable number of "
"arguments. For this case, you must write a callback, as :mod:`!optparse` "
"doesn't provide any built-in capabilities for it.  And you have to deal with "
"certain intricacies of conventional Unix command-line parsing that :mod:`!"
"optparse` normally handles for you.  In particular, callbacks should "
"implement the conventional rules for bare ``--`` and ``-`` arguments:"
msgstr ""

#: ../../library/optparse.rst:1920
msgid "either ``--`` or ``-`` can be option arguments"
msgstr "either ``--`` or ``-`` can be option arguments"

#: ../../library/optparse.rst:1922
msgid ""
"bare ``--`` (if not the argument to some option): halt command-line "
"processing and discard the ``--``"
msgstr ""
"裸の ``--`` (何らかのオプションの引数でない場合): コマンドライン処理を停止"
"し、``--`` を無視します"

#: ../../library/optparse.rst:1925
msgid ""
"bare ``-`` (if not the argument to some option): halt command-line "
"processing but keep the ``-`` (append it to ``parser.largs``)"
msgstr ""
"裸の ``-`` (何らかのオプションの引数でない場合): コマンドライン処理を停止しま"
"すが、``-`` は残します (``parser.largs`` に追加します)"

#: ../../library/optparse.rst:1928
msgid ""
"If you want an option that takes a variable number of arguments, there are "
"several subtle, tricky issues to worry about.  The exact implementation you "
"choose will be based on which trade-offs you're willing to make for your "
"application (which is why :mod:`!optparse` doesn't support this sort of "
"thing directly)."
msgstr ""

#: ../../library/optparse.rst:1934
msgid ""
"Nevertheless, here's a stab at a callback for an option with variable "
"arguments::"
msgstr ""
"とはいえ、可変個の引数をもつオプションに対するスタブ (stub、仲介インター"
"フェース) を以下に示しておきます::"

#: ../../library/optparse.rst:1937
msgid ""
"def vararg_callback(option, opt_str, value, parser):\n"
"    assert value is None\n"
"    value = []\n"
"\n"
"    def floatable(str):\n"
"        try:\n"
"            float(str)\n"
"            return True\n"
"        except ValueError:\n"
"            return False\n"
"\n"
"    for arg in parser.rargs:\n"
"        # stop on --foo like options\n"
"        if arg[:2] == \"--\" and len(arg) > 2:\n"
"            break\n"
"        # stop on -a, but not on -3 or -3.0\n"
"        if arg[:1] == \"-\" and len(arg) > 1 and not floatable(arg):\n"
"            break\n"
"        value.append(arg)\n"
"\n"
"    del parser.rargs[:len(value)]\n"
"    setattr(parser.values, option.dest, value)\n"
"\n"
"...\n"
"parser.add_option(\"-c\", \"--callback\", dest=\"vararg_attr\",\n"
"                  action=\"callback\", callback=vararg_callback)"
msgstr ""

#: ../../library/optparse.rst:1968
msgid "Extending :mod:`!optparse`"
msgstr ""

#: ../../library/optparse.rst:1970
msgid ""
"Since the two major controlling factors in how :mod:`!optparse` interprets "
"command-line options are the action and type of each option, the most likely "
"direction of extension is to add new actions and new types."
msgstr ""

#: ../../library/optparse.rst:1978
msgid "Adding new types"
msgstr "新しい型の追加"

#: ../../library/optparse.rst:1980
msgid ""
"To add new types, you need to define your own subclass of :mod:`!"
"optparse`'s :class:`Option` class.  This class has a couple of attributes "
"that define :mod:`!optparse`'s types: :attr:`~Option.TYPES` and :attr:"
"`~Option.TYPE_CHECKER`."
msgstr ""

#: ../../library/optparse.rst:1986
msgid ""
"A tuple of type names; in your subclass, simply define a new tuple :attr:"
"`TYPES` that builds on the standard one."
msgstr ""
":attr:`TYPES` は型名のタプルです。新しく作るサブクラスでは、タプル :attr:"
"`TYPES` を単純に標準のものを利用して新しく定義すると良いでしょう。"

#: ../../library/optparse.rst:1991
msgid ""
"A dictionary mapping type names to type-checking functions.  A type-checking "
"function has the following signature::"
msgstr ""
":attr:`TYPE_CHECKER` は辞書で型名を型チェック関数に対応付けるものです。型"
"チェック関数は以下のようなシグネチャを持ちます::"

#: ../../library/optparse.rst:1994
msgid "def check_mytype(option, opt, value)"
msgstr ""

#: ../../library/optparse.rst:1996
msgid ""
"where ``option`` is an :class:`Option` instance, ``opt`` is an option string "
"(e.g., ``-f``), and ``value`` is the string from the command line that must "
"be checked and converted to your desired type.  ``check_mytype()`` should "
"return an object of the hypothetical type ``mytype``.  The value returned by "
"a type-checking function will wind up in the OptionValues instance returned "
"by :meth:`OptionParser.parse_args`, or be passed to a callback as the "
"``value`` parameter."
msgstr ""
"ここで ``option`` は :class:`Option` のインスタンスであり、 ``opt`` はオプ"
"ション文字列(たとえば ``-f``)で、 ``value`` は望みの型としてチェックされ変換"
"されるべくコマンドラインで与えられる文字列です。 ``check_mytype()`` は想定さ"
"れている型 ``mytype`` のオブジェクトを返さなければなりません。型チェック関数"
"から返される値は :meth:`OptionParser.parse_args` で返されるOptionValues イン"
"スタンスに収められるか、またはコールバックに ``value`` パラメータとして渡され"
"ます。"

#: ../../library/optparse.rst:2004
msgid ""
"Your type-checking function should raise :exc:`OptionValueError` if it "
"encounters any problems.  :exc:`OptionValueError` takes a single string "
"argument, which is passed as-is to :class:`OptionParser`'s :meth:`error` "
"method, which in turn prepends the program name and the string ``\"error:"
"\"`` and prints everything to stderr before terminating the process."
msgstr ""
"型チェック関数は何か問題に遭遇したら :exc:`OptionValueError` を送出しなければ"
"なりません。 :exc:`OptionValueError` は文字列一つを引数に取り、それはそのま"
"ま :class:`OptionParser` の :meth:`error` メソッドに渡され、そこでプログラム"
"名と文字列 ``\"error:\"`` が前置されてプロセスが終了する前に stderr に出力さ"
"れます。"

#: ../../library/optparse.rst:2010
msgid ""
"Here's a silly example that demonstrates adding a ``\"complex\"`` option "
"type to parse Python-style complex numbers on the command line.  (This is "
"even sillier than it used to be, because :mod:`!optparse` 1.3 added built-in "
"support for complex numbers, but never mind.)"
msgstr ""

#: ../../library/optparse.rst:2015
msgid "First, the necessary imports::"
msgstr "最初に必要な import 文を書きます::"

#: ../../library/optparse.rst:2017
msgid ""
"from copy import copy\n"
"from optparse import Option, OptionValueError"
msgstr ""

#: ../../library/optparse.rst:2020
msgid ""
"You need to define your type-checker first, since it's referred to later (in "
"the :attr:`~Option.TYPE_CHECKER` class attribute of your Option subclass)::"
msgstr ""
"まずは型チェック関数を定義しなければなりません。これは後で(これから定義する "
"Option のサブクラスの :attr:`~Option.TYPE_CHECKER` クラス属性の中で) 参照され"
"ることになります::"

#: ../../library/optparse.rst:2023
msgid ""
"def check_complex(option, opt, value):\n"
"    try:\n"
"        return complex(value)\n"
"    except ValueError:\n"
"        raise OptionValueError(\n"
"            \"option %s: invalid complex value: %r\" % (opt, value))"
msgstr ""

#: ../../library/optparse.rst:2030
msgid "Finally, the Option subclass::"
msgstr "最後に Option のサブクラスです::"

#: ../../library/optparse.rst:2032
msgid ""
"class MyOption (Option):\n"
"    TYPES = Option.TYPES + (\"complex\",)\n"
"    TYPE_CHECKER = copy(Option.TYPE_CHECKER)\n"
"    TYPE_CHECKER[\"complex\"] = check_complex"
msgstr ""

#: ../../library/optparse.rst:2037
msgid ""
"(If we didn't make a :func:`copy` of :attr:`Option.TYPE_CHECKER`, we would "
"end up modifying the :attr:`~Option.TYPE_CHECKER` attribute of :mod:`!"
"optparse`'s Option class.  This being Python, nothing stops you from doing "
"that except good manners and common sense.)"
msgstr ""

#: ../../library/optparse.rst:2042
msgid ""
"That's it!  Now you can write a script that uses the new option type just "
"like any other :mod:`!optparse`\\ -based script, except you have to instruct "
"your OptionParser to use MyOption instead of Option::"
msgstr ""

#: ../../library/optparse.rst:2046
msgid ""
"parser = OptionParser(option_class=MyOption)\n"
"parser.add_option(\"-c\", type=\"complex\")"
msgstr ""

#: ../../library/optparse.rst:2049
msgid ""
"Alternately, you can build your own option list and pass it to OptionParser; "
"if you don't use :meth:`add_option` in the above way, you don't need to tell "
"OptionParser which option class to use::"
msgstr ""
"別のやり方として、オプションリストを構築して OptionParser に渡すという方法も"
"あります。 :meth:`add_option` を上でやったように使わないならば、OptionParser "
"にどのクラスを使うのか教える必要はありません::"

#: ../../library/optparse.rst:2053
msgid ""
"option_list = [MyOption(\"-c\", action=\"store\", type=\"complex\", "
"dest=\"c\")]\n"
"parser = OptionParser(option_list=option_list)"
msgstr ""

#: ../../library/optparse.rst:2060
msgid "Adding new actions"
msgstr "新しいアクションの追加"

#: ../../library/optparse.rst:2062
msgid ""
"Adding new actions is a bit trickier, because you have to understand that :"
"mod:`!optparse` has a couple of classifications for actions:"
msgstr ""

#: ../../library/optparse.rst:2065
msgid "\"store\" actions"
msgstr "\"store\" アクション"

#: ../../library/optparse.rst:2066
msgid ""
"actions that result in :mod:`!optparse` storing a value to an attribute of "
"the current OptionValues instance; these options require a :attr:`~Option."
"dest` attribute to be supplied to the Option constructor."
msgstr ""

#: ../../library/optparse.rst:2070
msgid "\"typed\" actions"
msgstr "\"typed\" アクション"

#: ../../library/optparse.rst:2071
msgid ""
"actions that take a value from the command line and expect it to be of a "
"certain type; or rather, a string that can be converted to a certain type. "
"These options require a :attr:`~Option.type` attribute to the Option "
"constructor."
msgstr ""
"コマンドラインから引数を受け取り、それがある型であることが期待されているアク"
"ションです。もう少しはっきり言えば、その型に変換される文字列を受け取るもので"
"す。この種類のオプションは Option のコンストラクタに :attr:`~Option.type` 属"
"性を与えることが要求されます。"

#: ../../library/optparse.rst:2076
msgid ""
"These are overlapping sets: some default \"store\" actions are "
"``\"store\"``, ``\"store_const\"``, ``\"append\"``, and ``\"count\"``, while "
"the default \"typed\" actions are ``\"store\"``, ``\"append\"``, and "
"``\"callback\"``."
msgstr ""
"この分類には重複する部分があります。デフォルトの \"store\" アクションには "
"``\"store\"``, ``\"store_const\"``, ``\"append\"``, ``\"count\"`` などがあり"
"ますが、デフォルトの \"typed\" オプションは ``\"store\"``, ``\"append\"``, "
"``\"callback\"`` の三つです。"

#: ../../library/optparse.rst:2080
msgid ""
"When you add an action, you need to categorize it by listing it in at least "
"one of the following class attributes of Option (all are lists of strings):"
msgstr ""
"アクションを追加する際に、以下の Option のクラス属性(全て文字列のリストです) "
"の中の少なくとも一つに付け加えることでそのアクションを分類する必要があります:"

#: ../../library/optparse.rst:2085
msgid "All actions must be listed in ACTIONS."
msgstr "全てのアクションは ACTIONS にリストされていなければなりません。"

#: ../../library/optparse.rst:2089
msgid "\"store\" actions are additionally listed here."
msgstr "\"store\" アクションはここにもリストされます。"

#: ../../library/optparse.rst:2093
msgid "\"typed\" actions are additionally listed here."
msgstr "\"typed\" アクションはここにもリストされます。"

#: ../../library/optparse.rst:2097
msgid ""
"Actions that always take a type (i.e. whose options always take a value) are "
"additionally listed here.  The only effect of this is that :mod:`!optparse` "
"assigns the default type, ``\"string\"``, to options with no explicit type "
"whose action is listed in :attr:`ALWAYS_TYPED_ACTIONS`."
msgstr ""

#: ../../library/optparse.rst:2102
msgid ""
"In order to actually implement your new action, you must override Option's :"
"meth:`take_action` method and add a case that recognizes your action."
msgstr ""
"実際に新しいアクションを実装するには、Option の :meth:`take_action` メソッド"
"をオーバライドしてそのアクションを認識する場合分けを追加しなければなりませ"
"ん。"

#: ../../library/optparse.rst:2105
msgid ""
"For example, let's add an ``\"extend\"`` action.  This is similar to the "
"standard ``\"append\"`` action, but instead of taking a single value from "
"the command-line and appending it to an existing list, ``\"extend\"`` will "
"take multiple values in a single comma-delimited string, and extend an "
"existing list with them.  That is, if ``--names`` is an ``\"extend\"`` "
"option of type ``\"string\"``, the command line ::"
msgstr ""
"例えば、``\"extend\"`` アクションというのを追加してみましょう。このアクション"
"は標準的な ``\"append\"`` アクションと似ていますが、コマンドラインから一つだ"
"け値を読み取って既存のリストに追加するのではなく、複数の値をコンマ区切りの文"
"字列として読み取ってそれらで既存のリストを拡張します。すなわち、もし ``--"
"names`` が ``\"string\"`` 型の ``\"extend\"`` オプションだとすると、次のコマ"
"ンドライン  ::"

#: ../../library/optparse.rst:2112
msgid "--names=foo,bar --names blah --names ding,dong"
msgstr ""

#: ../../library/optparse.rst:2114
msgid "would result in a list  ::"
msgstr "の結果は次のリストになります ::"

#: ../../library/optparse.rst:2116
msgid "[\"foo\", \"bar\", \"blah\", \"ding\", \"dong\"]"
msgstr ""

#: ../../library/optparse.rst:2118
msgid "Again we define a subclass of Option::"
msgstr "再び Option のサブクラスを定義します::"

#: ../../library/optparse.rst:2120
msgid ""
"class MyOption(Option):\n"
"\n"
"    ACTIONS = Option.ACTIONS + (\"extend\",)\n"
"    STORE_ACTIONS = Option.STORE_ACTIONS + (\"extend\",)\n"
"    TYPED_ACTIONS = Option.TYPED_ACTIONS + (\"extend\",)\n"
"    ALWAYS_TYPED_ACTIONS = Option.ALWAYS_TYPED_ACTIONS + (\"extend\",)\n"
"\n"
"    def take_action(self, action, dest, opt, value, values, parser):\n"
"        if action == \"extend\":\n"
"            lvalue = value.split(\",\")\n"
"            values.ensure_value(dest, []).extend(lvalue)\n"
"        else:\n"
"            Option.take_action(\n"
"                self, action, dest, opt, value, values, parser)"
msgstr ""

#: ../../library/optparse.rst:2135
msgid "Features of note:"
msgstr "注意すべきは次のようなところです:"

#: ../../library/optparse.rst:2137
msgid ""
"``\"extend\"`` both expects a value on the command-line and stores that "
"value somewhere, so it goes in both :attr:`~Option.STORE_ACTIONS` and :attr:"
"`~Option.TYPED_ACTIONS`."
msgstr ""
"``\"extend\"`` はコマンドラインの値を予期していると同時にその値をどこかに格納"
"しますので、 :attr:`~Option.STORE_ACTIONS` と :attr:`~Option.TYPED_ACTIONS` "
"の両方に入ります。"

#: ../../library/optparse.rst:2141
msgid ""
"to ensure that :mod:`!optparse` assigns the default type of ``\"string\"`` "
"to ``\"extend\"`` actions, we put the ``\"extend\"`` action in :attr:"
"`~Option.ALWAYS_TYPED_ACTIONS` as well."
msgstr ""

#: ../../library/optparse.rst:2145
msgid ""
":meth:`MyOption.take_action` implements just this one new action, and passes "
"control back to :meth:`Option.take_action` for the standard :mod:`!optparse` "
"actions."
msgstr ""

#: ../../library/optparse.rst:2149
msgid ""
"``values`` is an instance of the optparse_parser.Values class, which "
"provides the very useful :meth:`ensure_value` method. :meth:`ensure_value` "
"is essentially :func:`getattr` with a safety valve; it is called as ::"
msgstr ""
"``values`` は optparse_parser.Values クラスのインスタンスであり、非常に有用"
"な :meth:`ensure_value` メソッドを提供しています。 :meth:`ensure_value` は本"
"質的に安全弁付きの :func:`getattr` です。次のように呼び出します ::"

#: ../../library/optparse.rst:2153
msgid "values.ensure_value(attr, value)"
msgstr ""

#: ../../library/optparse.rst:2155
msgid ""
"If the ``attr`` attribute of ``values`` doesn't exist or is ``None``, then "
"ensure_value() first sets it to ``value``, and then returns ``value``. This "
"is very handy for actions like ``\"extend\"``, ``\"append\"``, and "
"``\"count\"``, all of which accumulate data in a variable and expect that "
"variable to be of a certain type (a list for the first two, an integer for "
"the latter).  Using :meth:`ensure_value` means that scripts using your "
"action don't have to worry about setting a default value for the option "
"destinations in question; they can just leave the default as ``None`` and :"
"meth:`ensure_value` will take care of getting it right when it's needed."
msgstr ""
"``values`` に ``attr`` 属性が無いか ``None`` だった場合に、 :meth:"
"`ensure_value` は最初に ``value`` をセットし、それから ``value`` を返します。"
"この振る舞いは ``\"extend\"``, ``\"append\"``, ``\"count\"`` のように、データ"
"を変数に集積し、またその変数がある型 (最初の二つはリスト、最後のは整数) であ"
"ると期待されるアクションを作るのにとても使い易いものです。 :meth:"
"`ensure_value` を使えば、作ったアクションを使うスクリプトはオプションに保存先"
"にデフォルト値をセットすることに煩わされずに済みます。デフォルトを ``None`` "
"にしておけば :meth:`ensure_value` がそれが必要になったときに適当な値を返して"
"くれます。"

#: ../../library/optparse.rst:2166
msgid "Exceptions"
msgstr "例外"

#: ../../library/optparse.rst:2170
msgid ""
"Raised if an :class:`Option` instance is created with invalid or "
"inconsistent arguments."
msgstr ""

#: ../../library/optparse.rst:2175
msgid "Raised if conflicting options are added to an :class:`OptionParser`."
msgstr ""

#: ../../library/optparse.rst:2179
msgid "Raised if an invalid option value is encountered on the command line."
msgstr ""

#: ../../library/optparse.rst:2183
msgid "Raised if an invalid option is passed on the command line."
msgstr ""

#: ../../library/optparse.rst:2187
msgid "Raised if an ambiguous option is passed on the command line."
msgstr ""