# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2021, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
# 
# Translators:
# Takanori Suzuki <takanori@takanory.net>, 2021
# tomo, 2021
# Yusuke Miyazaki <miyazaki.dev@gmail.com>, 2021
# 
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.10\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2021-08-07 13:13+0000\n"
"PO-Revision-Date: 2021-06-28 01:50+0000\n"
"Last-Translator: Yusuke Miyazaki <miyazaki.dev@gmail.com>, 2021\n"
"Language-Team: Japanese (https://www.transifex.com/python-doc/teams/5390/ja/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: ja\n"
"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../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 function :func:`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 ""
"パーサは違反の起きている行を表示し、小さな「矢印」を表示して、行中でエラーが検出された最初の位置を示します。エラーは矢印の *直前の* "
"トークンでひき起こされています (または、少なくともそこで検出されています)。上記の例では、エラーは関数 :func:`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 occurred, 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 :keyword:`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 try/except block."
msgstr ""

#: ../../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 ""

#: ../../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 ""

#: ../../tutorial/errors.rst:123
msgid ""
"A class in an :keyword:`except` clause is compatible with an exception if it"
" is the same class or a base class thereof (but not the other way around ---"
" an *except clause* listing a derived class is not compatible with a base "
"class). For example, the following code will print B, C, D in that order::"
msgstr ""

#: ../../tutorial/errors.rst:147
msgid ""
"Note that if the *except clauses* were reversed (with ``except B`` first), "
"it would have printed B, B, B --- the first matching *except clause* is "
"triggered."
msgstr ""

#: ../../tutorial/errors.rst:150
msgid ""
"All exceptions inherit from :exc:`BaseException`, and so it can be used 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 ""

#: ../../tutorial/errors.rst:169
msgid ""
"Alternatively the last except clause may omit the exception name(s), however"
" the exception value must then be retrieved from ``sys.exc_info()[1]``."
msgstr ""

#: ../../tutorial/errors.rst:172
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 ""

#: ../../tutorial/errors.rst:186
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` 節の方がよいでしょう。\n"
"なぜなら、そうすることで :keyword:`!try` ... :keyword:`!except` 文で保護されたコードから送出されたもの以外の例外を過って捕捉してしまうという事態を避けられるからです。"

#: ../../tutorial/errors.rst:191
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:195
msgid ""
"The *except clause* may specify a variable after the exception name.  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``.  One may also instantiate an exception first before "
"raising it and add any attributes to it as desired. ::"
msgstr ""

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

#: ../../tutorial/errors.rst:222
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 ""

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

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

#: ../../tutorial/errors.rst:250
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`).  If an exception class is passed, it "
"will be implicitly instantiated by calling its constructor with no "
"arguments::"
msgstr ""
":keyword:`raise` の唯一の引数は送出される例外を指し示します。\n"
"これは例外インスタンスか例外クラス (:class:`Exception` を継承したクラス) でなければなりません。\n"
"例外クラスが渡された場合は、引数無しのコンストラクタが呼び出され、暗黙的にインスタンス化されます::"

#: ../../tutorial/errors.rst:257
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:276
msgid "Exception Chaining"
msgstr "例外の連鎖"

#: ../../tutorial/errors.rst:278
msgid ""
"The :keyword:`raise` statement allows an optional :keyword:`from<raise>` "
"which enables chaining exceptions. For example::"
msgstr ":keyword:`raise` 文では :keyword:`from <raise>` を使い、例外を連鎖することができます。例えば::"

#: ../../tutorial/errors.rst:284
msgid "This can be useful when you are transforming exceptions. For example::"
msgstr "これは例外を変換するときに便利です。例えば::"

#: ../../tutorial/errors.rst:305
msgid ""
"Exception chaining happens automatically when an exception is raised inside "
"an :keyword:`except` or :keyword:`finally` section. This can be disabled by "
"using ``from None`` idiom:"
msgstr ""

#: ../../tutorial/errors.rst:318
msgid ""
"For more information about chaining mechanics, see :ref:`bltin-exceptions`."
msgstr "例外の連鎖の仕組みに関して、詳しくは :ref:`bltin-exceptions` を参照してください。"

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

#: ../../tutorial/errors.rst:326
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."
msgstr ""
"プログラム上で新しい例外クラスを作成することで、独自の例外を指定することができます (Python のクラスについては :ref:`tut-"
"classes` 参照)。例外は、典型的に :exc:`Exception` クラスから、直接または間接的に派生したものです。"

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

#: ../../tutorial/errors.rst:371
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:379
msgid "Defining Clean-up Actions"
msgstr "クリーンアップ動作を定義する"

#: ../../tutorial/errors.rst:381
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:395
msgid ""
"If a :keyword:`finally` clause is present, the :keyword:`!finally` clause "
"will execute as the last task before the :keyword:`try` statement completes."
" The :keyword:`!finally` clause runs whether or not the :keyword:`!try` "
"statement produces an exception. The following points discuss more complex "
"cases when an exception occurs:"
msgstr ""
"もし :keyword:`finally` 節がある場合、 :keyword:`try` 文が終わる前の最後の処理を、 "
":keyword:`!finally` 節が実行します。 :keyword:`!try` 文が例外を発生させるか否かに関わらず、 "
":keyword:`!finally` 節は実行されます。以下では、例外が発生するという更に複雑なケースを議論します:"

#: ../../tutorial/errors.rst:401
msgid ""
"If an exception occurs during execution of the :keyword:`!try` clause, the "
"exception may be handled by an :keyword:`except` clause. If the exception is"
" not handled by an :keyword:`!except` clause, the exception is re-raised "
"after the :keyword:`!finally` clause has been executed."
msgstr ""
"もし :keyword:`!try` 文の実行中に例外が発生したら、その例外は :keyword:`except` "
"節によって処理されるでしょう。もしその例外が :keyword:`!except` 節によって処理されなければ、 :keyword:`!finally`"
" 節が実行された後に、その例外が再送出されます。"

#: ../../tutorial/errors.rst:407
msgid ""
"An exception could occur during execution of an :keyword:`!except` or "
":keyword:`!else` clause. Again, the exception is re-raised after the "
":keyword:`!finally` clause has been executed."
msgstr ""
":keyword:`!except` 節または :keyword:`!else` 節の実行中に例外が発生することがあり得ます。その場合も、 "
":keyword:`!finally` 節が実行された後に例外が再送出されます。"

#: ../../tutorial/errors.rst:411
msgid ""
"If the :keyword:`!finally` clause executes a :keyword:`break`, "
":keyword:`continue` or :keyword:`return` statement, exceptions are not re-"
"raised."
msgstr ""

#: ../../tutorial/errors.rst:415
msgid ""
"If the :keyword:`!try` statement reaches a :keyword:`break`, "
":keyword:`continue` or :keyword:`return` statement, the :keyword:`!finally` "
"clause will execute just prior to the :keyword:`!break`, "
":keyword:`!continue` or :keyword:`!return` statement's execution."
msgstr ""
"もし :keyword:`!try` 文が :keyword:`break` 文、 :keyword:`continue` 文または "
":keyword:`return` 文のいずれかに達すると、その :keyword:`!break` 文、 :keyword:`!continue` "
"文または :keyword:`!return` 文の実行の直前に :keyword:`!finally` 節が実行されます。"

#: ../../tutorial/errors.rst:421
msgid ""
"If a :keyword:`!finally` clause includes a :keyword:`!return` statement, the"
" returned value will be the one from the :keyword:`!finally` clause's "
":keyword:`!return` statement, not the value from the :keyword:`!try` "
"clause's :keyword:`!return` statement."
msgstr ""
"もし :keyword:`!finally` 節が :keyword:`!return` 文を含む場合、返される値は :keyword:`!try` "
"節の :keyword:`!return` 文ではなく、:keyword:`!finally` 節の :keyword:`!return` "
"文によるものになります。"

#: ../../tutorial/errors.rst:427
msgid "For example::"
msgstr "例えば::"

#: ../../tutorial/errors.rst:438
msgid "A more complicated example::"
msgstr "より複雑な例::"

#: ../../tutorial/errors.rst:463
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` 節はどの場合にも実行されています。\n"
"文字列で割り算をすることで発生した :exc:`TypeError` は :keyword:`except` 節で処理されていないので、 :keyword:`!finally` 節実行後に再度送出されています。"

#: ../../tutorial/errors.rst:468
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:476
msgid "Predefined Clean-up Actions"
msgstr "定義済みクリーンアップ処理"

#: ../../tutorial/errors.rst:478
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:486
msgid ""
"The problem with this code is that it leaves the file open for an "
"indeterminate amount of time after this part of 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:496
msgid ""
"After the statement is executed, the file *f* is always closed, even if a "
"problem was encountered while processing the lines. Objects which, like "
"files, provide predefined clean-up actions will indicate this in their "
"documentation."
msgstr ""
"この文が実行されたあとで、たとえ行の処理中に問題があったとしても、ファイル *f* は常に close "
"されます。ファイルなどの、定義済みクリーンアップ処理を持つオブジェクトについては、それぞれのドキュメントで示されます。"