# SOME DESCRIPTIVE TITLE.

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

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

#

# Translators:

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2020-06-20 18:04+0800\n"

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

"Last-Translator: Adrian Liaw <adrianliaw2000@gmail.com>\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, extended BNF notation "

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

"alternative of) a syntax rule has the form"

msgstr ""

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

msgid ""

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

"same as for ``othername``."

msgstr ""

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

msgid "Arithmetic conversions"

msgstr ""

#: ../../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 ""

#: ../../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 ""

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

msgid "Identifiers (Names)"

msgstr ""

#: ../../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 ""

#: ../../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 ""

#: ../../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 ""

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

msgid "Literals"

msgstr ""

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

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

msgstr ""

#: ../../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 ""

#: ../../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 ""

#: ../../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 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:154

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

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

msgid "Displays for lists, sets and dictionaries"

msgstr ""

#: ../../reference/expressions.rst:165

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

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

msgstr ""

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

msgid ""

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

"dfn:`comprehension`."

msgstr ""

#: ../../reference/expressions.rst:178

msgid "Common syntax elements for comprehensions are:"

msgstr ""

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

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

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

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

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

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

msgid "Asynchronous comprehensions were introduced."

msgstr ""

#: ../../reference/expressions.rst:226 ../../reference/expressions.rst:397

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

msgstr ""

#: ../../reference/expressions.rst:233

msgid "List displays"

msgstr ""

#: ../../reference/expressions.rst:243

msgid ""

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

"brackets:"

msgstr ""

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

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

msgid "Set displays"

msgstr ""

#: ../../reference/expressions.rst:267

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

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

msgid ""

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

"empty dictionary."

msgstr ""

#: ../../reference/expressions.rst:286

msgid "Dictionary displays"

msgstr ""

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

msgid ""

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

"in curly braces:"

msgstr ""

#: ../../reference/expressions.rst:305

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

msgstr ""

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

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

#: ../../reference/expressions.rst:317

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

#: ../../reference/expressions.rst:322

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

msgstr ""

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

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

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

#: ../../reference/expressions.rst:339

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

msgid "Generator expressions"

msgstr ""

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

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

msgstr ""

#: ../../reference/expressions.rst:361

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

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, so that an error "

"produced by it 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:376

msgid ""

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

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

msgstr ""

#: ../../reference/expressions.rst:379

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

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

msgid "Asynchronous generator expressions were introduced."

msgstr ""

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

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

msgid "Yield expressions"

msgstr ""

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

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

#: ../../reference/expressions.rst:429

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

msgid ""

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

"implement comprehensions and generator expressions."

msgstr ""

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

msgid ""

"Generator functions are described below, while asynchronous generator "

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

"functions`."

msgstr ""

#: ../../reference/expressions.rst:441

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

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

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

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

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

#: ../../reference/expressions.rst:484

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

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

msgstr ""

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

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

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

msgstr ""

#: ../../reference/expressions.rst:499

msgid ""

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

"Python."

msgstr ""

#: ../../reference/expressions.rst:503

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

msgstr ""

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

msgid ""

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

"as simple coroutines."

msgstr ""

#: ../../reference/expressions.rst:507

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

msgstr ""

#: ../../reference/expressions.rst:506

msgid ""

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

"to subgenerators easy."

msgstr ""

#: ../../reference/expressions.rst:510

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

msgstr ""

#: ../../reference/expressions.rst:510

msgid ""

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

"coroutine functions."

msgstr ""

#: ../../reference/expressions.rst:517

msgid "Generator-iterator methods"

msgstr ""

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

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

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

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

#: ../../reference/expressions.rst:539

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

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

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

#: ../../reference/expressions.rst:567

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

#: ../../reference/expressions.rst:578

msgid "Examples"

msgstr ""

#: ../../reference/expressions.rst:580

msgid ""

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

"generator functions::"

msgstr ""

#: ../../reference/expressions.rst:607

msgid ""

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

"Python.\""

msgstr ""

#: ../../reference/expressions.rst:613

msgid "Asynchronous generator functions"

msgstr ""

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

msgid ""

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

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

"generator` function."

msgstr ""

#: ../../reference/expressions.rst:619

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

#: ../../reference/expressions.rst:626

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

#: ../../reference/expressions.rst:642

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

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

msgid ""

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

"asynchronous generator function."

msgstr ""

#: ../../reference/expressions.rst:669

msgid "Asynchronous generator-iterator methods"

msgstr ""

#: ../../reference/expressions.rst:671

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

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 an :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 a :exc:`StopAsyncIteration` "

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

msgstr ""

#: ../../reference/expressions.rst:691

msgid ""

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

msgstr ""

#: ../../reference/expressions.rst:696

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

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, a :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:726

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

msgid "Primaries"

msgstr ""

#: ../../reference/expressions.rst:746

msgid ""

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

"syntax is:"

msgstr ""

#: ../../reference/expressions.rst:756

msgid "Attribute references"

msgstr ""

#: ../../reference/expressions.rst:762

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

msgstr ""

#: ../../reference/expressions.rst:772

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

#: ../../reference/expressions.rst:784

msgid "Subscriptions"

msgstr ""

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

msgid ""

"A subscription selects an item of a sequence (string, tuple or list) or "

"mapping (dictionary) object:"

msgstr ""

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

msgid ""

"The primary must evaluate to an object that supports subscription (lists or "

"dictionaries for example). User-defined objects can support subscription by "

"defining a :meth:`__getitem__` method."

msgstr ""

#: ../../reference/expressions.rst:809

msgid ""

"For built-in objects, there are two types of objects that support "

"subscription:"

msgstr ""

#: ../../reference/expressions.rst:811

msgid ""

"If the primary is a mapping, the expression list must evaluate to an object "

"whose value is one of the keys of the mapping, and the subscription selects "

"the value in the mapping that corresponds to that key. (The expression list "

"is a tuple except if it has exactly one item.)"

msgstr ""

#: ../../reference/expressions.rst:816

msgid ""

"If the primary is a sequence, the expression list must evaluate to an "

"integer or a slice (as discussed in the following section)."

msgstr ""

#: ../../reference/expressions.rst:819

msgid ""

"The formal syntax makes no special provision for negative indices in "

"sequences; however, built-in sequences all provide a :meth:`__getitem__` "

"method that interprets negative indices by adding the length of the sequence "

"to the index (so that ``x[-1]`` selects the last item of ``x``). The "

"resulting value must be a nonnegative integer less than the number of items "

"in the sequence, and the subscription selects the item whose index is that "

"value (counting from zero). Since the support for negative indices and "

"slicing occurs in the object's :meth:`__getitem__` method, subclasses "

"overriding this method will need to explicitly add that support."

msgstr ""

#: ../../reference/expressions.rst:833

msgid ""

"A string's items are characters. A character is not a separate data type "

"but a string of exactly one character."

msgstr ""

#: ../../reference/expressions.rst:840

msgid "Slicings"

msgstr ""

#: ../../reference/expressions.rst:854

msgid ""

"A slicing selects a range of items in a sequence object (e.g., a string, "

"tuple or list). Slicings may be used as expressions or as targets in "

"assignment or :keyword:`del` statements. The syntax for a slicing:"

msgstr ""

#: ../../reference/expressions.rst:867

msgid ""

"There is ambiguity in the formal syntax here: anything that looks like an "

"expression list also looks like a slice list, so any subscription can be "

"interpreted as a slicing. Rather than further complicating the syntax, this "

"is disambiguated by defining that in this case the interpretation as a "

"subscription takes priority over the interpretation as a slicing (this is "

"the case if the slice list contains no proper slice)."

msgstr ""

#: ../../reference/expressions.rst:879

msgid ""

"The semantics for a slicing are as follows. The primary is indexed (using "

"the same :meth:`__getitem__` method as normal subscription) with a key that "

"is constructed from the slice list, as follows. If the slice list contains "

"at least one comma, the key is a tuple containing the conversion of the "

"slice items; otherwise, the conversion of the lone slice item is the key. "

"The conversion of a slice item that is an expression is that expression. "

"The conversion of a proper slice is a slice object (see section :ref:"

"`types`) whose :attr:`~slice.start`, :attr:`~slice.stop` and :attr:`~slice."

"step` attributes are the values of the expressions given as lower bound, "

"upper bound and stride, respectively, substituting ``None`` for missing "

"expressions."

msgstr ""

#: ../../reference/expressions.rst:903

msgid "Calls"

msgstr ""

#: ../../reference/expressions.rst:905

msgid ""

"A call calls a callable object (e.g., a :term:`function`) with a possibly "

"empty series of :term:`arguments <argument>`:"

msgstr ""

#: ../../reference/expressions.rst:922

msgid ""

"An optional trailing comma may be present after the positional and keyword "

"arguments but does not affect the semantics."

msgstr ""

#: ../../reference/expressions.rst:928

msgid ""

"The primary must evaluate to a callable object (user-defined functions, "

"built-in functions, methods of built-in objects, class objects, methods of "

"class instances, and all objects having a :meth:`__call__` method are "

"callable). All argument expressions are evaluated before the call is "

"attempted. Please refer to section :ref:`function` for the syntax of "

"formal :term:`parameter` lists."

msgstr ""

#: ../../reference/expressions.rst:936

msgid ""

"If keyword arguments are present, they are first converted to positional "

"arguments, as follows. First, a list of unfilled slots is created for the "

"formal parameters. If there are N positional arguments, they are placed in "

"the first N slots. Next, for each keyword argument, the identifier is used "

"to determine the corresponding slot (if the identifier is the same as the "

"first formal parameter name, the first slot is used, and so on). If the "

"slot is already filled, a :exc:`TypeError` exception is raised. Otherwise, "

"the value of the argument is placed in the slot, filling it (even if the "

"expression is ``None``, it fills the slot). When all arguments have been "

"processed, the slots that are still unfilled are filled with the "

"corresponding default value from the function definition. (Default values "

"are calculated, once, when the function is defined; thus, a mutable object "

"such as a list or dictionary used as default value will be shared by all "

"calls that don't specify an argument value for the corresponding slot; this "

"should usually be avoided.) If there are any unfilled slots for which no "

"default value is specified, a :exc:`TypeError` exception is raised. "

"Otherwise, the list of filled slots is used as the argument list for the "

"call."

msgstr ""

#: ../../reference/expressions.rst:956

msgid ""

"An implementation may provide built-in functions whose positional parameters "

"do not have names, even if they are 'named' for the purpose of "

"documentation, and which therefore cannot be supplied by keyword. In "

"CPython, this is the case for functions implemented in C that use :c:func:"

"`PyArg_ParseTuple` to parse their arguments."

msgstr ""

#: ../../reference/expressions.rst:962

msgid ""

"If there are more positional arguments than there are formal parameter "

"slots, a :exc:`TypeError` exception is raised, unless a formal parameter "

"using the syntax ``*identifier`` is present; in this case, that formal "

"parameter receives a tuple containing the excess positional arguments (or an "

"empty tuple if there were no excess positional arguments)."

msgstr ""

#: ../../reference/expressions.rst:968

msgid ""

"If any keyword argument does not correspond to a formal parameter name, a :"

"exc:`TypeError` exception is raised, unless a formal parameter using the "

"syntax ``**identifier`` is present; in this case, that formal parameter "

"receives a dictionary containing the excess keyword arguments (using the "

"keywords as keys and the argument values as corresponding values), or a "

"(new) empty dictionary if there were no excess keyword arguments."

msgstr ""

#: ../../reference/expressions.rst:979

msgid ""

"If the syntax ``*expression`` appears in the function call, ``expression`` "

"must evaluate to an :term:`iterable`. Elements from these iterables are "

"treated as if they were additional positional arguments. For the call "

"``f(x1, x2, *y, x3, x4)``, if *y* evaluates to a sequence *y1*, ..., *yM*, "

"this is equivalent to a call with M+4 positional arguments *x1*, *x2*, "

"*y1*, ..., *yM*, *x3*, *x4*."

msgstr ""