forked from AFPy/python-docs-fr
745 lines
29 KiB
Plaintext
745 lines
29 KiB
Plaintext
# SOME DESCRIPTIVE TITLE.
|
|
# Copyright (C) 2001-2016, Python Software Foundation
|
|
# This file is distributed under the same license as the Python package.
|
|
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
|
|
#
|
|
msgid ""
|
|
msgstr ""
|
|
"Project-Id-Version: Python 3.6\n"
|
|
"Report-Msgid-Bugs-To: \n"
|
|
"POT-Creation-Date: 2017-12-01 07:43+0100\n"
|
|
"PO-Revision-Date: 2017-08-10 00:54+0200\n"
|
|
"Last-Translator: Julien Palard <julien@palard.fr>\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 1.8.11\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:622
|
|
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:649
|
|
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 <parameter>` 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 and are evaluated when "
|
|
"the function definition is executed. Annotations may be evaluated in a "
|
|
"different order than they appear in the source code. 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."
|
|
msgstr ""
|
|
|
|
#: ../Doc/reference/compound_stmts.rst:571
|
|
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:579
|
|
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:587
|
|
msgid ":pep:`3107` - Function Annotations"
|
|
msgstr ""
|
|
|
|
#: ../Doc/reference/compound_stmts.rst:588
|
|
msgid "The original specification for function annotations."
|
|
msgstr ""
|
|
|
|
#: ../Doc/reference/compound_stmts.rst:594
|
|
msgid "Class definitions"
|
|
msgstr ""
|
|
|
|
#: ../Doc/reference/compound_stmts.rst:606
|
|
msgid "A class definition defines a class object (see section :ref:`types`):"
|
|
msgstr ""
|
|
|
|
#: ../Doc/reference/compound_stmts.rst:613
|
|
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:627
|
|
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:636
|
|
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:641
|
|
msgid ""
|
|
"Class creation can be customized heavily using :ref:`metaclasses "
|
|
"<metaclasses>`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/reference/compound_stmts.rst:643
|
|
msgid "Classes can also be decorated: just like when decorating functions, ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/reference/compound_stmts.rst:654
|
|
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:657
|
|
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 "
|
|
"<descriptors>` can be used to create instance variables with different "
|
|
"implementation details."
|
|
msgstr ""
|
|
|
|
#: ../Doc/reference/compound_stmts.rst:669
|
|
msgid ":pep:`3115` - Metaclasses in Python 3 :pep:`3129` - Class Decorators"
|
|
msgstr ""
|
|
|
|
#: ../Doc/reference/compound_stmts.rst:674
|
|
msgid "Coroutines"
|
|
msgstr "Coroutines"
|
|
|
|
#: ../Doc/reference/compound_stmts.rst:682
|
|
msgid "Coroutine function definition"
|
|
msgstr ""
|
|
|
|
#: ../Doc/reference/compound_stmts.rst:691
|
|
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:697
|
|
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:700
|
|
msgid ""
|
|
"It is a :exc:`SyntaxError` to use ``yield from`` expressions in ``async "
|
|
"def`` coroutines."
|
|
msgstr ""
|
|
|
|
#: ../Doc/reference/compound_stmts.rst:703
|
|
msgid "An example of a coroutine function::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/reference/compound_stmts.rst:714
|
|
msgid "The :keyword:`async for` statement"
|
|
msgstr ""
|
|
|
|
#: ../Doc/reference/compound_stmts.rst:719
|
|
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:723
|
|
msgid ""
|
|
"The ``async for`` statement allows convenient iteration over asynchronous "
|
|
"iterators."
|
|
msgstr ""
|
|
|
|
#: ../Doc/reference/compound_stmts.rst:726
|
|
#: ../Doc/reference/compound_stmts.rst:766
|
|
msgid "The following code::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/reference/compound_stmts.rst:733
|
|
#: ../Doc/reference/compound_stmts.rst:771
|
|
msgid "Is semantically equivalent to::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/reference/compound_stmts.rst:748
|
|
msgid "See also :meth:`__aiter__` and :meth:`__anext__` for details."
|
|
msgstr ""
|
|
|
|
#: ../Doc/reference/compound_stmts.rst:750
|
|
msgid ""
|
|
"It is a :exc:`SyntaxError` to use ``async for`` statement outside of an :"
|
|
"keyword:`async def` function."
|
|
msgstr ""
|
|
|
|
#: ../Doc/reference/compound_stmts.rst:758
|
|
msgid "The :keyword:`async with` statement"
|
|
msgstr ""
|
|
|
|
#: ../Doc/reference/compound_stmts.rst:763
|
|
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:786
|
|
msgid "See also :meth:`__aenter__` and :meth:`__aexit__` for details."
|
|
msgstr ""
|
|
|
|
#: ../Doc/reference/compound_stmts.rst:788
|
|
msgid ""
|
|
"It is a :exc:`SyntaxError` to use ``async with`` statement outside of an :"
|
|
"keyword:`async def` function."
|
|
msgstr ""
|
|
|
|
#: ../Doc/reference/compound_stmts.rst:793
|
|
msgid ":pep:`492` - Coroutines with async and await syntax"
|
|
msgstr ""
|
|
|
|
#: ../Doc/reference/compound_stmts.rst:797
|
|
msgid "Footnotes"
|
|
msgstr "Notes"
|
|
|
|
#: ../Doc/reference/compound_stmts.rst:798
|
|
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:802
|
|
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:806
|
|
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:810
|
|
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 ""
|