# SOME DESCRIPTIVE TITLE.

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

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

#

# Translators:

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2020-02-09 18:46+0900\n"

"PO-Revision-Date: 2019-09-01 05:18+0000\n"

"Last-Translator: Adorilson Bezerra <adorilson@gmail.com>\n"

"Language-Team: Portuguese (Brazil) (http://www.transifex.com/python-doc/"

"python-27/language/pt_BR/)\n"

"Language: pt_BR\n"

"MIME-Version: 1.0\n"

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

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

"Plural-Forms: nplurals=2; plural=(n > 1);\n"

#: ../../reference/simple_stmts.rst:6

msgid "Simple statements"

msgstr "Instruções simples"

#: ../../reference/simple_stmts.rst:10

msgid ""

"Simple statements are 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 ""

#: ../../reference/simple_stmts.rst:36

msgid "Expression statements"

msgstr "Instruções de expressão"

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

"As instruções de expressão são usadas (principalmente interativamente) para "

"calcular e escrever um valor, ou (geralmente) para chamar um procedimento "

"(uma função que não retorna nenhum resultado significativo; em Python, os "

"procedimentos retornam o valor ``None``). Outros usos de instruções de "

"expressão são permitidos e ocasionalmente úteis. A sintaxe para uma "

"instrução de expressão é:"

#: ../../reference/simple_stmts.rst:51

msgid ""

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

"expression)."

msgstr ""

"Uma instrução de expressão avalia a lista de expressões (que pode ser uma "

"única expressão)."

#: ../../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 (see section :ref:`print`) on a line by itself. "

"(Expression statements yielding ``None`` are not written, so that procedure "

"calls do not cause any output.)"

msgstr ""

#: ../../reference/simple_stmts.rst:73

msgid "Assignment statements"

msgstr "Instruções de atribuição"

#: ../../reference/simple_stmts.rst:83

msgid ""

"Assignment statements are used to (re)bind names to values and to modify "

"attributes or items of mutable objects:"

msgstr ""

"As instruções de atribuição são usadas para (re)vincular nomes a valores e "

"modificar atributos ou itens de objetos mutáveis:"

#: ../../reference/simple_stmts.rst:96 ../../reference/simple_stmts.rst:268

msgid ""

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

"symbols.)"

msgstr ""

#: ../../reference/simple_stmts.rst:101

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

"Uma instrução de atribuição avalia a lista de expressões (lembre-se de que "

"pode ser uma única expressão ou uma lista separada por vírgulas, a última "

"produzindo uma tupla) e atribui o único objeto resultante a cada uma das "

"listas alvos, da esquerda para a direita."

#: ../../reference/simple_stmts.rst:110

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

"A atribuição é definida recursivamente dependendo da forma do alvo (lista). "

"Quando um alvo faz parte de um objeto mutável (uma referência de atributo, "

"assinatura ou divisão), o objeto mutável deve, em última análise, executar a "

"atribuição e decidir sobre sua validade e pode levantar uma exceção se a "

"atribuição for inaceitável. As regras observadas pelos vários tipos e as "

"exceções levantadas são dadas com a definição dos tipos de objetos (ver "

"seção :ref:`types`)."

#: ../../reference/simple_stmts.rst:119

msgid ""

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

msgstr ""

#: ../../reference/simple_stmts.rst:121

msgid ""

"If the target list is a single target: The object is assigned to that target."

msgstr ""

#: ../../reference/simple_stmts.rst:123

msgid ""

"If the target list is a comma-separated list of targets: 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 ""

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

msgid ""

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

msgstr ""

"A atribuição de um objeto a um único alvo é definida recursivamente da "

"maneira a seguir."

#: ../../reference/simple_stmts.rst:129

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

msgstr "Se o alvo for um identificador (nome):"

#: ../../reference/simple_stmts.rst:133

msgid ""

"If the name does not occur in a :keyword:`global` statement in the current "

"code block: the name is bound to the object in the current local namespace."

msgstr ""

#: ../../reference/simple_stmts.rst:136

msgid ""

"Otherwise: the name is bound to the object in the current global namespace."

msgstr ""

#: ../../reference/simple_stmts.rst:140

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

"O nome é vinculado novamente se já estiver vinculado. Isso pode fazer com "

"que a contagem de referências para o objeto anteriormente vinculado ao nome "

"chegue a zero, fazendo com que o objeto seja desalocado e seu destrutor (se "

"houver) seja chamado."

#: ../../reference/simple_stmts.rst:144

msgid ""

"If the target is a target list enclosed in parentheses or in square "

"brackets: The object must be an iterable with the same number of items as "

"there are targets in the target list, and its items are assigned, from left "

"to right, to the corresponding targets."

msgstr ""

#: ../../reference/simple_stmts.rst:151

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

"Se o alvo for uma referência de atributo: a expressão primária na referência "

"é avaliada. Deve produzir um objeto com atributos atribuíveis; se este não "

"for o caso, a exceção :exc:`TypeError` é levanta. Esse objeto é então "

"solicitado a atribuir o objeto atribuído ao atributo fornecido; se não puder "

"executar a atribuição, ele levanta uma exceção (geralmente, mas não "

"necessariamente :exc:`AttributeError`)."

#: ../../reference/simple_stmts.rst:160

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

#: ../../reference/simple_stmts.rst:174

msgid ""

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

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

msgstr ""

"Esta descrição não se aplica necessariamente aos atributos do descritor, "

"como propriedades criadas com :func:`property`."

#: ../../reference/simple_stmts.rst:181

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

#: ../../reference/simple_stmts.rst:190

msgid ""

"If the primary is a mutable sequence object (such as a list), the subscript "

"must yield a plain 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 ""

#: ../../reference/simple_stmts.rst:201

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

#: ../../reference/simple_stmts.rst:209

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 "

"(small) 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 object allows it."

msgstr ""

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

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

"Na implementação atual, a sintaxe dos alvos é considerada a mesma das "

"expressões e a sintaxe inválida é rejeitada durante a fase de geração do "

"código, causando mensagens de erro menos detalhadas."

#: ../../reference/simple_stmts.rst:227

msgid ""

"WARNING: Although the definition of assignment implies that overlaps between "

"the left-hand side and the right-hand side are 'safe' (for example ``a, b = "

"b, a`` swaps two variables), overlaps *within* the collection of assigned-to "

"variables are not safe! For instance, the following program prints ``[0, "

"2]``::"

msgstr ""

#: ../../reference/simple_stmts.rst:241

msgid "Augmented assignment statements"

msgstr "Instruções de atribuição aumentada"

#: ../../reference/simple_stmts.rst:259

msgid ""

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

"operation and an assignment statement:"

msgstr ""

"A atribuição aumentada é a combinação, em uma única instrução, de uma "

"operação binária e uma instrução de atribuição:"

#: ../../reference/simple_stmts.rst:271

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

"Uma atribuição aumentada avalia o alvo (que, diferentemente das instruções "

"de atribuição normais, não pode ser um desempacotamento) e a lista de "

"expressões, executa a operação binária específica para o tipo de atribuição "

"nos dois operandos e atribui o resultado ao alvo original. O alvo é avaliado "

"apenas uma vez."

#: ../../reference/simple_stmts.rst:276

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

#: ../../reference/simple_stmts.rst:282

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

"Com exceção da atribuição a tuplas e vários alvos em uma única instrução, a "

"atribuição feita por instruções de atribuição aumentada é tratada da mesma "

"maneira que atribuições normais. Da mesma forma, com exceção do possível "

"comportamento *in-place*, a operação binária executada por atribuição "

"aumentada é a mesma que as operações binárias normais."

#: ../../reference/simple_stmts.rst:288

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

"Para alvos que são referências de atributos, a mesma :ref:`advertência sobre "

"atributos de classe e instância <attr-target-note>` se aplica a atribuições "

"regulares."

#: ../../reference/simple_stmts.rst:295

msgid "The :keyword:`assert` statement"

msgstr ""

#: ../../reference/simple_stmts.rst:301

msgid ""

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

"program:"

msgstr ""

"As instruções assert são uma maneira conveniente de inserir asserções de "

"depuração em um programa:"

#: ../../reference/simple_stmts.rst:307

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

msgstr "A forma simples, ``assert expression``, é equivalente a ::"

#: ../../reference/simple_stmts.rst:312

msgid ""

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

msgstr ""

"A forma estendida, ``assert expression1, expression2``, é equivalente a ::"

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

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

#: ../../reference/simple_stmts.rst:330

msgid ""

"Assignments to :const:`__debug__` are illegal. The value for the built-in "

"variable is determined when the interpreter starts."

msgstr ""

"Atribuições a :const:`__debug__` são ilegais. O valor da variável embutida é "

"determinado quando o interpretador é iniciado."

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

msgid "The :keyword:`pass` statement"

msgstr ""

#: ../../reference/simple_stmts.rst:346

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

":keyword:`pass` é uma operação nula --- quando é executada, nada acontece. É "

"útil como um espaço reservado quando uma instrução é necessária "

"sintaticamente, mas nenhum código precisa ser executado, por exemplo::"

#: ../../reference/simple_stmts.rst:358

msgid "The :keyword:`del` statement"

msgstr "O comando :keyword:`del`"

#: ../../reference/simple_stmts.rst:368

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

"A exclusão é definida recursivamente de maneira muito semelhante à maneira "

"como a atribuição é definida. Em vez de explicar em detalhes, aqui estão "

"algumas dicas."

#: ../../reference/simple_stmts.rst:371

msgid ""

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

"right."

msgstr ""

"A exclusão de uma lista alvo exclui recursivamente cada alvo, da esquerda "

"para a direita."

#: ../../reference/simple_stmts.rst:377

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

#: ../../reference/simple_stmts.rst:384

msgid ""

"It is illegal to delete a name from the local namespace if it occurs as a "

"free variable in a nested block."

msgstr ""

#: ../../reference/simple_stmts.rst:389

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

"A exclusão de referências de atributos, assinaturas e fatias é passada para "

"o objeto principal envolvido; a exclusão de um fatiamento é em geral "

"equivalente à atribuição de uma fatia vazia do tipo certo (mas mesmo isso é "

"determinado pelo objeto fatiado)."

#: ../../reference/simple_stmts.rst:398

msgid "The :keyword:`print` statement"

msgstr ""

#: ../../reference/simple_stmts.rst:406

msgid ""

":keyword:`print` evaluates each expression in turn and writes the resulting "

"object to standard output (see below). If an object is not a string, it is "

"first converted to a string using the rules for string conversions. The "

"(resulting or original) string is then written. A space is written before "

"each object is (converted and) written, unless the output system believes it "

"is positioned at the beginning of a line. This is the case (1) when no "

"characters have yet been written to standard output, (2) when the last "

"character written to standard output is a whitespace character except ``' "

"'``, or (3) when the last write operation on standard output was not a :"

"keyword:`print` statement. (In some cases it may be functional to write an "

"empty string to standard output for this reason.)"

msgstr ""

#: ../../reference/simple_stmts.rst:420

msgid ""

"Objects which act like file objects but which are not the built-in file "

"objects often do not properly emulate this aspect of the file object's "

"behavior, so it is best not to rely on this."

msgstr ""

#: ../../reference/simple_stmts.rst:430

msgid ""

"A ``'\\n'`` character is written at the end, unless the :keyword:`print` "

"statement ends with a comma. This is the only action if the statement "

"contains just the keyword :keyword:`print`."

msgstr ""

#: ../../reference/simple_stmts.rst:440

msgid ""

"Standard output is defined as the file object named ``stdout`` in the built-"

"in module :mod:`sys`. If no such object exists, or if it does not have a :"

"meth:`write` method, a :exc:`RuntimeError` exception is raised."

msgstr ""

#: ../../reference/simple_stmts.rst:446

msgid ""

":keyword:`print` also has an extended form, defined by the second portion of "

"the syntax described above. This form is sometimes referred to as \":keyword:"

"`print` chevron.\" In this form, the first expression after the ``>>`` must "

"evaluate to a \"file-like\" object, specifically an object that has a :meth:"

"`write` method as described above. With this extended form, the subsequent "

"expressions are printed to this file object. If the first expression "

"evaluates to ``None``, then ``sys.stdout`` is used as the file for output."

msgstr ""

#: ../../reference/simple_stmts.rst:458

msgid "The :keyword:`return` statement"

msgstr ""

#: ../../reference/simple_stmts.rst:468

msgid ""

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

"definition, not within a nested class definition."

msgstr ""

":keyword:`return` só pode ocorrer sintaticamente aninhado em uma definição "

"de função, não em uma definição de classe aninhada."

#: ../../reference/simple_stmts.rst:471

msgid ""

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

"substituted."

msgstr ""

"Se uma lista de expressões estiver presente, ela será avaliada, caso "

"contrário, ``None`` será substituído."

#: ../../reference/simple_stmts.rst:473

msgid ""

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

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

msgstr ""

":keyword:`return` deixa a chamada da função atual com a lista de expressões "

"(ou ``None``) como valor de retorno."

#: ../../reference/simple_stmts.rst:478

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

#: ../../reference/simple_stmts.rst:482

msgid ""

"In a generator function, the :keyword:`return` statement is not allowed to "

"include an :token:`expression_list`. In that context, a bare :keyword:"

"`return` indicates that the generator is done and will cause :exc:"

"`StopIteration` to be raised."

msgstr ""

#: ../../reference/simple_stmts.rst:491

msgid "The :keyword:`yield` statement"

msgstr "A declaração :keyword:`yield`"

#: ../../reference/simple_stmts.rst:503

msgid ""

"The :keyword:`yield` statement is only used when defining a generator "

"function, and is only used in the body of the generator function. Using a :"

"keyword:`yield` statement in a function definition is sufficient to cause "

"that definition to create a generator function instead of a normal function."

msgstr ""

#: ../../reference/simple_stmts.rst:508

msgid ""

"When a generator function is called, it returns an iterator known as a "

"generator iterator, or more commonly, a generator. The body of the "

"generator function is executed by calling the generator's :meth:`~generator."

"next` method repeatedly until it raises an exception."

msgstr ""

#: ../../reference/simple_stmts.rst:513

msgid ""

"When a :keyword:`yield` statement is executed, the state of the generator is "

"frozen and the value of :token:`expression_list` is returned to :meth:"

"`~generator.next`'s caller. By \"frozen\" we mean that all local state is "

"retained, including the current bindings of local variables, the instruction "

"pointer, and the internal evaluation stack: enough information is saved so "

"that the next time :meth:`~generator.next` is invoked, the function can "

"proceed exactly as if the :keyword:`yield` statement were just another "

"external call."

msgstr ""

#: ../../reference/simple_stmts.rst:521

msgid ""

"As of Python version 2.5, the :keyword:`yield` statement is now allowed in "

"the :keyword:`try` clause of a :keyword:`try` ... :keyword:`finally` "

"construct. If the generator is not resumed before it is finalized (by "

"reaching a zero reference count or by being garbage collected), the "

"generator-iterator's :meth:`close` method will be called, allowing any "

"pending :keyword:`finally` clauses to execute."

msgstr ""

#: ../../reference/simple_stmts.rst:528

msgid ""

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

"`yieldexpr` section."

msgstr ""

"Para detalhes completos da semântica :keyword:`yield`, consulte a seção :ref:"

"`yieldexpr`."

#: ../../reference/simple_stmts.rst:533

msgid ""

"In Python 2.2, the :keyword:`yield` statement was only allowed when the "

"``generators`` feature has been enabled. This ``__future__`` import "

"statement was used to enable the feature::"

msgstr ""

#: ../../reference/simple_stmts.rst:543

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

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

#: ../../reference/simple_stmts.rst:543

msgid ""

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

"Python."

msgstr ""

"A proposta para adicionar geradores e a instrução :keyword:`yield` ao Python."

#: ../../reference/simple_stmts.rst:546

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

msgstr ":pep:`342` - Corrotinas via Geradores Aprimorados"

#: ../../reference/simple_stmts.rst:546

msgid ""

"The proposal that, among other generator enhancements, proposed allowing :"

"keyword:`yield` to appear inside a :keyword:`try` ... :keyword:`finally` "

"block."

msgstr ""

#: ../../reference/simple_stmts.rst:553

msgid "The :keyword:`raise` statement"

msgstr ""

#: ../../reference/simple_stmts.rst:563

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:`TypeError` exception is raised indicating that this "

"is an error (if running under IDLE, a :exc:`Queue.Empty` exception is raised "

"instead)."

msgstr ""

#: ../../reference/simple_stmts.rst:568

msgid ""

"Otherwise, :keyword:`raise` evaluates the expressions to get three objects, "

"using ``None`` as the value of omitted expressions. The first two objects "

"are used to determine the *type* and *value* of the exception."

msgstr ""

#: ../../reference/simple_stmts.rst:572

msgid ""

"If the first object is an instance, the type of the exception is the class "

"of the instance, the instance itself is the value, and the second object "

"must be ``None``."

msgstr ""

#: ../../reference/simple_stmts.rst:576

msgid ""

"If the first object is a class, it becomes the type of the exception. The "

"second object is used to determine the exception value: If it is an instance "

"of the class, the instance becomes the exception value. If the second object "

"is a tuple, it is used as the argument list for the class constructor; if it "

"is ``None``, an empty argument list is used, and any other object is treated "

"as a single argument to the constructor. The instance so created by calling "

"the constructor is used as the exception value."

msgstr ""

#: ../../reference/simple_stmts.rst:586

msgid ""

"If a third object is present and not ``None``, it must be a traceback object "

"(see section :ref:`types`), and it is substituted instead of the current "

"location as the place where the exception occurred. If the third object is "

"present and not a traceback object or ``None``, a :exc:`TypeError` exception "

"is raised. The three-expression form of :keyword:`raise` is useful to re-"

"raise an exception transparently in an except clause, but :keyword:`raise` "

"with no expressions should be preferred if the exception to be re-raised was "

"the most recently active exception in the current scope."

msgstr ""

#: ../../reference/simple_stmts.rst:595

msgid ""

"Additional information on exceptions can be found in section :ref:"

"`exceptions`, and information about handling exceptions is in section :ref:"

"`try`."

msgstr ""

"Informações adicionais sobre exceções podem ser encontradas na seção :ref:"

"`exceptions`, e informações sobre como lidar com exceções estão na seção :"

"ref:`try`."

#: ../../reference/simple_stmts.rst:602

msgid "The :keyword:`break` statement"

msgstr ""

#: ../../reference/simple_stmts.rst:613

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

":keyword:`break` só pode ocorrer sintaticamente aninhado em um laço :keyword:"

"`for` ou :keyword:`while`, mas não aninhado em uma função ou definição de "

"classe dentro desse laço."

#: ../../reference/simple_stmts.rst:619

msgid ""

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

"`else` clause if the loop has one."

msgstr ""

#: ../../reference/simple_stmts.rst:624

msgid ""

"If a :keyword:`for` loop is terminated by :keyword:`break`, the loop control "

"target keeps its current value."

msgstr ""

"Se um laço :keyword:`for` é encerrado por :keyword:`break`, o alvo de "

"controle do laço mantém seu valor atual."

#: ../../reference/simple_stmts.rst:629

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

#: ../../reference/simple_stmts.rst:637

msgid "The :keyword:`continue` statement"

msgstr ""

#: ../../reference/simple_stmts.rst:649

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

#: ../../reference/simple_stmts.rst:654

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

#: ../../reference/simple_stmts.rst:663

msgid "The :keyword:`import` statement"

msgstr ""

#: ../../reference/simple_stmts.rst:683

msgid ""

"Import statements are executed in two steps: (1) find a module, and "

"initialize it if necessary; (2) define a name or names in the local "

"namespace (of the scope where the :keyword:`import` statement occurs). The "

"statement comes in two forms differing on whether it uses the :keyword:"

"`from` keyword. The first form (without :keyword:`from`) repeats these steps "

"for each identifier in the list. The form with :keyword:`from` performs step "

"(1) once, and then performs step (2) repeatedly."

msgstr ""

#: ../../reference/simple_stmts.rst:694

msgid ""

"To understand how step (1) occurs, one must first understand how Python "

"handles hierarchical naming of modules. To help organize modules and provide "

"a hierarchy in naming, Python has a concept of packages. A package can "

"contain other packages and modules while modules cannot contain other "

"modules or packages. From a file system perspective, packages are "

"directories and modules are files."

msgstr ""

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

msgid ""

"Once the name of the module is known (unless otherwise specified, the term "

"\"module\" will refer to both packages and modules), searching for the "

"module or package can begin. The first place checked is :data:`sys.modules`, "

"the cache of all modules that have been imported previously. If the module "

"is found there then it is used in step (2) of import."

msgstr ""

#: ../../reference/simple_stmts.rst:716

msgid ""

"If the module is not found in the cache, then :data:`sys.meta_path` is "

"searched (the specification for :data:`sys.meta_path` can be found in :pep:"

"`302`). The object is a list of :term:`finder` objects which are queried in "

"order as to whether they know how to load the module by calling their :meth:"

"`find_module` method with the name of the module. If the module happens to "

"be contained within a package (as denoted by the existence of a dot in the "

"name), then a second argument to :meth:`find_module` is given as the value "

"of the :attr:`__path__` attribute from the parent package (everything up to "

"the last dot in the name of the module being imported). If a finder can find "

"the module it returns a :term:`loader` (discussed later) or returns ``None``."

msgstr ""

#: ../../reference/simple_stmts.rst:732

msgid ""

"If none of the finders on :data:`sys.meta_path` are able to find the module "

"then some implicitly defined finders are queried. Implementations of Python "

"vary in what implicit meta path finders are defined. The one they all do "

"define, though, is one that handles :data:`sys.path_hooks`, :data:`sys."

"path_importer_cache`, and :data:`sys.path`."

msgstr ""

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

msgid ""

"The implicit finder searches for the requested module in the \"paths\" "

"specified in one of two places (\"paths\" do not have to be file system "

"paths). If the module being imported is supposed to be contained within a "

"package then the second argument passed to :meth:`find_module`, :attr:"

"`__path__` on the parent package, is used as the source of paths. If the "

"module is not contained in a package then :data:`sys.path` is used as the "

"source of paths."

msgstr ""

#: ../../reference/simple_stmts.rst:745

msgid ""

"Once the source of paths is chosen it is iterated over to find a finder that "

"can handle that path. The dict at :data:`sys.path_importer_cache` caches "

"finders for paths and is checked for a finder. If the path does not have a "

"finder cached then :data:`sys.path_hooks` is searched by calling each object "

"in the list with a single argument of the path, returning a finder or "

"raises :exc:`ImportError`. If a finder is returned then it is cached in :"

"data:`sys.path_importer_cache` and then used for that path entry. If no "

"finder can be found but the path exists then a value of ``None`` is stored "

"in :data:`sys.path_importer_cache` to signify that an implicit, file-based "

"finder that handles modules stored as individual files should be used for "

"that path. If the path does not exist then a finder which always returns "

"``None`` is placed in the cache for the path."

msgstr ""

#: ../../reference/simple_stmts.rst:763

msgid ""

"If no finder can find the module then :exc:`ImportError` is raised. "

"Otherwise some finder returned a loader whose :meth:`load_module` method is "

"called with the name of the module to load (see :pep:`302` for the original "

"definition of loaders). A loader has several responsibilities to perform on "

"a module it loads. First, if the module already exists in :data:`sys."

"modules` (a possibility if the loader is called outside of the import "

"machinery) then it is to use that module for initialization and not a new "

"module. But if the module does not exist in :data:`sys.modules` then it is "

"to be added to that dict before initialization begins. If an error occurs "

"during loading of the module and it was added to :data:`sys.modules` it is "

"to be removed from the dict. If an error occurs but the module was already "

"in :data:`sys.modules` it is left in the dict."

msgstr ""

#: ../../reference/simple_stmts.rst:783

msgid ""

"The loader must set several attributes on the module. :data:`__name__` is to "

"be set to the name of the module. :data:`__file__` is to be the \"path\" to "

"the file unless the module is built-in (and thus listed in :data:`sys."

"builtin_module_names`) in which case the attribute is not set. If what is "

"being imported is a package then :data:`__path__` is to be set to a list of "

"paths to be searched when looking for modules and packages contained within "

"the package being imported. :data:`__package__` is optional but should be "

"set to the name of package that contains the module or package (the empty "

"string is used for module not contained in a package). :data:`__loader__` is "

"also optional but should be set to the loader object that is loading the "

"module."

msgstr ""

#: ../../reference/simple_stmts.rst:798

msgid ""

"If an error occurs during loading then the loader raises :exc:`ImportError` "

"if some other exception is not already being propagated. Otherwise the "

"loader returns the module that was loaded and initialized."

msgstr ""

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

msgid ""

"When step (1) finishes without raising an exception, step (2) can begin."

msgstr ""

#: ../../reference/simple_stmts.rst:804

msgid ""

"The first form of :keyword:`import` statement binds the module name in the "

"local namespace to the module object, and then goes on to import the next "

"identifier, if any. If the module name is followed by :keyword:`as`, the "

"name following :keyword:`as` is used as the local name for the module."

msgstr ""

#: ../../reference/simple_stmts.rst:813

msgid ""

"The :keyword:`from` form does not bind the module name: it goes through the "

"list of identifiers, looks each one of them up in the module found in step "

"(1), and binds the name in the local namespace to the object thus found. As "

"with the first form of :keyword:`import`, an alternate local name can be "

"supplied by specifying \":keyword:`as` localname\". If a name is not "

"found, :exc:`ImportError` is raised. If the list of identifiers is replaced "

"by a star (``'*'``), all public names defined in the module are bound in the "

"local namespace of the :keyword:`import` statement.."

msgstr ""

#: ../../reference/simple_stmts.rst:824

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

#: ../../reference/simple_stmts.rst:834

msgid ""

"The :keyword:`from` form with ``*`` may only occur in a module scope. If "

"the wild card form of import --- ``import *`` --- is used in a function and "

"the function contains or is a nested block with free variables, the compiler "

"will raise a :exc:`SyntaxError`."

msgstr ""

#: ../../reference/simple_stmts.rst:842

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

#: ../../reference/simple_stmts.rst:855

msgid ""

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

"determine which modules need to be loaded dynamically."

msgstr ""

#: ../../reference/simple_stmts.rst:862

msgid "Future statements"

msgstr "Instruções future"

#: ../../reference/simple_stmts.rst:866

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

#: ../../reference/simple_stmts.rst:881

msgid ""

"A future statement must appear near the top of the module. The only lines "

"that can appear before a future statement are:"

msgstr ""

"Uma instrução future deve aparecer perto do topo do módulo. As únicas linhas "

"que podem aparecer antes de uma instrução future são:"

#: ../../reference/simple_stmts.rst:884

msgid "the module docstring (if any),"

msgstr "o módulo docstring (se houver),"

#: ../../reference/simple_stmts.rst:885

msgid "comments,"

msgstr "omentários,"

#: ../../reference/simple_stmts.rst:886

msgid "blank lines, and"

msgstr "linhas vazias e"

#: ../../reference/simple_stmts.rst:887

msgid "other future statements."

msgstr "outras instruções future."

#: ../../reference/simple_stmts.rst:889

msgid ""

"The features recognized by Python 2.6 are ``unicode_literals``, "

"``print_function``, ``absolute_import``, ``division``, ``generators``, "

"``nested_scopes`` and ``with_statement``. ``generators``, "

"``with_statement``, ``nested_scopes`` are redundant in Python version 2.6 "

"and above because they are always enabled."

msgstr ""

#: ../../reference/simple_stmts.rst:895

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

"Uma instrução future é reconhecida e tratada especialmente em tempo de "

"compilação: as alterações na semântica das construções principais são "

"frequentemente implementadas gerando código diferente. Pode até ser o caso "

"de um novo recurso introduzir uma nova sintaxe incompatível (como uma nova "

"palavra reservada), caso em que o compilador pode precisar analisar o módulo "

"de maneira diferente. Tais decisões não podem ser adiadas até o tempo de "

"execução."

#: ../../reference/simple_stmts.rst:902

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

"Para qualquer versão, o compilador sabe quais nomes de recursos foram "

"definidos e levanta um erro em tempo de compilação se uma instrução future "

"contiver um recurso desconhecido."

#: ../../reference/simple_stmts.rst:906

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

"A semântica do tempo de execução direto é a mesma de qualquer instrução de "

"importação: existe um módulo padrão :mod:`__future__`, descrito "

"posteriormente, e será importado da maneira usual no momento em que a "

"instrução future for executada."

#: ../../reference/simple_stmts.rst:910

msgid ""