# SOME DESCRIPTIVE TITLE.

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

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

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# python-doc bot, 2025

#

#, fuzzy

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2025-09-22 21:56+0000\n"

"PO-Revision-Date: 2025-09-22 17:56+0000\n"

"Last-Translator: python-doc bot, 2025\n"

"Language-Team: Portuguese (Brazil) (https://app.transifex.com/python-doc/"

"teams/5390/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=3; plural=(n == 0 || n == 1) ? 0 : n != 0 && n % "

"1000000 == 0 ? 1 : 2;\n"

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

msgid "Simple statements"

msgstr "Instruções simples"

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

"Uma instrução simples consiste uma única linha lógica. Várias instruções "

"simples podem ocorrer em uma única linha separada por ponto e vírgula. A "

"sintaxe para instruções simples é:"

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

msgid "Expression statements"

msgstr "Instruções de expressão"

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

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

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

"No modo interativo, se o valor não for ``None``, ele será convertido em uma "

"string usando a função embutida :func:`repr` e a string resultante será "

"gravada na saída padrão em uma linha sozinha (exceto se o resultado é "

"``None``, de modo que as chamadas de procedimento não causam nenhuma saída.)"

#: ../../reference/simple_stmts.rst:72

msgid "Assignment statements"

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

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

"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

msgid ""

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

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

msgstr ""

"(Veja a seção :ref:`primaries` para as definições de sintaxe de "

"*attributeref*, *subscription* e *slicing*.)"

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

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

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

msgid ""

"Assignment of an object to a target list, optionally enclosed in parentheses "

"or square brackets, is recursively defined as follows."

msgstr ""

"A atribuição de um objeto a uma lista alvo, opcionalmente entre parênteses "

"ou colchetes, é definida recursivamente da maneira a seguir."

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

"Se a lista alvo contiver um único alvo sem vírgula à direita, opcionalmente "

"entre parênteses, o objeto será atribuído a esse alvo."

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

msgid "Else:"

msgstr "Senão:"

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

"Se a lista alvo contiver um alvo prefixado com um asterisco, chamado de alvo "

"\"com estrela\" *(starred)*: o objeto deve ser um iterável com pelo menos "

"tantos itens quantos os alvos na lista alvo, menos um. Os primeiros itens do "

"iterável são atribuídos, da esquerda para a direita, aos alvos antes do alvo "

"com estrela. Os itens finais do iterável são atribuídos aos alvos após o "

"alvo com estrela. Uma lista dos itens restantes no iterável é então "

"atribuída ao alvo com estrela (a lista pode estar vazia)."

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

"Senão: o objeto deve ser um iterável com o mesmo número de itens que existem "

"alvos na lista alvos, e os itens são atribuídos, da esquerda para a direita, "

"aos alvos correspondentes."

#: ../../reference/simple_stmts.rst:141

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

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

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

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

"Se o nome não ocorrer em uma instrução :keyword:`global` ou :keyword:"

"`nonlocal` no bloco de código atual: o nome está vinculado ao objeto no "

"espaço de nomes local atual."

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

"Caso contrário: o nome é vinculado ao objeto no espaço de nomes global "

"global ou no espaço de nomes global externo determinado por :keyword:"

"`nonlocal`, respectivamente."

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

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

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

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

"Nota: Se o objeto for uma instância de classe e a referência de atributo "

"ocorrer em ambos os lados do operador de atribuição, a expressão do lado "

"direito, ``a.x`` pode acessar um atributo de instância ou (se não existir "

"nenhum atributo de instância) uma classe atributo. O alvo do lado esquerdo "

"``a.x`` é sempre definido como um atributo de instância, criando-o se "

"necessário. Assim, as duas ocorrências de ``a.x`` não necessariamente se "

"referem ao mesmo atributo: se a expressão do lado direito se refere a um "

"atributo de classe, o lado esquerdo cria um novo atributo de instância como "

"alvo da atribuição::"

#: ../../reference/simple_stmts.rst:183

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

"Se o alvo for uma assinatura: a expressão primária na referência é avaliada. "

"Deve produzir um objeto de sequência mutável (como uma lista) ou um objeto "

"de mapeamento (como um dicionário). Em seguida, a expressão subscrito é "

"avaliada."

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

"Se o primário for um objeto de sequência mutável (como uma lista), o "

"subscrito deverá produzir um inteiro. Se for negativo, o comprimento da "

"sequência é adicionado a ela. O valor resultante deve ser um inteiro não "

"negativo menor que o comprimento da sequência, e a sequência é solicitada a "

"atribuir o objeto atribuído ao seu item com esse índice. Se o índice estiver "

"fora do intervalo, a exceção :exc:`IndexError` será levantada (a atribuição "

"a uma sequência subscrita não pode adicionar novos itens a uma lista)."

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

"Se o primário for um objeto de mapeamento (como um dicionário), o subscrito "

"deve ter um tipo compatível com o tipo de chave do mapeamento, e o "

"mapeamento é solicitado a criar um par chave/data que mapeia o subscrito "

"para o objeto atribuído. Isso pode substituir um par de chave/valor "

"existente pelo mesmo valor de chave ou inserir um novo par de chave/valor "

"(se não existir nenhuma chave com o mesmo valor)."

#: ../../reference/simple_stmts.rst:216

msgid ""

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

"appropriate arguments."

msgstr ""

"Para objetos definidos pelo usuário, o método :meth:`__setitem__` é chamado "

"com argumentos apropriados."

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

"Se o alvo for um fatiamento: a expressão primária na referência é avaliada. "

"Deve produzir um objeto de sequência mutável (como uma lista). O objeto "

"atribuído deve ser um objeto de sequência do mesmo tipo. Em seguida, as "

"expressões de limite inferior e superior são avaliadas, na medida em que "

"estiverem presentes; os padrões são zero e o comprimento da sequência. Os "

"limites devem ser avaliados como inteiros. Se um dos limites for negativo, o "

"comprimento da sequência será adicionado a ele. Os limites resultantes são "

"cortados para ficarem entre zero e o comprimento da sequência, inclusive. "

"Finalmente, o objeto de sequência é solicitado a substituir a fatia pelos "

"itens da sequência atribuída. O comprimento da fatia pode ser diferente do "

"comprimento da sequência atribuída, alterando assim o comprimento da "

"sequência alvo, se a sequência alvo permitir."

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

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

"Embora a definição de atribuição implique que as sobreposições entre o lado "

"esquerdo e o lado direito sejam \"simultâneas\" (por exemplo, ``a, b = b, "

"a`` troca duas variáveis), sobreposições *dentro* da coleção de variáveis "

"atribuídas ocorrem da esquerda para a direita, às vezes resultando em "

"confusão. Por exemplo, o programa a seguir imprime ``[0, 2]``::"

#: ../../reference/simple_stmts.rst:253

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

msgstr ":pep:`3132` - Desempacotamento estendido de iterável"

#: ../../reference/simple_stmts.rst:254

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

msgstr "A especificação para o recurso ``*target``."

#: ../../reference/simple_stmts.rst:260

msgid "Augmented assignment statements"

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

#: ../../reference/simple_stmts.rst:278

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

msgid ""

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

"symbols.)"

msgstr ""

"(Veja a seção :ref:`primaries` para as definições de sintaxe dos últimos "

"três símbolos.)"

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

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

"Uma expressão de atribuição aumentada como ``x += 1`` pode ser reescrita "

"como ``x = x + 1`` para obter um efeito semelhante, mas não exatamente "

"igual. Na versão aumentada, ``x`` é avaliado apenas uma vez. Além disso, "

"quando possível, a operação real é executada *no local*, o que significa "

"que, em vez de criar um novo objeto e atribuí-lo ao alvo, o objeto antigo é "

"modificado."

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

"Ao contrário das atribuições normais, as atribuições aumentadas avaliam o "

"lado esquerdo *antes* de avaliar o lado direito. Por exemplo, ``a[i] += "

"f(x)`` primeiro procura ``a[i]``, então avalia ``f(x)`` e executa a adição "

"e, por último, escreve o resultado de volta para ``a[i]``."

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

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

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

msgid "Annotated assignment statements"

msgstr "instruções de atribuição anotado"

#: ../../reference/simple_stmts.rst:326

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

"A atribuição de :term:`anotação <variable annotation>` é a combinação, em "

"uma única instrução, de uma anotação de variável ou atributo e uma instrução "

"de atribuição opcional:"

#: ../../reference/simple_stmts.rst:333

msgid ""

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

"allowed."

msgstr ""

#: ../../reference/simple_stmts.rst:335

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

"Para nomes simples como alvos de atribuição, se no escopo de classe ou "

"módulo, as anotações são avaliadas e armazenadas em uma classe especial ou "

"atributo de módulo :attr:`__annotations__` que é um mapeamento de dicionário "

"de nomes de variáveis (desconfigurados se privados) para anotações "

"avaliadas. Este atributo é gravável e é criado automaticamente no início da "

"execução do corpo da classe ou módulo, se as anotações forem encontradas "

"estaticamente."

#: ../../reference/simple_stmts.rst:343

msgid ""

"For expressions as assignment targets, the annotations are evaluated if in "

"class or module scope, but not stored."

msgstr ""

"Para expressões como alvos de atribuição, as anotações são avaliadas se "

"estiverem no escopo da classe ou do módulo, mas não armazenadas."

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

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

"Se um nome for anotado em um escopo de função, esse nome será local para "

"esse escopo. As anotações nunca são avaliadas e armazenadas em escopos de "

"função."

#: ../../reference/simple_stmts.rst:349

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

"Se o lado direito estiver presente, uma atribuição anotada executa a "

"atribuição real antes de avaliar as anotações (quando aplicável). Se o lado "

"direito não estiver presente para um alvo de expressão, então o "

"interpretador avalia o alvo, exceto para a última chamada :meth:"

"`__setitem__` ou :meth:`__setattr__`."

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

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

msgstr ":pep:`526` - Sintaxe para Anotações de Variáveis"

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

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

"A proposta que adicionou sintaxe para anotar os tipos de variáveis "

"(incluindo variáveis de classe e variáveis de instância), em vez de expressá-"

"las por meio de comentários."

#: ../../reference/simple_stmts.rst:364

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

msgstr ":pep:`484` - Dicas de tipo"

#: ../../reference/simple_stmts.rst:363

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

"A proposta que adicionou o módulo :mod:`typing` para fornecer uma sintaxe "

"padrão para anotações de tipo que podem ser usadas em ferramentas de análise "

"estática e IDEs."

#: ../../reference/simple_stmts.rst:367

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

#: ../../reference/simple_stmts.rst:376

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

msgstr "A instrução :keyword:`!assert`"

#: ../../reference/simple_stmts.rst:383

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

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

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

#: ../../reference/simple_stmts.rst:394

msgid ""

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

msgstr ""

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

#: ../../reference/simple_stmts.rst:403

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

"Essas equivalências presumem que :const:`__debug__` e :exc:`AssertionError` "

"referem-se às variáveis embutidas com esses nomes. Na implementação atual, a "

"variável embutida :const:`__debug__` é ``True`` em circunstâncias normais, "

"``False`` quando a otimização é solicitada (opção de linha de comando :"

"option:`-O`). O gerador de código atual não emite código para uma instrução "

"assert quando a otimização é solicitada em tempo de compilação. Observe que "

"não é necessário incluir o código-fonte da expressão que falhou na mensagem "

"de erro; ele será exibido como parte do stack trace (situação da pilha de "

"execução)."

#: ../../reference/simple_stmts.rst:412

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

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

msgstr "A instrução :keyword:`!pass`"

#: ../../reference/simple_stmts.rst:429

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

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

msgstr "A instrução :keyword:`!del`"

#: ../../reference/simple_stmts.rst:451

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

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

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

"A exclusão de um nome remove a ligação desse nome do espaço de nomes local "

"ou global, dependendo se o nome ocorre em uma instrução :keyword:`global` no "

"mesmo bloco de código. Se o nome for desvinculado, uma exceção :exc:"

"`NameError` será levantada."

#: ../../reference/simple_stmts.rst:467

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

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

"Anteriormente, era ilegal excluir um nome do espaço de nomes local se ele "

"ocorresse como uma variável livre em um bloco aninhado."

#: ../../reference/simple_stmts.rst:480

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

msgstr "A instrução :keyword:`!return`"

#: ../../reference/simple_stmts.rst:490

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

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

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

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

"Quando :keyword:`return` passa o controle de uma instrução :keyword:`try` "

"com uma cláusula :keyword:`finally`, essa cláusula :keyword:`!finally` é "

"executada antes de realmente sair da função."

#: ../../reference/simple_stmts.rst:504

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

"Em uma função geradora, a instrução :keyword:`return` indica que o gerador "

"está pronto e fará com que :exc:`StopIteration` seja gerado. O valor "

"retornado (se houver) é usado como argumento para construir :exc:"

"`StopIteration` e se torna o atributo :attr:`StopIteration.value`."

#: ../../reference/simple_stmts.rst:509

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

"Em uma função de gerador assíncrono, uma instrução :keyword:`return` vazia "

"indica que o gerador assíncrono está pronto e fará com que :exc:"

"`StopAsyncIteration` seja gerado. Uma instrução :keyword:`!return` não vazia "

"é um erro de sintaxe em uma função de gerador assíncrono."

#: ../../reference/simple_stmts.rst:517

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

msgstr "A instrução :keyword:`!yield`"

#: ../../reference/simple_stmts.rst:529

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

"Uma instrução :keyword:`yield` é semanticamente equivalente a uma :ref:"

"`expressão yield <yieldexpr>`. A instrução yield pode ser usada para omitir "

"os parênteses que, de outra forma, seriam necessários na instrução de "

"expressão yield equivalente. Por exemplo, as instruções yield ::"

#: ../../reference/simple_stmts.rst:537

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

msgstr "são equivalentes às instruções de expressão yield ::"

#: ../../reference/simple_stmts.rst:542

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

"Expressões e instruções yield são usadas apenas ao definir uma função :term:"

"`geradora <gerador>` e são usadas apenas no corpo da função geradora. Usar "

"yield em uma definição de função é suficiente para fazer com que essa "

"definição crie uma função geradora em vez de uma função normal."

#: ../../reference/simple_stmts.rst:547

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

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

msgstr "A instrução :keyword:`!raise`"

#: ../../reference/simple_stmts.rst:564

msgid ""

"If no expressions are present, :keyword:`raise` re-raises the exception that "

"is currently being handled, which is also known as the *active exception*. "

"If there isn't currently an active exception, a :exc:`RuntimeError` "

"exception is raised indicating that this is an error."

msgstr ""

"Se nenhuma expressão estiver presente, :keyword:`raise` reativa a exceção "

"que está sendo tratada no momento, que também é conhecida como *exceção "

"ativa*. Se não houver uma exceção ativa no momento, uma exceção :exc:"

"`RuntimeError` é levantada indicando que isso é um erro."

#: ../../reference/simple_stmts.rst:569

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

"Caso contrário, :keyword:`raise` avalia a primeira expressão como o objeto "

"de exceção. Deve ser uma subclasse ou uma instância de :class:"

"`BaseException`. Se for uma classe, a instância de exceção será obtida "

"quando necessário instanciando a classe sem argumentos."

#: ../../reference/simple_stmts.rst:574

msgid ""

"The :dfn:`type` of the exception is the exception instance's class, the :dfn:"

"`value` is the instance itself."

msgstr ""

"O :dfn:`tipo` da exceção é a classe da instância de exceção, o :dfn:`valor` "

"é a própria instância."

#: ../../reference/simple_stmts.rst:579

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:`~BaseException.with_traceback` exception method (which "

"returns the same exception instance, with its traceback set to its "

"argument), like so::"

msgstr ""

"Um objeto traceback (situação da pilha de execução) normalmente é criado "

"automaticamente quando uma exceção é levantada e anexada a ele como o "

"atributo :attr:`__traceback__`, que é gravável. Você pode criar uma exceção "

"e definir seu próprio traceback em uma etapa usando o método de exceção :"

"meth:`~BaseException.with_traceback` (que retorna a mesma instância de "

"exceção, com seu traceback definido para seu argumento), assim::"

#: ../../reference/simple_stmts.rst:591

msgid ""

"The ``from`` clause is used for exception chaining: if given, the second "

"*expression* must be another exception class or instance. If the second "

"expression is an exception instance, it will be attached to the raised "

"exception as the :attr:`__cause__` attribute (which is writable). If the "

"expression is an exception class, the class will be instantiated and the "

"resulting exception instance will be attached to the raised exception as "

"the :attr:`__cause__` attribute. If the raised exception is not handled, "

"both exceptions will be printed::"

msgstr ""

"A cláusula ``from`` é usada para encadeamento de exceções: se fornecida, a "

"segunda expressão, *expression*, deve ser outra classe ou instância de "

"exceção. Se a segunda expressão for uma instância de exceção, ela será "

"anexada à exceção levantada como o atributo :attr:`__cause__` (que é "

"gravável). Se a expressão for uma classe de exceção, a classe será "

"instanciada e a instância de exceção resultante será anexada à exceção "

"levantada como o atributo :attr:`__cause__`. Se a exceção levantada não for "

"tratada, ambas as exceções serão impressas::"

#: ../../reference/simple_stmts.rst:615

msgid ""

"A similar mechanism works implicitly if a new exception is raised when an "

"exception is already being handled. An exception may be handled when an :"

"keyword:`except` or :keyword:`finally` clause, or a :keyword:`with` "

"statement, is used. The previous exception is then attached as the new "

"exception's :attr:`__context__` attribute::"

msgstr ""

"Um mecanismo semelhante funciona implicitamente se uma nova exceção for "

"levantada quando uma exceção já estiver sendo tratada. Uma exceção pode ser "

"tratada quando uma cláusula :keyword:`except` ou :keyword:`finally`, ou uma "

"instrução :keyword:`with`, é usada. A exceção anterior é então anexada como "

"o atributo :attr:`__context__` da nova exceção::"

#: ../../reference/simple_stmts.rst:636

msgid ""

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

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

msgstr ""

"O encadeamento de exceção pode ser explicitamente suprimido especificando :"

"const:`None` na cláusula ``from``::"

#: ../../reference/simple_stmts.rst:648

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

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

msgstr ":const:`None` agora é permitido como ``Y`` em ``raise X from Y``."

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

msgid ""

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

"exception context."

msgstr ""

"O atributo ``__suppress_context__`` para suprimir a exibição automática do "

"contexto de exceção."

#: ../../reference/simple_stmts.rst:661

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

msgstr "A instrução :keyword:`!break`"

#: ../../reference/simple_stmts.rst:672

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

msgid ""

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

"else` clause if the loop has one."

msgstr ""

"Ele termina o laço de fechamento mais próximo, pulando a cláusula opcional :"

"keyword:`!else` se o laço tiver uma."

#: ../../reference/simple_stmts.rst:682

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

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

"Quando :keyword:`break` passa o controle de uma instrução :keyword:`try` com "

"uma cláusula :keyword:`finally`, essa cláusula :keyword:`!finally` é "

"executada antes de realmente sair do laço."

#: ../../reference/simple_stmts.rst:695

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

msgstr "A instrução :keyword:`!continue`"

#: ../../reference/simple_stmts.rst:707

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

":keyword:`continue` 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. Ele continua com o próximo ciclo do "

"laço de fechamento mais próximo."

#: ../../reference/simple_stmts.rst:711

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

"Quando :keyword:`continue` passa o controle de uma instrução :keyword:`try` "

"com uma cláusula :keyword:`finally`, essa cláusula :keyword:`!finally` é "

"executada antes realmente iniciar o próximo ciclo do laço."

#: ../../reference/simple_stmts.rst:720

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

msgstr "A instrução :keyword:`!import`"

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

msgid ""

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

"steps:"

msgstr ""

"A instrução de importação básica (sem cláusula :keyword:`from`) é executada "

"em duas etapas:"

#: ../../reference/simple_stmts.rst:744

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

msgstr "encontra um módulo, carregando e inicializando-o se necessário"

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

msgid ""

"define a name or names in the local namespace for the scope where the :"

"keyword:`import` statement occurs."

msgstr ""

"define um nome ou nomes no espaço de nomes local para o escopo onde ocorre a "

"instrução :keyword:`import`."

#: ../../reference/simple_stmts.rst:748

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

"Quando a instrução contém várias cláusulas (separadas por vírgulas), as duas "

"etapas são executadas separadamente para cada cláusula, como se as cláusulas "

"tivessem sido separadas em instruções de importação individuais."

#: ../../reference/simple_stmts.rst:753