# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001-2020, Python Software Foundation

# This file is distributed under the same license as the Python package.

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# 上野 雄二 <y-ueno@nalux.co.jp>, 2019

# tomo, 2020

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

#

#, fuzzy

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2020-02-09 18:48+0900\n"

"PO-Revision-Date: 2018-06-29 17:51+0000\n"

"Last-Translator: Yusuke Miyazaki <miyazaki.dev@gmail.com>, 2021\n"

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

"ja/)\n"

"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/expressions.rst:6

msgid "Expressions"

msgstr "式 (expression)"

#: ../../reference/expressions.rst:10

msgid ""

"This chapter explains the meaning of the elements of expressions in Python."

msgstr "この章では、Python の式における個々の要素の意味について解説します。"

#: ../../reference/expressions.rst:12

msgid ""

"**Syntax Notes:** In this and the following chapters, extended BNF notation "

"will be used to describe syntax, not lexical analysis. When (one "

"alternative of) a syntax rule has the form"

msgstr ""

"**表記法に関する注意:** この章と以降の章での拡張BNF (extended BNF) 表記は、字"

"句解析規則ではなく、構文規則を記述するために用いられています。ある構文規則 "

"(のある表現方法) が、以下の形式"

#: ../../reference/expressions.rst:19

msgid ""

"and no semantics are given, the semantics of this form of ``name`` are the "

"same as for ``othername``."

msgstr ""

"で記述されていて、この構文特有の意味付け (semantics) が記述されていない場"

"合、 ``name`` の形式をとる構文の意味付けは ``othername`` の意味付けと同じにな"

"ります。"

#: ../../reference/expressions.rst:26

msgid "Arithmetic conversions"

msgstr "算術変換 (arithmetic conversion)"

#: ../../reference/expressions.rst:30

msgid ""

"When a description of an arithmetic operator below uses the phrase \"the "

"numeric arguments are converted to a common type,\" this means that the "

"operator implementation for built-in types works as follows:"

msgstr ""

"以下の算術演算子の記述で、「数値引数は共通の型に変換されます」と書かれている"

"とき、組み込み型に対する演算子の実装は以下の通りに動作します:"

#: ../../reference/expressions.rst:34

msgid ""

"If either argument is a complex number, the other is converted to complex;"

msgstr "片方の引数が複素数型であれば、他方は複素数型に変換されます;"

#: ../../reference/expressions.rst:36

msgid ""

"otherwise, if either argument is a floating point number, the other is "

"converted to floating point;"

msgstr ""

"それ以外の場合で、片方の引数が浮動小数点数であれば、他方は浮動小数点型に変換"

"されます;"

#: ../../reference/expressions.rst:39

msgid "otherwise, both must be integers and no conversion is necessary."

msgstr ""

"それ以外場合は、両方の引数は整数でなければならず、変換の必要はありません。"

#: ../../reference/expressions.rst:41

msgid ""

"Some additional rules apply for certain operators (e.g., a string as a left "

"argument to the '%' operator). Extensions must define their own conversion "

"behavior."

msgstr ""

"特定の演算子 ('%' 演算子の左引数としての文字列) には、さらに別の規則が適用さ"

"れます。拡張は、それ自身の型変換のふるまいを定義していなければなりません。"

#: ../../reference/expressions.rst:49

msgid "Atoms"

msgstr "アトム、原子的要素 (atom)"

#: ../../reference/expressions.rst:53

msgid ""

"Atoms are the most basic elements of expressions. The simplest atoms are "

"identifiers or literals. Forms enclosed in parentheses, brackets or braces "

"are also categorized syntactically as atoms. The syntax for atoms is:"

msgstr ""

"atom は、式の一番基本的な要素です。もっとも単純な atom は、識別子またはリテラ"

"ルです。丸括弧、角括弧、または波括弧で囲われた形式 (form) もまた、構文上アト"

"ムに分類されます。atom の構文は以下のようになります:"

#: ../../reference/expressions.rst:66

msgid "Identifiers (Names)"

msgstr "識別子 (identifier、または名前 (name))"

#: ../../reference/expressions.rst:70

msgid ""

"An identifier occurring as an atom is a name. See section :ref:"

"`identifiers` for lexical definition and section :ref:`naming` for "

"documentation of naming and binding."

msgstr ""

"アトムの形になっている識別子 (identifier) は名前 (name) です。字句定義につい"

"ては :ref:`identifiers` 節を、名前付けや束縛については :ref:`naming` 節を参照"

"してください。"

#: ../../reference/expressions.rst:76

msgid ""

"When the name is bound to an object, evaluation of the atom yields that "

"object. When a name is not bound, an attempt to evaluate it raises a :exc:"

"`NameError` exception."

msgstr ""

"名前があるオブジェクトに束縛されている場合、名前 atom を評価するとそのオブ"

"ジェクトになります。名前が束縛されていない場合、 atom を評価しようとすると :"

"exc:`NameError` 例外を送出します。"

#: ../../reference/expressions.rst:84

msgid ""

"**Private name mangling:** When an identifier that textually occurs in a "

"class definition begins with two or more underscore characters and does not "

"end in two or more underscores, it is considered a :dfn:`private name` of "

"that class. Private names are transformed to a longer form before code is "

"generated for them. The transformation inserts the class name, with leading "

"underscores removed and a single underscore inserted, in front of the name. "

"For example, the identifier ``__spam`` occurring in a class named ``Ham`` "

"will be transformed to ``_Ham__spam``. This transformation is independent "

"of the syntactical context in which the identifier is used. If the "

"transformed name is extremely long (longer than 255 characters), "

"implementation defined truncation may happen. If the class name consists "

"only of underscores, no transformation is done."

msgstr ""

"**プライベートな名前のマングリング:** クラス定義内に書かれた識別子で、2つ以上"

"のアンダースコアから始まり、末尾が2つ以上のアンダースコアで終わっていないもの"

"は、そのクラスの :dfn:`プライベートな名前` とみなされます。プライベートな名前"

"は、コードが生成される前により長い形式に変換されます。この変換によって、クラ"

"ス名の先頭にアンダースコアがあれば除去し、先頭にアンダースコアを1つ付加し、名"

"前の前に挿入されます。例えば、クラス名 ``Ham`` の中の識別子 ``__spam`` は、"

"``_Ham__spam`` に変換されます。変換は識別子が使用されている構文のコンテキスト"

"からは独立しています。変換された名前が非常に長い (255文字を超える) 場合、実装"

"によっては名前の切り詰めが行われるかもしれません。クラス名がアンダースコアの"

"みから成る場合は変換は行われません。"

#: ../../reference/expressions.rst:100

msgid "Literals"

msgstr "リテラル"

#: ../../reference/expressions.rst:104

msgid "Python supports string and bytes literals and various numeric literals:"

msgstr ""

"Python では、文字列やバイト列リテラルと、様々な数値リテラルをサポートしていま"

"す:"

#: ../../reference/expressions.rst:110

msgid ""

"Evaluation of a literal yields an object of the given type (string, bytes, "

"integer, floating point number, complex number) with the given value. The "

"value may be approximated in the case of floating point and imaginary "

"(complex) literals. See section :ref:`literals` for details."

msgstr ""

"リテラルの評価は、与えられた型 (文字列、バイト列、整数、浮動小数点数、複素"

"数) の与えられた値を持つオブジェクトを与えます。浮動小数点や虚数 (複素数) リ"

"テラルの場合、値は近似値になる場合があります。詳しくは :ref:`literals` を参照"

"してください。"

#: ../../reference/expressions.rst:119

msgid ""

"All literals correspond to immutable data types, and hence the object's "

"identity is less important than its value. Multiple evaluations of literals "

"with the same value (either the same occurrence in the program text or a "

"different occurrence) may obtain the same object or a different object with "

"the same value."

msgstr ""

"リテラルは全て変更不能なデータ型に対応します。このため、オブジェクトのアイデ"

"ンティティはオブジェクトの値ほど重要ではありません。同じ値を持つ複数のリテラ"

"ルを評価した場合、(それらのリテラルがプログラムの同じ場所由来のものであって"

"も、そうでなくても) 同じオブジェクトを指しているか、まったく同じ値を持つ別の"

"オブジェクトになります。"

#: ../../reference/expressions.rst:129

msgid "Parenthesized forms"

msgstr "丸括弧形式 (parenthesized form)"

#: ../../reference/expressions.rst:135

msgid ""

"A parenthesized form is an optional expression list enclosed in parentheses:"

msgstr "丸括弧形式とは、式リストの一形態で、丸括弧で囲ったものです:"

#: ../../reference/expressions.rst:140

msgid ""

"A parenthesized expression list yields whatever that expression list yields: "

"if the list contains at least one comma, it yields a tuple; otherwise, it "

"yields the single expression that makes up the expression list."

msgstr ""

"丸括弧で囲われた式のリストは、個々の式が表現するものになります: リスト内に少"

"なくとも一つのカンマが入っていた場合、タプルになります; そうでない場合、式の"

"リストを構成している単一の式自体の値になります。"

#: ../../reference/expressions.rst:146

msgid ""

"An empty pair of parentheses yields an empty tuple object. Since tuples are "

"immutable, the rules for literals apply (i.e., two occurrences of the empty "

"tuple may or may not yield the same object)."

msgstr ""

"中身が空の丸括弧のペアは、空のタプルオブジェクトを表します。タプルは変更不能"

"なので、リテラルと同じ規則が適用されます (すなわち、空のタプルが二箇所で使わ"

"れると、それらは同じオブジェクトになることもあるし、ならないこともあります)。"

#: ../../reference/expressions.rst:155

msgid ""

"Note that tuples are not formed by the parentheses, but rather by use of the "

"comma operator. The exception is the empty tuple, for which parentheses "

"*are* required --- allowing unparenthesized \"nothing\" in expressions would "

"cause ambiguities and allow common typos to pass uncaught."

msgstr ""

"タプルは丸括弧で作成されるのではなく、カンマによって作成されることに注意して"

"ください。例外は空のタプルで、この場合には丸括弧が *必要です* --- 丸括弧のつ"

"かない \"何も記述しない式 (nothing)\" を使えるようにしてしまうと、文法があい"

"まいなものになってしまい、よくあるタイプミスが検出されなくなってしまいます。"

#: ../../reference/expressions.rst:164

msgid "Displays for lists, sets and dictionaries"

msgstr "リスト、集合、辞書の表示"

#: ../../reference/expressions.rst:166

msgid ""

"For constructing a list, a set or a dictionary Python provides special "

"syntax called \"displays\", each of them in two flavors:"

msgstr ""

"Python は、リスト、集合、または辞書を構成するために、 \"表示 (display)\" と呼"

"ばれる特殊な構文を、それぞれ二種類づつ提供していて、コンテナの内容は:"

#: ../../reference/expressions.rst:169

msgid "either the container contents are listed explicitly, or"

msgstr "明示的に列挙される、または"

#: ../../reference/expressions.rst:171

msgid ""

"they are computed via a set of looping and filtering instructions, called a :"

"dfn:`comprehension`."

msgstr ""

":dfn:`内包表記 (comprehension)` と呼ばれる、ループ処理とフィルター処理の命令"

"の組み合わせを通じて計算されます。"

#: ../../reference/expressions.rst:179

msgid "Common syntax elements for comprehensions are:"

msgstr "内包表記の共通の構文要素はこの通りです:"

#: ../../reference/expressions.rst:187

msgid ""

"The comprehension consists of a single expression followed by at least one :"

"keyword:`for` clause and zero or more :keyword:`for` or :keyword:`if` "

"clauses. In this case, the elements of the new container are those that "

"would be produced by considering each of the :keyword:`for` or :keyword:`if` "

"clauses a block, nesting from left to right, and evaluating the expression "

"to produce an element each time the innermost block is reached."

msgstr ""

"内包表記はまず単一の式、続いて少なくとも 1 個の :keyword:`for` 節、さらに続い"

"て 0 個以上の :keyword:`for` 節あるいは :keyword:`if` 節からなります。\n"

"この場合、各々の :keyword:`for` や :keyword:`if` 節を、左から右へ深くなってい"

"くネストしたブロックとみなし、ネストの最内のブロックに到達するごとに内包表記"

"の先頭にある式を評価した結果が、最終的にできあがるコンテナの各要素になりま"

"す。"

#: ../../reference/expressions.rst:194

msgid ""

"Note that the comprehension is executed in a separate scope, so names "

"assigned to in the target list don't \"leak\" into the enclosing scope."

msgstr ""

"なお、これらの内包表記は別のスコープで実行されるので、対象のリスト内で代入さ"

"れた名前が外側のスコープに \"漏れる\" ことはありません。"

#: ../../reference/expressions.rst:200

msgid ""

"Since Python 3.6, in an :keyword:`async def` function, an :keyword:`async "

"for` clause may be used to iterate over a :term:`asynchronous iterator`. A "

"comprehension in an :keyword:`async def` function may consist of either a :"

"keyword:`for` or :keyword:`async for` clause following the leading "

"expression, may contain additional :keyword:`for` or :keyword:`async for` "

"clauses, and may also use :keyword:`await` expressions. If a comprehension "

"contains either :keyword:`async for` clauses or :keyword:`await` expressions "

"it is called an :dfn:`asynchronous comprehension`. An asynchronous "

"comprehension may suspend the execution of the coroutine function in which "

"it appears. See also :pep:`530`."

msgstr ""

#: ../../reference/expressions.rst:215

msgid "List displays"

msgstr "リスト表現"

#: ../../reference/expressions.rst:225

msgid ""

"A list display is a possibly empty series of expressions enclosed in square "

"brackets:"

msgstr ""

"リスト表現は、角括弧で囲われた式の系列です。系列は空の系列であってもかまいま"

"せん:"

#: ../../reference/expressions.rst:231

msgid ""

"A list display yields a new list object, the contents being specified by "

"either a list of expressions or a comprehension. When a comma-separated "

"list of expressions is supplied, its elements are evaluated from left to "

"right and placed into the list object in that order. When a comprehension "

"is supplied, the list is constructed from the elements resulting from the "

"comprehension."

msgstr ""

"リスト表示は、新しいリストオブジェクトを与えます。リストの内容は、式のリスト"

"またはリスト内包表記 (list comprehension) で指定されます。\n"

"カンマで区切られた式のリストが与えられたときは、それらの各要素は左から右へと"

"順に評価され、その順にリスト内に配置されます。\n"

"内包表記が与えられたときは、内包表記の結果の要素でリストが構成されます。"

#: ../../reference/expressions.rst:241

msgid "Set displays"

msgstr "集合表現"

#: ../../reference/expressions.rst:249

msgid ""

"A set display is denoted by curly braces and distinguishable from dictionary "

"displays by the lack of colons separating keys and values:"

msgstr ""

"集合表現は波括弧で表され、キーと値を分けるコロンがないことで辞書表現と区別さ"

"れます:"

#: ../../reference/expressions.rst:255

msgid ""

"A set display yields a new mutable set object, the contents being specified "

"by either a sequence of expressions or a comprehension. When a comma-"

"separated list of expressions is supplied, its elements are evaluated from "

"left to right and added to the set object. When a comprehension is "

"supplied, the set is constructed from the elements resulting from the "

"comprehension."

msgstr ""

"集合表示は、新しいミュータブルな集合オブジェクトを与えます。集合の内容は、式"

"の並びまたは内包表記によって指定されます。\n"

"カンマ区切りの式のリストが与えられたときは、その要素は左から右へ順に評価さ"

"れ、集合オブジェクトに加えられます。\n"

"内包表記が与えられたときは、内包表記の結果の要素で集合が構成されます。"

#: ../../reference/expressions.rst:261

msgid ""

"An empty set cannot be constructed with ``{}``; this literal constructs an "

"empty dictionary."

msgstr "空集合は ``{}`` で構成できません。このリテラルは空の辞書を構成します。"

#: ../../reference/expressions.rst:268

msgid "Dictionary displays"

msgstr "辞書表現"

#: ../../reference/expressions.rst:278

msgid ""

"A dictionary display is a possibly empty series of key/datum pairs enclosed "

"in curly braces:"

msgstr ""

"辞書表現は、波括弧で囲われた、キーと値のペアからなる系列です。系列は空の系列"

"であってもかまいません:"

#: ../../reference/expressions.rst:287

msgid "A dictionary display yields a new dictionary object."

msgstr "辞書表現は、新たな辞書オブジェクトを表します。"

#: ../../reference/expressions.rst:289

msgid ""

"If a comma-separated sequence of key/datum pairs is given, they are "

"evaluated from left to right to define the entries of the dictionary: each "

"key object is used as a key into the dictionary to store the corresponding "

"datum. This means that you can specify the same key multiple times in the "

"key/datum list, and the final dictionary's value for that key will be the "

"last one given."

msgstr ""

"キーとデータからなる対の並びがカンマ区切りで与えられたときは、その要素は左か"

"ら右へ評価され、辞書のエントリーを定義します。すなわち、それぞれのキーオブ"

"ジェクトが、辞書内で対応するデータを保存するキーとして使われます。\n"

"これにより、キーとデータのリストの中で同じキーを複数回指定することができ、そ"

"のキーに対する最終的な辞書の値は、最後に与えられたものになります。"

#: ../../reference/expressions.rst:299

msgid ""

"A double asterisk ``**`` denotes :dfn:`dictionary unpacking`. Its operand "

"must be a :term:`mapping`. Each mapping item is added to the new "

"dictionary. Later values replace values already set by earlier key/datum "

"pairs and earlier dictionary unpackings."

msgstr ""

"ダブルアスタリスク ``**`` は :dfn:`辞書のアンパック` を表します。このとき被演"

"算子は :term:`mapping` でなければなりません。それぞれのmappingの要素は、新た"

"な辞書に追加されます。キー/データの対もしくは辞書のアンパックによって先に追加"

"された値は、後から追加された値によって上書きされます。"

#: ../../reference/expressions.rst:304

msgid "Unpacking into dictionary displays, originally proposed by :pep:`448`."

msgstr "辞書表示のアンパッキングは最初に :pep:`448` で提案されました。"

#: ../../reference/expressions.rst:307

msgid ""

"A dict comprehension, in contrast to list and set comprehensions, needs two "

"expressions separated with a colon followed by the usual \"for\" and \"if\" "

"clauses. When the comprehension is run, the resulting key and value elements "

"are inserted in the new dictionary in the order they are produced."

msgstr ""

"辞書内包表記は、リストや集合の内包表記とは対照的に、通常の \"for\" や \"if\" "

"節の前に、コロンで分けられた 2 つの式が必要です。内包表記が起動すると、結果の"

"キーと値の要素が、作られた順に新しい辞書に挿入されます。"

#: ../../reference/expressions.rst:315

msgid ""

"Restrictions on the types of the key values are listed earlier in section :"

"ref:`types`. (To summarize, the key type should be :term:`hashable`, which "

"excludes all mutable objects.) Clashes between duplicate keys are not "

"detected; the last datum (textually rightmost in the display) stored for a "

"given key value prevails."

msgstr ""

"キーの値として使える型に関する制限は :ref:`types` 節ですでに列挙しています。"

"(一言でいうと、キーは変更可能なオブジェクトを全て排除した :term:`hashable` で"

"なければなりません。) 重複するキー間で衝突が起きても、衝突が検出されることは"

"ありません; あるキーに対して、最後に渡されたデータ (プログラムテキスト上で"

"は、辞書表記の最も右側値となるもの) が使われます。"

#: ../../reference/expressions.rst:325

msgid "Generator expressions"

msgstr "ジェネレータ式"

#: ../../reference/expressions.rst:332

msgid "A generator expression is a compact generator notation in parentheses:"

msgstr ""

"ジェネレータ式 (generator expression) とは、丸括弧を使ったコンパクトなジェネ"

"レータ表記法です:"

#: ../../reference/expressions.rst:337

msgid ""

"A generator expression yields a new generator object. Its syntax is the "

"same as for comprehensions, except that it is enclosed in parentheses "

"instead of brackets or curly braces."

msgstr ""

"ジェネレータ式は新たなジェネレータオブジェクトを与えます。この構文は内包表記"

"とほぼ同じですが、角括弧や波括弧ではなく、丸括弧で囲まれます。"

#: ../../reference/expressions.rst:341

msgid ""

"Variables used in the generator expression are evaluated lazily when the :"

"meth:`~generator.__next__` method is called for the generator object (in the "

"same fashion as normal generators). However, the leftmost :keyword:`for` "

"clause is immediately evaluated, so that an error produced by it can be seen "

"before any other possible error in the code that handles the generator "

"expression. Subsequent :keyword:`for` clauses cannot be evaluated "

"immediately since they may depend on the previous :keyword:`for` loop. For "

"example: ``(x*y for x in range(10) for y in bar(x))``."

msgstr ""

"ジェネレータ式の中で使われている変数は、 (通常のジェネレータと同じように) そ"

"のジェネレータオブジェクトに対して :meth:`~generator.__next__` メソッドが呼ば"

"れたときに遅延評価されます。ただし、最も左に位置する :keyword:`for` 節は直ち"

"に評価されるため、そこで生じたエラーは、 ジェネレータ式を扱うコードの中で起き"

"る他のエラーよりも前に表示されます。前の :keyword:`for` ループに依存するかも"

"しれないので、後の :keyword:`for` 節は即座に評価することができません。例え"

"ば: ``(x*y for x in range(10) for y in bar(x))`` 。"

#: ../../reference/expressions.rst:350

msgid ""

"The parentheses can be omitted on calls with only one argument. See "

"section :ref:`calls` for details."

msgstr ""

"関数の唯一の引数として渡す場合には、丸括弧を省略できます。詳しくは :ref:"

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

#: ../../reference/expressions.rst:353

msgid ""

"Since Python 3.6, if the generator appears in an :keyword:`async def` "

"function, then :keyword:`async for` clauses and :keyword:`await` expressions "

"are permitted as with an asynchronous comprehension. If a generator "

"expression contains either :keyword:`async for` clauses or :keyword:`await` "

"expressions it is called an :dfn:`asynchronous generator expression`. An "

"asynchronous generator expression yields a new asynchronous generator "

"object, which is an asynchronous iterator (see :ref:`async-iterators`)."

msgstr ""

#: ../../reference/expressions.rst:365

msgid "Yield expressions"

msgstr "Yield 式"

#: ../../reference/expressions.rst:377

msgid ""

"The yield expression is used when defining a :term:`generator` function or "

"an :term:`asynchronous generator` function and thus can only be used in the "

"body of a function definition. Using a yield expression in a function's "

"body causes that function to be a generator, and using it in an :keyword:"

"`async def` function's body causes that coroutine function to be an "

"asynchronous generator. For example::"

msgstr ""

"yield 式は :term:`ジェネレータ <generator>` 関数や term:`非同期ジェネレータ "

"<asynchronous generator>` を定義するときに使われます。従って、関数定義の本体"

"でのみ使えます。\n"

"関数の本体で yield 式 を使用するとその関数はジェネレータになり、 :keyword:"

"`async def` 関数の本体で使用するとそのコルーチン関数は非同期ジェネレータにな"

"ります。\n"

"例えば次のようになります::"

#: ../../reference/expressions.rst:390

msgid ""

"Generator functions are described below, while asynchronous generator "

"functions are described separately in section :ref:`asynchronous-generator-"

"functions`."

msgstr ""

"ジェネレータ関数についてはすぐ下で説明されています。非同期ジェネレータ関数"

"は、 :ref:`asynchronous-generator-functions` 節に分けて説明されています。"

#: ../../reference/expressions.rst:394

msgid ""

"When a generator function is called, it returns an iterator known as a "

"generator. That generator then controls the execution of the generator "

"function. The execution starts when one of the generator's methods is "

"called. At that time, the execution proceeds to the first yield expression, "

"where it is suspended again, returning the value of :token:`expression_list` "

"to the generator's caller. By suspended, we mean that all local state is "

"retained, including the current bindings of local variables, the instruction "

"pointer, the internal evaluation stack, and the state of any exception "

"handling. When the execution is resumed by calling one of the generator's "

"methods, the function can proceed exactly as if the yield expression were "

"just another external call. The value of the yield expression after "

"resuming depends on the method which resumed the execution. If :meth:"

"`~generator.__next__` is used (typically via either a :keyword:`for` or the :"

"func:`next` builtin) then the result is :const:`None`. Otherwise, if :meth:"

"`~generator.send` is used, then the result will be the value passed in to "

"that method."

msgstr ""

"ジェネレータ関数が呼び出された時、ジェネレータとしてのイテレータを返します。"

"ジェネレータはその後ジェネレータ関数の実行を制御します。ジェネレータのメソッ"

"ドが呼び出されると実行が開始されます。開始されると、最初の yield 式まで処理し"

"て一時停止し、呼び出し元へ :token:`expression_list` の値を返します。ここで言"

"う一時停止とは、ローカル変数の束縛、命令ポインタや内部の評価スタック、そして"

"例外処理のを含むすべてのローカル状態が保持されることを意味します。再度、ジェ"

"ネレータのメソッドが呼び出されて実行を再開した時、ジェネレータは yield 式がた"

"だの外部呼び出しであったかのように処理を継続します。再開後の yield 式の値は実"

"行を再開するメソッドに依存します。:meth:`~generator.__next__` を使用した場合 "

"(一般に :keyword:`for` 文や組み込み関数 :func:`next` など) の結果は :const:"

"`None` となり、:meth:`~generator.send` を使用した場合はそのメソッドに渡された"

"値が結果になります。"

#: ../../reference/expressions.rst:413

msgid ""

"All of this makes generator functions quite similar to coroutines; they "

"yield multiple times, they have more than one entry point and their "

"execution can be suspended. The only difference is that a generator "

"function cannot control where the execution should continue after it yields; "

"the control is always transferred to the generator's caller."

msgstr ""

"これまで説明した内容から、ジェネレータ関数はコルーチンにとてもよく似ていま"

"す。ジェネレータ関数は何度も生成し、1つ以上のエントリポイントを持ち、その実行"

"は一時停止されます。ジェネレータ関数は yield した後で実行の継続を制御できない"

"ことが唯一の違いです。その制御は常にジェネレータの呼び出し元へ移されます。"

#: ../../reference/expressions.rst:419

msgid ""

"Yield expressions are allowed anywhere in a :keyword:`try` construct. If "

"the generator is not resumed before it is finalized (by reaching a zero "

"reference count or by being garbage collected), the generator-iterator's :"

"meth:`~generator.close` method will be called, allowing any pending :keyword:"

"`finally` clauses to execute."

msgstr ""

"yield 式は :keyword:`try` 構造内で使用できます。ジェネレータの (参照カウント"

"がゼロに達するか、ガベージコレクションによる) 完了前に再開されない場合、ジェ"

"ネレータ-イテレータの :meth:`~generator.close` メソッドが呼ばれ、:keyword:"

"`finally` 節が実行されます。"

#: ../../reference/expressions.rst:428

msgid ""

"When ``yield from <expr>`` is used, it treats the supplied expression as a "

"subiterator. All values produced by that subiterator are passed directly to "

"the caller of the current generator's methods. Any values passed in with :"

"meth:`~generator.send` and any exceptions passed in with :meth:`~generator."

"throw` are passed to the underlying iterator if it has the appropriate "

"methods. If this is not the case, then :meth:`~generator.send` will raise :"

"exc:`AttributeError` or :exc:`TypeError`, while :meth:`~generator.throw` "

"will just raise the passed in exception immediately."

msgstr ""

"``yield from <expr>`` を使用した場合、与えられた式はサブイテレータとして扱わ"

"れます。サブイテレータによって生成されたすべての値は現在のジェネレータのメ"

"ソッドの呼び出し元へ直接渡されます。:meth:`~generator.send` で渡されたあらゆ"

"る値と :meth:`~generator.throw` で渡されたあらゆる例外は根底のイテレータに適"

"切なメソッドがあれば渡されます。適切なメソッドがない場合、:meth:`~generator."

"send` は :exc:`AttributeError` か :exc:`TypeError` を、:meth:`~generator."

"throw` は渡された例外を即座に送出します。"

#: ../../reference/expressions.rst:437

msgid ""

"When the underlying iterator is complete, the :attr:`~StopIteration.value` "

"attribute of the raised :exc:`StopIteration` instance becomes the value of "

"the yield expression. It can be either set explicitly when raising :exc:"

"`StopIteration`, or automatically when the sub-iterator is a generator (by "

"returning a value from the sub-generator)."

msgstr ""

"根底のイテレータの完了時、引き起こされた :exc:`StopIteration` インスタンス"

"の :attr:`~StopIteration.value` 属性はその yield 式の値となります。 :exc:"

"`StopIteration` を起こす際に明示的にセットされるか、サブイテレータがジェネ"

"レータであれば (サブイテレータからかえる値で) 自動的にセットされるかのどちら"

"かです。"

#: ../../reference/expressions.rst:443

msgid "Added ``yield from <expr>`` to delegate control flow to a subiterator."

msgstr ""

"サブイテレータに制御フローを委譲するために ``yield from <expr>`` が追加されま"

"した。"

#: ../../reference/expressions.rst:446

msgid ""

"The parentheses may be omitted when the yield expression is the sole "

"expression on the right hand side of an assignment statement."

msgstr "yield 式が代入文の単独の右辺式であるとき、括弧は省略できます。"

#: ../../reference/expressions.rst:452

msgid ":pep:`255` - Simple Generators"

msgstr ":pep:`255` - 単純なジェネレータ"

#: ../../reference/expressions.rst:452

msgid ""

"The proposal for adding generators and the :keyword:`yield` statement to "

"Python."

msgstr "Python へのジェネレータと :keyword:`yield` 文の導入提案。"

#: ../../reference/expressions.rst:456

msgid ":pep:`342` - Coroutines via Enhanced Generators"

msgstr ":pep:`0342` - 拡張されたジェネレータを用いたコルーチン"

#: ../../reference/expressions.rst:455

msgid ""

"The proposal to enhance the API and syntax of generators, making them usable "

"as simple coroutines."

msgstr ""

"シンプルなコルーチンとして利用できるように、ジェネレータの構文と API を拡張す"

"る提案です。"

#: ../../reference/expressions.rst:460

msgid ":pep:`380` - Syntax for Delegating to a Subgenerator"

msgstr ":pep:`380` - サブジェネレータへの委譲構文"

#: ../../reference/expressions.rst:459

msgid ""

"The proposal to introduce the :token:`yield_from` syntax, making delegation "

"to sub-generators easy."

msgstr ""

"サブジェネレータの委譲を簡単にするための、 :token:`yield_from` 構文の導入提"

"案。"

#: ../../reference/expressions.rst:463

msgid ":pep:`525` - Asynchronous Generators"

msgstr ":pep:`525` - 非同期ジェネレータ"

#: ../../reference/expressions.rst:463

msgid ""

"The proposal that expanded on :pep:`492` by adding generator capabilities to "

"coroutine functions."

msgstr ""

"コルーチン関数へのジェネレータの実装能力の追加による :pep:`492` の拡張提案。"

#: ../../reference/expressions.rst:470

msgid "Generator-iterator methods"

msgstr "ジェネレータ-イテレータメソッド"

#: ../../reference/expressions.rst:472

msgid ""

"This subsection describes the methods of a generator iterator. They can be "

"used to control the execution of a generator function."

msgstr ""

"この説ではジェネレータイテレータのメソッドについて説明します。これらはジェネ"

"レータ関数の実行制御に使用できます。"

#: ../../reference/expressions.rst:475

msgid ""

"Note that calling any of the generator methods below when the generator is "

"already executing raises a :exc:`ValueError` exception."

msgstr ""

"以下のジェネレータメソッドの呼び出しは、ジェネレータが既に実行中の場合 :exc:"

"`ValueError` 例外を送出する点に注意してください。"

#: ../../reference/expressions.rst:483

msgid ""

"Starts the execution of a generator function or resumes it at the last "

"executed yield expression. When a generator function is resumed with a :"

"meth:`~generator.__next__` method, the current yield expression always "

"evaluates to :const:`None`. The execution then continues to the next yield "

"expression, where the generator is suspended again, and the value of the :"

"token:`expression_list` is returned to :meth:`__next__`'s caller. If the "

"generator exits without yielding another value, a :exc:`StopIteration` "

"exception is raised."

msgstr ""

"ジェネレータ関数の実行を開始するか、最後に yield 式が実行されたところから再開"

"します。ジェネレータ関数が :meth:`~generator.__next__` メソッドによって再開さ"

"れた時、その時点の :keyword:`yield` 式の値は常に :const:`None` と評価されま"

"す。その後次の :keyword:`yield` 式まで実行し、ジェネレータは一時停止し、:"

"token:`expression_list` の値を :meth:`__next__` メソッドの呼び出し元に返しま"

"す。ジェネレータが次の値を yield せずに終了した場合、:exc:`StopIteration` 例"

"外が送出されます。"

#: ../../reference/expressions.rst:492

msgid ""

"This method is normally called implicitly, e.g. by a :keyword:`for` loop, or "

"by the built-in :func:`next` function."

msgstr ""

"このメソッドは通常、例えば :keyword:`for` ループや組み込みの :func:`next` 関"

"数によって暗黙に呼び出されます。"

#: ../../reference/expressions.rst:498

msgid ""

"Resumes the execution and \"sends\" a value into the generator function. "

"The *value* argument becomes the result of the current yield expression. "

"The :meth:`send` method returns the next value yielded by the generator, or "

"raises :exc:`StopIteration` if the generator exits without yielding another "

"value. When :meth:`send` is called to start the generator, it must be "

"called with :const:`None` as the argument, because there is no yield "

"expression that could receive the value."

msgstr ""

"ジェネレータ関数の内部へ値を \"送り\"、実行を再開します。引数の *value* はそ"

"の時点の yield 式の結果になります。 :meth:`send` メソッドは次にジェネレータが"

"生成した値を返し、ジェネレータが次の値を生成することなく終了すると :exc:"

"`StopIteration` を送出します。 :meth:`send` が呼び出されてジェネレータが開始"

"するときは、値を受け取る yield 式が存在しないので、 :const:`None` を引数とし"

"て呼び出さなければなりません。"

#: ../../reference/expressions.rst:509

msgid ""

"Raises an exception of type ``type`` at the point where the generator was "

"paused, and returns the next value yielded by the generator function. If "

"the generator exits without yielding another value, a :exc:`StopIteration` "

"exception is raised. If the generator function does not catch the passed-in "

"exception, or raises a different exception, then that exception propagates "

"to the caller."

msgstr ""

"ジェネレータが中断した位置で ``type`` 型の例外を発生させて、そのジェネレータ"

"関数が生成する次の値を返します。ジェネレータが値を生成することなく終了する"

"と :exc:`StopIteration` が発生します。ジェネレータ関数が渡された例外を捕捉し"

"ない、もしくは違う例外を発生させるなら、その例外は呼び出し元へ伝搬されます。"

#: ../../reference/expressions.rst:520

msgid ""

"Raises a :exc:`GeneratorExit` at the point where the generator function was "

"paused. If the generator function then exits gracefully, is already closed, "

"or raises :exc:`GeneratorExit` (by not catching the exception), close "

"returns to its caller. If the generator yields a value, a :exc:"

"`RuntimeError` is raised. If the generator raises any other exception, it "

"is propagated to the caller. :meth:`close` does nothing if the generator "

"has already exited due to an exception or normal exit."

msgstr ""

"ジェネレータ関数が一時停止した時点で :exc:`GeneratorExit` を発生させます。\n"

"そして、ジェネレータ関数が無事に終了するか、既にクローズされているか、(例外が"

"捕捉されなかったために) :exc:`GeneratorExit` が送出された場合、 close は呼び"

"出し元へ戻ります。\n"

"ジェネレータが値を生成する場合 :exc:`RuntimeError` が発生します。\n"

":meth:`close` はジェネレータが例外や正常な終了により既に終了している場合は何"

"もしません。"

#: ../../reference/expressions.rst:531

msgid "Examples"

msgstr "使用例"

#: ../../reference/expressions.rst:533

msgid ""

"Here is a simple example that demonstrates the behavior of generators and "

"generator functions::"

msgstr ""

"以下の簡単なサンプルはジェネレータとジェネレータ関数の振る舞いを実際に紹介し"

"ます::"

#: ../../reference/expressions.rst:560

msgid ""

"For examples using ``yield from``, see :ref:`pep-380` in \"What's New in "

"Python.\""

msgstr ""

"``yield from`` の使用例は、\"What's New in Python.\" の :ref:`pep-380` を参照"

"してください。"

#: ../../reference/expressions.rst:566

msgid "Asynchronous generator functions"

msgstr "非同期ジェネレータ関数 (asynchronous generator function)"

#: ../../reference/expressions.rst:568

msgid ""

"The presence of a yield expression in a function or method defined using :"

"keyword:`async def` further defines the function as a :term:`asynchronous "

"generator` function."

msgstr ""

":keyword:`async def` を使用して定義された関数やメソッドに yield 式があると、"

"その関数は :term:`非同期ジェネレータ <asynchronous generator>` 関数として定義"

"されます。"

#: ../../reference/expressions.rst:572

msgid ""

"When an asynchronous generator function is called, it returns an "

"asynchronous iterator known as an asynchronous generator object. That object "

"then controls the execution of the generator function. An asynchronous "

"generator object is typically used in an :keyword:`async for` statement in a "

"coroutine function analogously to how a generator object would be used in a :"

"keyword:`for` statement."

msgstr ""

"非同期ジェネレータ関数が呼び出されると、非同期ジェネレータオブジェクトと呼ば"

"れる非同期イテレータが返されます。そのオブジェクトは、ジェネレータ関数の実行"

"を制御します。\n"

"通常、非同期ジェネレータオブジェクトは、コルーチン関数の :keyword:`async "

"for` ステートメントで、ジェネレータオブジェクトが :keyword:`for` ステートメン"

"トで使用される方法と同様に使用されます。"

#: ../../reference/expressions.rst:579

msgid ""

"Calling one of the asynchronous generator's methods returns an :term:"

"`awaitable` object, and the execution starts when this object is awaited on. "

"At that time, the execution proceeds to the first yield expression, where it "

"is suspended again, returning the value of :token:`expression_list` to the "

"awaiting coroutine. As with a generator, suspension means that all local "

"state is retained, including the current bindings of local variables, the "

"instruction pointer, the internal evaluation stack, and the state of any "

"exception handling. When the execution is resumed by awaiting on the next "

"object returned by the asynchronous generator's methods, the function can "

"proceed exactly as if the yield expression were just another external call. "

"The value of the yield expression after resuming depends on the method which "

"resumed the execution. If :meth:`~agen.__anext__` is used then the result "

"is :const:`None`. Otherwise, if :meth:`~agen.asend` is used, then the result "

"will be the value passed in to that method."

msgstr ""

"非同期ジェネレータのメソッドの1つを呼び出すと :term:`awaitable`オブジェクトが"

"返され、このオブジェクトが待機しているときに実行が開始されます。その時点で、"

"実行は最初の yield 式に進み、そこで再び中断され、:token:`expression_list` の"

"値を待機中のコルーチンに返します。\n"

"ジェネレータと同様に、中断とは、ローカル変数の現在のバインディング、命令ポイ"

"ンタ、内部評価スタック、および例外処理の状態など、すべてのローカル状態が保持"

"されることを意味します。\n"

"非同期ジェネレータのメソッドによって返された次のオブジェクトで待機することに"

"よって実行が再開されると、関数はyield式が単なる外部呼び出しであるかのように正"

"確に処理を進めることができます。\n"

"再開後の yield 式の値は、実行を再開したメソッドによって異なります。:meth:"

"`~agen.__anext__` を使うと、結果は :const:`None` になります。それ以外の場"

"合、 :meth:`~agen.asend` が使用された場合、結果はそのメソッドに渡された値にな"

"ります。"

#: ../../reference/expressions.rst:595

msgid ""

"In an asynchronous generator function, yield expressions are allowed "

"anywhere in a :keyword:`try` construct. However, if an asynchronous "

"generator is not resumed before it is finalized (by reaching a zero "

"reference count or by being garbage collected), then a yield expression "

"within a :keyword:`try` construct could result in a failure to execute "

"pending :keyword:`finally` clauses. In this case, it is the responsibility "

"of the event loop or scheduler running the asynchronous generator to call "

"the asynchronous generator-iterator's :meth:`~agen.aclose` method and run "

"the resulting coroutine object, thus allowing any pending :keyword:`finally` "

"clauses to execute."

msgstr ""

#: ../../reference/expressions.rst:606

msgid ""

"To take care of finalization, an event loop should define a *finalizer* "

"function which takes an asynchronous generator-iterator and presumably "

"calls :meth:`~agen.aclose` and executes the coroutine. This *finalizer* may "

"be registered by calling :func:`sys.set_asyncgen_hooks`. When first iterated "

"over, an asynchronous generator-iterator will store the registered "

"*finalizer* to be called upon finalization. For a reference example of a "

"*finalizer* method see the implementation of ``asyncio.Loop."

"shutdown_asyncgens`` in :source:`Lib/asyncio/base_events.py`."

msgstr ""

#: ../../reference/expressions.rst:615

msgid ""

"The expression ``yield from <expr>`` is a syntax error when used in an "

"asynchronous generator function."

msgstr ""

"``yield from <expr>`` 式は、非同期ジェネレータ関数で使われると文法エラーにな"

"ります。"

#: ../../reference/expressions.rst:622

msgid "Asynchronous generator-iterator methods"

msgstr "非同期ジェネレータイテレータメソッド"

#: ../../reference/expressions.rst:624

msgid ""

"This subsection describes the methods of an asynchronous generator iterator, "

"which are used to control the execution of a generator function."

msgstr ""

"この小節では、ジェネレータ関数の実行制御に使われる非同期ジェネレータイテレー"

"タのメソッドについて説明します。"

#: ../../reference/expressions.rst:632

msgid ""

"Returns an awaitable which when run starts to execute the asynchronous "

"generator or resumes it at the last executed yield expression. When an "

"asynchronous generator function is resumed with a :meth:`~agen.__anext__` "

"method, the current yield expression always evaluates to :const:`None` in "

"the returned awaitable, which when run will continue to the next yield "

"expression. The value of the :token:`expression_list` of the yield "

"expression is the value of the :exc:`StopIteration` exception raised by the "

"completing coroutine. If the asynchronous generator exits without yielding "

"another value, the awaitable instead raises an :exc:`StopAsyncIteration` "

"exception, signalling that the asynchronous iteration has completed."

msgstr ""

#: ../../reference/expressions.rst:644

msgid ""

"This method is normally called implicitly by a :keyword:`async for` loop."

msgstr ""

"このメソッドは通常、 :keyword:`for` ループによって暗黙に呼び出されます。"

#: ../../reference/expressions.rst:649

msgid ""

"Returns an awaitable which when run resumes the execution of the "

"asynchronous generator. As with the :meth:`~generator.send()` method for a "

"generator, this \"sends\" a value into the asynchronous generator function, "

"and the *value* argument becomes the result of the current yield expression. "

"The awaitable returned by the :meth:`asend` method will return the next "

"value yielded by the generator as the value of the raised :exc:"

"`StopIteration`, or raises :exc:`StopAsyncIteration` if the asynchronous "

"generator exits without yielding another value. When :meth:`asend` is "

"called to start the asynchronous generator, it must be called with :const:"

"`None` as the argument, because there is no yield expression that could "

"receive the value."

msgstr ""

#: ../../reference/expressions.rst:664

msgid ""

"Returns an awaitable that raises an exception of type ``type`` at the point "

"where the asynchronous generator was paused, and returns the next value "

"yielded by the generator function as the value of the raised :exc:"

"`StopIteration` exception. If the asynchronous generator exits without "

"yielding another value, an :exc:`StopAsyncIteration` exception is raised by "

"the awaitable. If the generator function does not catch the passed-in "

"exception, or raises a different exception, then when the awaitable is run "

"that exception propagates to the caller of the awaitable."

msgstr ""

#: ../../reference/expressions.rst:679

msgid ""

"Returns an awaitable that when run will throw a :exc:`GeneratorExit` into "

"the asynchronous generator function at the point where it was paused. If the "

"asynchronous generator function then exits gracefully, is already closed, or "

"raises :exc:`GeneratorExit` (by not catching the exception), then the "

"returned awaitable will raise a :exc:`StopIteration` exception. Any further "

"awaitables returned by subsequent calls to the asynchronous generator will "

"raise a :exc:`StopAsyncIteration` exception. If the asynchronous generator "

"yields a value, a :exc:`RuntimeError` is raised by the awaitable. If the "

"asynchronous generator raises any other exception, it is propagated to the "

"caller of the awaitable. If the asynchronous generator has already exited "

"due to an exception or normal exit, then further calls to :meth:`aclose` "

"will return an awaitable that does nothing."

msgstr ""

#: ../../reference/expressions.rst:695

msgid "Primaries"

msgstr "プライマリ"

#: ../../reference/expressions.rst:699

msgid ""

"Primaries represent the most tightly bound operations of the language. Their "

"syntax is:"

msgstr ""

"プライマリは、言語において最も結合の強い操作を表します。文法は以下のようにな"

"ります:"

#: ../../reference/expressions.rst:709

msgid "Attribute references"

msgstr "属性参照"

#: ../../reference/expressions.rst:715

msgid "An attribute reference is a primary followed by a period and a name:"

msgstr "属性参照は、プライマリの後ろにピリオドと名前を連ねたものです:"

#: ../../reference/expressions.rst:725

msgid ""

"The primary must evaluate to an object of a type that supports attribute "

"references, which most objects do. This object is then asked to produce the "

"attribute whose name is the identifier. This production can be customized "

"by overriding the :meth:`__getattr__` method. If this attribute is not "

"available, the exception :exc:`AttributeError` is raised. Otherwise, the "

"type and value of the object produced is determined by the object. Multiple "

"evaluations of the same attribute reference may yield different objects."

msgstr ""

"プライマリの評価は、属性参照をサポートする型のオブジェクトでなければならず、"

"これにはほとんどのオブジェクトが当てはまります。そしてこのオブジェクトは、名"

"前が指定した識別子名であるような属性を生成しなければなりません。この生成は :"

"meth:`__getattr__` メソッドをオーバーライドすることでカスタマイズできます。そ"

"の属性が得られなければ、例外 :exc:`AttributeError` が送出されます。そうでなけ"

"れば、生成されるオブジェクトの型と値は、属性を生成したオブジェクトにより決ま"

"ります。同じ属性参照を複数回評価すると、互いに異なる属性オブジェクトが得られ"

"ることがあります。"

#: ../../reference/expressions.rst:737

msgid "Subscriptions"

msgstr "添字表記 (subscription)"

#: ../../reference/expressions.rst:752

msgid ""