# 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. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: Python 3.6\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2017-04-02 22:11+0200\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: LANGUAGE \n" "Language: \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" #: ../Doc/reference/simple_stmts.rst:6 msgid "Simple statements" msgstr "" #: ../Doc/reference/simple_stmts.rst:10 msgid "" "A simple statement is comprised within a single logical line. Several simple " "statements may occur on a single line separated by semicolons. The syntax " "for simple statements is:" msgstr "" #: ../Doc/reference/simple_stmts.rst:35 msgid "Expression statements" msgstr "" #: ../Doc/reference/simple_stmts.rst:42 msgid "" "Expression statements are used (mostly interactively) to compute and write a " "value, or (usually) to call a procedure (a function that returns no " "meaningful result; in Python, procedures return the value ``None``). Other " "uses of expression statements are allowed and occasionally useful. The " "syntax for an expression statement is:" msgstr "" #: ../Doc/reference/simple_stmts.rst:51 msgid "" "An expression statement evaluates the expression list (which may be a single " "expression)." msgstr "" #: ../Doc/reference/simple_stmts.rst:63 msgid "" "In interactive mode, if the value is not ``None``, it is converted to a " "string using the built-in :func:`repr` function and the resulting string is " "written to standard output on a line by itself (except if the result is " "``None``, so that procedure calls do not cause any output.)" msgstr "" #: ../Doc/reference/simple_stmts.rst:71 msgid "Assignment statements" msgstr "" #: ../Doc/reference/simple_stmts.rst:81 msgid "" "Assignment statements are used to (re)bind names to values and to modify " "attributes or items of mutable objects:" msgstr "" #: ../Doc/reference/simple_stmts.rst:95 msgid "" "(See section :ref:`primaries` for the syntax definitions for *attributeref*, " "*subscription*, and *slicing*.)" msgstr "" #: ../Doc/reference/simple_stmts.rst:98 msgid "" "An assignment statement evaluates the expression list (remember that this " "can be a single expression or a comma-separated list, the latter yielding a " "tuple) and assigns the single resulting object to each of the target lists, " "from left to right." msgstr "" #: ../Doc/reference/simple_stmts.rst:107 msgid "" "Assignment is defined recursively depending on the form of the target " "(list). When a target is part of a mutable object (an attribute reference, " "subscription or slicing), the mutable object must ultimately perform the " "assignment and decide about its validity, and may raise an exception if the " "assignment is unacceptable. The rules observed by various types and the " "exceptions raised are given with the definition of the object types (see " "section :ref:`types`)." msgstr "" #: ../Doc/reference/simple_stmts.rst:116 msgid "" "Assignment of an object to a target list, optionally enclosed in parentheses " "or square brackets, is recursively defined as follows." msgstr "" #: ../Doc/reference/simple_stmts.rst:119 msgid "If the target list is empty: The object must also be an empty iterable." msgstr "" #: ../Doc/reference/simple_stmts.rst:121 msgid "" "If the target list is a single target in parentheses: The object is assigned " "to that target." msgstr "" #: ../Doc/reference/simple_stmts.rst:124 msgid "" "If the target list is a comma-separated list of targets, or a single target " "in square brackets: The object must be an iterable with the same number of " "items as there are targets in the target list, and the items are assigned, " "from left to right, to the corresponding targets." msgstr "" #: ../Doc/reference/simple_stmts.rst:129 msgid "" "If the target list contains one target prefixed with an asterisk, called a " "\"starred\" target: The object must be an iterable with at least as many " "items as there are targets in the target list, minus one. The first items " "of the iterable are assigned, from left to right, to the targets before the " "starred target. The final items of the iterable are assigned to the targets " "after the starred target. A list of the remaining items in the iterable is " "then assigned to the starred target (the list can be empty)." msgstr "" #: ../Doc/reference/simple_stmts.rst:137 msgid "" "Else: The object must be an iterable with the same number of items as there " "are targets in the target list, and the items are assigned, from left to " "right, to the corresponding targets." msgstr "" #: ../Doc/reference/simple_stmts.rst:141 msgid "" "Assignment of an object to a single target is recursively defined as follows." msgstr "" #: ../Doc/reference/simple_stmts.rst:143 msgid "If the target is an identifier (name):" msgstr "" #: ../Doc/reference/simple_stmts.rst:145 msgid "" "If the name does not occur in a :keyword:`global` or :keyword:`nonlocal` " "statement in the current code block: the name is bound to the object in the " "current local namespace." msgstr "" #: ../Doc/reference/simple_stmts.rst:149 msgid "" "Otherwise: the name is bound to the object in the global namespace or the " "outer namespace determined by :keyword:`nonlocal`, respectively." msgstr "" #: ../Doc/reference/simple_stmts.rst:154 msgid "" "The name is rebound if it was already bound. This may cause the reference " "count for the object previously bound to the name to reach zero, causing the " "object to be deallocated and its destructor (if it has one) to be called." msgstr "" #: ../Doc/reference/simple_stmts.rst:160 msgid "" "If the target is an attribute reference: The primary expression in the " "reference is evaluated. It should yield an object with assignable " "attributes; if this is not the case, :exc:`TypeError` is raised. That " "object is then asked to assign the assigned object to the given attribute; " "if it cannot perform the assignment, it raises an exception (usually but not " "necessarily :exc:`AttributeError`)." msgstr "" #: ../Doc/reference/simple_stmts.rst:169 msgid "" "Note: If the object is a class instance and the attribute reference occurs " "on both sides of the assignment operator, the RHS expression, ``a.x`` can " "access either an instance attribute or (if no instance attribute exists) a " "class attribute. The LHS target ``a.x`` is always set as an instance " "attribute, creating it if necessary. Thus, the two occurrences of ``a.x`` " "do not necessarily refer to the same attribute: if the RHS expression refers " "to a class attribute, the LHS creates a new instance attribute as the target " "of the assignment::" msgstr "" #: ../Doc/reference/simple_stmts.rst:183 msgid "" "This description does not necessarily apply to descriptor attributes, such " "as properties created with :func:`property`." msgstr "" #: ../Doc/reference/simple_stmts.rst:190 msgid "" "If the target is a subscription: The primary expression in the reference is " "evaluated. It should yield either a mutable sequence object (such as a " "list) or a mapping object (such as a dictionary). Next, the subscript " "expression is evaluated." msgstr "" #: ../Doc/reference/simple_stmts.rst:199 msgid "" "If the primary is a mutable sequence object (such as a list), the subscript " "must yield an integer. If it is negative, the sequence's length is added to " "it. The resulting value must be a nonnegative integer less than the " "sequence's length, and the sequence is asked to assign the assigned object " "to its item with that index. If the index is out of range, :exc:" "`IndexError` is raised (assignment to a subscripted sequence cannot add new " "items to a list)." msgstr "" #: ../Doc/reference/simple_stmts.rst:210 msgid "" "If the primary is a mapping object (such as a dictionary), the subscript " "must have a type compatible with the mapping's key type, and the mapping is " "then asked to create a key/datum pair which maps the subscript to the " "assigned object. This can either replace an existing key/value pair with " "the same key value, or insert a new key/value pair (if no key with the same " "value existed)." msgstr "" #: ../Doc/reference/simple_stmts.rst:216 msgid "" "For user-defined objects, the :meth:`__setitem__` method is called with " "appropriate arguments." msgstr "" #: ../Doc/reference/simple_stmts.rst:221 msgid "" "If the target is a slicing: The primary expression in the reference is " "evaluated. It should yield a mutable sequence object (such as a list). The " "assigned object should be a sequence object of the same type. Next, the " "lower and upper bound expressions are evaluated, insofar they are present; " "defaults are zero and the sequence's length. The bounds should evaluate to " "integers. If either bound is negative, the sequence's length is added to " "it. The resulting bounds are clipped to lie between zero and the sequence's " "length, inclusive. Finally, the sequence object is asked to replace the " "slice with the items of the assigned sequence. The length of the slice may " "be different from the length of the assigned sequence, thus changing the " "length of the target sequence, if the target sequence allows it." msgstr "" #: ../Doc/reference/simple_stmts.rst:235 msgid "" "In the current implementation, the syntax for targets is taken to be the " "same as for expressions, and invalid syntax is rejected during the code " "generation phase, causing less detailed error messages." msgstr "" #: ../Doc/reference/simple_stmts.rst:239 msgid "" "Although the definition of assignment implies that overlaps between the left-" "hand side and the right-hand side are 'simultaneous' (for example ``a, b = " "b, a`` swaps two variables), overlaps *within* the collection of assigned-to " "variables occur left-to-right, sometimes resulting in confusion. For " "instance, the following program prints ``[0, 2]``::" msgstr "" #: ../Doc/reference/simple_stmts.rst:253 msgid ":pep:`3132` - Extended Iterable Unpacking" msgstr "" #: ../Doc/reference/simple_stmts.rst:254 msgid "The specification for the ``*target`` feature." msgstr "" #: ../Doc/reference/simple_stmts.rst:260 msgid "Augmented assignment statements" msgstr "" #: ../Doc/reference/simple_stmts.rst:278 msgid "" "Augmented assignment is the combination, in a single statement, of a binary " "operation and an assignment statement:" msgstr "" #: ../Doc/reference/simple_stmts.rst:287 msgid "" "(See section :ref:`primaries` for the syntax definitions of the last three " "symbols.)" msgstr "" #: ../Doc/reference/simple_stmts.rst:290 msgid "" "An augmented assignment evaluates the target (which, unlike normal " "assignment statements, cannot be an unpacking) and the expression list, " "performs the binary operation specific to the type of assignment on the two " "operands, and assigns the result to the original target. The target is only " "evaluated once." msgstr "" #: ../Doc/reference/simple_stmts.rst:295 msgid "" "An augmented assignment expression like ``x += 1`` can be rewritten as ``x = " "x + 1`` to achieve a similar, but not exactly equal effect. In the augmented " "version, ``x`` is only evaluated once. Also, when possible, the actual " "operation is performed *in-place*, meaning that rather than creating a new " "object and assigning that to the target, the old object is modified instead." msgstr "" #: ../Doc/reference/simple_stmts.rst:301 msgid "" "Unlike normal assignments, augmented assignments evaluate the left-hand side " "*before* evaluating the right-hand side. For example, ``a[i] += f(x)`` " "first looks-up ``a[i]``, then it evaluates ``f(x)`` and performs the " "addition, and lastly, it writes the result back to ``a[i]``." msgstr "" #: ../Doc/reference/simple_stmts.rst:306 msgid "" "With the exception of assigning to tuples and multiple targets in a single " "statement, the assignment done by augmented assignment statements is handled " "the same way as normal assignments. Similarly, with the exception of the " "possible *in-place* behavior, the binary operation performed by augmented " "assignment is the same as the normal binary operations." msgstr "" #: ../Doc/reference/simple_stmts.rst:312 msgid "" "For targets which are attribute references, the same :ref:`caveat about " "class and instance attributes ` applies as for regular " "assignments." msgstr "" #: ../Doc/reference/simple_stmts.rst:319 msgid "Annotated assignment statements" msgstr "" #: ../Doc/reference/simple_stmts.rst:325 msgid "" "Annotation assignment is the combination, in a single statement, of a " "variable or attribute annotation and an optional assignment statement:" msgstr "" #: ../Doc/reference/simple_stmts.rst:331 msgid "" "The difference from normal :ref:`assignment` is that only single target and " "only single right hand side value is allowed." msgstr "" #: ../Doc/reference/simple_stmts.rst:334 msgid "" "For simple names as assignment targets, if in class or module scope, the " "annotations are evaluated and stored in a special class or module attribute :" "attr:`__annotations__` that is a dictionary mapping from variable names " "(mangled if private) to evaluated annotations. This attribute is writable " "and is automatically created at the start of class or module body execution, " "if annotations are found statically." msgstr "" #: ../Doc/reference/simple_stmts.rst:342 msgid "" "For expressions as assignment targets, the annotations are evaluated if in " "class or module scope, but not stored." msgstr "" #: ../Doc/reference/simple_stmts.rst:345 msgid "" "If a name is annotated in a function scope, then this name is local for that " "scope. Annotations are never evaluated and stored in function scopes." msgstr "" #: ../Doc/reference/simple_stmts.rst:348 msgid "" "If the right hand side is present, an annotated assignment performs the " "actual assignment before evaluating annotations (where applicable). If the " "right hand side is not present for an expression target, then the " "interpreter evaluates the target except for the last :meth:`__setitem__` or :" "meth:`__setattr__` call." msgstr "" #: ../Doc/reference/simple_stmts.rst:356 msgid "" ":pep:`526` - Variable and attribute annotation syntax :pep:`484` - Type hints" msgstr "" #: ../Doc/reference/simple_stmts.rst:363 msgid "The :keyword:`assert` statement" msgstr "" #: ../Doc/reference/simple_stmts.rst:369 msgid "" "Assert statements are a convenient way to insert debugging assertions into a " "program:" msgstr "" #: ../Doc/reference/simple_stmts.rst:375 msgid "The simple form, ``assert expression``, is equivalent to ::" msgstr "" #: ../Doc/reference/simple_stmts.rst:380 msgid "" "The extended form, ``assert expression1, expression2``, is equivalent to ::" msgstr "" #: ../Doc/reference/simple_stmts.rst:389 msgid "" "These equivalences assume that :const:`__debug__` and :exc:`AssertionError` " "refer to the built-in variables with those names. In the current " "implementation, the built-in variable :const:`__debug__` is ``True`` under " "normal circumstances, ``False`` when optimization is requested (command line " "option -O). The current code generator emits no code for an assert " "statement when optimization is requested at compile time. Note that it is " "unnecessary to include the source code for the expression that failed in the " "error message; it will be displayed as part of the stack trace." msgstr "" #: ../Doc/reference/simple_stmts.rst:398 msgid "" "Assignments to :const:`__debug__` are illegal. The value for the built-in " "variable is determined when the interpreter starts." msgstr "" #: ../Doc/reference/simple_stmts.rst:405 msgid "The :keyword:`pass` statement" msgstr "" #: ../Doc/reference/simple_stmts.rst:415 msgid "" ":keyword:`pass` is a null operation --- when it is executed, nothing " "happens. It is useful as a placeholder when a statement is required " "syntactically, but no code needs to be executed, for example::" msgstr "" #: ../Doc/reference/simple_stmts.rst:427 msgid "The :keyword:`del` statement" msgstr "L'instruction :keyword:`del`" #: ../Doc/reference/simple_stmts.rst:437 msgid "" "Deletion is recursively defined very similar to the way assignment is " "defined. Rather than spelling it out in full details, here are some hints." msgstr "" #: ../Doc/reference/simple_stmts.rst:440 msgid "" "Deletion of a target list recursively deletes each target, from left to " "right." msgstr "" #: ../Doc/reference/simple_stmts.rst:446 msgid "" "Deletion of a name removes the binding of that name from the local or global " "namespace, depending on whether the name occurs in a :keyword:`global` " "statement in the same code block. If the name is unbound, a :exc:" "`NameError` exception will be raised." msgstr "" #: ../Doc/reference/simple_stmts.rst:453 msgid "" "Deletion of attribute references, subscriptions and slicings is passed to " "the primary object involved; deletion of a slicing is in general equivalent " "to assignment of an empty slice of the right type (but even this is " "determined by the sliced object)." msgstr "" #: ../Doc/reference/simple_stmts.rst:458 msgid "" "Previously it was illegal to delete a name from the local namespace if it " "occurs as a free variable in a nested block." msgstr "" #: ../Doc/reference/simple_stmts.rst:466 msgid "The :keyword:`return` statement" msgstr "" #: ../Doc/reference/simple_stmts.rst:476 msgid "" ":keyword:`return` may only occur syntactically nested in a function " "definition, not within a nested class definition." msgstr "" #: ../Doc/reference/simple_stmts.rst:479 msgid "" "If an expression list is present, it is evaluated, else ``None`` is " "substituted." msgstr "" #: ../Doc/reference/simple_stmts.rst:481 msgid "" ":keyword:`return` leaves the current function call with the expression list " "(or ``None``) as return value." msgstr "" #: ../Doc/reference/simple_stmts.rst:486 msgid "" "When :keyword:`return` passes control out of a :keyword:`try` statement with " "a :keyword:`finally` clause, that :keyword:`finally` clause is executed " "before really leaving the function." msgstr "" #: ../Doc/reference/simple_stmts.rst:490 msgid "" "In a generator function, the :keyword:`return` statement indicates that the " "generator is done and will cause :exc:`StopIteration` to be raised. The " "returned value (if any) is used as an argument to construct :exc:" "`StopIteration` and becomes the :attr:`StopIteration.value` attribute." msgstr "" #: ../Doc/reference/simple_stmts.rst:495 msgid "" "In an asynchronous generator function, an empty :keyword:`return` statement " "indicates that the asynchronous generator is done and will cause :exc:" "`StopAsyncIteration` to be raised. A non-empty :keyword:`return` statement " "is a syntax error in an asynchronous generator function." msgstr "" #: ../Doc/reference/simple_stmts.rst:503 msgid "The :keyword:`yield` statement" msgstr "L'instruction :keyword:`yield`" #: ../Doc/reference/simple_stmts.rst:515 msgid "" "A :keyword:`yield` statement is semantically equivalent to a :ref:`yield " "expression `. The yield statement can be used to omit the " "parentheses that would otherwise be required in the equivalent yield " "expression statement. For example, the yield statements ::" msgstr "" #: ../Doc/reference/simple_stmts.rst:523 msgid "are equivalent to the yield expression statements ::" msgstr "" #: ../Doc/reference/simple_stmts.rst:528 msgid "" "Yield expressions and statements are only used when defining a :term:" "`generator` function, and are only used in the body of the generator " "function. Using yield in a function definition is sufficient to cause that " "definition to create a generator function instead of a normal function." msgstr "" #: ../Doc/reference/simple_stmts.rst:533 msgid "" "For full details of :keyword:`yield` semantics, refer to the :ref:" "`yieldexpr` section." msgstr "" #: ../Doc/reference/simple_stmts.rst:539 msgid "The :keyword:`raise` statement" msgstr "L'instruction :keyword:`raise`" #: ../Doc/reference/simple_stmts.rst:550 msgid "" "If no expressions are present, :keyword:`raise` re-raises the last exception " "that was active in the current scope. If no exception is active in the " "current scope, a :exc:`RuntimeError` exception is raised indicating that " "this is an error." msgstr "" #: ../Doc/reference/simple_stmts.rst:555 msgid "" "Otherwise, :keyword:`raise` evaluates the first expression as the exception " "object. It must be either a subclass or an instance of :class:" "`BaseException`. If it is a class, the exception instance will be obtained " "when needed by instantiating the class with no arguments." msgstr "" #: ../Doc/reference/simple_stmts.rst:560 msgid "" "The :dfn:`type` of the exception is the exception instance's class, the :dfn:" "`value` is the instance itself." msgstr "" #: ../Doc/reference/simple_stmts.rst:565 msgid "" "A traceback object is normally created automatically when an exception is " "raised and attached to it as the :attr:`__traceback__` attribute, which is " "writable. You can create an exception and set your own traceback in one step " "using the :meth:`with_traceback` exception method (which returns the same " "exception instance, with its traceback set to its argument), like so::" msgstr "" #: ../Doc/reference/simple_stmts.rst:577 msgid "" "The ``from`` clause is used for exception chaining: if given, the second " "*expression* must be another exception class or instance, which will then be " "attached to the raised exception as the :attr:`__cause__` attribute (which " "is writable). If the raised exception is not handled, both exceptions will " "be printed::" msgstr "" #: ../Doc/reference/simple_stmts.rst:598 msgid "" "A similar mechanism works implicitly if an exception is raised inside an " "exception handler or a :keyword:`finally` clause: the previous exception is " "then attached as the new exception's :attr:`__context__` attribute::" msgstr "" #: ../Doc/reference/simple_stmts.rst:617 msgid "" "Additional information on exceptions can be found in section :ref:" "`exceptions`, and information about handling exceptions is in section :ref:" "`try`." msgstr "" #: ../Doc/reference/simple_stmts.rst:624 msgid "The :keyword:`break` statement" msgstr "" #: ../Doc/reference/simple_stmts.rst:635 msgid "" ":keyword:`break` may only occur syntactically nested in a :keyword:`for` or :" "keyword:`while` loop, but not nested in a function or class definition " "within that loop." msgstr "" #: ../Doc/reference/simple_stmts.rst:642 msgid "" "It terminates the nearest enclosing loop, skipping the optional :keyword:" "`else` clause if the loop has one." msgstr "" #: ../Doc/reference/simple_stmts.rst:645 msgid "" "If a :keyword:`for` loop is terminated by :keyword:`break`, the loop control " "target keeps its current value." msgstr "" #: ../Doc/reference/simple_stmts.rst:650 msgid "" "When :keyword:`break` passes control out of a :keyword:`try` statement with " "a :keyword:`finally` clause, that :keyword:`finally` clause is executed " "before really leaving the loop." msgstr "" #: ../Doc/reference/simple_stmts.rst:658 msgid "The :keyword:`continue` statement" msgstr "" #: ../Doc/reference/simple_stmts.rst:670 msgid "" ":keyword:`continue` may only occur syntactically nested in a :keyword:`for` " "or :keyword:`while` loop, but not nested in a function or class definition " "or :keyword:`finally` clause within that loop. It continues with the next " "cycle of the nearest enclosing loop." msgstr "" #: ../Doc/reference/simple_stmts.rst:675 msgid "" "When :keyword:`continue` passes control out of a :keyword:`try` statement " "with a :keyword:`finally` clause, that :keyword:`finally` clause is executed " "before really starting the next loop cycle." msgstr "" #: ../Doc/reference/simple_stmts.rst:684 msgid "The :keyword:`import` statement" msgstr "" #: ../Doc/reference/simple_stmts.rst:703 msgid "" "The basic import statement (no :keyword:`from` clause) is executed in two " "steps:" msgstr "" #: ../Doc/reference/simple_stmts.rst:706 msgid "find a module, loading and initializing it if necessary" msgstr "" #: ../Doc/reference/simple_stmts.rst:707 msgid "" "define a name or names in the local namespace for the scope where the :" "keyword:`import` statement occurs." msgstr "" #: ../Doc/reference/simple_stmts.rst:710 msgid "" "When the statement contains multiple clauses (separated by commas) the two " "steps are carried out separately for each clause, just as though the clauses " "had been separated out into individual import statements." msgstr "" #: ../Doc/reference/simple_stmts.rst:715 msgid "" "The details of the first step, finding and loading modules are described in " "greater detail in the section on the :ref:`import system `, " "which also describes the various types of packages and modules that can be " "imported, as well as all the hooks that can be used to customize the import " "system. Note that failures in this step may indicate either that the module " "could not be located, *or* that an error occurred while initializing the " "module, which includes execution of the module's code." msgstr "" #: ../Doc/reference/simple_stmts.rst:723 msgid "" "If the requested module is retrieved successfully, it will be made available " "in the local namespace in one of three ways:" msgstr "" #: ../Doc/reference/simple_stmts.rst:728 msgid "" "If the module name is followed by :keyword:`as`, then the name following :" "keyword:`as` is bound directly to the imported module." msgstr "" #: ../Doc/reference/simple_stmts.rst:730 msgid "" "If no other name is specified, and the module being imported is a top level " "module, the module's name is bound in the local namespace as a reference to " "the imported module" msgstr "" #: ../Doc/reference/simple_stmts.rst:733 msgid "" "If the module being imported is *not* a top level module, then the name of " "the top level package that contains the module is bound in the local " "namespace as a reference to the top level package. The imported module must " "be accessed using its full qualified name rather than directly" msgstr "" #: ../Doc/reference/simple_stmts.rst:744 msgid "The :keyword:`from` form uses a slightly more complex process:" msgstr "" #: ../Doc/reference/simple_stmts.rst:746 msgid "" "find the module specified in the :keyword:`from` clause, loading and " "initializing it if necessary;" msgstr "" #: ../Doc/reference/simple_stmts.rst:748 msgid "for each of the identifiers specified in the :keyword:`import` clauses:" msgstr "" #: ../Doc/reference/simple_stmts.rst:750 msgid "check if the imported module has an attribute by that name" msgstr "" #: ../Doc/reference/simple_stmts.rst:751 msgid "" "if not, attempt to import a submodule with that name and then check the " "imported module again for that attribute" msgstr "" #: ../Doc/reference/simple_stmts.rst:753 msgid "if the attribute is not found, :exc:`ImportError` is raised." msgstr "" #: ../Doc/reference/simple_stmts.rst:754 msgid "" "otherwise, a reference to that value is stored in the local namespace, using " "the name in the :keyword:`as` clause if it is present, otherwise using the " "attribute name" msgstr "" #: ../Doc/reference/simple_stmts.rst:758 msgid "Examples::" msgstr "Exemples : ::" #: ../Doc/reference/simple_stmts.rst:766 msgid "" "If the list of identifiers is replaced by a star (``'*'``), all public names " "defined in the module are bound in the local namespace for the scope where " "the :keyword:`import` statement occurs." msgstr "" #: ../Doc/reference/simple_stmts.rst:772 msgid "" "The *public names* defined by a module are determined by checking the " "module's namespace for a variable named ``__all__``; if defined, it must be " "a sequence of strings which are names defined or imported by that module. " "The names given in ``__all__`` are all considered public and are required to " "exist. If ``__all__`` is not defined, the set of public names includes all " "names found in the module's namespace which do not begin with an underscore " "character (``'_'``). ``__all__`` should contain the entire public API. It " "is intended to avoid accidentally exporting items that are not part of the " "API (such as library modules which were imported and used within the module)." msgstr "" #: ../Doc/reference/simple_stmts.rst:782 msgid "" "The wild card form of import --- ``from module import *`` --- is only " "allowed at the module level. Attempting to use it in class or function " "definitions will raise a :exc:`SyntaxError`." msgstr "" #: ../Doc/reference/simple_stmts.rst:789 msgid "" "When specifying what module to import you do not have to specify the " "absolute name of the module. When a module or package is contained within " "another package it is possible to make a relative import within the same top " "package without having to mention the package name. By using leading dots in " "the specified module or package after :keyword:`from` you can specify how " "high to traverse up the current package hierarchy without specifying exact " "names. One leading dot means the current package where the module making the " "import exists. Two dots means up one package level. Three dots is up two " "levels, etc. So if you execute ``from . import mod`` from a module in the " "``pkg`` package then you will end up importing ``pkg.mod``. If you execute " "``from ..subpkg2 import mod`` from within ``pkg.subpkg1`` you will import " "``pkg.subpkg2.mod``. The specification for relative imports is contained " "within :pep:`328`." msgstr "" #: ../Doc/reference/simple_stmts.rst:802 msgid "" ":func:`importlib.import_module` is provided to support applications that " "determine dynamically the modules to be loaded." msgstr "" #: ../Doc/reference/simple_stmts.rst:809 msgid "Future statements" msgstr "" #: ../Doc/reference/simple_stmts.rst:813 msgid "" "A :dfn:`future statement` is a directive to the compiler that a particular " "module should be compiled using syntax or semantics that will be available " "in a specified future release of Python where the feature becomes standard." msgstr "" #: ../Doc/reference/simple_stmts.rst:817 msgid "" "The future statement is intended to ease migration to future versions of " "Python that introduce incompatible changes to the language. It allows use " "of the new features on a per-module basis before the release in which the " "feature becomes standard." msgstr "" #: ../Doc/reference/simple_stmts.rst:830 msgid "" "A future statement must appear near the top of the module. The only lines " "that can appear before a future statement are:" msgstr "" #: ../Doc/reference/simple_stmts.rst:833 msgid "the module docstring (if any)," msgstr "" #: ../Doc/reference/simple_stmts.rst:834 msgid "comments," msgstr "" #: ../Doc/reference/simple_stmts.rst:835 msgid "blank lines, and" msgstr "" #: ../Doc/reference/simple_stmts.rst:836 msgid "other future statements." msgstr "" #: ../Doc/reference/simple_stmts.rst:840 msgid "" "The features recognized by Python 3.0 are ``absolute_import``, ``division``, " "``generators``, ``unicode_literals``, ``print_function``, ``nested_scopes`` " "and ``with_statement``. They are all redundant because they are always " "enabled, and only kept for backwards compatibility." msgstr "" #: ../Doc/reference/simple_stmts.rst:845 msgid "" "A future statement is recognized and treated specially at compile time: " "Changes to the semantics of core constructs are often implemented by " "generating different code. It may even be the case that a new feature " "introduces new incompatible syntax (such as a new reserved word), in which " "case the compiler may need to parse the module differently. Such decisions " "cannot be pushed off until runtime." msgstr "" #: ../Doc/reference/simple_stmts.rst:852 msgid "" "For any given release, the compiler knows which feature names have been " "defined, and raises a compile-time error if a future statement contains a " "feature not known to it." msgstr "" #: ../Doc/reference/simple_stmts.rst:856 msgid "" "The direct runtime semantics are the same as for any import statement: there " "is a standard module :mod:`__future__`, described later, and it will be " "imported in the usual way at the time the future statement is executed." msgstr "" #: ../Doc/reference/simple_stmts.rst:860 msgid "" "The interesting runtime semantics depend on the specific feature enabled by " "the future statement." msgstr "" #: ../Doc/reference/simple_stmts.rst:863 msgid "Note that there is nothing special about the statement::" msgstr "" #: ../Doc/reference/simple_stmts.rst:867 msgid "" "That is not a future statement; it's an ordinary import statement with no " "special semantics or syntax restrictions." msgstr "" #: ../Doc/reference/simple_stmts.rst:870 msgid "" "Code compiled by calls to the built-in functions :func:`exec` and :func:" "`compile` that occur in a module :mod:`M` containing a future statement " "will, by default, use the new syntax or semantics associated with the future " "statement. This can be controlled by optional arguments to :func:`compile` " "--- see the documentation of that function for details." msgstr "" #: ../Doc/reference/simple_stmts.rst:876 msgid "" "A future statement typed at an interactive interpreter prompt will take " "effect for the rest of the interpreter session. If an interpreter is " "started with the :option:`-i` option, is passed a script name to execute, " "and the script includes a future statement, it will be in effect in the " "interactive session started after the script is executed." msgstr "" #: ../Doc/reference/simple_stmts.rst:884 msgid ":pep:`236` - Back to the __future__" msgstr ":pep:`236` - Back to the __future__" #: ../Doc/reference/simple_stmts.rst:885 msgid "The original proposal for the __future__ mechanism." msgstr "" #: ../Doc/reference/simple_stmts.rst:891 msgid "The :keyword:`global` statement" msgstr "" #: ../Doc/reference/simple_stmts.rst:900 msgid "" "The :keyword:`global` statement is a declaration which holds for the entire " "current code block. It means that the listed identifiers are to be " "interpreted as globals. It would be impossible to assign to a global " "variable without :keyword:`global`, although free variables may refer to " "globals without being declared global." msgstr "" #: ../Doc/reference/simple_stmts.rst:906 msgid "" "Names listed in a :keyword:`global` statement must not be used in the same " "code block textually preceding that :keyword:`global` statement." msgstr "" #: ../Doc/reference/simple_stmts.rst:909 msgid "" "Names listed in a :keyword:`global` statement must not be defined as formal " "parameters or in a :keyword:`for` loop control target, :keyword:`class` " "definition, function definition, :keyword:`import` statement, or variable " "annotation." msgstr "" #: ../Doc/reference/simple_stmts.rst:916 msgid "" "The current implementation does not enforce some of these restriction, but " "programs should not abuse this freedom, as future implementations may " "enforce them or silently change the meaning of the program." msgstr "" #: ../Doc/reference/simple_stmts.rst:925 msgid "" "**Programmer's note:** the :keyword:`global` is a directive to the parser. " "It applies only to code parsed at the same time as the :keyword:`global` " "statement. In particular, a :keyword:`global` statement contained in a " "string or code object supplied to the built-in :func:`exec` function does " "not affect the code block *containing* the function call, and code contained " "in such a string is unaffected by :keyword:`global` statements in the code " "containing the function call. The same applies to the :func:`eval` and :" "func:`compile` functions." msgstr "" #: ../Doc/reference/simple_stmts.rst:937 msgid "The :keyword:`nonlocal` statement" msgstr "" #: ../Doc/reference/simple_stmts.rst:948 msgid "" "The :keyword:`nonlocal` statement causes the listed identifiers to refer to " "previously bound variables in the nearest enclosing scope excluding globals. " "This is important because the default behavior for binding is to search the " "local namespace first. The statement allows encapsulated code to rebind " "variables outside of the local scope besides the global (module) scope." msgstr "" #: ../Doc/reference/simple_stmts.rst:958 msgid "" "Names listed in a :keyword:`nonlocal` statement, unlike those listed in a :" "keyword:`global` statement, must refer to pre-existing bindings in an " "enclosing scope (the scope in which a new binding should be created cannot " "be determined unambiguously)." msgstr "" #: ../Doc/reference/simple_stmts.rst:963 msgid "" "Names listed in a :keyword:`nonlocal` statement must not collide with pre-" "existing bindings in the local scope." msgstr "" #: ../Doc/reference/simple_stmts.rst:968 msgid ":pep:`3104` - Access to Names in Outer Scopes" msgstr "" #: ../Doc/reference/simple_stmts.rst:969 msgid "The specification for the :keyword:`nonlocal` statement." msgstr ""