# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001-2026, 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

# Rafael Fontenelle <rffontenelle@gmail.com>, 2025

#

#, fuzzy

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2026-03-25 15:54+0000\n"

"PO-Revision-Date: 2025-09-15 01:05+0000\n"

"Last-Translator: Rafael Fontenelle <rffontenelle@gmail.com>, 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:37

msgid "Expression statements"

msgstr "Instruções de expressão"

#: ../../reference/simple_stmts.rst:44

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

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

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

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

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

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

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

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

msgid "Else:"

msgstr "Senão:"

#: ../../reference/simple_stmts.rst:130

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

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

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

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

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

#: ../../reference/simple_stmts.rst:146

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

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

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

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

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

msgid ""

"class Cls:\n"

" x = 3 # class variable\n"

"inst = Cls()\n"

"inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3"

msgstr ""

"class Cls:\n"

" x = 3 # variável de classe\n"

"inst = Cls()\n"

"inst.x = inst.x + 1 # escreve inst.x como 4 deixando Cls.x como 3"

#: ../../reference/simple_stmts.rst:184

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

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

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

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/value 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/valore 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:217

msgid ""

"For user-defined objects, the :meth:`~object.__setitem__` method is called "

"with appropriate arguments."

msgstr ""

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

"chamado com argumentos apropriados."

#: ../../reference/simple_stmts.rst:222

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

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

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

msgid ""

"x = [0, 1]\n"

"i = 0\n"

"i, x[i] = 1, 2 # i is updated, then x[i] is updated\n"

"print(x)"

msgstr ""

"x = [0, 1]\n"

"i = 0\n"

"i, x[i] = 1, 2 # i é atualizado e, em seguida, x[i] é atualizado\n"

"print(x)"

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

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

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

#: ../../reference/simple_stmts.rst:255

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

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

#: ../../reference/simple_stmts.rst:261

msgid "Augmented assignment statements"

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

#: ../../reference/simple_stmts.rst:279

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

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

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

msgid ""

"An augmented assignment statement 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 instruçã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:302

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

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

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

msgid "Annotated assignment statements"

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

#: ../../reference/simple_stmts.rst:327

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

msgid ""

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

"allowed."

msgstr ""

"A diferença para as :ref:`assignment` normal é que apenas um único alvo é "

"permitido."

#: ../../reference/simple_stmts.rst:336

msgid ""

"The assignment target is considered \"simple\" if it consists of a single "

"name that is not enclosed in parentheses. For simple 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 ""

"O alvo da atribuição é considerado “simples” se consistir em um único nome "

"que não esteja entre parênteses. Para alvos de atribuição simples, 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:346

msgid ""

"If the assignment target is not simple (an attribute, subscript node, or "

"parenthesized name), the annotation is evaluated if in class or module "

"scope, but not stored."

msgstr ""

"Se o alvo da atribuição não for simples (um atributo, nó subscrito ou nome "

"entre parênteses), a anotação será avaliada se estiver no escopo da classe "

"ou do módulo, mas não será armazenada."

#: ../../reference/simple_stmts.rst:350

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

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:`~object."

"__setitem__` or :meth:`~object.__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:`~object."

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

#: ../../reference/simple_stmts.rst:361

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

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

#: ../../reference/simple_stmts.rst:362

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

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

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

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

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

msgid ""

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

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

"tuple expressions) caused a syntax error."

msgstr ""

"Agora, as atribuições anotadas permitem as mesmas expressões no lado direito "

"que as atribuições regulares. Anteriormente, algumas expressões (como "

"expressões de tupla sem parênteses) causavam um erro de sintaxe."

#: ../../reference/simple_stmts.rst:380

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

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

#: ../../reference/simple_stmts.rst:387

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

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

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

#: ../../reference/simple_stmts.rst:395

msgid ""

"if __debug__:\n"

" if not expression: raise AssertionError"

msgstr ""

"if __debug__:\n"

" if not expression: raise AssertionError"

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

msgid ""

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

msgstr ""

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

#: ../../reference/simple_stmts.rst:400

msgid ""

"if __debug__:\n"

" if not expression1: raise AssertionError(expression2)"

msgstr ""

"if __debug__:\n"

" if not expression1: raise AssertionError(expression2)"

#: ../../reference/simple_stmts.rst:407

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

"keyword:`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 ``__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 :"

"keyword:`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:416

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

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

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

#: ../../reference/simple_stmts.rst:433

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

msgid ""

"def f(arg): pass # a function that does nothing (yet)\n"

"\n"

"class C: pass # a class with no methods (yet)"

msgstr ""

"def f(arg): pass # uma função que faz nada (ainda)\n"

"\n"

"class C: pass # uma classe com nenhum método (ainda)"

#: ../../reference/simple_stmts.rst:445

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

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

#: ../../reference/simple_stmts.rst:455

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

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

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. Trying to delete an unbound name raises "

"a :exc:`NameError` exception."

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. Tentar excluir um nome desvinculado levanta uma "

"exceção :exc:`NameError`."

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

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

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

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

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

#: ../../reference/simple_stmts.rst:494

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

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, será usado o valor ``None``."

#: ../../reference/simple_stmts.rst:499

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

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

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 uma exceção :exc:`StopIteration` seja levantada. "

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

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

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

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 uma exceção :exc:"

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

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

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

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

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

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

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

msgid ""

"yield <expr>\n"

"yield from <expr>"

msgstr ""

"yield <expr>\n"

"yield from <expr>"

#: ../../reference/simple_stmts.rst:541

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

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

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

msgid ""

"(yield <expr>)\n"

"(yield from <expr>)"

msgstr ""

"(yield <expr>)\n"

"(yield from <expr>)"

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

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

"keyword:`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:551

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

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

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

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

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

"tratamento no momento, 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:573

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

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

msgid ""

"A traceback object is normally created automatically when an exception is "

"raised and attached to it as the :attr:`~BaseException.__traceback__` "

"attribute. 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:`~BaseException.__traceback__`. 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:589

msgid "raise Exception(\"foo occurred\").with_traceback(tracebackobj)"

msgstr "raise Exception(\"ocorreu foo\").with_traceback(tracebackobj)"

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

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:`~BaseException.__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:`~BaseException.__cause__` "

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

"instanciada e a instância 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:604

msgid ""

">>> try:\n"

"... print(1 / 0)\n"

"... except Exception as exc:\n"

"... raise RuntimeError(\"Something bad happened\") from exc\n"

"...\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 2, in <module>\n"

" print(1 / 0)\n"

" ~~^~~\n"

"ZeroDivisionError: division by zero\n"

"\n"

"The above exception was the direct cause of the following exception:\n"

"\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 4, in <module>\n"

" raise RuntimeError(\"Something bad happened\") from exc\n"

"RuntimeError: Something bad happened"

msgstr ""

">>> try:\n"

"... print(1 / 0)\n"

"... except Exception as exc:\n"

"... raise RuntimeError(\"Something bad happened\") from exc\n"

"...\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 2, in <module>\n"

" print(1 / 0)\n"

" ~~^~~\n"

"ZeroDivisionError: division by zero\n"

"\n"

"The above exception was the direct cause of the following exception:\n"

"\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 4, in <module>\n"

" raise RuntimeError(\"Something bad happened\") from exc\n"

"RuntimeError: Something bad happened"

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

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:`~BaseException.__context__` attribute:"

msgstr ""

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

"levantada enquanto outra 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:`~BaseException.__context__` da nova exceção:"

#: ../../reference/simple_stmts.rst:630

msgid ""

">>> try:\n"

"... print(1 / 0)\n"

"... except:\n"

"... raise RuntimeError(\"Something bad happened\")\n"

"...\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 2, in <module>\n"

" print(1 / 0)\n"

" ~~^~~\n"