# SOME DESCRIPTIVE TITLE. # Copyright (C) 2001-2016, Python Software Foundation # This file is distributed under the same license as the Python package. # FIRST AUTHOR , YEAR. # msgid "" msgstr "" "Project-Id-Version: Python 3.6\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2018-06-28 15:29+0200\n" "PO-Revision-Date: 2018-07-02 22:56+0200\n" "Last-Translator: Julien Palard \n" "Language-Team: \n" "Language: fr\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "X-Generator: Poedit 2.0.2\n" #: ../Doc/reference/compound_stmts.rst:5 msgid "Compound statements" msgstr "" #: ../Doc/reference/compound_stmts.rst:9 msgid "" "Compound statements contain (groups of) other statements; they affect or " "control the execution of those other statements in some way. In general, " "compound statements span multiple lines, although in simple incarnations a " "whole compound statement may be contained in one line." msgstr "" #: ../Doc/reference/compound_stmts.rst:14 msgid "" "The :keyword:`if`, :keyword:`while` and :keyword:`for` statements implement " "traditional control flow constructs. :keyword:`try` specifies exception " "handlers and/or cleanup code for a group of statements, while the :keyword:" "`with` statement allows the execution of initialization and finalization " "code around a block of code. Function and class definitions are also " "syntactically compound statements." msgstr "" #: ../Doc/reference/compound_stmts.rst:25 msgid "" "A compound statement consists of one or more 'clauses.' A clause consists " "of a header and a 'suite.' The clause headers of a particular compound " "statement are all at the same indentation level. Each clause header begins " "with a uniquely identifying keyword and ends with a colon. A suite is a " "group of statements controlled by a clause. A suite can be one or more " "semicolon-separated simple statements on the same line as the header, " "following the header's colon, or it can be one or more indented statements " "on subsequent lines. Only the latter form of a suite can contain nested " "compound statements; the following is illegal, mostly because it wouldn't be " "clear to which :keyword:`if` clause a following :keyword:`else` clause would " "belong::" msgstr "" #: ../Doc/reference/compound_stmts.rst:38 msgid "" "Also note that the semicolon binds tighter than the colon in this context, " "so that in the following example, either all or none of the :func:`print` " "calls are executed::" msgstr "" #: ../Doc/reference/compound_stmts.rst:44 msgid "Summarizing:" msgstr "" #: ../Doc/reference/compound_stmts.rst:66 msgid "" "Note that statements always end in a ``NEWLINE`` possibly followed by a " "``DEDENT``. Also note that optional continuation clauses always begin with " "a keyword that cannot start a statement, thus there are no ambiguities (the " "'dangling :keyword:`else`' problem is solved in Python by requiring nested :" "keyword:`if` statements to be indented)." msgstr "" #: ../Doc/reference/compound_stmts.rst:72 msgid "" "The formatting of the grammar rules in the following sections places each " "clause on a separate line for clarity." msgstr "" #: ../Doc/reference/compound_stmts.rst:81 msgid "The :keyword:`if` statement" msgstr "L'instruction :keyword:`if`" #: ../Doc/reference/compound_stmts.rst:90 msgid "The :keyword:`if` statement is used for conditional execution:" msgstr "" #: ../Doc/reference/compound_stmts.rst:97 msgid "" "It selects exactly one of the suites by evaluating the expressions one by " "one until one is found to be true (see section :ref:`booleans` for the " "definition of true and false); then that suite is executed (and no other " "part of the :keyword:`if` statement is executed or evaluated). If all " "expressions are false, the suite of the :keyword:`else` clause, if present, " "is executed." msgstr "" #: ../Doc/reference/compound_stmts.rst:107 msgid "The :keyword:`while` statement" msgstr "L'instruction :keyword:`while`" #: ../Doc/reference/compound_stmts.rst:115 msgid "" "The :keyword:`while` statement is used for repeated execution as long as an " "expression is true:" msgstr "" #: ../Doc/reference/compound_stmts.rst:122 msgid "" "This repeatedly tests the expression and, if it is true, executes the first " "suite; if the expression is false (which may be the first time it is tested) " "the suite of the :keyword:`else` clause, if present, is executed and the " "loop terminates." msgstr "" #: ../Doc/reference/compound_stmts.rst:131 msgid "" "A :keyword:`break` statement executed in the first suite terminates the loop " "without executing the :keyword:`else` clause's suite. A :keyword:`continue` " "statement executed in the first suite skips the rest of the suite and goes " "back to testing the expression." msgstr "" #: ../Doc/reference/compound_stmts.rst:140 msgid "The :keyword:`for` statement" msgstr "L'instruction :keyword:`for`" #: ../Doc/reference/compound_stmts.rst:153 msgid "" "The :keyword:`for` statement is used to iterate over the elements of a " "sequence (such as a string, tuple or list) or other iterable object:" msgstr "" #: ../Doc/reference/compound_stmts.rst:160 msgid "" "The expression list is evaluated once; it should yield an iterable object. " "An iterator is created for the result of the ``expression_list``. The suite " "is then executed once for each item provided by the iterator, in the order " "returned by the iterator. Each item in turn is assigned to the target list " "using the standard rules for assignments (see :ref:`assignment`), and then " "the suite is executed. When the items are exhausted (which is immediately " "when the sequence is empty or an iterator raises a :exc:`StopIteration` " "exception), the suite in the :keyword:`else` clause, if present, is " "executed, and the loop terminates." msgstr "" #: ../Doc/reference/compound_stmts.rst:173 msgid "" "A :keyword:`break` statement executed in the first suite terminates the loop " "without executing the :keyword:`else` clause's suite. A :keyword:`continue` " "statement executed in the first suite skips the rest of the suite and " "continues with the next item, or with the :keyword:`else` clause if there is " "no next item." msgstr "" #: ../Doc/reference/compound_stmts.rst:179 msgid "" "The for-loop makes assignments to the variables(s) in the target list. This " "overwrites all previous assignments to those variables including those made " "in the suite of the for-loop::" msgstr "" #: ../Doc/reference/compound_stmts.rst:193 msgid "" "Names in the target list are not deleted when the loop is finished, but if " "the sequence is empty, they will not have been assigned to at all by the " "loop. Hint: the built-in function :func:`range` returns an iterator of " "integers suitable to emulate the effect of Pascal's ``for i := a to b do``; " "e.g., ``list(range(3))`` returns the list ``[0, 1, 2]``." msgstr "" #: ../Doc/reference/compound_stmts.rst:205 msgid "" "There is a subtlety when the sequence is being modified by the loop (this " "can only occur for mutable sequences, i.e. lists). An internal counter is " "used to keep track of which item is used next, and this is incremented on " "each iteration. When this counter has reached the length of the sequence " "the loop terminates. This means that if the suite deletes the current (or a " "previous) item from the sequence, the next item will be skipped (since it " "gets the index of the current item which has already been treated). " "Likewise, if the suite inserts an item in the sequence before the current " "item, the current item will be treated again the next time through the loop. " "This can lead to nasty bugs that can be avoided by making a temporary copy " "using a slice of the whole sequence, e.g., ::" msgstr "" #: ../Doc/reference/compound_stmts.rst:226 msgid "The :keyword:`try` statement" msgstr "L'instruction :keyword:`try`" #: ../Doc/reference/compound_stmts.rst:234 msgid "" "The :keyword:`try` statement specifies exception handlers and/or cleanup " "code for a group of statements:" msgstr "" #: ../Doc/reference/compound_stmts.rst:247 msgid "" "The :keyword:`except` clause(s) specify one or more exception handlers. When " "no exception occurs in the :keyword:`try` clause, no exception handler is " "executed. When an exception occurs in the :keyword:`try` suite, a search for " "an exception handler is started. This search inspects the except clauses in " "turn until one is found that matches the exception. An expression-less " "except clause, if present, must be last; it matches any exception. For an " "except clause with an expression, that expression is evaluated, and the " "clause matches the exception if the resulting object is \"compatible\" with " "the exception. An object is compatible with an exception if it is the class " "or a base class of the exception object or a tuple containing an item " "compatible with the exception." msgstr "" #: ../Doc/reference/compound_stmts.rst:258 msgid "" "If no except clause matches the exception, the search for an exception " "handler continues in the surrounding code and on the invocation stack. [#]_" msgstr "" #: ../Doc/reference/compound_stmts.rst:261 msgid "" "If the evaluation of an expression in the header of an except clause raises " "an exception, the original search for a handler is canceled and a search " "starts for the new exception in the surrounding code and on the call stack " "(it is treated as if the entire :keyword:`try` statement raised the " "exception)." msgstr "" #: ../Doc/reference/compound_stmts.rst:266 msgid "" "When a matching except clause is found, the exception is assigned to the " "target specified after the :keyword:`as` keyword in that except clause, if " "present, and the except clause's suite is executed. All except clauses must " "have an executable block. When the end of this block is reached, execution " "continues normally after the entire try statement. (This means that if two " "nested handlers exist for the same exception, and the exception occurs in " "the try clause of the inner handler, the outer handler will not handle the " "exception.)" msgstr "" #: ../Doc/reference/compound_stmts.rst:274 msgid "" "When an exception has been assigned using ``as target``, it is cleared at " "the end of the except clause. This is as if ::" msgstr "" #: ../Doc/reference/compound_stmts.rst:280 msgid "was translated to ::" msgstr "" #: ../Doc/reference/compound_stmts.rst:288 msgid "" "This means the exception must be assigned to a different name to be able to " "refer to it after the except clause. Exceptions are cleared because with " "the traceback attached to them, they form a reference cycle with the stack " "frame, keeping all locals in that frame alive until the next garbage " "collection occurs." msgstr "" #: ../Doc/reference/compound_stmts.rst:297 msgid "" "Before an except clause's suite is executed, details about the exception are " "stored in the :mod:`sys` module and can be accessed via :func:`sys." "exc_info`. :func:`sys.exc_info` returns a 3-tuple consisting of the " "exception class, the exception instance and a traceback object (see section :" "ref:`types`) identifying the point in the program where the exception " "occurred. :func:`sys.exc_info` values are restored to their previous values " "(before the call) when returning from a function that handled an exception." msgstr "" #: ../Doc/reference/compound_stmts.rst:311 msgid "" "The optional :keyword:`else` clause is executed if and when control flows " "off the end of the :keyword:`try` clause. [#]_ Exceptions in the :keyword:" "`else` clause are not handled by the preceding :keyword:`except` clauses." msgstr "" #: ../Doc/reference/compound_stmts.rst:317 msgid "" "If :keyword:`finally` is present, it specifies a 'cleanup' handler. The :" "keyword:`try` clause is executed, including any :keyword:`except` and :" "keyword:`else` clauses. If an exception occurs in any of the clauses and is " "not handled, the exception is temporarily saved. The :keyword:`finally` " "clause is executed. If there is a saved exception it is re-raised at the " "end of the :keyword:`finally` clause. If the :keyword:`finally` clause " "raises another exception, the saved exception is set as the context of the " "new exception. If the :keyword:`finally` clause executes a :keyword:`return` " "or :keyword:`break` statement, the saved exception is discarded::" msgstr "" #: ../Doc/reference/compound_stmts.rst:336 msgid "" "The exception information is not available to the program during execution " "of the :keyword:`finally` clause." msgstr "" #: ../Doc/reference/compound_stmts.rst:344 msgid "" "When a :keyword:`return`, :keyword:`break` or :keyword:`continue` statement " "is executed in the :keyword:`try` suite of a :keyword:`try`...\\ :keyword:" "`finally` statement, the :keyword:`finally` clause is also executed 'on the " "way out.' A :keyword:`continue` statement is illegal in the :keyword:" "`finally` clause. (The reason is a problem with the current implementation " "--- this restriction may be lifted in the future)." msgstr "" #: ../Doc/reference/compound_stmts.rst:351 msgid "" "The return value of a function is determined by the last :keyword:`return` " "statement executed. Since the :keyword:`finally` clause always executes, a :" "keyword:`return` statement executed in the :keyword:`finally` clause will " "always be the last one executed::" msgstr "" #: ../Doc/reference/compound_stmts.rst:365 msgid "" "Additional information on exceptions can be found in section :ref:" "`exceptions`, and information on using the :keyword:`raise` statement to " "generate exceptions may be found in section :ref:`raise`." msgstr "" #: ../Doc/reference/compound_stmts.rst:374 msgid "The :keyword:`with` statement" msgstr "L'instruction :keyword:`with`" #: ../Doc/reference/compound_stmts.rst:380 msgid "" "The :keyword:`with` statement is used to wrap the execution of a block with " "methods defined by a context manager (see section :ref:`context-managers`). " "This allows common :keyword:`try`...\\ :keyword:`except`...\\ :keyword:" "`finally` usage patterns to be encapsulated for convenient reuse." msgstr "" #: ../Doc/reference/compound_stmts.rst:389 msgid "" "The execution of the :keyword:`with` statement with one \"item\" proceeds as " "follows:" msgstr "" #: ../Doc/reference/compound_stmts.rst:391 msgid "" "The context expression (the expression given in the :token:`with_item`) is " "evaluated to obtain a context manager." msgstr "" #: ../Doc/reference/compound_stmts.rst:394 msgid "The context manager's :meth:`__exit__` is loaded for later use." msgstr "" #: ../Doc/reference/compound_stmts.rst:396 msgid "The context manager's :meth:`__enter__` method is invoked." msgstr "" #: ../Doc/reference/compound_stmts.rst:398 msgid "" "If a target was included in the :keyword:`with` statement, the return value " "from :meth:`__enter__` is assigned to it." msgstr "" #: ../Doc/reference/compound_stmts.rst:403 msgid "" "The :keyword:`with` statement guarantees that if the :meth:`__enter__` " "method returns without an error, then :meth:`__exit__` will always be " "called. Thus, if an error occurs during the assignment to the target list, " "it will be treated the same as an error occurring within the suite would be. " "See step 6 below." msgstr "" #: ../Doc/reference/compound_stmts.rst:409 msgid "The suite is executed." msgstr "" #: ../Doc/reference/compound_stmts.rst:411 msgid "" "The context manager's :meth:`__exit__` method is invoked. If an exception " "caused the suite to be exited, its type, value, and traceback are passed as " "arguments to :meth:`__exit__`. Otherwise, three :const:`None` arguments are " "supplied." msgstr "" #: ../Doc/reference/compound_stmts.rst:416 msgid "" "If the suite was exited due to an exception, and the return value from the :" "meth:`__exit__` method was false, the exception is reraised. If the return " "value was true, the exception is suppressed, and execution continues with " "the statement following the :keyword:`with` statement." msgstr "" #: ../Doc/reference/compound_stmts.rst:421 msgid "" "If the suite was exited for any reason other than an exception, the return " "value from :meth:`__exit__` is ignored, and execution proceeds at the normal " "location for the kind of exit that was taken." msgstr "" #: ../Doc/reference/compound_stmts.rst:425 msgid "" "With more than one item, the context managers are processed as if multiple :" "keyword:`with` statements were nested::" msgstr "" #: ../Doc/reference/compound_stmts.rst:431 #: ../Doc/reference/compound_stmts.rst:635 msgid "is equivalent to ::" msgstr "est équivalente à : ::" #: ../Doc/reference/compound_stmts.rst:437 msgid "Support for multiple context expressions." msgstr "" #: ../Doc/reference/compound_stmts.rst:443 msgid ":pep:`343` - The \"with\" statement" msgstr ":pep:`343` - The \"with\" statement" #: ../Doc/reference/compound_stmts.rst:443 msgid "" "The specification, background, and examples for the Python :keyword:`with` " "statement." msgstr "" #: ../Doc/reference/compound_stmts.rst:454 msgid "Function definitions" msgstr "" #: ../Doc/reference/compound_stmts.rst:466 msgid "" "A function definition defines a user-defined function object (see section :" "ref:`types`):" msgstr "" #: ../Doc/reference/compound_stmts.rst:483 msgid "" "A function definition is an executable statement. Its execution binds the " "function name in the current local namespace to a function object (a wrapper " "around the executable code for the function). This function object contains " "a reference to the current global namespace as the global namespace to be " "used when the function is called." msgstr "" #: ../Doc/reference/compound_stmts.rst:489 msgid "" "The function definition does not execute the function body; this gets " "executed only when the function is called. [#]_" msgstr "" #: ../Doc/reference/compound_stmts.rst:495 msgid "" "A function definition may be wrapped by one or more :term:`decorator` " "expressions. Decorator expressions are evaluated when the function is " "defined, in the scope that contains the function definition. The result " "must be a callable, which is invoked with the function object as the only " "argument. The returned value is bound to the function name instead of the " "function object. Multiple decorators are applied in nested fashion. For " "example, the following code ::" msgstr "" #: ../Doc/reference/compound_stmts.rst:506 #: ../Doc/reference/compound_stmts.rst:662 msgid "is roughly equivalent to ::" msgstr "" #: ../Doc/reference/compound_stmts.rst:511 msgid "" "except that the original function is not temporarily bound to the name " "``func``." msgstr "" #: ../Doc/reference/compound_stmts.rst:517 msgid "" "When one or more :term:`parameters ` have the form *parameter* " "``=`` *expression*, the function is said to have \"default parameter values." "\" For a parameter with a default value, the corresponding :term:`argument` " "may be omitted from a call, in which case the parameter's default value is " "substituted. If a parameter has a default value, all following parameters " "up until the \"``*``\" must also have a default value --- this is a " "syntactic restriction that is not expressed by the grammar." msgstr "" #: ../Doc/reference/compound_stmts.rst:525 msgid "" "**Default parameter values are evaluated from left to right when the " "function definition is executed.** This means that the expression is " "evaluated once, when the function is defined, and that the same \"pre-" "computed\" value is used for each call. This is especially important to " "understand when a default parameter is a mutable object, such as a list or a " "dictionary: if the function modifies the object (e.g. by appending an item " "to a list), the default value is in effect modified. This is generally not " "what was intended. A way around this is to use ``None`` as the default, and " "explicitly test for it in the body of the function, e.g.::" msgstr "" #: ../Doc/reference/compound_stmts.rst:545 msgid "" "Function call semantics are described in more detail in section :ref:" "`calls`. A function call always assigns values to all parameters mentioned " "in the parameter list, either from position arguments, from keyword " "arguments, or from default values. If the form \"``*identifier``\" is " "present, it is initialized to a tuple receiving any excess positional " "parameters, defaulting to the empty tuple. If the form \"``**identifier``\" " "is present, it is initialized to a new ordered mapping receiving any excess " "keyword arguments, defaulting to a new empty mapping of the same type. " "Parameters after \"``*``\" or \"``*identifier``\" are keyword-only " "parameters and may only be passed used keyword arguments." msgstr "" #: ../Doc/reference/compound_stmts.rst:558 msgid "" "Parameters may have annotations of the form \"``: expression``\" following " "the parameter name. Any parameter may have an annotation even those of the " "form ``*identifier`` or ``**identifier``. Functions may have \"return\" " "annotation of the form \"``-> expression``\" after the parameter list. " "These annotations can be any valid Python expression. The presence of " "annotations does not change the semantics of a function. The annotation " "values are available as values of a dictionary keyed by the parameters' " "names in the :attr:`__annotations__` attribute of the function object. If " "the ``annotations`` import from :mod:`__future__` is used, annotations are " "preserved as strings at runtime which enables postponed evaluation. " "Otherwise, they are evaluated when the function definition is executed. In " "this case annotations may be evaluated in a different order than they appear " "in the source code." msgstr "" #: ../Doc/reference/compound_stmts.rst:573 msgid "" "It is also possible to create anonymous functions (functions not bound to a " "name), for immediate use in expressions. This uses lambda expressions, " "described in section :ref:`lambda`. Note that the lambda expression is " "merely a shorthand for a simplified function definition; a function defined " "in a \":keyword:`def`\" statement can be passed around or assigned to " "another name just like a function defined by a lambda expression. The \":" "keyword:`def`\" form is actually more powerful since it allows the execution " "of multiple statements and annotations." msgstr "" #: ../Doc/reference/compound_stmts.rst:581 msgid "" "**Programmer's note:** Functions are first-class objects. A \"``def``\" " "statement executed inside a function definition defines a local function " "that can be returned or passed around. Free variables used in the nested " "function can access the local variables of the function containing the def. " "See section :ref:`naming` for details." msgstr "" #: ../Doc/reference/compound_stmts.rst:590 msgid ":pep:`3107` - Function Annotations" msgstr "" #: ../Doc/reference/compound_stmts.rst:590 msgid "The original specification for function annotations." msgstr "" #: ../Doc/reference/compound_stmts.rst:593 msgid ":pep:`484` - Type Hints" msgstr ":pep:`484` -- indications de types" #: ../Doc/reference/compound_stmts.rst:593 msgid "Definition of a standard meaning for annotations: type hints." msgstr "" #: ../Doc/reference/compound_stmts.rst:597 msgid ":pep:`526` - Syntax for Variable Annotations" msgstr "" #: ../Doc/reference/compound_stmts.rst:596 msgid "" "Ability to type hint variable declarations, including class variables and " "instance variables" msgstr "" #: ../Doc/reference/compound_stmts.rst:600 msgid ":pep:`563` - Postponed Evaluation of Annotations" msgstr "" #: ../Doc/reference/compound_stmts.rst:600 msgid "" "Support for forward references within annotations by preserving annotations " "in a string form at runtime instead of eager evaluation." msgstr "" #: ../Doc/reference/compound_stmts.rst:607 msgid "Class definitions" msgstr "" #: ../Doc/reference/compound_stmts.rst:619 msgid "A class definition defines a class object (see section :ref:`types`):" msgstr "" #: ../Doc/reference/compound_stmts.rst:626 msgid "" "A class definition is an executable statement. The inheritance list usually " "gives a list of base classes (see :ref:`metaclasses` for more advanced " "uses), so each item in the list should evaluate to a class object which " "allows subclassing. Classes without an inheritance list inherit, by " "default, from the base class :class:`object`; hence, ::" msgstr "" #: ../Doc/reference/compound_stmts.rst:640 msgid "" "The class's suite is then executed in a new execution frame (see :ref:" "`naming`), using a newly created local namespace and the original global " "namespace. (Usually, the suite contains mostly function definitions.) When " "the class's suite finishes execution, its execution frame is discarded but " "its local namespace is saved. [#]_ A class object is then created using the " "inheritance list for the base classes and the saved local namespace for the " "attribute dictionary. The class name is bound to this class object in the " "original local namespace." msgstr "" #: ../Doc/reference/compound_stmts.rst:649 msgid "" "The order in which attributes are defined in the class body is preserved in " "the new class's ``__dict__``. Note that this is reliable only right after " "the class is created and only for classes that were defined using the " "definition syntax." msgstr "" #: ../Doc/reference/compound_stmts.rst:654 msgid "" "Class creation can be customized heavily using :ref:`metaclasses " "`." msgstr "" #: ../Doc/reference/compound_stmts.rst:656 msgid "Classes can also be decorated: just like when decorating functions, ::" msgstr "" #: ../Doc/reference/compound_stmts.rst:667 msgid "" "The evaluation rules for the decorator expressions are the same as for " "function decorators. The result is then bound to the class name." msgstr "" #: ../Doc/reference/compound_stmts.rst:670 msgid "" "**Programmer's note:** Variables defined in the class definition are class " "attributes; they are shared by instances. Instance attributes can be set in " "a method with ``self.name = value``. Both class and instance attributes are " "accessible through the notation \"``self.name``\", and an instance attribute " "hides a class attribute with the same name when accessed in this way. Class " "attributes can be used as defaults for instance attributes, but using " "mutable values there can lead to unexpected results. :ref:`Descriptors " "` can be used to create instance variables with different " "implementation details." msgstr "" #: ../Doc/reference/compound_stmts.rst:682 msgid ":pep:`3115` - Metaclasses in Python 3 :pep:`3129` - Class Decorators" msgstr "" #: ../Doc/reference/compound_stmts.rst:689 msgid "Coroutines" msgstr "Coroutines" #: ../Doc/reference/compound_stmts.rst:697 msgid "Coroutine function definition" msgstr "" #: ../Doc/reference/compound_stmts.rst:706 msgid "" "Execution of Python coroutines can be suspended and resumed at many points " "(see :term:`coroutine`). In the body of a coroutine, any ``await`` and " "``async`` identifiers become reserved keywords; :keyword:`await` " "expressions, :keyword:`async for` and :keyword:`async with` can only be used " "in coroutine bodies." msgstr "" #: ../Doc/reference/compound_stmts.rst:712 msgid "" "Functions defined with ``async def`` syntax are always coroutine functions, " "even if they do not contain ``await`` or ``async`` keywords." msgstr "" #: ../Doc/reference/compound_stmts.rst:715 msgid "" "It is a :exc:`SyntaxError` to use ``yield from`` expressions in ``async " "def`` coroutines." msgstr "" #: ../Doc/reference/compound_stmts.rst:718 msgid "An example of a coroutine function::" msgstr "" #: ../Doc/reference/compound_stmts.rst:729 msgid "The :keyword:`async for` statement" msgstr "" #: ../Doc/reference/compound_stmts.rst:734 msgid "" "An :term:`asynchronous iterable` is able to call asynchronous code in its " "*iter* implementation, and :term:`asynchronous iterator` can call " "asynchronous code in its *next* method." msgstr "" #: ../Doc/reference/compound_stmts.rst:738 msgid "" "The ``async for`` statement allows convenient iteration over asynchronous " "iterators." msgstr "" #: ../Doc/reference/compound_stmts.rst:741 #: ../Doc/reference/compound_stmts.rst:781 msgid "The following code::" msgstr "" #: ../Doc/reference/compound_stmts.rst:748 #: ../Doc/reference/compound_stmts.rst:786 msgid "Is semantically equivalent to::" msgstr "" #: ../Doc/reference/compound_stmts.rst:763 msgid "See also :meth:`__aiter__` and :meth:`__anext__` for details." msgstr "" #: ../Doc/reference/compound_stmts.rst:765 msgid "" "It is a :exc:`SyntaxError` to use ``async for`` statement outside of an :" "keyword:`async def` function." msgstr "" #: ../Doc/reference/compound_stmts.rst:773 msgid "The :keyword:`async with` statement" msgstr "" #: ../Doc/reference/compound_stmts.rst:778 msgid "" "An :term:`asynchronous context manager` is a :term:`context manager` that is " "able to suspend execution in its *enter* and *exit* methods." msgstr "" #: ../Doc/reference/compound_stmts.rst:801 msgid "See also :meth:`__aenter__` and :meth:`__aexit__` for details." msgstr "" #: ../Doc/reference/compound_stmts.rst:803 msgid "" "It is a :exc:`SyntaxError` to use ``async with`` statement outside of an :" "keyword:`async def` function." msgstr "" #: ../Doc/reference/compound_stmts.rst:808 msgid ":pep:`492` - Coroutines with async and await syntax" msgstr "" #: ../Doc/reference/compound_stmts.rst:812 msgid "Footnotes" msgstr "Notes" #: ../Doc/reference/compound_stmts.rst:813 msgid "" "The exception is propagated to the invocation stack unless there is a :" "keyword:`finally` clause which happens to raise another exception. That new " "exception causes the old one to be lost." msgstr "" #: ../Doc/reference/compound_stmts.rst:817 msgid "" "Currently, control \"flows off the end\" except in the case of an exception " "or the execution of a :keyword:`return`, :keyword:`continue`, or :keyword:" "`break` statement." msgstr "" #: ../Doc/reference/compound_stmts.rst:821 msgid "" "A string literal appearing as the first statement in the function body is " "transformed into the function's ``__doc__`` attribute and therefore the " "function's :term:`docstring`." msgstr "" #: ../Doc/reference/compound_stmts.rst:825 msgid "" "A string literal appearing as the first statement in the class body is " "transformed into the namespace's ``__doc__`` item and therefore the class's :" "term:`docstring`." msgstr ""