# Copyright (C) 2001 Python Software Foundation

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

#

# Translators:

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2026-02-19 00:20+0000\n"

"PO-Revision-Date: 2018-05-23 16:17+0000\n"

"Last-Translator: Adrian Liaw <[email protected]>\n"

"Language-Team: Chinese - TAIWAN (https://github.com/python/python-docs-zh-"

"tw)\n"

"Language: zh_TW\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 "運算式"

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

msgid ""

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

msgstr ""

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

msgid ""

"**Syntax Notes:** In this and the following chapters, :ref:`grammar notation "

"<notation>` will be used to describe syntax, not lexical analysis."

msgstr ""

#: ../../reference/expressions.rst:16

msgid "When (one alternative of) a syntax rule has the form:"

msgstr ""

#: ../../reference/expressions.rst:21

msgid ""

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

"same as for ``othername``."

msgstr ""

#: ../../reference/expressions.rst:28

msgid "Arithmetic conversions"

msgstr ""

#: ../../reference/expressions.rst:32

msgid ""

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

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

"operator implementation for built-in numeric types works as described in "

"the :ref:`Numeric Types <stdtypes-mixed-arithmetic>` section of the standard "

"library documentation."

msgstr ""

#: ../../reference/expressions.rst:38

msgid ""

"Some additional rules apply for certain operators and non-numeric operands "

"(for example, a string as a left argument to the ``%`` operator). Extensions "

"must define their own conversion behavior."

msgstr ""

#: ../../reference/expressions.rst:46

msgid "Atoms"

msgstr ""

#: ../../reference/expressions.rst:50

msgid ""

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

"ref:`names <identifiers>` or literals. Forms enclosed in parentheses, "

"brackets or braces are also categorized syntactically as atoms."

msgstr ""

#: ../../reference/expressions.rst:55

msgid "Formally, the syntax for atoms is:"

msgstr ""

#: ../../reference/expressions.rst:80

msgid "Built-in constants"

msgstr "內建常數"

#: ../../reference/expressions.rst:82

msgid ""

"The keywords ``True``, ``False``, and ``None`` name :ref:`built-in constants "

"<built-in-consts>`. The token ``...`` names the :py:data:`Ellipsis` constant."

msgstr ""

#: ../../reference/expressions.rst:86

msgid "Evaluation of these atoms yields the corresponding value."

msgstr ""

#: ../../reference/expressions.rst:90

msgid ""

"Several more built-in constants are available as global variables, but only "

"the ones mentioned here are :ref:`keywords <keywords>`. In particular, these "

"names cannot be reassigned or used as attributes:"

msgstr ""

#: ../../reference/expressions.rst:94

msgid ""

">>> False = 123\n"

" File \"<input>\", line 1\n"

" False = 123\n"

" ^^^^^\n"

"SyntaxError: cannot assign to False"

msgstr ""

#: ../../reference/expressions.rst:105

msgid "Identifiers (Names)"

msgstr ""

#: ../../reference/expressions.rst:109

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

#: ../../reference/expressions.rst:115

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

#: ../../reference/expressions.rst:126

msgid "Private name mangling"

msgstr ""

#: ../../reference/expressions.rst:128

msgid ""

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

msgstr ""

#: ../../reference/expressions.rst:134

msgid "The :ref:`class specifications <class>`."

msgstr ""

#: ../../reference/expressions.rst:136

msgid ""

"More precisely, private names are transformed to a longer form before code "

"is generated for them. If the transformed name is longer than 255 "

"characters, implementation-defined truncation may happen."

msgstr ""

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

msgid ""

"The transformation is independent of the syntactical context in which the "

"identifier is used but only the following private identifiers are mangled:"

msgstr ""

#: ../../reference/expressions.rst:143

msgid ""

"Any name used as the name of a variable that is assigned or read or any name "

"of an attribute being accessed."

msgstr ""

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

msgid ""

"The :attr:`~definition.__name__` attribute of nested functions, classes, and "

"type aliases is however not mangled."

msgstr ""

#: ../../reference/expressions.rst:149

msgid ""

"The name of imported modules, e.g., ``__spam`` in ``import __spam``. If the "

"module is part of a package (i.e., its name contains a dot), the name is "

"*not* mangled, e.g., the ``__foo`` in ``import __foo.bar`` is not mangled."

msgstr ""

#: ../../reference/expressions.rst:154

msgid ""

"The name of an imported member, e.g., ``__f`` in ``from spam import __f``."

msgstr ""

#: ../../reference/expressions.rst:156

msgid "The transformation rule is defined as follows:"

msgstr ""

#: ../../reference/expressions.rst:158

msgid ""

"The class name, with leading underscores removed and a single leading "

"underscore inserted, is inserted in front of the identifier, e.g., the "

"identifier ``__spam`` occurring in a class named ``Foo``, ``_Foo`` or "

"``__Foo`` is transformed to ``_Foo__spam``."

msgstr ""

#: ../../reference/expressions.rst:163

msgid ""

"If the class name consists only of underscores, the transformation is the "

"identity, e.g., the identifier ``__spam`` occurring in a class named ``_`` "

"or ``__`` is left as is."

msgstr ""

#: ../../reference/expressions.rst:170

msgid "Literals"

msgstr ""

#: ../../reference/expressions.rst:174

msgid ""

"A :dfn:`literal` is a textual representation of a value. Python supports "

"numeric, string and bytes literals. :ref:`Format strings <f-strings>` and :"

"ref:`template strings <t-strings>` are treated as string literals."

msgstr ""

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

msgid ""

"Numeric literals consist of a single :token:`NUMBER <python-grammar:NUMBER>` "

"token, which names an integer, floating-point number, or an imaginary "

"number. See the :ref:`numbers` section in Lexical analysis documentation for "

"details."

msgstr ""

#: ../../reference/expressions.rst:183

msgid ""

"String and bytes literals may consist of several tokens. See section :ref:"

"`string-concatenation` for details."

msgstr ""

#: ../../reference/expressions.rst:186

msgid ""

"Note that negative and complex numbers, like ``-3`` or ``3+4.2j``, are "

"syntactically not literals, but :ref:`unary <unary>` or :ref:`binary "

"<binary>` arithmetic operations involving the ``-`` or ``+`` operator."

msgstr ""

#: ../../reference/expressions.rst:191

msgid ""

"Evaluation of a literal yields an object of the given type (:class:`int`, :"

"class:`float`, :class:`complex`, :class:`str`, :class:`bytes`, or :class:"

"`~string.templatelib.Template`) with the given value. The value may be "

"approximated in the case of floating-point and imaginary literals."

msgstr ""

#: ../../reference/expressions.rst:197

msgid "The formal grammar for literals is:"

msgstr ""

#: ../../reference/expressions.rst:210

msgid "Literals and object identity"

msgstr ""

#: ../../reference/expressions.rst:212

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

msgid "CPython implementation detail"

msgstr ""

#: ../../reference/expressions.rst:220

msgid ""

"For example, in CPython, *small* integers with the same value evaluate to "

"the same object::"

msgstr ""

#: ../../reference/expressions.rst:223

msgid ""

">>> x = 7\n"

">>> y = 7\n"

">>> x is y\n"

"True"

msgstr ""

#: ../../reference/expressions.rst:228

msgid "However, large integers evaluate to different objects::"

msgstr ""

#: ../../reference/expressions.rst:230

msgid ""

">>> x = 123456789\n"

">>> y = 123456789\n"

">>> x is y\n"

"False"

msgstr ""

#: ../../reference/expressions.rst:235

msgid ""

"This behavior may change in future versions of CPython. In particular, the "

"boundary between \"small\" and \"large\" integers has already changed in the "

"past."

msgstr ""

#: ../../reference/expressions.rst:239

msgid ""

"CPython will emit a :py:exc:`SyntaxWarning` when you compare literals using "

"``is``::"

msgstr ""

#: ../../reference/expressions.rst:242

msgid ""

">>> x = 7\n"

">>> x is 7\n"

"<input>:1: SyntaxWarning: \"is\" with 'int' literal. Did you mean \"==\"?\n"

"True"

msgstr ""

#: ../../reference/expressions.rst:247

msgid "See :ref:`faq-identity-with-is` for more information."

msgstr ""

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

msgid ""

":ref:`Template strings <t-strings>` are immutable but may reference mutable "

"objects as :class:`~string.templatelib.Interpolation` values. For the "

"purposes of this section, two t-strings have the \"same value\" if both "

"their structure and the *identity* of the values match."

msgstr ""

#: ../../reference/expressions.rst:256

msgid ""

"Currently, each evaluation of a template string results in a different "

"object."

msgstr ""

#: ../../reference/expressions.rst:263

msgid "String literal concatenation"

msgstr ""

#: ../../reference/expressions.rst:265

msgid ""

"Multiple adjacent string or bytes literals, possibly using different quoting "

"conventions, are allowed, and their meaning is the same as their "

"concatenation::"

msgstr ""

#: ../../reference/expressions.rst:269

msgid ""

">>> \"hello\" 'world'\n"

"\"helloworld\""

msgstr ""

">>> \"hello\" 'world'\n"

"\"helloworld\""

#: ../../reference/expressions.rst:272

msgid ""

"This feature is defined at the syntactical level, so it only works with "

"literals. To concatenate string expressions at run time, the '+' operator "

"may be used::"

msgstr ""

#: ../../reference/expressions.rst:275

msgid ""

">>> greeting = \"Hello\"\n"

">>> space = \" \"\n"

">>> name = \"Blaise\"\n"

">>> print(greeting + space + name) # not: print(greeting space name)\n"

"Hello Blaise"

msgstr ""

">>> greeting = \"Hello\"\n"

">>> space = \" \"\n"

">>> name = \"Blaise\"\n"

">>> print(greeting + space + name) # 不是：print(greeting space name)\n"

"Hello Blaise"

#: ../../reference/expressions.rst:281

msgid ""

"Literal concatenation can freely mix raw strings, triple-quoted strings, and "

"formatted string literals. For example::"

msgstr ""

#: ../../reference/expressions.rst:285

msgid ""

">>> \"Hello\" r', ' f\"{name}!\"\n"

"\"Hello, Blaise!\""

msgstr ""

">>> \"Hello\" r', ' f\"{name}!\"\n"

"\"Hello, Blaise!\""

#: ../../reference/expressions.rst:288

msgid ""

"This feature can be used to reduce the number of backslashes needed, to "

"split long strings conveniently across long lines, or even to add comments "

"to parts of strings. For example::"

msgstr ""

#: ../../reference/expressions.rst:292

msgid ""

"re.compile(\"[A-Za-z_]\" # letter or underscore\n"

" \"[A-Za-z0-9_]*\" # letter, digit or underscore\n"

" )"

msgstr ""

#: ../../reference/expressions.rst:296

msgid ""

"However, bytes literals may only be combined with other byte literals; not "

"with string literals of any kind. Also, template string literals may only be "

"combined with other template string literals::"

msgstr ""

#: ../../reference/expressions.rst:301

msgid ""

">>> t\"Hello\" t\"{name}!\"\n"

"Template(strings=('Hello', '!'), interpolations=(...))"

msgstr ""

">>> t\"Hello\" t\"{name}!\"\n"

"Template(strings=('Hello', '!'), interpolations=(...))"

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

msgid "Formally:"

msgstr ""

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

msgid "Parenthesized forms"

msgstr ""

#: ../../reference/expressions.rst:321

msgid ""

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

msgstr ""

#: ../../reference/expressions.rst:326

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

msgid ""

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

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

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

msgstr ""

#: ../../reference/expressions.rst:340

msgid ""

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

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

#: ../../reference/expressions.rst:349

msgid "Displays for lists, sets and dictionaries"

msgstr ""

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

msgid ""

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

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

msgstr ""

#: ../../reference/expressions.rst:356

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

msgstr ""

#: ../../reference/expressions.rst:358

msgid ""

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

"dfn:`comprehension`."

msgstr ""

#: ../../reference/expressions.rst:366

msgid "Common syntax elements for comprehensions are:"

msgstr ""

#: ../../reference/expressions.rst:374

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

#: ../../reference/expressions.rst:381

msgid ""

"However, aside from the iterable expression in the leftmost :keyword:`!for` "

"clause, the comprehension is executed in a separate implicitly nested scope. "

"This ensures that names assigned to in the target list don't \"leak\" into "

"the enclosing scope."

msgstr ""

#: ../../reference/expressions.rst:385

msgid ""

"The iterable expression in the leftmost :keyword:`!for` clause is evaluated "

"directly in the enclosing scope and then passed as an argument to the "

"implicitly nested scope. Subsequent :keyword:`!for` clauses and any filter "

"condition in the leftmost :keyword:`!for` clause cannot be evaluated in the "

"enclosing scope as they may depend on the values obtained from the leftmost "

"iterable. For example: ``[x*y for x in range(10) for y in range(x, x+10)]``."

msgstr ""

#: ../../reference/expressions.rst:392

msgid ""

"To ensure the comprehension always results in a container of the appropriate "

"type, ``yield`` and ``yield from`` expressions are prohibited in the "

"implicitly nested scope."

msgstr ""

#: ../../reference/expressions.rst:399

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

msgstr ""

#: ../../reference/expressions.rst:406

msgid ""

"If a comprehension contains :keyword:`!async for` clauses, or if it "

"contains :keyword:`!await` expressions or other asynchronous comprehensions "

"anywhere except the iterable expression in the leftmost :keyword:`!for` "

"clause, 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:413

msgid "Asynchronous comprehensions were introduced."

msgstr ""

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

msgid "``yield`` and ``yield from`` prohibited in the implicitly nested scope."

msgstr ""

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

msgid ""

"Asynchronous comprehensions are now allowed inside comprehensions in "

"asynchronous functions. Outer comprehensions implicitly become asynchronous."

msgstr ""

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

msgid "List displays"

msgstr ""

#: ../../reference/expressions.rst:438

msgid ""

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

"brackets:"

msgstr ""

#: ../../reference/expressions.rst:444

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

#: ../../reference/expressions.rst:454

msgid "Set displays"

msgstr ""

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

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

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

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

msgid ""

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

"empty dictionary."

msgstr ""

#: ../../reference/expressions.rst:482

msgid "Dictionary displays"

msgstr ""

#: ../../reference/expressions.rst:493

msgid ""

"A dictionary display is a possibly empty series of dict items (key/value "

"pairs) enclosed in curly braces:"

msgstr ""

#: ../../reference/expressions.rst:502

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

msgstr ""

#: ../../reference/expressions.rst:504

msgid ""

"If a comma-separated sequence of dict items 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 value. This "

"means that you can specify the same key multiple times in the dict item "

"list, and the final dictionary's value for that key will be the last one "

"given."

msgstr ""

#: ../../reference/expressions.rst:514

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

"and earlier dictionary unpackings."

msgstr ""

#: ../../reference/expressions.rst:519

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

msgstr ""

#: ../../reference/expressions.rst:522

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

#: ../../reference/expressions.rst:530

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 value (textually rightmost in the display) stored for a "

"given key value prevails."

msgstr ""

#: ../../reference/expressions.rst:536

msgid ""

"Prior to Python 3.8, in dict comprehensions, the evaluation order of key and "

"value was not well-defined. In CPython, the value was evaluated before the "

"key. Starting with 3.8, the key is evaluated before the value, as proposed "

"by :pep:`572`."

msgstr ""

#: ../../reference/expressions.rst:546

msgid "Generator expressions"

msgstr ""

#: ../../reference/expressions.rst:553

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

msgstr ""

#: ../../reference/expressions.rst:558

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

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 iterable expression in the "

"leftmost :keyword:`!for` clause is immediately evaluated, and the :term:"

"`iterator` is immediately created for that iterable, so that an error "

"produced while creating the iterator will be emitted at the point where the "

"generator expression is defined, rather than at the point where the first "

"value is retrieved. Subsequent :keyword:`!for` clauses and any filter "

"condition in the leftmost :keyword:`!for` clause cannot be evaluated in the "

"enclosing scope as they may depend on the values obtained from the leftmost "

"iterable. For example: ``(x*y for x in range(10) for y in range(x, x+10))``."

msgstr ""

#: ../../reference/expressions.rst:574

msgid ""

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

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

msgstr ""

#: ../../reference/expressions.rst:577

msgid ""

"To avoid interfering with the expected operation of the generator expression "

"itself, ``yield`` and ``yield from`` expressions are prohibited in the "

"implicitly defined generator."

msgstr ""

#: ../../reference/expressions.rst:581

msgid ""

"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 returns a new "

"asynchronous generator object, which is an asynchronous iterator (see :ref:"

"`async-iterators`)."

msgstr ""

#: ../../reference/expressions.rst:587

msgid "Asynchronous generator expressions were introduced."

msgstr ""

#: ../../reference/expressions.rst:590

msgid ""

"Prior to Python 3.7, asynchronous generator expressions could only appear "

"in :keyword:`async def` coroutines. Starting with 3.7, any function can use "

"asynchronous generator expressions."

msgstr ""

#: ../../reference/expressions.rst:602

msgid "Yield expressions"

msgstr ""

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

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 function, and using it in an :"

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

"asynchronous generator function. For example::"

msgstr ""

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

msgid ""

"def gen(): # defines a generator function\n"

" yield 123\n"

"\n"

"async def agen(): # defines an asynchronous generator function\n"

" yield 123"

msgstr ""

"def gen(): # 定義一個產生器函式\n"

" yield 123\n"

"\n"

"async def agen(): # 定義一個非同步產生器函式\n"

" yield 123"

#: ../../reference/expressions.rst:628

msgid ""

"Due to their side effects on the containing scope, ``yield`` expressions are "

"not permitted as part of the implicitly defined scopes used to implement "

"comprehensions and generator expressions."

msgstr ""

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

msgid ""

"Yield expressions prohibited in the implicitly nested scopes used to "

"implement comprehensions and generator expressions."

msgstr ""

#: ../../reference/expressions.rst:636

msgid ""

"Generator functions are described below, while asynchronous generator "

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

"functions`."

msgstr ""

#: ../../reference/expressions.rst:640

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:`~python-grammar:"

"yield_list` to the generator's caller, or ``None`` if :token:`~python-"

"grammar:yield_list` is omitted. 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 ""

#: ../../reference/expressions.rst:660

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

#: ../../reference/expressions.rst:666

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

#: ../../reference/expressions.rst:675

msgid ""

"When ``yield from <expr>`` is used, the supplied expression must be an "

"iterable. The values produced by iterating that iterable 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 ""

#: ../../reference/expressions.rst:684

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 subiterator is a generator (by "

"returning a value from the subgenerator)."

msgstr ""

#: ../../reference/expressions.rst:690

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

msgstr ""

#: ../../reference/expressions.rst:693

msgid ""

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

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

msgstr ""

#: ../../reference/expressions.rst:698

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

msgstr ""

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

msgid ""

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

"Python."

msgstr ""

#: ../../reference/expressions.rst:701

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

msgstr ""

#: ../../reference/expressions.rst:702

msgid ""

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

"as simple coroutines."

msgstr ""

#: ../../reference/expressions.rst:705

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

msgstr ""

#: ../../reference/expressions.rst:706

msgid ""

"The proposal to introduce the :token:`~python-grammar:yield_from` syntax, "

"making delegation to subgenerators easy."

msgstr ""

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

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

msgstr ""

#: ../../reference/expressions.rst:710

msgid ""

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

"coroutine functions."

msgstr ""

#: ../../reference/expressions.rst:717

msgid "Generator-iterator methods"

msgstr ""

#: ../../reference/expressions.rst:719

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

msgid ""

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

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

msgstr ""

#: ../../reference/expressions.rst:730

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:`~python-grammar:yield_list` is returned to :meth:`__next__`'s "

"caller. If the generator exits without yielding another value, a :exc:"

"`StopIteration` exception is raised."

msgstr ""

#: ../../reference/expressions.rst:739

msgid ""

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

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

msgstr ""

#: ../../reference/expressions.rst:745

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

#: ../../reference/expressions.rst:757

msgid ""

"Raises an exception 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 ""

#: ../../reference/expressions.rst:763

msgid ""

"In typical use, this is called with a single exception instance similar to "

"the way the :keyword:`raise` keyword is used."

msgstr ""

#: ../../reference/expressions.rst:766

msgid ""

"For backwards compatibility, however, the second signature is supported, "

"following a convention from older versions of Python. The *type* argument "

"should be an exception class, and *value* should be an exception instance. "

"If the *value* is not provided, the *type* constructor is called to get an "

"instance. If *traceback* is provided, it is set on the exception, otherwise "

"any existing :attr:`~BaseException.__traceback__` attribute stored in "

"*value* may be cleared."

msgstr ""

#: ../../reference/expressions.rst:777 ../../reference/expressions.rst:963

msgid ""

"The second signature \\(type\\[, value\\[, traceback\\]\\]\\) is deprecated "

"and may be removed in a future version of Python."

msgstr ""

#: ../../reference/expressions.rst:785

msgid ""

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

"function was paused (equivalent to calling ``throw(GeneratorExit)``). The "

"exception is raised by the yield expression where the generator was paused. "

"If the generator function catches the exception and returns a value, this "

"value is returned from :meth:`close`. If the generator function is already "

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

"meth:`close` returns :const:`None`. If the generator yields a value, a :exc:"

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

"is propagated to the caller. If the generator has already exited due to an "

"exception or normal exit, :meth:`close` returns :const:`None` and has no "

"other effect."

msgstr ""

#: ../../reference/expressions.rst:799

msgid ""

"If a generator returns a value upon being closed, the value is returned by :"

"meth:`close`."

msgstr ""

#: ../../reference/expressions.rst:805

msgid "Examples"

msgstr "模組"

#: ../../reference/expressions.rst:807

msgid ""

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

"generator functions::"

msgstr ""

#: ../../reference/expressions.rst:810

msgid ""

">>> def echo(value=None):\n"

"... print(\"Execution starts when 'next()' is called for the first time."

"\")\n"

"... try:\n"

"... while True:\n"

"... try:\n"

"... value = (yield value)\n"

"... except Exception as e:\n"

"... value = e\n"

"... finally:\n"

"... print(\"Don't forget to clean up when 'close()' is called.\")\n"

"...\n"

">>> generator = echo(1)\n"

">>> print(next(generator))\n"

"Execution starts when 'next()' is called for the first time.\n"

"1\n"

">>> print(next(generator))\n"

"None\n"

">>> print(generator.send(2))\n"

"2\n"

">>> generator.throw(TypeError, \"spam\")\n"

"TypeError('spam',)\n"

">>> generator.close()\n"

"Don't forget to clean up when 'close()' is called."

msgstr ""

">>> def echo(value=None):\n"

"... print(\"Execution starts when 'next()' is called for the first time."