# SOME DESCRIPTIVE TITLE.
# Copyright (C) 1990-2021, Python Software Foundation
# This file is distributed under the same license as the Python package.
#
# Translators:
# tomo, 2017
# 秘湯 <xwhhsprings@gmail.com>, 2015
msgid ""
msgstr ""
"Project-Id-Version: Python 2.7\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2021-01-01 01:01+0900\n"
"PO-Revision-Date: 2018-12-22 16:43+0000\n"
"Last-Translator: tomo\n"
"Language-Team: Japanese (http://www.transifex.com/python-doc/python-27/"
"language/ja/)\n"
"Language: ja\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../tutorial/errors.rst:5
msgid "Errors and Exceptions"
msgstr "エラーと例外"

#: ../../tutorial/errors.rst:7
msgid ""
"Until now error messages haven't been more than mentioned, but if you have "
"tried out the examples you have probably seen some.  There are (at least) "
"two distinguishable kinds of errors: *syntax errors* and *exceptions*."
msgstr ""
"これまでエラーメッセージについては簡単に触れるだけでしたが、チュートリアル中"
"の例を自分で試していたら、実際にいくつかのエラーメッセージを見ていることで"
"しょう。エラーには (少なくとも) 二つのはっきり異なる種類があります。それは *"
"構文エラー (syntax error)* と *例外 (exception)* です。"

#: ../../tutorial/errors.rst:15
msgid "Syntax Errors"
msgstr "構文エラー"

#: ../../tutorial/errors.rst:17
msgid ""
"Syntax errors, also known as parsing errors, are perhaps the most common "
"kind of complaint you get while you are still learning Python::"
msgstr ""
"構文エラーは構文解析エラー (parsing error) としても知られており、Python を勉"
"強している間に最もよく遭遇する問題の一つでしょう::"

#: ../../tutorial/errors.rst:26
msgid ""
"The parser repeats the offending line and displays a little 'arrow' pointing "
"at the earliest point in the line where the error was detected.  The error "
"is caused by (or at least detected at) the token *preceding* the arrow: in "
"the example, the error is detected at the keyword :keyword:`print`, since a "
"colon (``':'``) is missing before it.  File name and line number are printed "
"so you know where to look in case the input came from a script."
msgstr ""
"パーサは違反の起きている行を表示し、小さな「矢印」を表示して、行中でエラーが"
"検出された最初の位置を示します。エラーは矢印の *直前の* トークンでひき起こさ"
"れています (または、少なくともそこで検出されています)。上記の例では、エラー"
"は :keyword:`print` で検出されています。コロン (``':'``) がその前に無いからで"
"す。入力がスクリプトから来ている場合は、どこを見ればよいか分かるようにファイ"
"ル名と行番号が出力されます。"

#: ../../tutorial/errors.rst:37
msgid "Exceptions"
msgstr "例外"

#: ../../tutorial/errors.rst:39
msgid ""
"Even if a statement or expression is syntactically correct, it may cause an "
"error when an attempt is made to execute it. Errors detected during "
"execution are called *exceptions* and are not unconditionally fatal: you "
"will soon learn how to handle them in Python programs.  Most exceptions are "
"not handled by programs, however, and result in error messages as shown "
"here::"
msgstr ""
"たとえ文や式が構文的に正しくても、実行しようとしたときにエラーが発生するかも"
"しれません。実行中に検出されたエラーは *例外 (exception)* と呼ばれ、常に致命"
"的とは限りません。これから、Python プログラムで例外をどのように扱うかを学んで"
"いきます。ほとんどの例外はプログラムで処理されず、以下に示されるようなメッ"
"セージになります::"

#: ../../tutorial/errors.rst:58
msgid ""
"The last line of the error message indicates what happened. Exceptions come "
"in different types, and the type is printed as part of the message: the "
"types in the example are :exc:`ZeroDivisionError`, :exc:`NameError` and :exc:"
"`TypeError`. The string printed as the exception type is the name of the "
"built-in exception that occurred.  This is true for all built-in exceptions, "
"but need not be true for user-defined exceptions (although it is a useful "
"convention). Standard exception names are built-in identifiers (not reserved "
"keywords)."
msgstr ""
"エラーメッセージの最終行は何が起こったかを示しています。例外は様々な型 "
"(type) で起こり、その型がエラーメッセージの一部として出力されます。上の例での"
"型は :exc:`ZeroDivisionError`, :exc:`NameError`, :exc:`TypeError` です。例外"
"型として出力される文字列は、発生した例外の組み込み名です。これは全ての組み込"
"み例外について成り立ちますが、ユーザ定義の例外では (成り立つようにするのは有"
"意義な慣習ですが) 必ずしも成り立ちません。標準例外の名前は組み込みの識別子で"
"す (予約語ではありません)。"

#: ../../tutorial/errors.rst:66
msgid ""
"The rest of the line provides detail based on the type of exception and what "
"caused it."
msgstr "残りの行は例外の詳細で、その例外の型と何が起きたかに依存します。"

#: ../../tutorial/errors.rst:69
msgid ""
"The preceding part of the error message shows the context where the "
"exception happened, in the form of a stack traceback. In general it contains "
"a stack traceback listing source lines; however, it will not display lines "
"read from standard input."
msgstr ""
"エラーメッセージの先頭部分では、例外が発生した実行コンテキスト (context) を、"
"スタックのトレースバック (stack traceback) の形式で示しています。一般には、こ"
"の部分にはソースコード行をリストしたトレースバックが表示されます。しかし、標"
"準入力から読み取られたコードは表示されません。"

#: ../../tutorial/errors.rst:74
msgid ""
":ref:`bltin-exceptions` lists the built-in exceptions and their meanings."
msgstr ""
":ref:`bltin-exceptions` には、組み込み例外とその意味がリストされています。"

#: ../../tutorial/errors.rst:80
msgid "Handling Exceptions"
msgstr "例外を処理する"

#: ../../tutorial/errors.rst:82
msgid ""
"It is possible to write programs that handle selected exceptions. Look at "
"the following example, which asks the user for input until a valid integer "
"has been entered, but allows the user to interrupt the program (using :kbd:"
"`Control-C` or whatever the operating system supports); note that a user-"
"generated interruption is signalled by raising the :exc:`KeyboardInterrupt` "
"exception. ::"
msgstr ""
"例外を選別して処理するようなプログラムを書くことができます。以下の例を見てく"
"ださい。この例では、有効な文字列が入力されるまでユーザに入力を促しますが、"
"ユーザがプログラムに (:kbd:`Control-C` か、またはオペレーティングシステムがサ"
"ポートしている何らかのキーを使って) 割り込みをかけてプログラムを中断させるこ"
"とができるようにしています。ユーザが生成した割り込みは、 :exc:"
"`KeyboardInterrupt` 例外が送出されることで通知されるということに注意してくだ"
"さい。 ::"

#: ../../tutorial/errors.rst:96
msgid "The :keyword:`try` statement works as follows."
msgstr ":keyword:`try` 文は下記のように動作します。"

#: ../../tutorial/errors.rst:98
msgid ""
"First, the *try clause* (the statement(s) between the :keyword:`try` and :"
"keyword:`except` keywords) is executed."
msgstr ""
"まず、 *try 節 (try clause)* (キーワード :keyword:`try` と :keyword:`except` "
"の間の文) が実行されます。"

#: ../../tutorial/errors.rst:101
msgid ""
"If no exception occurs, the *except clause* is skipped and execution of the :"
"keyword:`try` statement is finished."
msgstr ""
"何も例外が発生しなければ、 *except 節* をスキップして :keyword:`try` 文の実行"
"を終えます。"

#: ../../tutorial/errors.rst:104
msgid ""
"If an exception occurs during execution of the try clause, the rest of the "
"clause is skipped.  Then if its type matches the exception named after the :"
"keyword:`except` keyword, the except clause is executed, and then execution "
"continues after the :keyword:`try` statement."
msgstr ""
"try 節内の実行中に例外が発生すると、その節の残りは飛ばされます。次に、例外型"
"が :keyword:`except` キーワードの後に指定されている例外に一致する場合、"
"except 節が実行された後、 :keyword:`try` 文の後ろへ実行が継続されます。"

#: ../../tutorial/errors.rst:109
msgid ""
"If an exception occurs which does not match the exception named in the "
"except clause, it is passed on to outer :keyword:`try` statements; if no "
"handler is found, it is an *unhandled exception* and execution stops with a "
"message as shown above."
msgstr ""
"もしも except 節で指定された例外と一致しない例外が発生すると、その例外は :"
"keyword:`try` 文の外側に渡されます。例外に対するハンドラ (handler、処理部) が"
"どこにもなければ、 *処理されない例外 (unhandled exception)* となり、上記に示"
"したようなメッセージを出して実行を停止します。"

#: ../../tutorial/errors.rst:114
msgid ""
"A :keyword:`try` statement may have more than one except clause, to specify "
"handlers for different exceptions.  At most one handler will be executed. "
"Handlers only handle exceptions that occur in the corresponding try clause, "
"not in other handlers of the same :keyword:`try` statement.  An except "
"clause may name multiple exceptions as a parenthesized tuple, for example::"
msgstr ""
"一つの :keyword:`try` 文に複数の except 節を設けて、さまざまな例外に対するハ"
"ンドラを指定することができます。同時に一つ以上のハンドラが実行されることはあ"
"りません。ハンドラは対応する try 節内で発生した例外だけを処理し、同じ :"
"keyword:`try` 文内の別の例外ハンドラで起きた例外は処理しません。 except 節に"
"は複数の例外を丸括弧で囲ったタプルにして渡すことができます。例えば以下のよう"
"にします::"

#: ../../tutorial/errors.rst:123
msgid ""
"Note that the parentheses around this tuple are required, because ``except "
"ValueError, e:`` was the syntax used for what is normally written as "
"``except ValueError as e:`` in modern Python (described below). The old "
"syntax is still supported for backwards compatibility. This means ``except "
"RuntimeError, TypeError`` is not equivalent to ``except (RuntimeError, "
"TypeError):`` but to ``except RuntimeError as TypeError:`` which is not what "
"you want."
msgstr ""
"このタプルの周囲の括弧は必要です。というのも、 ``except ValueError, e:`` はモ"
"ダンな Python で普通 ``except ValueError as e:`` と書く(後述)のと同じ意味のか"
"つての文法でした。この古い文法は後方互換のために今でも残されています。つまり "
"``except RuntimeError, TypeError`` は ``except (RuntimeError, TypeError):`` "
"と同じではなく、お望みのものとは違う ``except RuntimeError as TypeError:`` だ"
"ということです。"

#: ../../tutorial/errors.rst:131
msgid ""
"The last except clause may omit the exception name(s), to serve as a "
"wildcard. Use this with extreme caution, since it is easy to mask a real "
"programming error in this way!  It can also be used to print an error "
"message and then re-raise the exception (allowing a caller to handle the "
"exception as well)::"
msgstr ""
"最後の except 節では例外名を省いて、ワイルドカード (wildcard、総称記号) にす"
"ることができます。ワイルドカードの except 節は非常に注意して使ってください。"
"というのは、ワイルドカードは通常のプログラムエラーをたやすく隠してしまうから"
"です！ワイルドカードの except 節はエラーメッセージを出力した後に例外を再送出"
"する (関数やメソッドの呼び出し側が同様にして例外を処理できるようにする) 用途"
"にも使えます::"

#: ../../tutorial/errors.rst:150
msgid ""
"The :keyword:`try` ... :keyword:`except` statement has an optional *else "
"clause*, which, when present, must follow all except clauses.  It is useful "
"for code that must be executed if the try clause does not raise an "
"exception.  For example::"
msgstr ""
":keyword:`try` ... :keyword:`except` 文には、オプションで *else 節 (else "
"clause)* を設けることができます。 :keyword:`else` 節を設ける場合、全ての :"
"keyword:`except` 節よりも後ろに置かなければなりません。 :keyword:`else` 節は "
"try 節で全く例外が送出されなかったときに実行されるコードを書くのに役立ちま"
"す。例えば次のようにします::"

#: ../../tutorial/errors.rst:164
msgid ""
"The use of the :keyword:`else` clause is better than adding additional code "
"to the :keyword:`try` clause because it avoids accidentally catching an "
"exception that wasn't raised by the code being protected by the :keyword:"
"`try` ... :keyword:`except` statement."
msgstr ""
"追加のコードを追加するのは :keyword:`try` 節の後ろよりも :keyword:`else` 節の"
"方がよいでしょう。なぜなら、そうすることで :keyword:`try` ... :keyword:"
"`except` 文で保護したいコードから送出されたもの以外の例外を偶然に捕捉してしま"
"うという事態を避けられるからです。"

#: ../../tutorial/errors.rst:169
msgid ""
"When an exception occurs, it may have an associated value, also known as the "
"exception's *argument*. The presence and type of the argument depend on the "
"exception type."
msgstr ""
"例外が発生するとき、例外は関連付けられた値を持つことができます。この値は例外"
"の *引数 (argument)* とも呼ばれます。引数の有無および引数の型は、例外の型に依"
"存します。"

#: ../../tutorial/errors.rst:173
msgid ""
"The except clause may specify a variable after the exception name (or "
"tuple). The variable is bound to an exception instance with the arguments "
"stored in ``instance.args``.  For convenience, the exception instance "
"defines :meth:`__str__` so the arguments can be printed directly without "
"having to reference ``.args``."
msgstr ""
"except 節では、例外名 (または例外名タプル) の後に変数を指定することができま"
"す。この変数は例外インスタンスに結び付けられており、 ``instance.args`` に例外"
"インスタンス生成時の引数が入っています。例外インスタンスには :meth:`__str__` "
"が定義されており、 ``.args`` を参照しなくても引数を直接印字できるように利便性"
"が図られています。"

#: ../../tutorial/errors.rst:179
msgid ""
"One may also instantiate an exception first before raising it and add any "
"attributes to it as desired. ::"
msgstr ""
"必要なら、例外を送出する前にインスタンス化して、任意の属性を追加できます。"

#: ../../tutorial/errors.rst:198
msgid ""
"If an exception has an argument, it is printed as the last part ('detail') "
"of the message for unhandled exceptions."
msgstr ""
"例外が引数を持っていれば、それらは処理されない例外のメッセージの最後の部分 "
"(「詳細説明」) に出力されます。"

#: ../../tutorial/errors.rst:201
msgid ""
"Exception handlers don't just handle exceptions if they occur immediately in "
"the try clause, but also if they occur inside functions that are called "
"(even indirectly) in the try clause. For example::"
msgstr ""
"例外ハンドラは、try 節の直接内側で発生した例外を処理するだけではなく、その "
"try 節から (たとえ間接的にでも) 呼び出された関数の内部で発生した例外も処理し"
"ます。例えば::"

#: ../../tutorial/errors.rst:219
msgid "Raising Exceptions"
msgstr "例外を送出する"

#: ../../tutorial/errors.rst:221
msgid ""
"The :keyword:`raise` statement allows the programmer to force a specified "
"exception to occur. For example::"
msgstr ""
":keyword:`raise` 文を使って、特定の例外を発生させることができます。例えば::"

#: ../../tutorial/errors.rst:229
msgid ""
"The sole argument to :keyword:`raise` indicates the exception to be raised. "
"This must be either an exception instance or an exception class (a class "
"that derives from :class:`Exception`)."
msgstr ""
":keyword:`raise` は送出したい例外を引数として取ります。これは例外クラス(:"
"class:`Exception` を継承したクラス)か、例外クラスのインスタンスです。"

#: ../../tutorial/errors.rst:233
msgid ""
"If you need to determine whether an exception was raised but don't intend to "
"handle it, a simpler form of the :keyword:`raise` statement allows you to re-"
"raise the exception::"
msgstr ""
"例外が発生したかどうかを判定したいだけで、その例外を処理するつもりがなけれ"
"ば、単純な形式の :keyword:`raise` 文を使って例外を再送出させることができま"
"す::"

#: ../../tutorial/errors.rst:252
msgid "User-defined Exceptions"
msgstr "ユーザー定義例外"

#: ../../tutorial/errors.rst:254
msgid ""
"Programs may name their own exceptions by creating a new exception class "
"(see :ref:`tut-classes` for more about Python classes).  Exceptions should "
"typically be derived from the :exc:`Exception` class, either directly or "
"indirectly.  For example::"
msgstr ""
"プログラム上で新しい例外クラスを作成することで、独自の例外を指定することがで"
"きます (Python のクラスについては :ref:`tut-classes` 参照)。例外は、典型的"
"に :exc:`Exception` クラスから、直接または間接的に派生したものです。例を示し"
"ます::"

#: ../../tutorial/errors.rst:276
msgid ""
"In this example, the default :meth:`__init__` of :class:`Exception` has been "
"overridden.  The new behavior simply creates the *value* attribute.  This "
"replaces the default behavior of creating the *args* attribute."
msgstr ""
"この例では :class:`Exception` のデフォルト :meth:`__init__` がオーバーライド"
"されています。新しい振る舞いでは、単に *value* 属性を作ります。これは、デフォ"
"ルトの *args* 属性を作成する振る舞いを置き換えています。"

#: ../../tutorial/errors.rst:280
msgid ""
"Exception classes can be defined which do anything any other class can do, "
"but are usually kept simple, often only offering a number of attributes that "
"allow information about the error to be extracted by handlers for the "
"exception.  When creating a module that can raise several distinct errors, a "
"common practice is to create a base class for exceptions defined by that "
"module, and subclass that to create specific exception classes for different "
"error conditions::"
msgstr ""
"例外クラスでは、普通のクラスができることなら何でも定義することができますが、"
"通常は単純なものにしておきます。大抵は、いくつかの属性だけを提供し、例外が発"
"生したときにハンドラがエラーに関する情報を取り出せるようにする程度にとどめま"
"す。複数の別個の例外を送出するようなモジュールを作成する際には、そのモジュー"
"ルで定義されている例外の基底クラスを作成するのが一般的なプラクティスです::"

#: ../../tutorial/errors.rst:318
msgid ""
"Most exceptions are defined with names that end in \"Error\", similar to the "
"naming of the standard exceptions."
msgstr ""
"ほとんどの例外は、標準の例外の名前付けと同様に、\"Error\" で終わる名前で定義"
"されています。"

#: ../../tutorial/errors.rst:321
msgid ""
"Many standard modules define their own exceptions to report errors that may "
"occur in functions they define.  More information on classes is presented in "
"chapter :ref:`tut-classes`."
msgstr ""
"多くの標準モジュールでは、モジュールで定義されている関数内で発生する可能性の"
"あるエラーを報告させるために、独自の例外を定義しています。クラスについての詳"
"細な情報は :ref:`tut-classes` 章で提供されています。"

#: ../../tutorial/errors.rst:329
msgid "Defining Clean-up Actions"
msgstr "クリーンアップ動作を定義する"

#: ../../tutorial/errors.rst:331
msgid ""
"The :keyword:`try` statement has another optional clause which is intended "
"to define clean-up actions that must be executed under all circumstances.  "
"For example::"
msgstr ""
":keyword:`try` 文にはもう一つオプションの節があります。この節はクリーンアップ"
"動作を定義するためのもので、どんな状況でも必ず実行されます。例を示します::"

#: ../../tutorial/errors.rst:345
msgid ""
"A *finally clause* is always executed before leaving the :keyword:`try` "
"statement, whether an exception has occurred or not. When an exception has "
"occurred in the :keyword:`try` clause and has not been handled by an :"
"keyword:`except` clause (or it has occurred in an :keyword:`except` or :"
"keyword:`else` clause), it is re-raised after the :keyword:`finally` clause "
"has been executed.  The :keyword:`finally` clause is also executed \"on the "
"way out\" when any other clause of the :keyword:`try` statement is left via "
"a :keyword:`break`, :keyword:`continue` or :keyword:`return` statement.  A "
"more complicated example (having :keyword:`except` and :keyword:`finally` "
"clauses in the same :keyword:`try` statement works as of Python 2.5)::"
msgstr ""
"*finally 節 (finally clause)* は、例外が発生したかどうかに関わらず、 :"
"keyword:`try` 文を抜ける前に常に実行されます。 :keyword:`try` 節の中で例外が"
"発生して、 :keyword:`except` 節で処理されていない場合、または :keyword:"
"`except` 節か :keyword:`else` 節で例外が発生した場合は、 :keyword:`finally` "
"節を実行した後、その例外を再送出します。 :keyword:`finally` 節はまた、 :"
"keyword:`try` 節から :keyword:`break` 文や :keyword:`continue` 文、 :keyword:"
"`return` 文経由で抜ける際にも、 \"抜ける途中で\" 実行されます。より複雑な例で"
"す (:keyword:`except` 節や :keyword:`finally` 節が同じ :keyword:`try` 文の中"
"にあって、 Python 2.5 以降で動作します)。"

#: ../../tutorial/errors.rst:379
msgid ""
"As you can see, the :keyword:`finally` clause is executed in any event.  "
"The :exc:`TypeError` raised by dividing two strings is not handled by the :"
"keyword:`except` clause and therefore re-raised after the :keyword:`finally` "
"clause has been executed."
msgstr ""
"見てわかるとおり、 :keyword:`finally` 節はどの場合にも実行されています。文字"
"列を割り算することで発生した :exc:`TypeError` は :keyword:`except` 節で処理さ"
"れていないので、 :keyword:`finally` 節実行後に再度送出されています。"

#: ../../tutorial/errors.rst:384
msgid ""
"In real world applications, the :keyword:`finally` clause is useful for "
"releasing external resources (such as files or network connections), "
"regardless of whether the use of the resource was successful."
msgstr ""
"実世界のアプリケーションでは、 :keyword:`finally` 節は(ファイルやネットワーク"
"接続などの)外部リソースを、利用が成功したかどうかにかかわらず解放するために便"
"利です。"

#: ../../tutorial/errors.rst:392
msgid "Predefined Clean-up Actions"
msgstr "定義済みクリーンアップ処理"

#: ../../tutorial/errors.rst:394
msgid ""
"Some objects define standard clean-up actions to be undertaken when the "
"object is no longer needed, regardless of whether or not the operation using "
"the object succeeded or failed. Look at the following example, which tries "
"to open a file and print its contents to the screen. ::"
msgstr ""
"オブジェクトのなかには、その利用の成否にかかわらず、不要になった際に実行され"
"る標準的なクリーンアップ処理が定義されているものがあります。以下の、ファイル"
"をオープンして内容を画面に表示する例をみてください。 ::"

#: ../../tutorial/errors.rst:402
msgid ""
"The problem with this code is that it leaves the file open for an "
"indeterminate amount of time after the code has finished executing. This is "
"not an issue in simple scripts, but can be a problem for larger "
"applications. The :keyword:`with` statement allows objects like files to be "
"used in a way that ensures they are always cleaned up promptly and "
"correctly. ::"
msgstr ""
"このコードの問題点は、コードの実行が終わった後に不定の時間ファイルを開いたま"
"までいることです。これは単純なスクリプトでは問題になりませんが、大きなアプリ"
"ケーションでは問題になりえます。 :keyword:`with` 文はファイルのようなオブジェ"
"クトが常に、即座に正しくクリーンアップされることを保証します。 ::"

#: ../../tutorial/errors.rst:412
msgid ""
"After the statement is executed, the file *f* is always closed, even if a "
"problem was encountered while processing the lines. Other objects which "
"provide predefined clean-up actions will indicate this in their "
"documentation."
msgstr ""
"この文が実行されたあとで、たとえ行の処理中に問題があったとしても、ファイル "
"*f* は常に close されます。ファイルなどの、定義済みクリーンアップ処理を持つオ"
"ブジェクトについては、それぞれのドキュメントで示されます。"