# 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:

# Yusuke Miyazaki <miyazaki.dev@gmail.com>, 2021

# 菊池 健志, 2023

# Arihiro TAKASE, 2023

# Osamu NAKAMURA, 2023

# Masato HASHIMOTO <cabezon.hashimoto@gmail.com>, 2023

# Nozomu Kaneko <nozom.kaneko@gmail.com>, 2023

# tomo, 2023

# digdugdog, 2023

# Takanori Suzuki <takanori@takanory.net>, 2023

# Takeshi Nakazato, 2024

#

#, fuzzy

msgid ""

msgstr ""

"Project-Id-Version: Python 3.14\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2025-05-23 14:20+0000\n"

"PO-Revision-Date: 2021-06-28 01:19+0000\n"

"Last-Translator: Takeshi Nakazato, 2024\n"

"Language-Team: Japanese (https://app.transifex.com/python-doc/teams/5390/"

"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"

#: ../../reference/compound_stmts.rst:5

msgid "Compound statements"

msgstr "複合文 (compound statement)"

#: ../../reference/compound_stmts.rst:9

msgid ""

"Compound statements contain (groups of) other statements; they affect or "

"control the execution of those other statements in some way. In general, "

"compound statements span multiple lines, although in simple incarnations a "

"whole compound statement may be contained in one line."

msgstr ""

"複合文には、他の文 (のグループ) が入ります; 複合文は、中に入っている他の文の"

"実行の制御に何らかのやり方で影響を及ぼします。一般的には、複合文は複数行にま"

"たがって書かれますが、全部の文を一行に連ねた単純な書き方もあります。"

#: ../../reference/compound_stmts.rst:14

msgid ""

"The :keyword:`if`, :keyword:`while` and :keyword:`for` statements implement "

"traditional control flow constructs. :keyword:`try` specifies exception "

"handlers and/or cleanup code for a group of statements, while the :keyword:"

"`with` statement allows the execution of initialization and finalization "

"code around a block of code. Function and class definitions are also "

"syntactically compound statements."

msgstr ""

":keyword:`if` 、 :keyword:`while` 、および :keyword:`for` 文は、伝統的な制御"

"フロー構成を実現します。 :keyword:`try` は例外処理および/または一連の文に対す"

"るクリーンアップコードを指定します。それに対して、 :keyword:`with` 文はコード"

"のかたまりの前後でコードの初期化と終了処理を実行できるようにします。関数とク"

"ラス定義もまた、構文的には複合文です。"

#: ../../reference/compound_stmts.rst:26

msgid ""

"A compound statement consists of one or more 'clauses.' A clause consists "

"of a header and a 'suite.' The clause headers of a particular compound "

"statement are all at the same indentation level. Each clause header begins "

"with a uniquely identifying keyword and ends with a colon. A suite is a "

"group of statements controlled by a clause. A suite can be one or more "

"semicolon-separated simple statements on the same line as the header, "

"following the header's colon, or it can be one or more indented statements "

"on subsequent lines. Only the latter form of a suite can contain nested "

"compound statements; the following is illegal, mostly because it wouldn't be "

"clear to which :keyword:`if` clause a following :keyword:`else` clause would "

"belong::"

msgstr ""

"複合文は、一つ以上の '節 (clause)' からなります。節は、ヘッダと 'スイート "

"(suite)' からなります。一つの複合文を成す各節のヘッダは、全て同じインデントレ"

"ベルに置かれます。各節のヘッダは一意に識別するキーワードで始まり、コロンで終"

"わります。スイートは、節によって制御される文の集まりです。スイートは、ヘッダ"

"がある行のコロンの後にセミコロンで区切って置かれた一つ以上の単純文、または、"

"ヘッダに続く行で一つ多くインデントされた文の集まりです。後者の形式のスイート"

"に限り、さらに複合文をネストできます; 以下の文は、 :keyword:`else` 節がどちら"

"の :keyword:`if` 節に属するかがはっきりしないなどの理由から不正になります::"

#: ../../reference/compound_stmts.rst:37

msgid "if test1: if test2: print(x)"

msgstr ""

#: ../../reference/compound_stmts.rst:39

msgid ""

"Also note that the semicolon binds tighter than the colon in this context, "

"so that in the following example, either all or none of the :func:`print` "

"calls are executed::"

msgstr ""

"また、このコンテキスト中では、セミコロンによる結合はコロンより強いです。従っ"

"て、以下の例では、 :func:`print` の呼び出しはは全て実行されるか、全く実行され"

"ないかのどちらかです::"

#: ../../reference/compound_stmts.rst:43

msgid "if x < y < z: print(x); print(y); print(z)"

msgstr ""

#: ../../reference/compound_stmts.rst:45

msgid "Summarizing:"

msgstr "まとめると、以下のようになります:"

#: ../../reference/compound_stmts.rst:69

msgid ""

"Note that statements always end in a ``NEWLINE`` possibly followed by a "

"``DEDENT``. Also note that optional continuation clauses always begin with "

"a keyword that cannot start a statement, thus there are no ambiguities (the "

"'dangling :keyword:`else`' problem is solved in Python by requiring nested :"

"keyword:`if` statements to be indented)."

msgstr ""

"なお、文は常に ``NEWLINE`` か、その後に ``DEDENT`` が続いたもので終了します。"

"また、オプションの継続節は必ず、文を開始できない予約語で始まるので、曖昧さは"

"存在しません。 (Python では、 'ぶら下がり (dangling) :keyword:`else`' 問題"

"は、ネストされた :keyword:`if` 文をインデントさせることで解決されます)。"

#: ../../reference/compound_stmts.rst:75

msgid ""

"The formatting of the grammar rules in the following sections places each "

"clause on a separate line for clarity."

msgstr ""

"以下の節における文法規則の記述方式は、明確さのために、各節を別々の行に書くよ"

"うにしています。"

#: ../../reference/compound_stmts.rst:84

msgid "The :keyword:`!if` statement"

msgstr ":keyword:`!if` 文"

#: ../../reference/compound_stmts.rst:92

msgid "The :keyword:`if` statement is used for conditional execution:"

msgstr ":keyword:`if` 文は、条件分岐を実行するために使われます:"

#: ../../reference/compound_stmts.rst:99

msgid ""

"It selects exactly one of the suites by evaluating the expressions one by "

"one until one is found to be true (see section :ref:`booleans` for the "

"definition of true and false); then that suite is executed (and no other "

"part of the :keyword:`if` statement is executed or evaluated). If all "

"expressions are false, the suite of the :keyword:`else` clause, if present, "

"is executed."

msgstr ""

":keyword:`if` 文は、式を一つ一つ評価してゆき、真になるまで続けて、真になった"

"節のスイートだけを選択します (真: true と偽: false の定義については、 :ref:"

"`booleans` 節を参照してください); 次に、選択したスイートを実行します (そし"

"て、 :keyword:`if` 文の他の部分は、実行や評価をされません)。全ての式が偽に"

"なった場合、 :keyword:`else` 節があれば、そのスイートが実行されます。"

#: ../../reference/compound_stmts.rst:109

msgid "The :keyword:`!while` statement"

msgstr ":keyword:`!while` 文"

#: ../../reference/compound_stmts.rst:117

msgid ""

"The :keyword:`while` statement is used for repeated execution as long as an "

"expression is true:"

msgstr ""

":keyword:`while` 文は、式の値が真である間、実行を繰り返すために使われます:"

#: ../../reference/compound_stmts.rst:124

msgid ""

"This repeatedly tests the expression and, if it is true, executes the first "

"suite; if the expression is false (which may be the first time it is tested) "

"the suite of the :keyword:`!else` clause, if present, is executed and the "

"loop terminates."

msgstr ""

":keyword:`while` 文は式を繰り返し真偽評価し、真であれば最初のスイートを実行し"

"ます。式が偽であれば (最初から偽になっていることもありえます)、 :keyword:`!"

"else` 節がある場合にはそれを実行し、ループを終了します。"

#: ../../reference/compound_stmts.rst:133

msgid ""

"A :keyword:`break` statement executed in the first suite terminates the loop "

"without executing the :keyword:`!else` clause's suite. A :keyword:"

"`continue` statement executed in the first suite skips the rest of the suite "

"and goes back to testing the expression."

msgstr ""

"最初のスイート内で :keyword:`break` 文が実行されると、 :keyword:`!else` 節の"

"スイートを実行することなくループを終了します。 :keyword:`continue` 文が最初の"

"スイート内で実行されると、スイート内にある残りの文の実行をスキップして、式の"

"真偽評価に戻ります。"

#: ../../reference/compound_stmts.rst:142

msgid "The :keyword:`!for` statement"

msgstr ":keyword:`!for` 文"

#: ../../reference/compound_stmts.rst:153

msgid ""

"The :keyword:`for` statement is used to iterate over the elements of a "

"sequence (such as a string, tuple or list) or other iterable object:"

msgstr ""

":keyword:`for` 文は、シーケンス (文字列、タプルまたはリスト) や、その他の反復"

"可能なオブジェクト (iterable object) 内の要素に渡って反復処理を行うために使わ"

"れます:"

#: ../../reference/compound_stmts.rst:160

msgid ""

"The :token:`~python-grammar:starred_expression_list` expression is evaluated "

"once; it should yield an :term:`iterable` object. An :term:`iterator` is "

"created for that iterable. The first item provided by the iterator is then "

"assigned to the target list using the standard rules for assignments (see :"

"ref:`assignment`), and the suite is executed. This repeats for each item "

"provided by the iterator. When the iterator is exhausted, the suite in the :"

"keyword:`!else` clause, if present, is executed, and the loop terminates."

msgstr ""

#: ../../reference/compound_stmts.rst:173

msgid ""

"A :keyword:`break` statement executed in the first suite terminates the loop "

"without executing the :keyword:`!else` clause's suite. A :keyword:"

"`continue` statement executed in the first suite skips the rest of the suite "

"and continues with the next item, or with the :keyword:`!else` clause if "

"there is no next item."

msgstr ""

"最初のスイートの中で :keyword:`break` 文が実行されると、 :keyword:`!else` 節"

"のスイートを実行することなくループを終了します。\n"

":keyword:`continue` 文が最初のスイート内で実行されると、スイート内にある残り"

"の文の実行をスキップして、次の要素の処理に移るか、これ以上次の要素が無い場合"

"は :keyword:`!else` 節の処理に移ります。"

#: ../../reference/compound_stmts.rst:179

msgid ""

"The for-loop makes assignments to the variables in the target list. This "

"overwrites all previous assignments to those variables including those made "

"in the suite of the for-loop::"

msgstr ""

"for ループはターゲットリスト内の変数への代入を行います。\n"

"これにより、for ループ内も含めて、それ以前の全ての代入は上書きされます::"

#: ../../reference/compound_stmts.rst:183

msgid ""

"for i in range(10):\n"

" print(i)\n"

" i = 5 # this will not affect the for-loop\n"

" # because i will be overwritten with the next\n"

" # index in the range"

msgstr ""

#: ../../reference/compound_stmts.rst:193

msgid ""

"Names in the target list are not deleted when the loop is finished, but if "

"the sequence is empty, they will not have been assigned to at all by the "

"loop. Hint: the built-in type :func:`range` represents immutable arithmetic "

"sequences of integers. For instance, iterating ``range(3)`` successively "

"yields 0, 1, and then 2."

msgstr ""

"ループが終了してもターゲットリスト内の名前は削除されませんが、イテラブルが空"

"の場合には、ループでの代入は全く行われません。ヒント: 組み込み型 :func:"

"`range` は、 整数の不変算術列を表します。例えば、 ``range(3)`` を反復すると"

"0、1そして2の順に結果を返します。"

#: ../../reference/compound_stmts.rst:198

msgid "Starred elements are now allowed in the expression list."

msgstr ""

"式のリストの中でアスタリスク付きの式 (starred elements) を指定できるようにな"

"りました。"

#: ../../reference/compound_stmts.rst:205

msgid "The :keyword:`!try` statement"

msgstr ":keyword:`!try` 文"

#: ../../reference/compound_stmts.rst:215

msgid ""

"The :keyword:`!try` statement specifies exception handlers and/or cleanup "

"code for a group of statements:"

msgstr ""

":keyword:`!try` 文は、ひとまとめの文に対して、例外処理および/またはクリーン"

"アップコードを指定します:"

#: ../../reference/compound_stmts.rst:231

msgid ""

"Additional information on exceptions can be found in section :ref:"

"`exceptions`, and information on using the :keyword:`raise` statement to "

"generate exceptions may be found in section :ref:`raise`."

msgstr ""

"例外に関するその他の情報は :ref:`exceptions` 節にあります。また、 :keyword:"

"`raise` 文の使用による例外の生成に関する情報は、 :ref:`raise` 節にあります。"

#: ../../reference/compound_stmts.rst:235

msgid ""

"Support for optionally dropping grouping parentheses when using multiple "

"exception types. See :pep:`758`."

msgstr ""

#: ../../reference/compound_stmts.rst:241

msgid ":keyword:`!except` clause"

msgstr ":keyword:`!except` 節"

#: ../../reference/compound_stmts.rst:243

msgid ""

"The :keyword:`!except` clause(s) specify one or more exception handlers. "

"When no exception occurs in the :keyword:`try` clause, no exception handler "

"is executed. When an exception occurs in the :keyword:`!try` suite, a search "

"for an exception handler is started. This search inspects the :keyword:`!"

"except` clauses in turn until one is found that matches the exception. An "

"expression-less :keyword:`!except` clause, if present, must be last; it "

"matches any exception."

msgstr ""

#: ../../reference/compound_stmts.rst:251

msgid ""

"For an :keyword:`!except` clause with an expression, the expression must "

"evaluate to an exception type or a tuple of exception types. Parentheses can "

"be dropped if multiple exception types are provided and the ``as`` clause is "

"not used. The raised exception matches an :keyword:`!except` clause whose "

"expression evaluates to the class or a :term:`non-virtual base class "

"<abstract base class>` of the exception object, or to a tuple that contains "

"such a class."

msgstr ""

#: ../../reference/compound_stmts.rst:258

msgid ""

"If no :keyword:`!except` clause matches the exception, the search for an "

"exception handler continues in the surrounding code and on the invocation "

"stack. [#]_"

msgstr ""

"例外がどの :keyword:`!except` 節にも合致しなかった場合、現在のコードを囲うさ"

"らに外側、そして呼び出しスタックへと検索を続けます。 [#]_"

#: ../../reference/compound_stmts.rst:262

msgid ""

"If the evaluation of an expression in the header of an :keyword:`!except` "

"clause raises an exception, the original search for a handler is canceled "

"and a search starts for the new exception in the surrounding code and on the "

"call stack (it is treated as if the entire :keyword:`try` statement raised "

"the exception)."

msgstr ""

":keyword:`!except` 節のヘッダにある式を値評価するときに例外が発生すると、元々"

"のハンドラ検索はキャンセルされ、新たな例外に対する例外ハンドラの検索を現在"

"の :keyword:`except` 節の外側のコードや呼び出しスタックに対して行います (:"

"keyword:`try` 文全体が例外を発行したかのように扱われます)。"

#: ../../reference/compound_stmts.rst:270

msgid ""

"When a matching :keyword:`!except` clause is found, the exception is "

"assigned to the target specified after the :keyword:`!as` keyword in that :"

"keyword:`!except` clause, if present, and the :keyword:`!except` clause's "

"suite is executed. All :keyword:`!except` clauses must have an executable "

"block. When the end of this block is reached, execution continues normally "

"after the entire :keyword:`try` statement. (This means that if two nested "

"handlers exist for the same exception, and the exception occurs in the :"

"keyword:`!try` clause of the inner handler, the outer handler will not "

"handle the exception.)"

msgstr ""

"対応する :keyword:`!except` 節が見つかると、:keyword:`!except` 節のスイートが"

"実行されます。その際、 :keyword:`!as` キーワードが :keyword:`!except` 節に存"

"在すれば、その後で指定されているターゲットに例外が代入されます。全ての :"

"keyword:`!except` 節は実行可能なブロックを持っていなければなりません。このブ"

"ロックの末尾に到達すると、通常は :keyword:`try` 文全体の直後から実行を継続し"

"ます。(このことは、ネストされた二つの例外ハンドラが同じ例外に対して存在し、内"

"側のハンドラ内の :keyword:`!try` 節で例外が発生した場合、外側のハンドラはその"

"例外を処理しないことを意味します。)"

#: ../../reference/compound_stmts.rst:281

msgid ""

"When an exception has been assigned using ``as target``, it is cleared at "

"the end of the :keyword:`!except` clause. This is as if ::"

msgstr ""

"例外が ``as target`` を使って代入されたとき、それは :keyword:`!except` 節の終"

"わりに消去されます。これはちょうど、以下のコード::"

#: ../../reference/compound_stmts.rst:284

msgid ""

"except E as N:\n"

" foo"

msgstr ""

#: ../../reference/compound_stmts.rst:287

msgid "was translated to ::"

msgstr "が、以下のコードに翻訳されたかのようなものです::"

#: ../../reference/compound_stmts.rst:289

msgid ""

"except E as N:\n"

" try:\n"

" foo\n"

" finally:\n"

" del N"

msgstr ""

#: ../../reference/compound_stmts.rst:295

msgid ""

"This means the exception must be assigned to a different name to be able to "

"refer to it after the :keyword:`!except` clause. Exceptions are cleared "

"because with the traceback attached to them, they form a reference cycle "

"with the stack frame, keeping all locals in that frame alive until the next "

"garbage collection occurs."

msgstr ""

"よって、例外を :keyword:`!except` 節以降で参照できるようにするためには、別の"

"名前に代入されなければなりません。例外が削除されるのは、トレースバックが付与"

"されると、そのスタックフレームと循環参照を形作り、次のガベージ収集までそのフ"

"レーム内のすべての局所変数を生存させてしまうからです。"

#: ../../reference/compound_stmts.rst:305

msgid ""

"Before an :keyword:`!except` clause's suite is executed, the exception is "

"stored in the :mod:`sys` module, where it can be accessed from within the "

"body of the :keyword:`!except` clause by calling :func:`sys.exception`. When "

"leaving an exception handler, the exception stored in the :mod:`sys` module "

"is reset to its previous value::"

msgstr ""

":keyword:`!except` 節のスイートが実行される前に、例外が :mod:`sys` モジュール"

"に格納されます。\n"

":keyword:`!except` 節の中では、 :func:`sys.exception` を呼び出す事によってこ"

"の例外にアクセスすることができます。\n"

"例外ハンドラを抜けると、 :mod:`sys` モジュールに格納されている例外の値が、一"

"つ前の値に戻ります::"

#: ../../reference/compound_stmts.rst:311

msgid ""

">>> print(sys.exception())\n"

"None\n"

">>> try:\n"

"... raise TypeError\n"

"... except:\n"

"... print(repr(sys.exception()))\n"

"... try:\n"

"... raise ValueError\n"

"... except:\n"

"... print(repr(sys.exception()))\n"

"... print(repr(sys.exception()))\n"

"...\n"

"TypeError()\n"

"ValueError()\n"

"TypeError()\n"

">>> print(sys.exception())\n"

"None"

msgstr ""

#: ../../reference/compound_stmts.rst:336

msgid ":keyword:`!except*` clause"

msgstr ":keyword:`!except*` 節"

#: ../../reference/compound_stmts.rst:338

msgid ""

"The :keyword:`!except*` clause(s) are used for handling :exc:"

"`ExceptionGroup`\\s. The exception type for matching is interpreted as in "

"the case of :keyword:`except`, but in the case of exception groups we can "

"have partial matches when the type matches some of the exceptions in the "

"group. This means that multiple :keyword:`!except*` clauses can execute, "

"each handling part of the exception group. Each clause executes at most once "

"and handles an exception group of all matching exceptions. Each exception "

"in the group is handled by at most one :keyword:`!except*` clause, the first "

"that matches it. ::"

msgstr ""

#: ../../reference/compound_stmts.rst:348

msgid ""

">>> try:\n"

"... raise ExceptionGroup(\"eg\",\n"

"... [ValueError(1), TypeError(2), OSError(3), OSError(4)])\n"

"... except* TypeError as e:\n"

"... print(f'caught {type(e)} with nested {e.exceptions}')\n"

"... except* OSError as e:\n"

"... print(f'caught {type(e)} with nested {e.exceptions}')\n"

"...\n"

"caught <class 'ExceptionGroup'> with nested (TypeError(2),)\n"

"caught <class 'ExceptionGroup'> with nested (OSError(3), OSError(4))\n"

" + Exception Group Traceback (most recent call last):\n"

" | File \"<stdin>\", line 2, in <module>\n"

" | ExceptionGroup: eg\n"

" +-+---------------- 1 ----------------\n"

" | ValueError: 1\n"

" +------------------------------------"

msgstr ""

#: ../../reference/compound_stmts.rst:366

msgid ""

"Any remaining exceptions that were not handled by any :keyword:`!except*` "

"clause are re-raised at the end, along with all exceptions that were raised "

"from within the :keyword:`!except*` clauses. If this list contains more than "

"one exception to reraise, they are combined into an exception group."

msgstr ""

#: ../../reference/compound_stmts.rst:372

msgid ""

"If the raised exception is not an exception group and its type matches one "

"of the :keyword:`!except*` clauses, it is caught and wrapped by an exception "

"group with an empty message string. ::"

msgstr ""

#: ../../reference/compound_stmts.rst:376

msgid ""

">>> try:\n"

"... raise BlockingIOError\n"

"... except* BlockingIOError as e:\n"

"... print(repr(e))\n"

"...\n"

"ExceptionGroup('', (BlockingIOError()))"

msgstr ""

#: ../../reference/compound_stmts.rst:383

msgid ""

"An :keyword:`!except*` clause must have a matching expression; it cannot be "

"``except*:``. Furthermore, this expression cannot contain exception group "

"types, because that would have ambiguous semantics."

msgstr ""

#: ../../reference/compound_stmts.rst:387

msgid ""

"It is not possible to mix :keyword:`except` and :keyword:`!except*` in the "

"same :keyword:`try`. :keyword:`break`, :keyword:`continue` and :keyword:"

"`return` cannot appear in an :keyword:`!except*` clause."

msgstr ""

#: ../../reference/compound_stmts.rst:402

msgid ":keyword:`!else` clause"

msgstr ":keyword:`!else` 節"

#: ../../reference/compound_stmts.rst:404

msgid ""

"The optional :keyword:`!else` clause is executed if the control flow leaves "

"the :keyword:`try` suite, no exception was raised, and no :keyword:"

"`return`, :keyword:`continue`, or :keyword:`break` statement was executed. "

"Exceptions in the :keyword:`!else` clause are not handled by the preceding :"

"keyword:`except` clauses."

msgstr ""

"オプションの :keyword:`!else` 節は、コントロールフローが :keyword:`try` ス"

"イートを抜け、例外が送出されず、 :keyword:`return` 文、 :keyword:`continue` "

"文、 :keyword:`break` 文のいずれもが実行されなかった場合に実行されます。\n"

":keyword:`!else` 節で起きた例外は、手前にある :keyword:`except` 節では処理さ"

"れません。"

#: ../../reference/compound_stmts.rst:416

msgid ":keyword:`!finally` clause"

msgstr ":keyword:`!finally` 節"

#: ../../reference/compound_stmts.rst:418

msgid ""

"If :keyword:`!finally` is present, it specifies a 'cleanup' handler. The :"

"keyword:`try` clause is executed, including any :keyword:`except` and :"

"keyword:`else` clauses. If an exception occurs in any of the clauses and is "

"not handled, the exception is temporarily saved. The :keyword:`!finally` "

"clause is executed. If there is a saved exception it is re-raised at the "

"end of the :keyword:`!finally` clause. If the :keyword:`!finally` clause "

"raises another exception, the saved exception is set as the context of the "

"new exception. If the :keyword:`!finally` clause executes a :keyword:"

"`return`, :keyword:`break` or :keyword:`continue` statement, the saved "

"exception is discarded. For example, this function returns 42."

msgstr ""

#: ../../reference/compound_stmts.rst:429

msgid ""

"def f():\n"

" try:\n"

" 1/0\n"

" finally:\n"

" return 42"

msgstr ""

#: ../../reference/compound_stmts.rst:437

msgid ""

"The exception information is not available to the program during execution "

"of the :keyword:`!finally` clause."

msgstr ""

":keyword:`!finally` 節を実行している間は、プログラムからは例外情報は利用でき"

"ません。"

#: ../../reference/compound_stmts.rst:445

msgid ""

"When a :keyword:`return`, :keyword:`break` or :keyword:`continue` statement "

"is executed in the :keyword:`try` suite of a :keyword:`!try`...\\ :keyword:`!"

"finally` statement, the :keyword:`!finally` clause is also executed 'on the "

"way out.'"

msgstr ""

":keyword:`try`...\\ :keyword:`!finally` 文の :keyword:`try` スイート内で :"

"keyword:`return` 、 :keyword:`break` 、または :keyword:`continue` 文が実行さ"

"れた場合、 :keyword:`!finally` 節も、この文を '抜け出る途中に' 実行されます。"

#: ../../reference/compound_stmts.rst:449

msgid ""

"The return value of a function is determined by the last :keyword:`return` "

"statement executed. Since the :keyword:`!finally` clause always executes, "

"a :keyword:`!return` statement executed in the :keyword:`!finally` clause "

"will always be the last one executed. The following function returns "

"'finally'."

msgstr ""

#: ../../reference/compound_stmts.rst:454

msgid ""

"def foo():\n"

" try:\n"

" return 'try'\n"

" finally:\n"

" return 'finally'"

msgstr ""

#: ../../reference/compound_stmts.rst:462

msgid ""

"Prior to Python 3.8, a :keyword:`continue` statement was illegal in the :"

"keyword:`!finally` clause due to a problem with the implementation."

msgstr ""

"Python3.8 以前では、実装上の問題により :keyword:`!finally` 節での :keyword:"

"`continue` 文は不正でした。"

#: ../../reference/compound_stmts.rst:466

msgid ""

"The compiler emits a :exc:`SyntaxWarning` when a :keyword:`return`, :keyword:"

"`break` or :keyword:`continue` appears in a :keyword:`!finally` block (see :"

"pep:`765`)."

msgstr ""

#: ../../reference/compound_stmts.rst:476

msgid "The :keyword:`!with` statement"

msgstr ":keyword:`!with` 文"

#: ../../reference/compound_stmts.rst:485

msgid ""

"The :keyword:`with` statement is used to wrap the execution of a block with "

"methods defined by a context manager (see section :ref:`context-managers`). "

"This allows common :keyword:`try`...\\ :keyword:`except`...\\ :keyword:"

"`finally` usage patterns to be encapsulated for convenient reuse."

msgstr ""

":keyword:`with` 文は、ブロックの実行を、コンテキストマネージャによって定義さ"

"れたメソッドでラップするために使われます (:ref:`context-managers` セクション"

"を参照してください)。これにより、よくある :keyword:`try`...\\ :keyword:"

"`except`...\\ :keyword:`finally` 利用パターンをカプセル化して便利に再利用する"

"ことができます。"

#: ../../reference/compound_stmts.rst:495

msgid ""

"The execution of the :keyword:`with` statement with one \"item\" proceeds as "

"follows:"

msgstr ""

"一つの \"要素\" を持つ :keyword:`with` 文の実行は以下のように進行します:"

#: ../../reference/compound_stmts.rst:497

msgid ""

"The context expression (the expression given in the :token:`~python-grammar:"

"with_item`) is evaluated to obtain a context manager."

msgstr ""

"コンテキスト式 (:token:`~python-grammar:with_item` で与えられた式) を評価する"

"ことで、コンテキストマネージャを取得します。"

#: ../../reference/compound_stmts.rst:500

msgid ""

"The context manager's :meth:`~object.__enter__` is loaded for later use."

msgstr ""

"コンテキストマネージャの :meth:`~object.__enter__` メソッドが、後で使うために"

"ロードされます。"

#: ../../reference/compound_stmts.rst:502

msgid "The context manager's :meth:`~object.__exit__` is loaded for later use."

msgstr ""

"コンテキストマネージャの :meth:`~object.__exit__` メソッドが、後で使うために"

"ロードされます。"

#: ../../reference/compound_stmts.rst:504

msgid "The context manager's :meth:`~object.__enter__` method is invoked."

msgstr ""

"コンテキストマネージャの :meth:`~object.__enter__` メソッドが呼ばれます。"

#: ../../reference/compound_stmts.rst:506

msgid ""

"If a target was included in the :keyword:`with` statement, the return value "

"from :meth:`~object.__enter__` is assigned to it."

msgstr ""

":keyword:`with` 文にターゲットが含まれていたら、それに :meth:`~object."

"__enter__` からの戻り値が代入されます。"

#: ../../reference/compound_stmts.rst:511

msgid ""

"The :keyword:`with` statement guarantees that if the :meth:`~object."

"__enter__` method returns without an error, then :meth:`~object.__exit__` "

"will always be called. Thus, if an error occurs during the assignment to the "

"target list, it will be treated the same as an error occurring within the "

"suite would be. See step 7 below."

msgstr ""

":keyword:`with` 文は、 :meth:`~object.__enter__` メソッドがエラーなく終了した"

"場合には :meth:`~object.__exit__` が常に呼ばれることを保証します。ですので、"

"もしターゲットリストへの代入中にエラーが発生した場合には、これはそのスイート"

"の中で発生したエラーと同じように扱われます。以下のステップ 7 を参照してくださ"

"い。"

#: ../../reference/compound_stmts.rst:517

msgid "The suite is executed."

msgstr "スイートが実行されます。"

#: ../../reference/compound_stmts.rst:519

msgid ""

"The context manager's :meth:`~object.__exit__` method is invoked. If an "

"exception caused the suite to be exited, its type, value, and traceback are "

"passed as arguments to :meth:`~object.__exit__`. Otherwise, three :const:"

"`None` arguments are supplied."

msgstr ""

"コンテキストマネージャの :meth:`~object.__exit__` メソッドが呼ばれます。ス"

"イートが例外によって終了されたのなら、その例外の型、値、トレースバックが :"

"meth:`~object.__exit__` に引数として渡されます。そうでなければ、 3 つの :"

"const:`None` 引数が与えられます。"

#: ../../reference/compound_stmts.rst:524

msgid ""

"If the suite was exited due to an exception, and the return value from the :"

"meth:`~object.__exit__` method was false, the exception is reraised. If the "

"return value was true, the exception is suppressed, and execution continues "

"with the statement following the :keyword:`with` statement."

msgstr ""

"スイートが例外により終了され、 :meth:`~object.__exit__` メソッドからの戻り値"

"が偽（false）ならば、例外が再送出されます。この戻り値が真（true）ならば例外は"

"抑制され、実行は :keyword:`with` 文の次の文から続きます。"

#: ../../reference/compound_stmts.rst:529

msgid ""

"If the suite was exited for any reason other than an exception, the return "

"value from :meth:`~object.__exit__` is ignored, and execution proceeds at "

"the normal location for the kind of exit that was taken."

msgstr ""

"もしそのスイートが例外でない何らかの理由で終了した場合、その :meth:`~object."

"__exit__` からの戻り値は無視されて、実行は発生した終了の種類に応じた通常の位"

"置から継続します。"

#: ../../reference/compound_stmts.rst:533

#: ../../reference/compound_stmts.rst:1550

#: ../../reference/compound_stmts.rst:1591

msgid "The following code::"

msgstr "以下のコード::"

#: ../../reference/compound_stmts.rst:535

msgid ""

"with EXPRESSION as TARGET:\n"

" SUITE"

msgstr ""

#: ../../reference/compound_stmts.rst:538

#: ../../reference/compound_stmts.rst:563

#: ../../reference/compound_stmts.rst:1596

msgid "is semantically equivalent to::"

msgstr "これは次と等価です::"

#: ../../reference/compound_stmts.rst:540

msgid ""

"manager = (EXPRESSION)\n"

"enter = type(manager).__enter__\n"

"exit = type(manager).__exit__\n"

"value = enter(manager)\n"

"hit_except = False\n"

"\n"

"try:\n"

" TARGET = value\n"

" SUITE\n"

"except:\n"

" hit_except = True\n"

" if not exit(manager, *sys.exc_info()):\n"

" raise\n"

"finally:\n"

" if not hit_except:\n"

" exit(manager, None, None, None)"

msgstr ""

#: ../../reference/compound_stmts.rst:557

msgid ""

"With more than one item, the context managers are processed as if multiple :"

"keyword:`with` statements were nested::"

msgstr ""

"複数の要素があるとき、コンテキストマネージャは複数の :keyword:`with` 文がネス"

"トされたかのように進行します::"

#: ../../reference/compound_stmts.rst:560

msgid ""

"with A() as a, B() as b:\n"

" SUITE"

msgstr ""

#: ../../reference/compound_stmts.rst:565

msgid ""

"with A() as a:\n"

" with B() as b:\n"

" SUITE"

msgstr ""

#: ../../reference/compound_stmts.rst:569

msgid ""

"You can also write multi-item context managers in multiple lines if the "

"items are surrounded by parentheses. For example::"

msgstr ""

"括弧で囲むことにより、複数のコンテキストマネージャを複数行に渡って書くことが"

"できます。\n"

"例::"

#: ../../reference/compound_stmts.rst:572

msgid ""

"with (\n"

" A() as a,\n"

" B() as b,\n"

"):\n"

" SUITE"

msgstr ""

#: ../../reference/compound_stmts.rst:578

msgid "Support for multiple context expressions."

msgstr "複数のコンテキスト式をサポートしました。"

#: ../../reference/compound_stmts.rst:581

msgid ""

"Support for using grouping parentheses to break the statement in multiple "

"lines."

msgstr "括弧で囲むことで、文を複数行に分割して書けるようになりました。"

#: ../../reference/compound_stmts.rst:586

msgid ":pep:`343` - The \"with\" statement"

msgstr ":pep:`343` - \"with\" ステートメント"

#: ../../reference/compound_stmts.rst:587

msgid ""

"The specification, background, and examples for the Python :keyword:`with` "

"statement."

msgstr "Python の :keyword:`with` 文の仕様、背景、および例が記載されています。"

#: ../../reference/compound_stmts.rst:593

msgid "The :keyword:`!match` statement"

msgstr ":keyword:`!match` 文"

#: ../../reference/compound_stmts.rst:607

msgid "The match statement is used for pattern matching. Syntax:"

msgstr ""

"match 文はパターンマッチングを行う目的で使われます。\n"

"構文:"

#: ../../reference/compound_stmts.rst:616

msgid ""

"This section uses single quotes to denote :ref:`soft keywords <soft-"

"keywords>`."

msgstr ""

"このセクションでは、一重引用符で囲まれているものは :ref:`ソフトキーワード "

"<soft-keywords>` を表します。"

#: ../../reference/compound_stmts.rst:619

msgid ""

"Pattern matching takes a pattern as input (following ``case``) and a subject "

"value (following ``match``). The pattern (which may contain subpatterns) is "

"matched against the subject value. The outcomes are:"

msgstr ""

"パターンマッチングは、パターン (``case`` の後ろ) とマッチング対象の値 "

"(``match`` の後ろ)を入力とします。\n"

"パターン (サブパターンを含みうる) は、マッチング対象の値に対して、マッチする"

"かどうかの判定が行われます。結果として次のことが起こります:"

#: ../../reference/compound_stmts.rst:623

msgid "A match success or failure (also termed a pattern success or failure)."

msgstr "マッチ成功、もしくはマッチ失敗 (パターン成功・失敗とも呼ばれます)。"

#: ../../reference/compound_stmts.rst:625

msgid ""

"Possible binding of matched values to a name. The prerequisites for this "

"are further discussed below."

msgstr "マッチした値の名前への束縛。必要な条件は後述します。"

#: ../../reference/compound_stmts.rst:628

msgid ""

"The ``match`` and ``case`` keywords are :ref:`soft keywords <soft-keywords>`."

msgstr ""

"``match`` と ``case`` キーワードは :ref:`ソフトキーワード <soft-keywords>` で"

"す。"

#: ../../reference/compound_stmts.rst:632

#: ../../reference/compound_stmts.rst:1189

msgid ":pep:`634` -- Structural Pattern Matching: Specification"

msgstr ":pep:`634` -- 構造的パターンマッチ: 仕様"

#: ../../reference/compound_stmts.rst:633

#: ../../reference/compound_stmts.rst:1190

msgid ":pep:`636` -- Structural Pattern Matching: Tutorial"

msgstr ":pep:`636` -- 構造的パターンマッチ: チュートリアル"

#: ../../reference/compound_stmts.rst:637

msgid "Overview"

msgstr "概要"

#: ../../reference/compound_stmts.rst:639

msgid "Here's an overview of the logical flow of a match statement:"

msgstr "match 文の論理的な動作の流れの概要は次の通りです:"

#: ../../reference/compound_stmts.rst:642

msgid ""

"The subject expression ``subject_expr`` is evaluated and a resulting subject "

"value obtained. If the subject expression contains a comma, a tuple is "

"constructed using :ref:`the standard rules <typesseq-tuple>`."

msgstr ""

"サブジェクト式 ``subject_expr`` が評価され、サブジェクト値が得られます。\n"

"サブジェクト式がコンマを含む場合、 :ref:`通常のルール <typesseq-tuple>` に"

"従ってタプルが作成されます。"

#: ../../reference/compound_stmts.rst:646

msgid ""

"Each pattern in a ``case_block`` is attempted to match with the subject "

"value. The specific rules for success or failure are described below. The "

"match attempt can also bind some or all of the standalone names within the "

"pattern. The precise pattern binding rules vary per pattern type and are "

"specified below. **Name bindings made during a successful pattern match "

"outlive the executed block and can be used after the match statement**."

msgstr ""

"``case_block`` 内の各パターンに対して、サブジェクト値がマッチするかどうかを"

"チェックします。\n"

"マッチ成功・失敗の具体的なルールは後述します。\n"

"マッチングのチェックにより、パターン内の名前の一部あるいはすべてに値が束縛さ"

"れます。\n"

"具体的な束縛ルールはパターンの種類によって異なるため、後述します。\n"

"**マッチが成功したパターンの中で束縛された名前は、そのパターンのブロック内だ"

"けでなく、 match 文の後でも使用することができます**。"

#: ../../reference/compound_stmts.rst:655

msgid ""

"During failed pattern matches, some subpatterns may succeed. Do not rely on "

"bindings being made for a failed match. Conversely, do not rely on "

"variables remaining unchanged after a failed match. The exact behavior is "

"dependent on implementation and may vary. This is an intentional decision "

"made to allow different implementations to add optimizations."

msgstr ""

"パターンマッチが全体として失敗しても、その中に含まれるサブパターンが成功する"

"可能性があります。\n"

"失敗したマッチで発生する名前束縛を前提としたコードを書かないように気をつけて"

"ください。\n"

"逆に、マッチが失敗したあとで変数の値が変わっていないというのも前提にしないで"

"ください。\n"

"実際どういう振る舞いになるかは Python の実装依存であり、実装間で異なる可能性"

"があります。\n"

"色々な実装が最適化を行えるよう、意図的に実装依存としています。"

#: ../../reference/compound_stmts.rst:662

msgid ""

"If the pattern succeeds, the corresponding guard (if present) is evaluated. "

"In this case all name bindings are guaranteed to have happened."

msgstr ""

"パターンが成功した場合、該当のガードが (もしあれば) 評価されます。\n"

"この場合、パターン内の名前がすべて束縛されていることが保証されています。"

#: ../../reference/compound_stmts.rst:665

msgid ""

"If the guard evaluates as true or is missing, the ``block`` inside "

"``case_block`` is executed."

msgstr ""

"ガードの評価値が真であるか、もしくはガードがなければ、 ``case_block`` 内の "

"``block`` が実行されます。"

#: ../../reference/compound_stmts.rst:668

msgid "Otherwise, the next ``case_block`` is attempted as described above."

msgstr ""

"そうでなければ、次の ``case_block`` に対して再び上記の処理が実行されます。"

#: ../../reference/compound_stmts.rst:670

msgid "If there are no further case blocks, the match statement is completed."

msgstr "これ以上 case block が存在しない場合は、 match 文が終了します。"

#: ../../reference/compound_stmts.rst:674

msgid ""

"Users should generally never rely on a pattern being evaluated. Depending "

"on implementation, the interpreter may cache values or use other "

"optimizations which skip repeated evaluations."

msgstr ""

"基本的に、 match 文のパターンが評価されるという前提でコードを書くべきではあり"

"ません。\n"

"インタープリタの実装によっては、結果をキャッシュするなどの最適化を行い、評価"

"をスキップする可能性があります。"

#: ../../reference/compound_stmts.rst:678

msgid "A sample match statement::"

msgstr "簡単な match 文の例::"

#: ../../reference/compound_stmts.rst:680

msgid ""

">>> flag = False\n"

">>> match (100, 200):\n"

"... case (100, 300): # Mismatch: 200 != 300\n"

"... print('Case 1')\n"

"... case (100, 200) if flag: # Successful match, but guard fails\n"

"... print('Case 2')\n"

"... case (100, y): # Matches and binds y to 200\n"

"... print(f'Case 3, y: {y}')\n"

"... case _: # Pattern not attempted\n"

"... print('Case 4, I match anything!')\n"

"...\n"

"Case 3, y: 200"

msgstr ""

#: ../../reference/compound_stmts.rst:694

msgid ""

"In this case, ``if flag`` is a guard. Read more about that in the next "

"section."

msgstr ""

"この例では、 ``if flag`` がガードです。\n"

"ガードについては次のセクションを参照してください。"

#: ../../reference/compound_stmts.rst:697

msgid "Guards"

msgstr "ガード"

#: ../../reference/compound_stmts.rst:704

msgid ""

"A ``guard`` (which is part of the ``case``) must succeed for code inside the "

"``case`` block to execute. It takes the form: :keyword:`if` followed by an "

"expression."

msgstr ""

"``guard`` (``case`` 一部として現れる) が成功してはじめて、その ``case`` ブ"

"ロックのコードが実行されます。\n"

"ガードは :keyword:`if` の後に式を書く形で表記されます。"