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

# E. Kawashima, 2017

# 秘湯 <xwhhsprings@gmail.com>, 2017

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

# Arihiro TAKASE, 2017

# tomo, 2021

# mollinaca, 2021

#

#, fuzzy

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2021-04-12 05:59+0000\n"

"PO-Revision-Date: 2017-02-16 23:39+0000\n"

"Last-Translator: mollinaca, 2021\n"

"Language-Team: Japanese (https://www.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/simple_stmts.rst:6

msgid "Simple statements"

msgstr "単純文 (simple statement)"

#: ../../reference/simple_stmts.rst:10

msgid ""

"A simple statement is comprised within a single logical line. Several simple "

"statements may occur on a single line separated by semicolons. The syntax "

"for simple statements is:"

msgstr ""

"単純文とは、単一の論理行内に収められる文です。単一の行内には、複数の単純文を"

"セミコロンで区切って入れることができます。単純文の構文は以下の通りです:"

#: ../../reference/simple_stmts.rst:36

msgid "Expression statements"

msgstr "式文 (expression statement)"

#: ../../reference/simple_stmts.rst:43

msgid ""

"Expression statements are used (mostly interactively) to compute and write a "

"value, or (usually) to call a procedure (a function that returns no "

"meaningful result; in Python, procedures return the value ``None``). Other "

"uses of expression statements are allowed and occasionally useful. The "

"syntax for an expression statement is:"

msgstr ""

"式文は、(主に対話的な使い方では) 値を計算して出力するために使ったり、(通常"

"は) プロシジャ (procedure: 有意な結果を返さない関数のことです; Python では、"

"プロシジャは値 ``None`` を返します) を呼び出すために使います。その他の使い方"

"でも式文を使うことができますし、有用なこともあります。式文の構文は以下の通り"

"です:"

#: ../../reference/simple_stmts.rst:52

msgid ""

"An expression statement evaluates the expression list (which may be a single "

"expression)."

msgstr "式文は式のリスト (単一の式のこともあります) を値評価します。"

#: ../../reference/simple_stmts.rst:64

msgid ""

"In interactive mode, if the value is not ``None``, it is converted to a "

"string using the built-in :func:`repr` function and the resulting string is "

"written to standard output on a line by itself (except if the result is "

"``None``, so that procedure calls do not cause any output.)"

msgstr ""

"対話モードでは、値が ``None`` でなければ、値を組み込み関数 :func:`repr` で文"

"字列に変換して、その結果の文字列を標準出力に一行使って書き出します。 "

"(``None`` になる式文の値は書き出されないので、プロシジャの呼び出しを行っても"

"出力は得られません。)"

#: ../../reference/simple_stmts.rst:72

msgid "Assignment statements"

msgstr "代入文 (assignment statement)"

#: ../../reference/simple_stmts.rst:82

msgid ""

"Assignment statements are used to (re)bind names to values and to modify "

"attributes or items of mutable objects:"

msgstr ""

"代入文は、名前を値に (再) 束縛したり、変更可能なオブジェクトの属性や要素を変"

"更したりするために使われます:"

#: ../../reference/simple_stmts.rst:96

msgid ""

"(See section :ref:`primaries` for the syntax definitions for *attributeref*, "

"*subscription*, and *slicing*.)"

msgstr ""

"(*attributeref*, *subscription*, *slicing* の構文については :ref:`primaries` "

"節を参照してください。)"

#: ../../reference/simple_stmts.rst:99

msgid ""

"An assignment statement evaluates the expression list (remember that this "

"can be a single expression or a comma-separated list, the latter yielding a "

"tuple) and assigns the single resulting object to each of the target lists, "

"from left to right."

msgstr ""

"代入文は式のリスト (これは単一の式でも、カンマで区切られた式リストでもよく、"

"後者はタプルになることを思い出してください) を評価し、得られた単一の結果オブ"

"ジェクトをターゲット (target) のリストに対して左から右へと代入してゆきます。"

#: ../../reference/simple_stmts.rst:108

msgid ""

"Assignment is defined recursively depending on the form of the target "

"(list). When a target is part of a mutable object (an attribute reference, "

"subscription or slicing), the mutable object must ultimately perform the "

"assignment and decide about its validity, and may raise an exception if the "

"assignment is unacceptable. The rules observed by various types and the "

"exceptions raised are given with the definition of the object types (see "

"section :ref:`types`)."

msgstr ""

"代入はターゲット (リスト) の形式に従って再帰的に行われます。ターゲットが変更"

"可能なオブジェクト (属性参照、添字表記、またはスライス) の一部である場合、こ"

"の変更可能なオブジェクトは最終的に代入を実行して、その代入が有効な操作である"

"か判断しなければなりません。代入が不可能な場合には例外を発行することもできま"

"す。型ごとにみられる規則や、送出される例外は、そのオブジェクト型定義で与えら"

"れています (:ref:`types` 節を参照してください)."

#: ../../reference/simple_stmts.rst:121

msgid ""

"Assignment of an object to a target list, optionally enclosed in parentheses "

"or square brackets, is recursively defined as follows."

msgstr ""

"ターゲットリストは、丸括弧や角括弧で囲まれていてもよく、それに対するオブジェ"

"クトの代入は、以下のように再帰的に定義されています。"

#: ../../reference/simple_stmts.rst:124

msgid ""

"If the target list is a single target with no trailing comma, optionally in "

"parentheses, the object is assigned to that target."

msgstr ""

"ターゲットリストのターゲットが1つだけでコンマが続いておらず、任意に丸括弧で囲"

"われている場合、オブジェクトはそのターゲットに代入されます。"

#: ../../reference/simple_stmts.rst:127 ../../reference/simple_stmts.rst:139

msgid ""

"Else: The object must be an iterable with the same number of items as there "

"are targets in the target list, and the items are assigned, from left to "

"right, to the corresponding targets."

msgstr ""

"そうでない場合: オブジェクトは、ターゲットリストのターゲットと同じ数の要素を"

"持つイテラブルでなければならず、要素は左から右へ対応するターゲットに代入され"

"ます。"

#: ../../reference/simple_stmts.rst:131

msgid ""

"If the target list contains one target prefixed with an asterisk, called a "

"\"starred\" target: The object must be an iterable with at least as many "

"items as there are targets in the target list, minus one. The first items "

"of the iterable are assigned, from left to right, to the targets before the "

"starred target. The final items of the iterable are assigned to the targets "

"after the starred target. A list of the remaining items in the iterable is "

"then assigned to the starred target (the list can be empty)."

msgstr ""

"\"星付き\"のターゲットと呼ばれる、頭にアスタリスクが一つ付いたターゲットが"

"ターゲットリストに一つだけ含まれている場合: オブジェクトはイテラブルで、少な"

"くともターゲットリストのターゲットの数よりも一つ少ない要素を持たなければはな"

"りません。\n"

"星付きのターゲットより前のターゲットに、イテラブルの先頭の要素が左から右へ代"

"入されます。\n"

"星付きのターゲットより後ろのターゲットに、イテラブルの末尾の要素が代入されま"

"す。\n"

"星付きのターゲットに、イテラブルの残った要素のリストが代入されます (リスト空"

"でもかまいません)。"

#: ../../reference/simple_stmts.rst:143

msgid ""

"Assignment of an object to a single target is recursively defined as follows."

msgstr ""

"単一のターゲットへの単一のオブジェクトの代入は、以下のようにして再帰的に定義"

"されています。"

#: ../../reference/simple_stmts.rst:145

msgid "If the target is an identifier (name):"

msgstr "ターゲットが識別子 (名前) の場合:"

#: ../../reference/simple_stmts.rst:147

msgid ""

"If the name does not occur in a :keyword:`global` or :keyword:`nonlocal` "

"statement in the current code block: the name is bound to the object in the "

"current local namespace."

msgstr ""

"名前が現在のコードブロック内の :keyword:`global` や :keyword:`nonlocal` 文に"

"書かれていないければ: 名前は現在のローカル名前空間内のオブジェクトに束縛され"

"ます。"

#: ../../reference/simple_stmts.rst:151

msgid ""

"Otherwise: the name is bound to the object in the global namespace or the "

"outer namespace determined by :keyword:`nonlocal`, respectively."

msgstr ""

"そうでなければ: 名前はそれぞれグローバル名前空間内か、 :keyword:`nonlocal` で"

"決められた外側の名前空間内のオブジェクトに束縛されます。"

#: ../../reference/simple_stmts.rst:156

msgid ""

"The name is rebound if it was already bound. This may cause the reference "

"count for the object previously bound to the name to reach zero, causing the "

"object to be deallocated and its destructor (if it has one) to be called."

msgstr ""

"名前がすでに束縛済みの場合、再束縛 (rebind) がおこなわれます。再束縛によっ"

"て、以前その名前に束縛されていたオブジェクトの参照カウント (reference count) "

"がゼロになった場合、オブジェクトは解放 (deallocate) され、デストラクタ "

"(destructor) が (存在すれば) 呼び出されます。"

#: ../../reference/simple_stmts.rst:162

msgid ""

"If the target is an attribute reference: The primary expression in the "

"reference is evaluated. It should yield an object with assignable "

"attributes; if this is not the case, :exc:`TypeError` is raised. That "

"object is then asked to assign the assigned object to the given attribute; "

"if it cannot perform the assignment, it raises an exception (usually but not "

"necessarily :exc:`AttributeError`)."

msgstr ""

"ターゲットが属性参照の場合: 参照されている一次語の式が値評価されます。値は代"

"入可能な属性を伴うオブジェクトでなければなりません; そうでなければ、 :exc:"

"`TypeError` が送出されます。次に、このオブジェクトに対して、被代入オブジェク"

"トを指定した属性に代入してよいか問い合わせます; 代入を実行できない場合、例外 "

"(通常は :exc:`AttributeError` ですが、必然ではありません) を送出します。"

#: ../../reference/simple_stmts.rst:171

msgid ""

"Note: If the object is a class instance and the attribute reference occurs "

"on both sides of the assignment operator, the right-hand side expression, "

"``a.x`` can access either an instance attribute or (if no instance attribute "

"exists) a class attribute. The left-hand side target ``a.x`` is always set "

"as an instance attribute, creating it if necessary. Thus, the two "

"occurrences of ``a.x`` do not necessarily refer to the same attribute: if "

"the right-hand side expression refers to a class attribute, the left-hand "

"side creates a new instance attribute as the target of the assignment::"

msgstr ""

"注意: オブジェクトがクラスインスタンスで、代入演算子の両辺に属性参照があると"

"き、右辺式の ``a.x`` はインスタンスの属性と (インスタンスの属性が存在しなけれ"

"ば) クラス属性のどちらにもアクセスする可能性があります。左辺のターゲット ``a."

"x`` は常にインスタンスの属性として割り当てられ、必要ならば生成されます。この"

"とおり、現れる二つの ``a.x`` は同じ値を参照するとは限りません: 右辺式はクラス"

"属性を参照し、左辺は新しいインスタンス属性を代入のターゲットとして生成するよ"

"うなとき::"

#: ../../reference/simple_stmts.rst:185

msgid ""

"This description does not necessarily apply to descriptor attributes, such "

"as properties created with :func:`property`."

msgstr ""

"このことは、 :func:`property` で作成されたプロパティのようなデスクリプタ属性"

"に対しては、必ずしもあてはまるとは限りません。"

#: ../../reference/simple_stmts.rst:192

msgid ""

"If the target is a subscription: The primary expression in the reference is "

"evaluated. It should yield either a mutable sequence object (such as a "

"list) or a mapping object (such as a dictionary). Next, the subscript "

"expression is evaluated."

msgstr ""

"ターゲットが添字表記なら: 参照されている一次語式が評価されます。参照から (リ"

"ストのような) ミュータブルなシーケンスオブジェクトか、(辞書のような) マッピン"

"グオブジェクトが得られなければなりません。次に、添字表記の表す式が評価されま"

"す。"

#: ../../reference/simple_stmts.rst:201

msgid ""

"If the primary is a mutable sequence object (such as a list), the subscript "

"must yield an integer. If it is negative, the sequence's length is added to "

"it. The resulting value must be a nonnegative integer less than the "

"sequence's length, and the sequence is asked to assign the assigned object "

"to its item with that index. If the index is out of range, :exc:"

"`IndexError` is raised (assignment to a subscripted sequence cannot add new "

"items to a list)."

msgstr ""

"一次語が (リストのような) ミュータブルなシーケンスオブジェクトであれば、添字"

"表記は整数を与えなければなりません。整数が負なら、シーケンスの長さが加算され"

"ます。整数は最終的に、シーケンスの長さよりも小さな非負の整数でなくてはなら"

"ず、シーケンスは、そのインデクスに持つ要素に被代入オブジェクトを代入してよい"

"か問い合わせられます。インデクスが範囲外なら、 :exc:`IndexError` が送出されま"

"す (添字指定されたシーケンスに代入を行っても、リスト要素の新たな追加はできま"

"せん)。"

#: ../../reference/simple_stmts.rst:212

msgid ""

"If the primary is a mapping object (such as a dictionary), the subscript "

"must have a type compatible with the mapping's key type, and the mapping is "

"then asked to create a key/datum pair which maps the subscript to the "

"assigned object. This can either replace an existing key/value pair with "

"the same key value, or insert a new key/value pair (if no key with the same "

"value existed)."

msgstr ""

"一次語が (辞書のような) マップオブジェクトの場合、まず添字はマップのキー型と"

"互換性のある型でなくてはなりません。次に、添字を被代入オブジェクトに関連付け"

"るようなキー/データの対を生成するようマップオブジェクトに問い合わせます。この"

"操作では、既存のキー/値の対を同じキーと別の値で置き換えてもよく、(同じ値を持"

"つキーが存在しない場合) 新たなキー/値の対を挿入してもかまいません。"

#: ../../reference/simple_stmts.rst:218

msgid ""

"For user-defined objects, the :meth:`__setitem__` method is called with "

"appropriate arguments."

msgstr ""

"ユーザ定義のオブジェクトには、適切な引数で :meth:`__setitem__` メソッドが呼び"

"出されます。"

#: ../../reference/simple_stmts.rst:223

msgid ""

"If the target is a slicing: The primary expression in the reference is "

"evaluated. It should yield a mutable sequence object (such as a list). The "

"assigned object should be a sequence object of the same type. Next, the "

"lower and upper bound expressions are evaluated, insofar they are present; "

"defaults are zero and the sequence's length. The bounds should evaluate to "

"integers. If either bound is negative, the sequence's length is added to "

"it. The resulting bounds are clipped to lie between zero and the sequence's "

"length, inclusive. Finally, the sequence object is asked to replace the "

"slice with the items of the assigned sequence. The length of the slice may "

"be different from the length of the assigned sequence, thus changing the "

"length of the target sequence, if the target sequence allows it."

msgstr ""

"ターゲットがスライスなら: 参照されている一次語式が評価されます。一次語式は、"

"(リストのような) ミュータブルなシーケンスオブジェクトを与えなければなりませ"

"ん。被代入オブジェクトは同じ型のシーケンスオブジェクトでなければなりません。"

"次に、スライスの下限と上限を示す式があれば評価されます; デフォルト値はそれぞ"

"れ 0 とシーケンスの長さです。上限と下限の評価は整数でなければなりません。いず"

"れかの境界が負数なら、シーケンスの長さが加算されます。最終的に、境界は 0 から"

"シーケンスの長さまでに収まるように刈りこまれます。最後に、スライスを被代入オ"

"ブジェクトで置き換えてよいかシーケンスオブジェクトに問い合わせます。ターゲッ"

"トシーケンスで許されている限り、スライスの長さは被代入シーケンスの長さと異"

"なっていてよく、この場合にはターゲットシーケンスの長さが変更されます。"

#: ../../reference/simple_stmts.rst:237

msgid ""

"In the current implementation, the syntax for targets is taken to be the "

"same as for expressions, and invalid syntax is rejected during the code "

"generation phase, causing less detailed error messages."

msgstr ""

"現在の実装では、ターゲットの構文は式の構文と同じであるとみなされており、無効"

"な構文はコード生成フェーズ中に詳細なエラーメッセージを伴って拒否されます。"

#: ../../reference/simple_stmts.rst:241

msgid ""

"Although the definition of assignment implies that overlaps between the left-"

"hand side and the right-hand side are 'simultaneous' (for example ``a, b = "

"b, a`` swaps two variables), overlaps *within* the collection of assigned-to "

"variables occur left-to-right, sometimes resulting in confusion. For "

"instance, the following program prints ``[0, 2]``::"

msgstr ""

"代入の定義によれば、左辺と右辺のオーバーラップは '同時 (simultaneous)' です "

"(例えば ``a, b = b, a`` は二つの変数を入れ替えます) が、代入対象となる変数群 "

"*どうし* のオーバーラップは左から右へ起こり、混乱の元です。例えば、以下のプロ"

"グラムは ``[0, 2]`` を出力してしまいます::"

#: ../../reference/simple_stmts.rst:255

msgid ":pep:`3132` - Extended Iterable Unpacking"

msgstr ":pep:`3132` - Extended Iterable Unpacking"

#: ../../reference/simple_stmts.rst:256

msgid "The specification for the ``*target`` feature."

msgstr "``*target`` の指定機能。"

#: ../../reference/simple_stmts.rst:262

msgid "Augmented assignment statements"

msgstr "累算代入文 (augmented assignment statement)"

#: ../../reference/simple_stmts.rst:280

msgid ""

"Augmented assignment is the combination, in a single statement, of a binary "

"operation and an assignment statement:"

msgstr "累算代入文は、二項演算と代入文を組み合わせて一つの文にしたものです:"

#: ../../reference/simple_stmts.rst:289

msgid ""

"(See section :ref:`primaries` for the syntax definitions of the last three "

"symbols.)"

msgstr "(最後の3つの構文定義については :ref:`primaries` を参照してください。)"

#: ../../reference/simple_stmts.rst:292

msgid ""

"An augmented assignment evaluates the target (which, unlike normal "

"assignment statements, cannot be an unpacking) and the expression list, "

"performs the binary operation specific to the type of assignment on the two "

"operands, and assigns the result to the original target. The target is only "

"evaluated once."

msgstr ""

"累算代入文は、ターゲット (通常の代入文と違って、アンパックは起こりません) と"

"式リストを評価し、それら二つの被演算子間で特定の累算代入型の二項演算を行い、"

"結果をもとのターゲットに代入します。ターゲットは一度しか評価されません。"

#: ../../reference/simple_stmts.rst:297

msgid ""

"An augmented assignment expression like ``x += 1`` can be rewritten as ``x = "

"x + 1`` to achieve a similar, but not exactly equal effect. In the augmented "

"version, ``x`` is only evaluated once. Also, when possible, the actual "

"operation is performed *in-place*, meaning that rather than creating a new "

"object and assigning that to the target, the old object is modified instead."

msgstr ""

"``x += 1`` のような累算代入式は、 ``x = x + 1`` のように書き換えてほぼ同様の"

"動作にできますが、厳密に等価にはなりません。累算代入の方では、 ``x`` は一度し"

"か評価されません。また、実際の処理として、可能ならば *インプレース (in-"

"place)* 演算が実行されます。これは、代入時に新たなオブジェクトを生成してター"

"ゲットに代入するのではなく、以前のオブジェクトの内容を変更するということで"

"す。"

#: ../../reference/simple_stmts.rst:303

msgid ""

"Unlike normal assignments, augmented assignments evaluate the left-hand side "

"*before* evaluating the right-hand side. For example, ``a[i] += f(x)`` "

"first looks-up ``a[i]``, then it evaluates ``f(x)`` and performs the "

"addition, and lastly, it writes the result back to ``a[i]``."

msgstr ""

"通常の代入とは違い、累算代入文は右辺を評価する *前に* 左辺を評価します。たと"

"えば、``a[i] += f(x)`` はまず ``a[i]`` を調べ、``f(x)`` を評価して加算を行"

"い、最後に結果を ``a[i]`` に割り当てます。"

#: ../../reference/simple_stmts.rst:308

msgid ""

"With the exception of assigning to tuples and multiple targets in a single "

"statement, the assignment done by augmented assignment statements is handled "

"the same way as normal assignments. Similarly, with the exception of the "

"possible *in-place* behavior, the binary operation performed by augmented "

"assignment is the same as the normal binary operations."

msgstr ""

"累算代入文で行われる代入は、タプルへの代入や、一文中に複数のターゲットが存在"

"する場合を除き、通常の代入と同じように扱われます。同様に、累算代入で行われる"

"二項演算は、場合によって *インプレース演算* が行われることを除き、通常の二項"

"演算と同じです。"

#: ../../reference/simple_stmts.rst:314

msgid ""

"For targets which are attribute references, the same :ref:`caveat about "

"class and instance attributes <attr-target-note>` applies as for regular "

"assignments."

msgstr ""

"属性参照のターゲットの場合、 :ref:`クラス属性とインスタンス属性についての注"

"意 <attr-target-note>` と同様に通常の代入が適用されます。"

#: ../../reference/simple_stmts.rst:321

msgid "Annotated assignment statements"

msgstr "注釈付き代入文 (annotated assignment statements)"

#: ../../reference/simple_stmts.rst:328

msgid ""

":term:`Annotation <variable annotation>` assignment is the combination, in a "

"single statement, of a variable or attribute annotation and an optional "

"assignment statement:"

msgstr ""

":term:`注釈 <variable annotation>` 代入は、1 つの文の中で変数や属性のアノテー"

"ションとオプションの代入文を組み合わせたものです:"

#: ../../reference/simple_stmts.rst:335

msgid ""

"The difference from normal :ref:`assignment` is that only single target is "

"allowed."

msgstr ""

#: ../../reference/simple_stmts.rst:337

msgid ""

"For simple names as assignment targets, if in class or module scope, the "

"annotations are evaluated and stored in a special class or module attribute :"

"attr:`__annotations__` that is a dictionary mapping from variable names "

"(mangled if private) to evaluated annotations. This attribute is writable "

"and is automatically created at the start of class or module body execution, "

"if annotations are found statically."

msgstr ""

"代入先として単純名を使うと、クラススコープもしくはモジュールスコープの場合、"

"注釈は評価され、クラスもしくはモジュールの特殊属性 :attr:`__annotations__` に"

"格納されます。\n"

"この属性は、変数名 (プライベート変数の場合はマングリングされた名前) から評価"

"後の注釈への対応付けを持つ辞書です。\n"

"この属性は書き込み可能であり、注釈が静的に存在している場合、クラスもしくはモ"

"ジュールの本体の実行の先頭で自動的に作成されます。"

#: ../../reference/simple_stmts.rst:345

msgid ""

"For expressions as assignment targets, the annotations are evaluated if in "

"class or module scope, but not stored."

msgstr ""

"代入先として式を使うと、クラススコープもしくはモジュールスコープの場合、注釈"

"は評価されますが、格納されません。"

#: ../../reference/simple_stmts.rst:348

msgid ""

"If a name is annotated in a function scope, then this name is local for that "

"scope. Annotations are never evaluated and stored in function scopes."

msgstr ""

"関数スコープで名前に注釈が付いていた場合は、その名前はその関数スコープでロー"

"カルなものになります。\n"

"注釈は絶対に評価されず、関数スコープにも格納されません。"

#: ../../reference/simple_stmts.rst:351

msgid ""

"If the right hand side is present, an annotated assignment performs the "

"actual assignment before evaluating annotations (where applicable). If the "

"right hand side is not present for an expression target, then the "

"interpreter evaluates the target except for the last :meth:`__setitem__` or :"

"meth:`__setattr__` call."

msgstr ""

"右辺がある場合、注釈代入はアノテーション (有効であれば) を評価する前に、実際"

"に代入を行います。\n"

"対象となる式の右辺が無い場合は、インタプリタは最後の :meth:`__setitem__` や :"

"meth:`__setattr__` 呼び出し以外の対象の式を評価します。"

#: ../../reference/simple_stmts.rst:362

msgid ":pep:`526` - Syntax for Variable Annotations"

msgstr ":pep:`526` - Syntax for Variable Annotations"

#: ../../reference/simple_stmts.rst:360

msgid ""

"The proposal that added syntax for annotating the types of variables "

"(including class variables and instance variables), instead of expressing "

"them through comments."

msgstr ""

"(クラス変数やインスタンス変数を含んだ) 変数の型注釈を付ける、コメントで表現す"

"るのではない文法の追加提案。"

#: ../../reference/simple_stmts.rst:366

msgid ":pep:`484` - Type hints"

msgstr ":pep:`484` - Type hints"

#: ../../reference/simple_stmts.rst:365

msgid ""

"The proposal that added the :mod:`typing` module to provide a standard "

"syntax for type annotations that can be used in static analysis tools and "

"IDEs."

msgstr ""

":mod:`typing` モジュールを追加し、静的解析ツールや IDE で使える型アノテーショ"

"ンの標準的な文法を提供する提案。"

#: ../../reference/simple_stmts.rst:369

msgid ""

"Now annotated assignments allow same expressions in the right hand side as "

"the regular assignments. Previously, some expressions (like un-parenthesized "

"tuple expressions) caused a syntax error."

msgstr ""

#: ../../reference/simple_stmts.rst:378

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

msgstr ":keyword:`!assert` 文"

#: ../../reference/simple_stmts.rst:385

msgid ""

"Assert statements are a convenient way to insert debugging assertions into a "

"program:"

msgstr ""

"assert 文は、プログラム内にデバッグ用アサーション (debugging assertion) を仕"

"掛けるための便利な方法です:"

#: ../../reference/simple_stmts.rst:391

msgid "The simple form, ``assert expression``, is equivalent to ::"

msgstr "単純な形式 ``assert expression`` は ::"

#: ../../reference/simple_stmts.rst:396

msgid ""

"The extended form, ``assert expression1, expression2``, is equivalent to ::"

msgstr ""

"と等価です。拡張形式 ``assert expression1, expression2`` は、これと等価で"

"す ::"

#: ../../reference/simple_stmts.rst:405

msgid ""

"These equivalences assume that :const:`__debug__` and :exc:`AssertionError` "

"refer to the built-in variables with those names. In the current "

"implementation, the built-in variable :const:`__debug__` is ``True`` under "

"normal circumstances, ``False`` when optimization is requested (command line "

"option :option:`-O`). The current code generator emits no code for an "

"assert statement when optimization is requested at compile time. Note that "

"it is unnecessary to include the source code for the expression that failed "

"in the error message; it will be displayed as part of the stack trace."

msgstr ""

"上記の等価関係は、 ``__debug__`` と :exc:`AssertionError` が、同名の組み込み"

"変数を参照しているという前提の上に成り立っています。現在の実装では、組み込み"

"変数 ``__debug__`` は通常の状況では ``True`` であり、最適化が要求された場合"

"（コマンドラインオプション :option:`-O`）は ``False`` です。現状のコード生成"

"器は、コンパイル時に最適化が要求されていると assert 文のコードを一切出力しま"

"せん。実行に失敗した式のソースコードをエラーメッセージ内に入れる必要はありま"

"せん; コードはスタックトレース内で表示されます。"

#: ../../reference/simple_stmts.rst:414

msgid ""

"Assignments to :const:`__debug__` are illegal. The value for the built-in "

"variable is determined when the interpreter starts."

msgstr ""

":const:`__debug__` への代入は不正な操作です。組み込み変数の値は、インタプリタ"

"が開始するときに決定されます。"

#: ../../reference/simple_stmts.rst:421

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

msgstr ":keyword:`!pass` 文"

#: ../../reference/simple_stmts.rst:431

msgid ""

":keyword:`pass` is a null operation --- when it is executed, nothing "

"happens. It is useful as a placeholder when a statement is required "

"syntactically, but no code needs to be executed, for example::"

msgstr ""

":keyword:`pass` はヌル操作 (null operation) です --- :keyword:`pass` が実行さ"

"れても、何も起きません。 :keyword:`pass` は、構文法的には文が必要だが、コード"

"としては何も実行したくない場合のプレースホルダとして有用です。例えば::"

#: ../../reference/simple_stmts.rst:443

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

msgstr ":keyword:`!del` 文"

#: ../../reference/simple_stmts.rst:453

msgid ""

"Deletion is recursively defined very similar to the way assignment is "

"defined. Rather than spelling it out in full details, here are some hints."

msgstr ""

"オブジェクトの削除 (deletion) は、代入の定義と非常に似た方法で再帰的に定義さ"

"れています。ここでは完全な詳細は記述せず、いくつかのヒントを述べるにとどめま"

"す。"

#: ../../reference/simple_stmts.rst:456

msgid ""

"Deletion of a target list recursively deletes each target, from left to "

"right."

msgstr ""

"ターゲットリストに対する削除は、各々のターゲットを左から右へと順に再帰的に削"

"除します。"

#: ../../reference/simple_stmts.rst:462

msgid ""

"Deletion of a name removes the binding of that name from the local or global "

"namespace, depending on whether the name occurs in a :keyword:`global` "

"statement in the same code block. If the name is unbound, a :exc:"

"`NameError` exception will be raised."

msgstr ""

"名前の削除は、ローカルまたはグローバル名前空間からその名前の束縛を取り除きま"

"す。どちらの名前空間かは、名前が同じコードブロック内の :keyword:`global` 文で"

"宣言されているかどうかによります。名前が未束縛 (unbound) なら、 :exc:"

"`NameError` 例外が送出されます。"

#: ../../reference/simple_stmts.rst:469

msgid ""

"Deletion of attribute references, subscriptions and slicings is passed to "

"the primary object involved; deletion of a slicing is in general equivalent "

"to assignment of an empty slice of the right type (but even this is "

"determined by the sliced object)."

msgstr ""

"属性参照、添字表記、およびスライスの削除操作は、対象となる一次語オブジェクト"

"に渡されます; スライスの削除は一般的には適切な型の空のスライスを代入するのと"

"等価です (が、この仕様自体もスライスされるオブジェクトで決定されています)。"

#: ../../reference/simple_stmts.rst:474

msgid ""

"Previously it was illegal to delete a name from the local namespace if it "

"occurs as a free variable in a nested block."

msgstr ""

"以前は、ある名前がネストしたブロックの自由変数として表れる場合は、ローカル名"

"前空間からその名前を削除することは不正な処理でした。"

#: ../../reference/simple_stmts.rst:482

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

msgstr ":keyword:`!return` 文"

#: ../../reference/simple_stmts.rst:492

msgid ""

":keyword:`return` may only occur syntactically nested in a function "

"definition, not within a nested class definition."

msgstr ""

":keyword:`return` は、関数定義内で構文法的にネストして現れますが、ネストした"

"クラス定義内には現れません。"

#: ../../reference/simple_stmts.rst:495

msgid ""

"If an expression list is present, it is evaluated, else ``None`` is "

"substituted."

msgstr ""

"式リストがある場合、リストが値評価されます。それ以外の場合は ``None`` で置き"

"換えられます。"

#: ../../reference/simple_stmts.rst:497

msgid ""

":keyword:`return` leaves the current function call with the expression list "

"(or ``None``) as return value."

msgstr ""

":keyword:`return` を使うと、式リスト (または ``None``) を戻り値として、現在の"

"関数呼び出しから抜け出します。"

#: ../../reference/simple_stmts.rst:502

msgid ""

"When :keyword:`return` passes control out of a :keyword:`try` statement with "

"a :keyword:`finally` clause, that :keyword:`!finally` clause is executed "

"before really leaving the function."

msgstr ""

":keyword:`return` によって、 :keyword:`finally` 節をともなう :keyword:`try` "

"文の外に処理が引き渡されると、実際に関数から抜ける前に :keyword:`!finally` 節"

"が実行されます。"

#: ../../reference/simple_stmts.rst:506

msgid ""

"In a generator function, the :keyword:`return` statement indicates that the "

"generator is done and will cause :exc:`StopIteration` to be raised. The "

"returned value (if any) is used as an argument to construct :exc:"

"`StopIteration` and becomes the :attr:`StopIteration.value` attribute."

msgstr ""

"ジェネレータ関数では、 :keyword:`return` 文はジェネレータの終わりを示し、 :"

"exc:`StopIteration` 例外を送出させます。返された値は (あれば)、 :exc:"

"`StopIteration` を構成する引数に使われ、 :attr:`StopIteration.value` 属性にな"

"ります。"

#: ../../reference/simple_stmts.rst:511

msgid ""

"In an asynchronous generator function, an empty :keyword:`return` statement "

"indicates that the asynchronous generator is done and will cause :exc:"

"`StopAsyncIteration` to be raised. A non-empty :keyword:`!return` statement "

"is a syntax error in an asynchronous generator function."

msgstr ""

"非同期ジェネレータ関数では、引数無しの :keyword:`return` 文は非同期ジェネレー"

"タの終わりを示し、 :exc:`StopAsyncIteration` を送出させます。\n"

"引数ありの :keyword:`!return` 文は、非同期ジェネレータ関数では文法エラーで"

"す。"

#: ../../reference/simple_stmts.rst:519

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

msgstr ":keyword:`!yield` 文"

#: ../../reference/simple_stmts.rst:531

msgid ""

"A :keyword:`yield` statement is semantically equivalent to a :ref:`yield "

"expression <yieldexpr>`. The yield statement can be used to omit the "

"parentheses that would otherwise be required in the equivalent yield "

"expression statement. For example, the yield statements ::"

msgstr ""

":keyword:`yield` 文は意味的に :ref:`yield 式 <yieldexpr>` と同じです。yield "

"文を用いると yield 式文で必要な括弧を省略することが出来ます。例えば、yield "

"文 ::"

#: ../../reference/simple_stmts.rst:539

msgid "are equivalent to the yield expression statements ::"

msgstr "は以下の yield 式文と等価です ::"

#: ../../reference/simple_stmts.rst:544

msgid ""

"Yield expressions and statements are only used when defining a :term:"

"`generator` function, and are only used in the body of the generator "

"function. Using yield in a function definition is sufficient to cause that "

"definition to create a generator function instead of a normal function."

msgstr ""

"yield 式及び文は :term:`generator` を定義するときに、その本体内でのみ使うこと"

"が出来ます。関数定義内で yield を使用することで、その定義は通常の関数でなく"

"ジェネレータ関数になります。"

#: ../../reference/simple_stmts.rst:549

msgid ""

"For full details of :keyword:`yield` semantics, refer to the :ref:"

"`yieldexpr` section."

msgstr ""

":keyword:`yield` の意味の完全な説明は、 :ref:`yieldexpr` 節を参照してくださ"

"い。"

#: ../../reference/simple_stmts.rst:555

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

msgstr ":keyword:`!raise` 文"

#: ../../reference/simple_stmts.rst:566

msgid ""

"If no expressions are present, :keyword:`raise` re-raises the last exception "

"that was active in the current scope. If no exception is active in the "

"current scope, a :exc:`RuntimeError` exception is raised indicating that "

"this is an error."

msgstr ""

"式を伴わなければ、 :keyword:`raise` は現在のスコープで最終的に有効になってい"

"る例外を再送出します。そのような例外が現在のスコープでアクティブでない場"

"合、 :exc:`RuntimeError` 例外が送出されて、これがエラーであることを示します。"

#: ../../reference/simple_stmts.rst:571

msgid ""

"Otherwise, :keyword:`raise` evaluates the first expression as the exception "

"object. It must be either a subclass or an instance of :class:"

"`BaseException`. If it is a class, the exception instance will be obtained "

"when needed by instantiating the class with no arguments."

msgstr ""

"そうでなければ、 :keyword:`raise` は最初の式を、例外オブジェクトとして評価し"

"ます。これは、 :class:`BaseException` のサブクラスまたはインスタンスでなけれ"

"ばなりません。クラスなら、例外インスタンスが必要なとき、クラスを無引数でイン"

"スタンス化することで得られます。"

#: ../../reference/simple_stmts.rst:576

msgid ""

"The :dfn:`type` of the exception is the exception instance's class, the :dfn:"

"`value` is the instance itself."

msgstr ""

"例外の :dfn:`型` は例外インスタンスのクラスで、 :dfn:`値` はインスタンスその"

"ものです。"

#: ../../reference/simple_stmts.rst:581

msgid ""

"A traceback object is normally created automatically when an exception is "

"raised and attached to it as the :attr:`__traceback__` attribute, which is "

"writable. You can create an exception and set your own traceback in one step "

"using the :meth:`with_traceback` exception method (which returns the same "

"exception instance, with its traceback set to its argument), like so::"

msgstr ""

"トレースバックオブジェクトは通常、例外が送出される時に自動で作られ、その例外"

"に書き込み可能の :attr:`__traceback__` 属性として付与されます。 :meth:"

"`with_traceback` 例外メソッド (トレースバックを引数に設定した同じ例外を返しま"

"す) を使い、例外を作って独自のトレースバックを設定するのを一度に出来ます。こ"

"のように::"

#: ../../reference/simple_stmts.rst:593

msgid ""

"The ``from`` clause is used for exception chaining: if given, the second "

"*expression* must be another exception class or instance. If the second "

"expression is an exception instance, it will be attached to the raised "

"exception as the :attr:`__cause__` attribute (which is writable). If the "

"expression is an exception class, the class will be instantiated and the "

"resulting exception instance will be attached to the raised exception as "

"the :attr:`__cause__` attribute. If the raised exception is not handled, "

"both exceptions will be printed::"

msgstr ""

#: ../../reference/simple_stmts.rst:617

msgid ""

"A similar mechanism works implicitly if an exception is raised inside an "

"exception handler or a :keyword:`finally` clause: the previous exception is "

"then attached as the new exception's :attr:`__context__` attribute::"

msgstr ""

"例外ハンドラまたは :keyword:`finally` 節の中で例外が送出された時も、同じよう"

"な機構が暗黙に働きます。このとき、先に起こった例外が、新しい例外の :attr:"

"`__context__` 属性に付与されます::"

#: ../../reference/simple_stmts.rst:636

msgid ""

"Exception chaining can be explicitly suppressed by specifying :const:`None` "

"in the ``from`` clause::"

msgstr ""

"``from`` 節に :const:`None` を指定することで、例外の連鎖を明示的に非表示にで"

"きます::"

#: ../../reference/simple_stmts.rst:648

msgid ""

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

"`exceptions`, and information about handling exceptions is in section :ref:"

"`try`."

msgstr ""

"例外に関する追加情報は :ref:`exceptions` 節にあります。また、例外処理に関する"

"情報は :ref:`try` 節にあります。"

#: ../../reference/simple_stmts.rst:651

msgid ":const:`None` is now permitted as ``Y`` in ``raise X from Y``."

msgstr ""

":const:`None` が ``raise X from Y`` の ``Y`` として使えるようになりました。"

#: ../../reference/simple_stmts.rst:654

msgid ""

"The ``__suppress_context__`` attribute to suppress automatic display of the "

"exception context."

msgstr ""

"``__suppress_context__`` 属性の設定で、例外のコンテキストが自動的に非表示にな"

"ります。"

#: ../../reference/simple_stmts.rst:661

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

msgstr ":keyword:`!break` 文"

#: ../../reference/simple_stmts.rst:672

msgid ""

":keyword:`break` may only occur syntactically nested in a :keyword:`for` or :"

"keyword:`while` loop, but not nested in a function or class definition "

"within that loop."

msgstr ""

":keyword:`break` 文は、構文としては :keyword:`for` ループや :keyword:`while` "

"ループの内側でのみ出現することができますが、ループ内の関数定義やクラス定義の"

"内側には出現できません。"

#: ../../reference/simple_stmts.rst:679

msgid ""

"It terminates the nearest enclosing loop, skipping the optional :keyword:`!"

"else` clause if the loop has one."

msgstr ""

":keyword:`break` 文は、文を囲う最も内側のループを終了させ、ループにオプション"

"の :keyword:`!else` 節がある場合にはそれをスキップします。"

#: ../../reference/simple_stmts.rst:682

msgid ""

"If a :keyword:`for` loop is terminated by :keyword:`break`, the loop control "

"target keeps its current value."

msgstr ""

":keyword:`for` ループを :keyword:`break` によって終了すると、ループ制御ター"

"ゲットはその時の値を保持します。"

#: ../../reference/simple_stmts.rst:687

msgid ""

"When :keyword:`break` passes control out of a :keyword:`try` statement with "

"a :keyword:`finally` clause, that :keyword:`!finally` clause is executed "

"before really leaving the loop."

msgstr ""

":keyword:`break` が :keyword:`finally` 節を伴う :keyword:`try` 文の外側に処理"

"を渡す際には、ループを実際に抜ける前にその :keyword:`!finally` 節が実行されま"

"す。"

#: ../../reference/simple_stmts.rst:695

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

msgstr ":keyword:`!continue` 文"

#: ../../reference/simple_stmts.rst:707

msgid ""

":keyword:`continue` may only occur syntactically nested in a :keyword:`for` "

"or :keyword:`while` loop, but not nested in a function or class definition "

"within that loop. It continues with the next cycle of the nearest enclosing "

"loop."

msgstr ""

":keyword:`continue` 文は :keyword:`for` ループや :keyword:`while` ループ内の"

"ネストで構文法的にのみ現れますが、ループ内の関数定義やクラス定義の中には現れ"

"ません。 :keyword:`continue` 文は、文を囲う最も内側のループの次の周期に処理を"

"継続します。"

#: ../../reference/simple_stmts.rst:711

msgid ""

"When :keyword:`continue` passes control out of a :keyword:`try` statement "

"with a :keyword:`finally` clause, that :keyword:`!finally` clause is "

"executed before really starting the next loop cycle."

msgstr ""

":keyword:`continue` が :keyword:`finally` 句を持った :keyword:`try` 文を抜け"

"るとき、その :keyword:`!finally` 句が次のループサイクルを始める前に実行されま"

"す。"

#: ../../reference/simple_stmts.rst:720

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

msgstr ":keyword:`!import` 文"

#: ../../reference/simple_stmts.rst:741

msgid ""

"The basic import statement (no :keyword:`from` clause) is executed in two "

"steps:"

msgstr ""

"(:keyword:`from` 節が無い) 基本の import 文は 2 つのステップで実行されます:"

#: ../../reference/simple_stmts.rst:744

msgid "find a module, loading and initializing it if necessary"

msgstr "モジュールを見付け出し、必要であればロードし初期化する"

#: ../../reference/simple_stmts.rst:745

msgid ""

"define a name or names in the local namespace for the scope where the :"

"keyword:`import` statement occurs."

msgstr ""

":keyword:`import` 文が表れるスコープのローカル名前空間で名前を定義する。"

#: ../../reference/simple_stmts.rst:748

msgid ""

"When the statement contains multiple clauses (separated by commas) the two "

"steps are carried out separately for each clause, just as though the clauses "

"had been separated out into individual import statements."

msgstr ""

"文が (カンマで区切られた) 複数の節を含んでいるときは、ちょうどその節が個別の "

"import 文に分割されたかのように、2つのステップが節ごとに個別に実行されます。"

#: ../../reference/simple_stmts.rst:753

msgid ""

"The details of the first step, finding and loading modules are described in "

"greater detail in the section on the :ref:`import system <importsystem>`, "

"which also describes the various types of packages and modules that can be "

"imported, as well as all the hooks that can be used to customize the import "

"system. Note that failures in this step may indicate either that the module "

"could not be located, *or* that an error occurred while initializing the "

"module, which includes execution of the module's code."

msgstr ""

"モジュールを見付け、ロードする 1 つ目のステップの詳細については、 :ref:`イン"

"ポートシステム <importsystem>` の節により詳しく書かれています。そこでは、イン"

"ポートシステムの動作をカスタマイズするのに使える全てのフックの仕組みだけでな"

"く、様々な種類のインポートできるパッケージとモジュールについても解説されてい"

"ます。このステップが失敗するということは、おそらくモジュールが見付からない"

"か、 *あるいは* モジュールにあるコードの実行を含め、モジュールの初期化の途中"

"でエラーが起きるかのどちらかが起きていることに注意してください。"

#: ../../reference/simple_stmts.rst:761

msgid ""

"If the requested module is retrieved successfully, it will be made available "

"in the local namespace in one of three ways:"

msgstr ""

"要求したモジュールが無事に取得できた場合、次の 3 つのうちの 1 つの方法でロー"

"カル名前空間で使えるようになります:"

#: ../../reference/simple_stmts.rst:766

msgid ""

"If the module name is followed by :keyword:`!as`, then the name following :"

"keyword:`!as` is bound directly to the imported module."

msgstr ""

"モジュール名の後に :keyword:`!as` が続いていた場合は、 :keyword:`!as` の後ろ"

"の名前を直接、インポートされたモジュールが束縛します。"

#: ../../reference/simple_stmts.rst:768

msgid ""

"If no other name is specified, and the module being imported is a top level "

"module, the module's name is bound in the local namespace as a reference to "

"the imported module"

msgstr ""

"他の名前が指定されておらず、インポートされているモジュールが最上位のモジュー"

"ルだった場合、そのモジュール名がインポートされたモジュールへの参照として、"

"ローカル名前空間で束縛されます"

#: ../../reference/simple_stmts.rst:771

msgid ""

"If the module being imported is *not* a top level module, then the name of "

"the top level package that contains the module is bound in the local "