errors.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2025, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# tomo, 2021
# Yusuke Miyazaki <miyazaki.dev@gmail.com>, 2021
# Arihiro TAKASE, 2023
# souma987, 2023
# Takuya Futatsugi, 2024
# TENMYO Masakazu, 2024
# Takanori Suzuki <takanori@takanory.net>, 2025
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.13\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2025-02-14 14:17+0000\n"
"PO-Revision-Date: 2021-06-28 01:50+0000\n"
"Last-Translator: Takanori Suzuki <takanori@takanory.net>, 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"

#: ../../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:20
msgid ""
">>> while True print('Hello world')\n"
"  File \"<stdin>\", line 1\n"
"    while True print('Hello world')\n"
"               ^^^^^\n"
"SyntaxError: invalid syntax"
msgstr ""
">>> while True print('Hello world')\n"
"  File \"<stdin>\", line 1\n"
"    while True print('Hello world')\n"
"               ^^^^^\n"
"SyntaxError: invalid syntax"

#: ../../tutorial/errors.rst:26
msgid ""
"The parser repeats the offending line and displays little arrows pointing at "
"the token in the line where the error was detected.  The error may be caused "
"by the absence of a token *before* the indicated token.  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:45
msgid ""
">>> 10 * (1/0)\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"    10 * (1/0)\n"
"          ~^~\n"
"ZeroDivisionError: division by zero\n"
">>> 4 + spam*3\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"    4 + spam*3\n"
"        ^^^^\n"
"NameError: name 'spam' is not defined\n"
">>> '2' + 2\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"    '2' + 2\n"
"    ~~~~^~~\n"
"TypeError: can only concatenate str (not \"int\") to str"
msgstr ""
">>> 10 * (1/0)\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"    10 * (1/0)\n"
"          ~^~\n"
"ZeroDivisionError: division by zero\n"
">>> 4 + spam*3\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"    4 + spam*3\n"
"        ^^^^\n"
"NameError: name 'spam' is not defined\n"
">>> '2' + 2\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"    '2' + 2\n"
"    ~~~~^~~\n"
"TypeError: can only concatenate str (not \"int\") to str"

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

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

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

#: ../../tutorial/errors.rst:88
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:94
msgid ""
">>> while True:\n"
"...     try:\n"
"...         x = int(input(\"Please enter a number: \"))\n"
"...         break\n"
"...     except ValueError:\n"
"...         print(\"Oops!  That was no valid number.  Try again...\")\n"
"..."
msgstr ""

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

#: ../../tutorial/errors.rst:104
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:107
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:110
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 ""
":keyword:`try` 節内の実行中に例外が発生すると、その節の残りは飛ばされます。次"
"に、例外型が :keyword:`except` キーワードの後に指定されている例外に一致する場"
"合、except 節が実行された後、 try/except ブロックの後ろへ実行が継続されます。"

#: ../../tutorial/errors.rst:115
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 an "
"error message."
msgstr ""
"もしも *except 節* で指定された例外と一致しない例外が発生すると、その例外は :"
"keyword:`try` 文の外側に渡されます。例外に対するハンドラ (handler、処理部) が"
"どこにもなければ、 *処理されない例外 (unhandled exception)* となり、エラー"
"メッセージを出して実行を停止します。"

#: ../../tutorial/errors.rst:119
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 節* が付けられ、別々の例外に対する"
"ハンドラを指定できます。\n"
"多くとも一つのハンドラしか実行されません。\n"
"ハンドラは対応する *try 節* 内で発生した例外だけを処理し、同じ :keyword:`!"
"try` 節内の別の例外ハンドラで起きた例外は処理しません。\n"
"*except 節* では丸括弧で囲ったタプルという形で複数の例外を指定できます。例え"
"ば次のようにします::"

#: ../../tutorial/errors.rst:125
msgid ""
"... except (RuntimeError, TypeError, NameError):\n"
"...     pass"
msgstr ""

#: ../../tutorial/errors.rst:128
msgid ""
"A class in an :keyword:`except` clause matches exceptions which are "
"instances of the class itself or one of its derived classes (but not the "
"other way around --- an *except clause* listing a derived class does not "
"match instances of its base classes). For example, the following code will "
"print B, C, D in that order::"
msgstr ""
":keyword:`except` 節 内のクラスは、そのクラスや派生クラスのインスタンスである"
"例外とマッチします（その逆はありません --- 派生クラスが書かれた *except節* "
"は、その基底クラスのインスタンスにはマッチしません）。例えば、次のコードは "
"B, C, D の順に出力されます::"

#: ../../tutorial/errors.rst:133
msgid ""
"class B(Exception):\n"
"    pass\n"
"\n"
"class C(B):\n"
"    pass\n"
"\n"
"class D(C):\n"
"    pass\n"
"\n"
"for cls in [B, C, D]:\n"
"    try:\n"
"        raise cls()\n"
"    except D:\n"
"        print(\"D\")\n"
"    except C:\n"
"        print(\"C\")\n"
"    except B:\n"
"        print(\"B\")"
msgstr ""

#: ../../tutorial/errors.rst:152
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 ""
"*except 節* が逆に並んでいた場合 (``except B`` が最初にくる場合)、 B, B, B と"
"出力されるはずだったことに注意してください --- 最初に一致した *except 節* が"
"駆動されるのです。"

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

#: ../../tutorial/errors.rst:159
msgid ""
"The *except clause* may specify a variable after the exception name.  The "
"variable is bound to the exception instance which typically has an ``args`` "
"attribute that stores the arguments. For convenience, builtin exception "
"types define :meth:`~object.__str__` to print all the arguments without "
"explicitly accessing ``.args``.  ::"
msgstr ""
"except節は例外名の後に変数を指定できます。その変数は例外インスタンスに紐付け"
"られ、一般的には引数を保持する ``args`` 属性を持ちます。利便性のため、組み込"
"み例外型には :meth:`~object.__str__` が定義されており、明示的に ``.args`` を"
"参照せずとも すべての引数を表示できます。"

#: ../../tutorial/errors.rst:165
msgid ""
">>> try:\n"
"...     raise Exception('spam', 'eggs')\n"
"... except Exception as inst:\n"
"...     print(type(inst))    # the exception type\n"
"...     print(inst.args)     # arguments stored in .args\n"
"...     print(inst)          # __str__ allows args to be printed directly,\n"
"...                          # but may be overridden in exception "
"subclasses\n"
"...     x, y = inst.args     # unpack args\n"
"...     print('x =', x)\n"
"...     print('y =', y)\n"
"...\n"
"<class 'Exception'>\n"
"('spam', 'eggs')\n"
"('spam', 'eggs')\n"
"x = spam\n"
"y = eggs"
msgstr ""

#: ../../tutorial/errors.rst:182
msgid ""
"The exception's :meth:`~object.__str__` output is printed as the last part "
"('detail') of the message for unhandled exceptions."
msgstr ""
"例外の :meth:`~object.__str__` 出力は、処理されない例外のメッセージ末尾 ('詳"
"細') として表示されます。"

#: ../../tutorial/errors.rst:185
msgid ""
":exc:`BaseException` is the common base class of all exceptions. One of its "
"subclasses, :exc:`Exception`, is the base class of all the non-fatal "
"exceptions. Exceptions which are not subclasses of :exc:`Exception` are not "
"typically handled, because they are used to indicate that the program should "
"terminate. They include :exc:`SystemExit` which is raised by :meth:`sys."
"exit` and :exc:`KeyboardInterrupt` which is raised when a user wishes to "
"interrupt the program."
msgstr ""
":exc:`BaseException` はすべての例外に共通する基底クラスです。そのサブクラスの"
"一つである :exc:`Exception` は、致命的でない例外すべての基底クラスです。 :"
"exc:`Exception` のサブクラスではない例外は、一般的にプログラムが終了すること"
"を示すために使われているため処理されません。例えば、:meth:`sys.exit` によって"
"送出される :exc:`SystemExit` や、ユーザーがプログラムを中断させたいときに送出"
"される :exc:`KeyboardInterrupt` があります。"

#: ../../tutorial/errors.rst:193
msgid ""
":exc:`Exception` can be used as a wildcard that catches (almost) everything. "
"However, it is good practice to be as specific as possible with the types of "
"exceptions that we intend to handle, and to allow any unexpected exceptions "
"to propagate on."
msgstr ""
":exc:`Exception` はほぼすべての例外を捕捉するワイルドカードとして使えます。し"
"かし良い例外処理の手法とは、処理対象の例外の型をできる限り詳細に書き、予期し"
"ない例外はそのまま伝わるようにすることです。"

#: ../../tutorial/errors.rst:198
msgid ""
"The most common pattern for handling :exc:`Exception` is to print or log the "
"exception and then re-raise it (allowing a caller to handle the exception as "
"well)::"
msgstr ""
":exc:`Exception` に対する最も一般的な例外処理のパターンでは、例外を表示あるい"
"はログ出力してから再度送出します(呼び出し側でも例外を処理できるようにします):"

#: ../../tutorial/errors.rst:202
msgid ""
"import sys\n"
"\n"
"try:\n"
"    f = open('myfile.txt')\n"
"    s = f.readline()\n"
"    i = int(s.strip())\n"
"except OSError as err:\n"
"    print(\"OS error:\", err)\n"
"except ValueError:\n"
"    print(\"Could not convert data to an integer.\")\n"
"except Exception as err:\n"
"    print(f\"Unexpected {err=}, {type(err)=}\")\n"
"    raise"
msgstr ""

#: ../../tutorial/errors.rst:216
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:221
msgid ""
"for arg in sys.argv[1:]:\n"
"    try:\n"
"        f = open(arg, 'r')\n"
"    except OSError:\n"
"        print('cannot open', arg)\n"
"    else:\n"
"        print(arg, 'has', len(f.readlines()), 'lines')\n"
"        f.close()"
msgstr ""

#: ../../tutorial/errors.rst:230
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:235
msgid ""
"Exception handlers do not handle only exceptions that occur immediately in "
"the *try clause*, but also those that occur inside functions that are called "
"(even indirectly) in the *try clause*. For example::"
msgstr ""
"例外ハンドラは、*try 節* の直接内側で発生した例外を処理するだけではなくその "
"*try 節* から (たとえ間接的にでも) 呼び出された関数の内部で発生した例外も処理"
"します。例えば::"

#: ../../tutorial/errors.rst:239
msgid ""
">>> def this_fails():\n"
"...     x = 1/0\n"
"...\n"
">>> try:\n"
"...     this_fails()\n"
"... except ZeroDivisionError as err:\n"
"...     print('Handling run-time error:', err)\n"
"...\n"
"Handling run-time error: division by zero"
msgstr ""

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

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

#: ../../tutorial/errors.rst:258
msgid ""
">>> raise NameError('HiThere')\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"    raise NameError('HiThere')\n"
"NameError: HiThere"
msgstr ""

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

#: ../../tutorial/errors.rst:270
msgid "raise ValueError  # shorthand for 'raise ValueError()'"
msgstr ""

#: ../../tutorial/errors.rst:272
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 ""
">>> try:\n"
"...     raise NameError('HiThere')\n"
"... except NameError:\n"
"...     print('An exception flew by!')\n"
"...     raise\n"
"...\n"
"An exception flew by!\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 2, in <module>\n"
"    raise NameError('HiThere')\n"
"NameError: HiThere"
msgstr ""

#: ../../tutorial/errors.rst:292
msgid "Exception Chaining"
msgstr "例外の連鎖"

#: ../../tutorial/errors.rst:294
msgid ""
"If an unhandled exception occurs inside an :keyword:`except` section, it "
"will have the exception being handled attached to it and included in the "
"error message::"
msgstr ""
":keyword:`except` 節の中で未処理の例外が発生した場合、その未処理の例外は処理"
"された例外のエラーメッセージに含まれます::"

#: ../../tutorial/errors.rst:298
msgid ""
">>> try:\n"
"...     open(\"database.sqlite\")\n"
"... except OSError:\n"
"...     raise RuntimeError(\"unable to handle error\")\n"
"...\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 2, in <module>\n"
"    open(\"database.sqlite\")\n"
"    ~~~~^^^^^^^^^^^^^^^^^^^\n"
"FileNotFoundError: [Errno 2] No such file or directory: 'database.sqlite'\n"
"\n"
"During handling of the above exception, another exception occurred:\n"
"\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 4, in <module>\n"
"    raise RuntimeError(\"unable to handle error\")\n"
"RuntimeError: unable to handle error"
msgstr ""

#: ../../tutorial/errors.rst:316
msgid ""
"To indicate that an exception is a direct consequence of another, the :"
"keyword:`raise` statement allows an optional :keyword:`from<raise>` clause::"
msgstr ""
"ある例外が他の例外から直接影響されていることを示すために、:keyword:`raise` 文"
"にオプションの :keyword:`from<raise>` 句を指定します::"

#: ../../tutorial/errors.rst:319
msgid ""
"# exc must be exception instance or None.\n"
"raise RuntimeError from exc"
msgstr ""

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

#: ../../tutorial/errors.rst:324
msgid ""
">>> def func():\n"
"...     raise ConnectionError\n"
"...\n"
">>> try:\n"
"...     func()\n"
"... except ConnectionError as exc:\n"
"...     raise RuntimeError('Failed to open database') from exc\n"
"...\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 2, in <module>\n"
"    func()\n"
"    ~~~~^^\n"
"  File \"<stdin>\", line 2, in func\n"
"ConnectionError\n"
"\n"
"The above exception was the direct cause of the following exception:\n"
"\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 4, in <module>\n"
"    raise RuntimeError('Failed to open database') from exc\n"
"RuntimeError: Failed to open database"
msgstr ""

#: ../../tutorial/errors.rst:346
msgid ""
"It also allows disabling automatic exception chaining using the ``from "
"None`` idiom::"
msgstr "また、自動的な例外の連鎖を無効にするには ``from None`` を指定します。"

#: ../../tutorial/errors.rst:349
msgid ""
">>> try:\n"
"...     open('database.sqlite')\n"
"... except OSError:\n"
"...     raise RuntimeError from None\n"
"...\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 4, in <module>\n"
"    raise RuntimeError from None\n"
"RuntimeError"
msgstr ""

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

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

#: ../../tutorial/errors.rst:367
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:371
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."
msgstr ""
"例外クラスでは、普通のクラスができることなら何でも定義することができますが、"
"通常は単純なものにしておきます。大抵は、いくつかの属性だけを提供し、例外が発"
"生したときにハンドラがエラーに関する情報を取り出せるようにする程度にとどめま"
"す。"

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

#: ../../tutorial/errors.rst:378
msgid ""
"Many standard modules define their own exceptions to report errors that may "
"occur in functions they define."
msgstr ""
"多くの標準モジュールでは、モジュールで定義されている関数内で発生する可能性の"
"あるエラーを報告させるために、独自の例外を定義しています。"

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

#: ../../tutorial/errors.rst:387
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:391
msgid ""
">>> try:\n"
"...     raise KeyboardInterrupt\n"
"... finally:\n"
"...     print('Goodbye, world!')\n"
"...\n"
"Goodbye, world!\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 2, in <module>\n"
"    raise KeyboardInterrupt\n"
"KeyboardInterrupt"
msgstr ""

#: ../../tutorial/errors.rst:402
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:408
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:414
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:418
msgid ""
"If the :keyword:`!finally` clause executes a :keyword:`break`, :keyword:"
"`continue` or :keyword:`return` statement, exceptions are not re-raised."
msgstr ""
":keyword:`!finally` 節で :keyword:`break`、:keyword:`continue` または :"
"keyword:`return` 文が実行された場合、例外は再送出されません。"

#: ../../tutorial/errors.rst:422
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:428
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:434
msgid "For example::"
msgstr "例えば::"

#: ../../tutorial/errors.rst:436
msgid ""
">>> def bool_return():\n"
"...     try:\n"
"...         return True\n"
"...     finally:\n"
"...         return False\n"
"...\n"
">>> bool_return()\n"
"False"
msgstr ""

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

#: ../../tutorial/errors.rst:447
msgid ""
">>> def divide(x, y):\n"
"...     try:\n"
"...         result = x / y\n"
"...     except ZeroDivisionError:\n"
"...         print(\"division by zero!\")\n"
"...     else:\n"
"...         print(\"result is\", result)\n"
"...     finally:\n"
"...         print(\"executing finally clause\")\n"
"...\n"
">>> divide(2, 1)\n"
"result is 2.0\n"
"executing finally clause\n"
">>> divide(2, 0)\n"
"division by zero!\n"
"executing finally clause\n"
">>> divide(\"2\", \"1\")\n"
"executing finally clause\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"    divide(\"2\", \"1\")\n"
"    ~~~~~~^^^^^^^^^^\n"
"  File \"<stdin>\", line 3, in divide\n"
"    result = x / y\n"
"             ~~^~~\n"
"TypeError: unsupported operand type(s) for /: 'str' and 'str'"
msgstr ""

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

#: ../../tutorial/errors.rst:489
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:494
msgid ""
"for line in open(\"myfile.txt\"):\n"
"    print(line, end=\"\")"
msgstr ""

#: ../../tutorial/errors.rst:497
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:503
msgid ""
"with open(\"myfile.txt\") as f:\n"
"    for line in f:\n"
"        print(line, end=\"\")"
msgstr ""

#: ../../tutorial/errors.rst:507
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 されます。ファイルなどの、定義済みクリーンアップ処理を持つオ"
"ブジェクトについては、それぞれのドキュメントで示されます。"

#: ../../tutorial/errors.rst:515
msgid "Raising and Handling Multiple Unrelated Exceptions"
msgstr "複数の関連しない例外の送出と処理"

#: ../../tutorial/errors.rst:517
msgid ""
"There are situations where it is necessary to report several exceptions that "
"have occurred. This is often the case in concurrency frameworks, when "
"several tasks may have failed in parallel, but there are also other use "
"cases where it is desirable to continue execution and collect multiple "
"errors rather than raise the first exception."
msgstr ""
"いくつか発生した例外の報告が必要な状況があります。並列処理のフレームワークで"
"は、複数のタスクが平行して失敗することがたびたびあります。他にも最初の例外を"
"送出するよりも、処理を継続して複数の例外を集約した方が望ましいユースケースも"
"あります。"

#: ../../tutorial/errors.rst:523
msgid ""
"The builtin :exc:`ExceptionGroup` wraps a list of exception instances so "
"that they can be raised together. It is an exception itself, so it can be "
"caught like any other exception. ::"
msgstr ""
"組み込みの :exc:`ExceptionGroup` は例外インスタンスのリストをまとめ、同時に送"
"出できるようにします。ExceptionGroupも例外なので、他の例外と同じように捕捉で"
"きます。::"

#: ../../tutorial/errors.rst:527
msgid ""
">>> def f():\n"
"...     excs = [OSError('error 1'), SystemError('error 2')]\n"
"...     raise ExceptionGroup('there were problems', excs)\n"
"...\n"
">>> f()\n"
"  + Exception Group Traceback (most recent call last):\n"
"  |   File \"<stdin>\", line 1, in <module>\n"
"  |     f()\n"
"  |     ~^^\n"
"  |   File \"<stdin>\", line 3, in f\n"
"  |     raise ExceptionGroup('there were problems', excs)\n"
"  | ExceptionGroup: there were problems (2 sub-exceptions)\n"
"  +-+---------------- 1 ----------------\n"
"    | OSError: error 1\n"
"    +---------------- 2 ----------------\n"
"    | SystemError: error 2\n"
"    +------------------------------------\n"
">>> try:\n"
"...     f()\n"
"... except Exception as e:\n"
"...     print(f'caught {type(e)}: e')\n"
"...\n"
"caught <class 'ExceptionGroup'>: e\n"
">>>"
msgstr ""

#: ../../tutorial/errors.rst:552
msgid ""
"By using ``except*`` instead of ``except``, we can selectively handle only "
"the exceptions in the group that match a certain type. In the following "
"example, which shows a nested exception group, each ``except*`` clause "
"extracts from the group exceptions of a certain type while letting all other "
"exceptions propagate to other clauses and eventually to be reraised. ::"
msgstr ""
"``except`` の代わりに ``except*`` を使用すると、グループの中にある特定の型に"
"一致した例外だけを選択して処理できます。以下の例では、ネストした例外グループ"
"に対して各 ``except*`` 節で特定の型の例外を取り出し、それ以外の例外は他の節に"
"伝えられ、最終的に例外が送出されます。::"

#: ../../tutorial/errors.rst:559
msgid ""
">>> def f():\n"
"...     raise ExceptionGroup(\n"
"...         \"group1\",\n"
"...         [\n"
"...             OSError(1),\n"
"...             SystemError(2),\n"
"...             ExceptionGroup(\n"
"...                 \"group2\",\n"
"...                 [\n"
"...                     OSError(3),\n"
"...                     RecursionError(4)\n"
"...                 ]\n"
"...             )\n"
"...         ]\n"
"...     )\n"
"...\n"
">>> try:\n"
"...     f()\n"
"... except* OSError as e:\n"
"...     print(\"There were OSErrors\")\n"
"... except* SystemError as e:\n"
"...     print(\"There were SystemErrors\")\n"
"...\n"
"There were OSErrors\n"
"There were SystemErrors\n"
"  + Exception Group Traceback (most recent call last):\n"
"  |   File \"<stdin>\", line 2, in <module>\n"
"  |     f()\n"
"  |     ~^^\n"
"  |   File \"<stdin>\", line 2, in f\n"
"  |     raise ExceptionGroup(\n"
"  |     ...<12 lines>...\n"
"  |     )\n"
"  | ExceptionGroup: group1 (1 sub-exception)\n"
"  +-+---------------- 1 ----------------\n"
"    | ExceptionGroup: group2 (1 sub-exception)\n"
"    +-+---------------- 1 ----------------\n"
"      | RecursionError: 4\n"
"      +------------------------------------\n"
">>>"
msgstr ""

#: ../../tutorial/errors.rst:600
msgid ""
"Note that the exceptions nested in an exception group must be instances, not "
"types. This is because in practice the exceptions would typically be ones "
"that have already been raised and caught by the program, along the following "
"pattern::"
msgstr ""
"例外グループの中に含める例外は、型ではなくインスタンスである必要があることに"
"注意してください。これは一般的に、以下のパターンようにプログラムで送出された"
"複数の例外を捕捉することが多いためです。::"

#: ../../tutorial/errors.rst:605
msgid ""
">>> excs = []\n"
"... for test in tests:\n"
"...     try:\n"
"...         test.run()\n"
"...     except Exception as e:\n"
"...         excs.append(e)\n"
"...\n"
">>> if excs:\n"
"...    raise ExceptionGroup(\"Test Failures\", excs)\n"
"..."
msgstr ""

#: ../../tutorial/errors.rst:620
msgid "Enriching Exceptions with Notes"
msgstr "ノートによって例外を充実させる"

#: ../../tutorial/errors.rst:622
msgid ""
"When an exception is created in order to be raised, it is usually "
"initialized with information that describes the error that has occurred. "
"There are cases where it is useful to add information after the exception "
"was caught. For this purpose, exceptions have a method ``add_note(note)`` "
"that accepts a string and adds it to the exception's notes list. The "
"standard traceback rendering includes all notes, in the order they were "
"added, after the exception. ::"
msgstr ""
"例外を送出するために生成するときに、通常は発生したエラーを説明する情報で初期"
"化されます。例外を受け取ったあとに情報を追加すると便利な場合があります。この"
"目的のために、例外は ``add_note(note)`` メソッドを持ちます。このメソッドは文"
"字列を受け取り、例外のノートのリストに追加します。標準のトレースバックでは例"
"外の後に、全てのノートが追加した順番に出力されます。::"

#: ../../tutorial/errors.rst:629
msgid ""
">>> try:\n"
"...     raise TypeError('bad type')\n"
"... except Exception as e:\n"
"...     e.add_note('Add some information')\n"
"...     e.add_note('Add some more information')\n"
"...     raise\n"
"...\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 2, in <module>\n"
"    raise TypeError('bad type')\n"
"TypeError: bad type\n"
"Add some information\n"
"Add some more information\n"
">>>"
msgstr ""

#: ../../tutorial/errors.rst:644
msgid ""
"For example, when collecting exceptions into an exception group, we may want "
"to add context information for the individual errors. In the following each "
"exception in the group has a note indicating when this error has occurred. ::"
msgstr ""
"たとえば、複数の例外を1つの例外グループにまとめるときに、各エラーのコンテキス"
"ト情報を追加したい場合があります。以下のグループ内の各例外が持つノートは、エ"
"ラーがいつ発生したかを示しています。::"

#: ../../tutorial/errors.rst:648
msgid ""
">>> def f():\n"
"...     raise OSError('operation failed')\n"
"...\n"
">>> excs = []\n"
">>> for i in range(3):\n"
"...     try:\n"
"...         f()\n"
"...     except Exception as e:\n"
"...         e.add_note(f'Happened in Iteration {i+1}')\n"
"...         excs.append(e)\n"
"...\n"
">>> raise ExceptionGroup('We have some problems', excs)\n"
"  + Exception Group Traceback (most recent call last):\n"
"  |   File \"<stdin>\", line 1, in <module>\n"
"  |     raise ExceptionGroup('We have some problems', excs)\n"
"  | ExceptionGroup: We have some problems (3 sub-exceptions)\n"
"  +-+---------------- 1 ----------------\n"
"    | Traceback (most recent call last):\n"
"    |   File \"<stdin>\", line 3, in <module>\n"
"    |     f()\n"
"    |     ~^^\n"
"    |   File \"<stdin>\", line 2, in f\n"
"    |     raise OSError('operation failed')\n"
"    | OSError: operation failed\n"
"    | Happened in Iteration 1\n"
"    +---------------- 2 ----------------\n"
"    | Traceback (most recent call last):\n"
"    |   File \"<stdin>\", line 3, in <module>\n"
"    |     f()\n"
"    |     ~^^\n"
"    |   File \"<stdin>\", line 2, in f\n"
"    |     raise OSError('operation failed')\n"
"    | OSError: operation failed\n"
"    | Happened in Iteration 2\n"
"    +---------------- 3 ----------------\n"
"    | Traceback (most recent call last):\n"
"    |   File \"<stdin>\", line 3, in <module>\n"
"    |     f()\n"
"    |     ~^^\n"
"    |   File \"<stdin>\", line 2, in f\n"
"    |     raise OSError('operation failed')\n"
"    | OSError: operation failed\n"
"    | Happened in Iteration 3\n"
"    +------------------------------------\n"
">>>"
msgstr ""