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

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

# Maintained by the python-doc-es workteam.

# docs-es@python.org /

# https://mail.python.org/mailman3/lists/docs-es.python.org/

# Check https://github.com/PyCampES/python-docs-es/blob/3.8/TRANSLATORS to

# get the list of volunteers

#

#, fuzzy

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2020-05-05 12:54+0200\n"

"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"

"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"

"Language-Team: python-doc-es\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=utf-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Generated-By: Babel 2.8.0\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:36

msgid "Expression statements"

msgstr ""

#: ../Doc/reference/simple_stmts.rst:43

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

msgid ""

"An expression statement evaluates the expression list (which may be a single "

"expression)."

msgstr ""

#: ../Doc/reference/simple_stmts.rst:64

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

msgid "Assignment statements"

msgstr ""

#: ../Doc/reference/simple_stmts.rst:82

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

msgid ""

"(See section :ref:`primaries` for the syntax definitions for *attributeref*, "

"*subscription*, and *slicing*.)"

msgstr ""

#: ../Doc/reference/simple_stmts.rst:99

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

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

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

msgid ""

"If the target list is a single target with no trailing comma, optionally in "

"parentheses, the object is assigned to that target."

msgstr ""

#: ../Doc/reference/simple_stmts.rst:127 ../Doc/reference/simple_stmts.rst:139

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

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

msgid ""

"Assignment of an object to a single target is recursively defined as follows."

msgstr ""

#: ../Doc/reference/simple_stmts.rst:145

msgid "If the target is an identifier (name):"

msgstr ""

#: ../Doc/reference/simple_stmts.rst:147

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

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

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

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

msgid ""

"Note: If the object is a class instance and the attribute reference occurs "

"on both sides of the assignment operator, the right-hand side expression, "

"``a.x`` can access either an instance attribute or (if no instance attribute "

"exists) a class attribute. The left-hand side 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 right-hand side expression refers to a class attribute, the left-hand "

"side creates a new instance attribute as the target of the assignment::"

msgstr ""

#: ../Doc/reference/simple_stmts.rst:185

msgid ""

"This description does not necessarily apply to descriptor attributes, such "

"as properties created with :func:`property`."

msgstr ""

#: ../Doc/reference/simple_stmts.rst:192

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

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

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

msgid ""

"For user-defined objects, the :meth:`__setitem__` method is called with "

"appropriate arguments."

msgstr ""

#: ../Doc/reference/simple_stmts.rst:223

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

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

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

msgid ":pep:`3132` - Extended Iterable Unpacking"

msgstr ""

#: ../Doc/reference/simple_stmts.rst:256

msgid "The specification for the ``*target`` feature."

msgstr ""

#: ../Doc/reference/simple_stmts.rst:262

msgid "Augmented assignment statements"

msgstr ""

#: ../Doc/reference/simple_stmts.rst:280

msgid ""

"Augmented assignment is the combination, in a single statement, of a binary "

"operation and an assignment statement:"

msgstr ""

#: ../Doc/reference/simple_stmts.rst:289

msgid ""

"(See section :ref:`primaries` for the syntax definitions of the last three "

"symbols.)"

msgstr ""

#: ../Doc/reference/simple_stmts.rst:292

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

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

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

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

msgid ""

"For targets which are attribute references, the same :ref:`caveat about "

"class and instance attributes <attr-target-note>` applies as for regular "

"assignments."

msgstr ""

#: ../Doc/reference/simple_stmts.rst:321

msgid "Annotated assignment statements"

msgstr ""

#: ../Doc/reference/simple_stmts.rst:328

msgid ""

":term:`Annotation <variable 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:335

msgid ""

"The difference from normal :ref:`assignment` is that only single target is "

"allowed."

msgstr ""

#: ../Doc/reference/simple_stmts.rst:337

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

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

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

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

msgid ":pep:`526` - Syntax for Variable Annotations"

msgstr ""

#: ../Doc/reference/simple_stmts.rst:360

msgid ""

"The proposal that added syntax for annotating the types of variables "

"(including class variables and instance variables), instead of expressing "

"them through comments."

msgstr ""

#: ../Doc/reference/simple_stmts.rst:366

msgid ":pep:`484` - Type hints"

msgstr ""

#: ../Doc/reference/simple_stmts.rst:365

msgid ""

"The proposal that added the :mod:`typing` module to provide a standard "

"syntax for type annotations that can be used in static analysis tools and "

"IDEs."

msgstr ""

#: ../Doc/reference/simple_stmts.rst:369

msgid ""

"Now annotated assignments allow same expressions in the right hand side as "

"the regular assignments. Previously, some expressions (like un-parenthesized "

"tuple expressions) caused a syntax error."

msgstr ""

#: ../Doc/reference/simple_stmts.rst:378

msgid "The :keyword:`!assert` statement"

msgstr ""

#: ../Doc/reference/simple_stmts.rst:385

msgid ""

"Assert statements are a convenient way to insert debugging assertions into a "

"program:"

msgstr ""

#: ../Doc/reference/simple_stmts.rst:391

msgid "The simple form, ``assert expression``, is equivalent to ::"

msgstr ""

#: ../Doc/reference/simple_stmts.rst:396

msgid ""

"The extended form, ``assert expression1, expression2``, is equivalent to ::"

msgstr ""

#: ../Doc/reference/simple_stmts.rst:405

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

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

msgid "The :keyword:`!pass` statement"

msgstr ""

#: ../Doc/reference/simple_stmts.rst:431

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

msgid "The :keyword:`!del` statement"

msgstr ""

#: ../Doc/reference/simple_stmts.rst:453

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

msgid ""

"Deletion of a target list recursively deletes each target, from left to "

"right."

msgstr ""

#: ../Doc/reference/simple_stmts.rst:462

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

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

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

msgid "The :keyword:`!return` statement"

msgstr ""

#: ../Doc/reference/simple_stmts.rst:492

msgid ""

":keyword:`return` may only occur syntactically nested in a function "

"definition, not within a nested class definition."

msgstr ""

#: ../Doc/reference/simple_stmts.rst:495

msgid ""

"If an expression list is present, it is evaluated, else ``None`` is "

"substituted."

msgstr ""

#: ../Doc/reference/simple_stmts.rst:497

msgid ""

":keyword:`return` leaves the current function call with the expression list "

"(or ``None``) as return value."

msgstr ""

#: ../Doc/reference/simple_stmts.rst:502

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

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

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

msgid "The :keyword:`!yield` statement"

msgstr ""

#: ../Doc/reference/simple_stmts.rst:531

msgid ""

"A :keyword:`yield` statement is semantically equivalent to a :ref:`yield "

"expression <yieldexpr>`. 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:539

msgid "are equivalent to the yield expression statements ::"

msgstr ""

#: ../Doc/reference/simple_stmts.rst:544

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

msgid ""

"For full details of :keyword:`yield` semantics, refer to the :ref:"

"`yieldexpr` section."

msgstr ""

#: ../Doc/reference/simple_stmts.rst:555

msgid "The :keyword:`!raise` statement"

msgstr ""

#: ../Doc/reference/simple_stmts.rst:566

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

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

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

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

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

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

msgid ""

"Exception chaining can be explicitly suppressed by specifying :const:`None` "

"in the ``from`` clause::"

msgstr ""

#: ../Doc/reference/simple_stmts.rst:645

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

msgid ":const:`None` is now permitted as ``Y`` in ``raise X from Y``."

msgstr ""

#: ../Doc/reference/simple_stmts.rst:651

msgid ""

"The ``__suppress_context__`` attribute to suppress automatic display of the "

"exception context."

msgstr ""

#: ../Doc/reference/simple_stmts.rst:658

msgid "The :keyword:`!break` statement"

msgstr ""

#: ../Doc/reference/simple_stmts.rst:669

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

msgid ""

"It terminates the nearest enclosing loop, skipping the optional :keyword:`!"

"else` clause if the loop has one."

msgstr ""

#: ../Doc/reference/simple_stmts.rst:679

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

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

msgid "The :keyword:`!continue` statement"

msgstr ""

#: ../Doc/reference/simple_stmts.rst:704

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 "

"within that loop. It continues with the next cycle of the nearest enclosing "

"loop."

msgstr ""

#: ../Doc/reference/simple_stmts.rst:708

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

msgid "The :keyword:`!import` statement"

msgstr ""

#: ../Doc/reference/simple_stmts.rst:738

msgid ""

"The basic import statement (no :keyword:`from` clause) is executed in two "

"steps:"

msgstr ""

#: ../Doc/reference/simple_stmts.rst:741

msgid "find a module, loading and initializing it if necessary"

msgstr ""

#: ../Doc/reference/simple_stmts.rst:742

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

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

msgid ""

"The details of the first step, finding and loading modules are described in "

"greater detail in the section on the :ref:`import system <importsystem>`, "

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

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

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

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

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

msgid "The :keyword:`from` form uses a slightly more complex process:"

msgstr ""

#: ../Doc/reference/simple_stmts.rst:780

msgid ""

"find the module specified in the :keyword:`from` clause, loading and "

"initializing it if necessary;"

msgstr ""

#: ../Doc/reference/simple_stmts.rst:782

msgid "for each of the identifiers specified in the :keyword:`import` clauses:"

msgstr ""

#: ../Doc/reference/simple_stmts.rst:784

msgid "check if the imported module has an attribute by that name"

msgstr ""

#: ../Doc/reference/simple_stmts.rst:785

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

msgid "if the attribute is not found, :exc:`ImportError` is raised."

msgstr ""

#: ../Doc/reference/simple_stmts.rst:788

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

msgid "Examples::"

msgstr ""

#: ../Doc/reference/simple_stmts.rst:802

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

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

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

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

"the :ref:`relativeimports` section."

msgstr ""

#: ../Doc/reference/simple_stmts.rst:839

msgid ""

":func:`importlib.import_module` is provided to support applications that "

"determine dynamically the modules to be loaded."

msgstr ""

#: ../Doc/reference/simple_stmts.rst:843

msgid ""

"Raises an :ref:`auditing event <auditing>` ``import`` with arguments "

"``module``, ``filename``, ``sys.path``, ``sys.meta_path``, ``sys."

"path_hooks``."

msgstr ""

#: ../Doc/reference/simple_stmts.rst:847

msgid "Future statements"

msgstr ""

#: ../Doc/reference/simple_stmts.rst:853

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

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

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

msgid "the module docstring (if any),"

msgstr ""

#: ../Doc/reference/simple_stmts.rst:873

msgid "comments,"

msgstr ""

#: ../Doc/reference/simple_stmts.rst:874

msgid "blank lines, and"

msgstr ""

#: ../Doc/reference/simple_stmts.rst:875

msgid "other future statements."

msgstr ""

#: ../Doc/reference/simple_stmts.rst:877

msgid ""

"The only feature in Python 3.7 that requires using the future statement is "

"``annotations``."

msgstr ""

#: ../Doc/reference/simple_stmts.rst:880

msgid ""

"All historical features enabled by the future statement are still recognized "

"by Python 3. The list includes ``absolute_import``, ``division``, "

"``generators``, ``generator_stop``, ``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:887

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

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

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

msgid ""

"The interesting runtime semantics depend on the specific feature enabled by "

"the future statement."

msgstr ""

#: ../Doc/reference/simple_stmts.rst:905

msgid "Note that there is nothing special about the statement::"

msgstr ""

#: ../Doc/reference/simple_stmts.rst:909

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

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

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

msgid ":pep:`236` - Back to the __future__"

msgstr ""

#: ../Doc/reference/simple_stmts.rst:927

msgid "The original proposal for the __future__ mechanism."

msgstr ""

#: ../Doc/reference/simple_stmts.rst:933

msgid "The :keyword:`!global` statement"

msgstr ""

#: ../Doc/reference/simple_stmts.rst:943

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

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

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

msgid ""

"The current implementation does not enforce some of these restrictions, 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:968

msgid ""

"**Programmer's note:** :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 "