# SOME DESCRIPTIVE TITLE.

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

# Adorilson Bezerra <adorilson@gmail.com>, 2025

#

#, fuzzy

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2026-02-19 14:43+0000\n"

"PO-Revision-Date: 2025-09-16 00:02+0000\n"

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

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

"teams/5390/pt_BR/)\n"

"MIME-Version: 1.0\n"

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

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

"Language: pt_BR\n"

"Plural-Forms: nplurals=3; plural=(n == 0 || n == 1) ? 0 : n != 0 && n % "

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

#: ../../reference/compound_stmts.rst:5

msgid "Compound statements"

msgstr "Instruções compostas"

#: ../../reference/compound_stmts.rst:9

msgid ""

"Compound statements contain (groups of) other statements; they affect or "

"control the execution of those other statements in some way. In general, "

"compound statements span multiple lines, although in simple incarnations a "

"whole compound statement may be contained in one line."

msgstr ""

"Instruções compostas contém (grupos de) outras instruções; Elas afetam ou "

"controlam a execução dessas outras instruções de alguma maneira. Em geral, "

"instruções compostas abrangem múltiplas linhas, no entanto em algumas "

"manifestações simples uma instrução composta inteira pode estar contida em "

"uma linha."

#: ../../reference/compound_stmts.rst:14

msgid ""

"The :keyword:`if`, :keyword:`while` and :keyword:`for` statements implement "

"traditional control flow constructs. :keyword:`try` specifies exception "

"handlers and/or cleanup code for a group of statements, while the :keyword:"

"`with` statement allows the execution of initialization and finalization "

"code around a block of code. Function and class definitions are also "

"syntactically compound statements."

msgstr ""

"As instruções :keyword:`if`, :keyword:`while` e :keyword:`for` implementam "

"construções tradicionais de controle do fluxo de execução. :keyword:`try` "

"especifica tratadores de exceção e/ou código de limpeza para uma instrução "

"ou grupo de instruções, enquanto a palavra reservada :keyword:`with` permite "

"a execução de código de inicialização e finalização em volta de um bloco de "

"código. Definições de função e classe também são sintaticamente instruções "

"compostas."

#: ../../reference/compound_stmts.rst:26

msgid ""

"A compound statement consists of one or more 'clauses.' A clause consists "

"of a header and a 'suite.' The clause headers of a particular compound "

"statement are all at the same indentation level. Each clause header begins "

"with a uniquely identifying keyword and ends with a colon. A suite is a "

"group of statements controlled by a clause. A suite can be one or more "

"semicolon-separated simple statements on the same line as the header, "

"following the header's colon, or it can be one or more indented statements "

"on subsequent lines. Only the latter form of a suite can contain nested "

"compound statements; the following is illegal, mostly because it wouldn't be "

"clear to which :keyword:`if` clause a following :keyword:`else` clause would "

"belong::"

msgstr ""

"Uma instrução composta consiste em uma ou mais \"cláusulas\". Uma cláusula "

"consiste em um cabeçalho e um \"conjunto\". Os cabeçalhos das cláusulas de "

"uma instrução composta específica estão todos no mesmo nível de indentação. "

"Cada cabeçalho de cláusula começa com uma palavra reservada de identificação "

"exclusiva e termina com dois pontos. Um conjunto é um grupo de instruções "

"controladas por uma cláusula. Um conjunto pode ser uma ou mais instruções "

"simples separadas por ponto e vírgula na mesma linha do cabeçalho, após os "

"dois pontos do cabeçalho, ou pode ser uma ou mais instruções indentadas nas "

"linhas subsequentes. Somente a última forma de conjunto pode conter "

"instruções compostas aninhadas; o seguinte é ilegal, principalmente porque "

"não ficaria claro a qual cláusula :keyword:`if` a seguinte cláusula :keyword:"

"`else` pertenceria::"

#: ../../reference/compound_stmts.rst:37

msgid "if test1: if test2: print(x)"

msgstr "if test1: if test2: print(x)"

#: ../../reference/compound_stmts.rst:39

msgid ""

"Also note that the semicolon binds tighter than the colon in this context, "

"so that in the following example, either all or none of the :func:`print` "

"calls are executed::"

msgstr ""

"Observe também que o ponto e vírgula é mais vinculado que os dois pontos "

"neste contexto, de modo que no exemplo a seguir, todas ou nenhuma das "

"chamadas :func:`print` são executadas::"

#: ../../reference/compound_stmts.rst:43

msgid "if x < y < z: print(x); print(y); print(z)"

msgstr "if x < y < z: print(x); print(y); print(z)"

#: ../../reference/compound_stmts.rst:45

msgid "Summarizing:"

msgstr "Resumindo:"

#: ../../reference/compound_stmts.rst:69

msgid ""

"Note that statements always end in a ``NEWLINE`` possibly followed by a "

"``DEDENT``. Also note that optional continuation clauses always begin with "

"a keyword that cannot start a statement, thus there are no ambiguities (the "

"'dangling :keyword:`else`' problem is solved in Python by requiring nested :"

"keyword:`if` statements to be indented)."

msgstr ""

"Note que instruções sempre terminam em uma ``NEWLINE`` possivelmente seguida "

"por uma ``DEDENT``. Note também que cláusulas opcionais de continuação "

"sempre começam com uma palavra reservada que não pode iniciar uma instrução, "

"desta forma não há ambiguidades (o problema do \":keyword:`else` pendurado\" "

"é resolvido em Python obrigando que instruções :keyword:`if` aninhadas "

"tenham indentação)"

#: ../../reference/compound_stmts.rst:75

msgid ""

"The formatting of the grammar rules in the following sections places each "

"clause on a separate line for clarity."

msgstr ""

"A formatação das regras de gramática nas próximas seções põe cada cláusula "

"em uma linha separada para as tornar mais claras."

#: ../../reference/compound_stmts.rst:84

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

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

#: ../../reference/compound_stmts.rst:92

msgid "The :keyword:`if` statement is used for conditional execution:"

msgstr "A instrução :keyword:`if` é usada para execução condicional:"

#: ../../reference/compound_stmts.rst:99

msgid ""

"It selects exactly one of the suites by evaluating the expressions one by "

"one until one is found to be true (see section :ref:`booleans` for the "

"definition of true and false); then that suite is executed (and no other "

"part of the :keyword:`if` statement is executed or evaluated). If all "

"expressions are false, the suite of the :keyword:`else` clause, if present, "

"is executed."

msgstr ""

"Ela seleciona exatamente um dos conjuntos *suite* avaliando as expressões "

"*assigment_expression* uma por uma até que uma seja considerada verdadeira "

"(veja a seção :ref:`booleans` para a definição de verdadeiro e falso); então "

"esse conjunto é executado (e nenhuma outra parte da instrução :keyword:`if` "

"é executada ou avaliada). Se todas as expressões forem falsas, o *suite* da "

"cláusula :keyword:`else`, se presente, é executado."

#: ../../reference/compound_stmts.rst:109

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

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

#: ../../reference/compound_stmts.rst:117

msgid ""

"The :keyword:`while` statement is used for repeated execution as long as an "

"expression is true:"

msgstr ""

"A instrução :keyword:`while` é usada para execução repetida desde que uma "

"expressão seja verdadeira:"

#: ../../reference/compound_stmts.rst:124

msgid ""

"This repeatedly tests the expression and, if it is true, executes the first "

"suite; if the expression is false (which may be the first time it is tested) "

"the suite of the :keyword:`!else` clause, if present, is executed and the "

"loop terminates."

msgstr ""

"Isto testa repetidamente a expressão e, se for verdadeira, executa o "

"primeiro conjunto; se a expressão for falsa (o que pode ser a primeira vez "

"que ela é testada) o conjunto da cláusula :keyword:`!else`, se presente, é "

"executado e o laço termina."

#: ../../reference/compound_stmts.rst:133

msgid ""

"A :keyword:`break` statement executed in the first suite terminates the loop "

"without executing the :keyword:`!else` clause's suite. A :keyword:"

"`continue` statement executed in the first suite skips the rest of the suite "

"and goes back to testing the expression."

msgstr ""

"Uma instrução :keyword:`break` executada no primeiro conjunto termina o laço "

"sem executar o conjunto da cláusula :keyword:`!else`. Uma instrução :keyword:"

"`continue` executada no primeiro conjunto ignora o resto do conjunto e volta "

"a testar a expressão."

#: ../../reference/compound_stmts.rst:142

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

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

#: ../../reference/compound_stmts.rst:153

msgid ""

"The :keyword:`for` statement is used to iterate over the elements of a "

"sequence (such as a string, tuple or list) or other iterable object:"

msgstr ""

"A instrução :keyword:`for` é usada para iterar sobre os elementos de uma "

"sequência (como uma string, tupla ou lista) ou outro objeto iterável:"

#: ../../reference/compound_stmts.rst:160

msgid ""

"The :token:`~python-grammar:starred_expression_list` expression is evaluated "

"once; it should yield an :term:`iterable` object. An :term:`iterator` is "

"created for that iterable. The first item provided by the iterator is then "

"assigned to the target list using the standard rules for assignments (see :"

"ref:`assignment`), and the suite is executed. This repeats for each item "

"provided by the iterator. When the iterator is exhausted, the suite in the :"

"keyword:`!else` clause, if present, is executed, and the loop terminates."

msgstr ""

"A expressão :token:`~python-grammar:starred_expression_list` é avaliada uma "

"vez; deve produzir um objeto :term:`iterável`. Um :term:`iterador` é criado "

"para esse iterável. O primeiro item fornecido pelo iterador é então "

"atribuído à lista de alvos usando as regras padrão para atribuições (veja :"

"ref:`assignment`), e o conjunto é executado. Isso se repete para cada item "

"fornecido pelo iterador. Quando o iterador se esgota, o conjunto na "

"cláusula :keyword:`!else`, se presente, é executado e laço termina."

#: ../../reference/compound_stmts.rst:173

msgid ""

"A :keyword:`break` statement executed in the first suite terminates the loop "

"without executing the :keyword:`!else` clause's suite. A :keyword:"

"`continue` statement executed in the first suite skips the rest of the suite "

"and continues with the next item, or with the :keyword:`!else` clause if "

"there is no next item."

msgstr ""

"Uma instrução :keyword:`break` executada no primeiro conjunto termina o loop "

"sem executar o conjunto da cláusula :keyword:`!else`. Uma instrução :keyword:"

"`continue` executada no primeiro conjunto pula o resto do conjunto e "

"continua com o próximo item, ou com a cláusula :keyword:`!else` se não "

"houver próximo item."

#: ../../reference/compound_stmts.rst:179

msgid ""

"The for-loop makes assignments to the variables in the target list. This "

"overwrites all previous assignments to those variables including those made "

"in the suite of the for-loop::"

msgstr ""

"O laço for faz atribuições às variáveis na lista de destino. Isso substitui "

"todas as atribuições anteriores a essas variáveis, incluindo aquelas feitas "

"no conjunto do laço for::"

#: ../../reference/compound_stmts.rst:183

msgid ""

"for i in range(10):\n"

" print(i)\n"

" i = 5 # this will not affect the for-loop\n"

" # because i will be overwritten with the next\n"

" # index in the range"

msgstr ""

"for i in range(10):\n"

" print(i)\n"

" i = 5 # não afeta o laço for, porque i será\n"

" # substituída pelo índice seguinte no range"

#: ../../reference/compound_stmts.rst:193

msgid ""

"Names in the target list are not deleted when the loop is finished, but if "

"the sequence is empty, they will not have been assigned to at all by the "

"loop. Hint: the built-in type :func:`range` represents immutable arithmetic "

"sequences of integers. For instance, iterating ``range(3)`` successively "

"yields 0, 1, and then 2."

msgstr ""

"Os nomes na lista de destinos não são excluídos quando o laço termina, mas "

"se a sequência estiver vazia, eles não serão atribuídos pelo laço. Dica: o "

"tipo embutido :func:`range` representa sequências aritméticas imutáveis de "

"inteiros. Por exemplo, iterar ``range(3)`` sucessivamente produz 0, 1 e "

"depois 2."

#: ../../reference/compound_stmts.rst:198

msgid "Starred elements are now allowed in the expression list."

msgstr ""

"Elementos marcados com estrela agora são permitidos na lista de expressões."

#: ../../reference/compound_stmts.rst:205

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

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

#: ../../reference/compound_stmts.rst:215

msgid ""

"The :keyword:`!try` statement specifies exception handlers and/or cleanup "

"code for a group of statements:"

msgstr ""

"A instrução :keyword:`!try` especifica manipuladores de exceção e/ou código "

"de limpeza para um grupo de instruções:"

#: ../../reference/compound_stmts.rst:231

msgid ""

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

"`exceptions`, and information on using the :keyword:`raise` statement to "

"generate exceptions may be found in section :ref:`raise`."

msgstr ""

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

"`exceptions`, e informações sobre como usar a instrução :keyword:`raise` "

"para gerar exceções podem ser encontradas na seção :ref:`raise`."

#: ../../reference/compound_stmts.rst:235

msgid ""

"Support for optionally dropping grouping parentheses when using multiple "

"exception types. See :pep:`758`."

msgstr ""

"Suporte para a remoção opcional de parênteses de agrupamento ao usar vários "

"tipos de exceção. Veja :pep:`758`."

#: ../../reference/compound_stmts.rst:241

msgid ":keyword:`!except` clause"

msgstr "Cláusula :keyword:`!except`"

#: ../../reference/compound_stmts.rst:243

msgid ""

"The :keyword:`!except` clause(s) specify one or more exception handlers. "

"When no exception occurs in the :keyword:`try` clause, no exception handler "

"is executed. When an exception occurs in the :keyword:`!try` suite, a search "

"for an exception handler is started. This search inspects the :keyword:`!"

"except` clauses in turn until one is found that matches the exception. An "

"expression-less :keyword:`!except` clause, if present, must be last; it "

"matches any exception."

msgstr ""

"As cláusulas :keyword:`!except` especificam um ou mais manipuladores de "

"exceção. Quando nenhuma exceção ocorre na cláusula :keyword:`try`, nenhum "

"manipulador de exceção é executado. Quando uma exceção ocorre no bloco :"

"keyword:`!try`, uma busca por um manipulador de exceção é iniciada. Essa "

"busca inspeciona as cláusulas :keyword:`!except` por vez até encontrar uma "

"que corresponda à exceção. Uma cláusula :keyword:`!except` sem expressão, se "

"presente, deve ser a última; ela corresponde a qualquer exceção."

#: ../../reference/compound_stmts.rst:251

msgid ""

"For an :keyword:`!except` clause with an expression, the expression must "

"evaluate to an exception type or a tuple of exception types. Parentheses can "

"be dropped if multiple exception types are provided and the ``as`` clause is "

"not used. The raised exception matches an :keyword:`!except` clause whose "

"expression evaluates to the class or a :term:`non-virtual base class "

"<abstract base class>` of the exception object, or to a tuple that contains "

"such a class."

msgstr ""

"Para uma cláusula :keyword:`!except` com uma expressão, a expressão deve ser "

"avaliada como um tipo de exceção ou como uma tupla de tipos de exceção. "

"Parênteses podem ser omitidos se vários tipos de exceção forem fornecidos e "

"a cláusula ``as`` não for usada. A exceção levantada corresponde a uma "

"cláusula :keyword:`!except` cuja expressão é avaliada como a classe ou uma :"

"term:`classe base não virtual <abstract base class>` do objeto exceção, ou "

"como uma tupla que contém tal classe."

#: ../../reference/compound_stmts.rst:258

msgid ""

"If no :keyword:`!except` clause matches the exception, the search for an "

"exception handler continues in the surrounding code and on the invocation "

"stack. [#]_"

msgstr ""

"Se nenhuma cláusula :keyword:`!except` corresponder à exceção, a busca por "

"um manipulador de exceção continua no código circundante e na pilha de "

"invocação. [#]_"

#: ../../reference/compound_stmts.rst:262

msgid ""

"If the evaluation of an expression in the header of an :keyword:`!except` "

"clause raises an exception, the original search for a handler is canceled "

"and a search starts for the new exception in the surrounding code and on the "

"call stack (it is treated as if the entire :keyword:`try` statement raised "

"the exception)."

msgstr ""

"Se a avaliação de uma expressão no cabeçalho de uma cláusula :keyword:`!"

"except` levantar uma exceção, a busca original por um manipulador será "

"cancelada e uma busca pela nova exceção será iniciada no código circundante "

"e na pilha de chamadas (ela é tratada como se toda a instrução :keyword:"

"`try` levantasse a exceção)."

#: ../../reference/compound_stmts.rst:270

msgid ""

"When a matching :keyword:`!except` clause is found, the exception is "

"assigned to the target specified after the :keyword:`!as` keyword in that :"

"keyword:`!except` clause, if present, and the :keyword:`!except` clause's "

"suite is executed. All :keyword:`!except` clauses must have an executable "

"block. When the end of this block is reached, execution continues normally "

"after the entire :keyword:`try` statement. (This means that if two nested "

"handlers exist for the same exception, and the exception occurs in the :"

"keyword:`!try` clause of the inner handler, the outer handler will not "

"handle the exception.)"

msgstr ""

"Quando uma cláusula :keyword:`!except` correspondente é encontrada, a "

"exceção é atribuída ao destino especificado após a palavra reservada :"

"keyword:`!as` nessa cláusula :keyword:`!except`, se presente, e o conjunto "

"da cláusula :keyword:`!except` é executado. Todas as cláusulas :keyword:`!"

"except` devem ter um bloco executável. Quando o final deste bloco é "

"atingido, a execução continua normalmente após toda a instrução :keyword:"

"`try`. (Isso significa que, se existirem dois manipuladores aninhados para a "

"mesma exceção e a exceção ocorrer na cláusula :keyword:`!try` do manipulador "

"interno, o manipulador externo não tratará a exceção.)"

#: ../../reference/compound_stmts.rst:281

msgid ""

"When an exception has been assigned using ``as target``, it is cleared at "

"the end of the :keyword:`!except` clause. This is as if ::"

msgstr ""

"Quando uma exceção é atribuída usando ``as target``, ela é limpa no final da "

"cláusula :keyword:`!except`. É como se ::"

#: ../../reference/compound_stmts.rst:284

msgid ""

"except E as N:\n"

" foo"

msgstr ""

"except E as N:\n"

" foo"

#: ../../reference/compound_stmts.rst:287

msgid "was translated to ::"

msgstr "fosse traduzido para ::"

#: ../../reference/compound_stmts.rst:289

msgid ""

"except E as N:\n"

" try:\n"

" foo\n"

" finally:\n"

" del N"

msgstr ""

"except E as N:\n"

" try:\n"

" foo\n"

" finally:\n"

" del N"

#: ../../reference/compound_stmts.rst:295

msgid ""

"This means the exception must be assigned to a different name to be able to "

"refer to it after the :keyword:`!except` clause. Exceptions are cleared "

"because with the traceback attached to them, they form a reference cycle "

"with the stack frame, keeping all locals in that frame alive until the next "

"garbage collection occurs."

msgstr ""

"Isso significa que a exceção deve ser atribuída a um nome diferente para "

"poder ser referenciada após a cláusula :keyword:`!except`. As exceções são "

"limpas porque, com o traceback (situação da pilha de execução) anexado a "

"elas, formam um ciclo de referência com o quadro de pilha, mantendo todos os "

"locais nesse quadro vivos até que ocorra a próxima coleta de lixo."

#: ../../reference/compound_stmts.rst:305

msgid ""

"Before an :keyword:`!except` clause's suite is executed, the exception is "

"stored in the :mod:`sys` module, where it can be accessed from within the "

"body of the :keyword:`!except` clause by calling :func:`sys.exception`. When "

"leaving an exception handler, the exception stored in the :mod:`sys` module "

"is reset to its previous value::"

msgstr ""

"Antes de um conjunto de cláusulas :keyword:`!except` ser executado, a "

"exceção é armazenada no módulo :mod:`sys`, onde pode ser acessada no corpo "

"da cláusula :keyword:`!except` chamando :func:`sys.exception`. Ao sair de um "

"manipulador de exceções, a exceção armazenada no módulo :mod:`sys` é "

"redefinida para seu valor anterior::"

#: ../../reference/compound_stmts.rst:311

msgid ""

">>> print(sys.exception())\n"

"None\n"

">>> try:\n"

"... raise TypeError\n"

"... except:\n"

"... print(repr(sys.exception()))\n"

"... try:\n"

"... raise ValueError\n"

"... except:\n"

"... print(repr(sys.exception()))\n"

"... print(repr(sys.exception()))\n"

"...\n"

"TypeError()\n"

"ValueError()\n"

"TypeError()\n"

">>> print(sys.exception())\n"

"None"

msgstr ""

">>> print(sys.exception())\n"

"None\n"

">>> try:\n"

"... raise TypeError\n"

"... except:\n"

"... print(repr(sys.exception()))\n"

"... try:\n"

"... raise ValueError\n"

"... except:\n"

"... print(repr(sys.exception()))\n"

"... print(repr(sys.exception()))\n"

"...\n"

"TypeError()\n"

"ValueError()\n"

"TypeError()\n"

">>> print(sys.exception())\n"

"None"

#: ../../reference/compound_stmts.rst:336

msgid ":keyword:`!except*` clause"

msgstr "Cláusula :keyword:`!except*`"

#: ../../reference/compound_stmts.rst:338

msgid ""

"The :keyword:`!except*` clause(s) specify one or more handlers for groups of "

"exceptions (:exc:`BaseExceptionGroup` instances). A :keyword:`try` statement "

"can have either :keyword:`except` or :keyword:`!except*` clauses, but not "

"both. The exception type for matching is mandatory in the case of :keyword:`!"

"except*`, so ``except*:`` is a syntax error. The type is interpreted as in "

"the case of :keyword:`!except`, but matching is performed on the exceptions "

"contained in the group that is being handled. An :exc:`TypeError` is raised "

"if a matching type is a subclass of :exc:`!BaseExceptionGroup`, because that "

"would have ambiguous semantics."

msgstr ""

"A cláusula :keyword:`!except*` especifica um ou mais manipuladores para "

"grupos de exceções (instâncias de :exc:`BaseExceptionGroup`). Uma instrução :"

"keyword:`try` pode ter cláusulas :keyword:`except` ou :keyword:`!except*`, "

"mas não ambas. O tipo de exceção para correspondência é obrigatório no caso "

"de :keyword:`!except*`, portanto, ``except*:`` resulta em um erro de "

"sintaxe. O tipo é interpretado como no caso de :keyword:`!except`, mas a "

"correspondência é realizada com as exceções contidas no grupo que está sendo "

"tratado. Uma exceção :exc:`TypeError` é levantada se um tipo correspondente "

"for uma subclasse de :exc:`!BaseExceptionGroup`, pois isso teria uma "

"semântica ambígua."

#: ../../reference/compound_stmts.rst:348

msgid ""

"When an exception group is raised in the try block, each :keyword:`!except*` "

"clause splits (see :meth:`~BaseExceptionGroup.split`) it into the subgroups "

"of matching and non-matching exceptions. If the matching subgroup is not "

"empty, it becomes the handled exception (the value returned from :func:`sys."

"exception`) and assigned to the target of the :keyword:`!except*` clause (if "

"there is one). Then, the body of the :keyword:`!except*` clause executes. If "

"the non-matching subgroup is not empty, it is processed by the next :keyword:"

"`!except*` in the same manner. This continues until all exceptions in the "

"group have been matched, or the last :keyword:`!except*` clause has run."

msgstr ""

"Quando um grupo de exceções é levantado dentro de um bloco try, cada "

"cláusula :keyword:`!except*` o divide (consulte :meth:`~BaseExceptionGroup."

"split`) em subgrupos de exceções correspondentes e não correspondentes. Se o "

"subgrupo correspondente não estiver vazio, ele se torna a exceção tratada (o "

"valor retornado por :func:`sys.exception`) e é atribuído ao alvo da "

"cláusula :keyword:`!except*` (se houver). Em seguida, o corpo da cláusula :"

"keyword:`!except*` é executado. Se o subgrupo não correspondente não estiver "

"vazio, ele é processado pela próxima cláusula :keyword:`!except*` da mesma "

"maneira. Isso continua até que todas as exceções do grupo tenham sido "

"tratadas ou até que a última cláusula :keyword:`!except*` tenha sido "

"executada."

#: ../../reference/compound_stmts.rst:358

msgid ""

"After all :keyword:`!except*` clauses execute, the group of unhandled "

"exceptions is merged with any exceptions that were raised or re-raised from "

"within :keyword:`!except*` clauses. This merged exception group propagates "

"on.::"

msgstr ""

"Após a execução de todas as cláusulas :keyword:`!except*`, o grupo de "

"exceções não tratadas é mesclado com quaisquer exceções que foram levantadas "

"uma ou mais vezes em cláusulas :keyword:`!except*`. Esse grupo de exceções "

"mesclado se propaga."

#: ../../reference/compound_stmts.rst:362

msgid ""

">>> try:\n"

"... raise ExceptionGroup(\"eg\",\n"

"... [ValueError(1), TypeError(2), OSError(3), OSError(4)])\n"

"... except* TypeError as e:\n"

"... print(f'caught {type(e)} with nested {e.exceptions}')\n"

"... except* OSError as e:\n"

"... print(f'caught {type(e)} with nested {e.exceptions}')\n"

"...\n"

"caught <class 'ExceptionGroup'> with nested (TypeError(2),)\n"

"caught <class 'ExceptionGroup'> with nested (OSError(3), OSError(4))\n"

" + Exception Group Traceback (most recent call last):\n"

" | File \"<doctest default[0]>\", line 2, in <module>\n"

" | raise ExceptionGroup(\"eg\",\n"

" | [ValueError(1), TypeError(2), OSError(3), OSError(4)])\n"

" | ExceptionGroup: eg (1 sub-exception)\n"

" +-+---------------- 1 ----------------\n"

" | ValueError: 1\n"

" +------------------------------------"

msgstr ""

">>> try:\n"

"... raise ExceptionGroup(\"eg\",\n"

"... [ValueError(1), TypeError(2), OSError(3), OSError(4)])\n"

"... except* TypeError as e:\n"

"... print(f'caught {type(e)} with nested {e.exceptions}')\n"

"... except* OSError as e:\n"

"... print(f'caught {type(e)} with nested {e.exceptions}')\n"

"...\n"

"caught <class 'ExceptionGroup'> with nested (TypeError(2),)\n"

"caught <class 'ExceptionGroup'> with nested (OSError(3), OSError(4))\n"

" + Exception Group Traceback (most recent call last):\n"

" | File \"<doctest default[0]>\", line 2, in <module>\n"

" | raise ExceptionGroup(\"eg\",\n"

" | [ValueError(1), TypeError(2), OSError(3), OSError(4)])\n"

" | ExceptionGroup: eg (1 sub-exception)\n"

" +-+---------------- 1 ----------------\n"

" | ValueError: 1\n"

" +------------------------------------"

#: ../../reference/compound_stmts.rst:381

msgid ""

"If the exception raised from the :keyword:`try` block is not an exception "

"group and its type matches one of the :keyword:`!except*` clauses, it is "

"caught and wrapped by an exception group with an empty message string. This "

"ensures that the type of the target ``e`` is consistently :exc:"

"`BaseExceptionGroup`::"

msgstr ""

"Se a exceção levantada do bloco :keyword:`try` não for um grupo de exceções "

"e seu tipo corresponder a uma das cláusulas :keyword:`!except*`, ela será "

"capturada e encapsulada por um grupo de exceções com uma string de mensagem "

"vazia. Isso garante que o tipo do alvo ``e`` seja :exc:`BaseExceptionGroup` "

"de forma consistente::"

#: ../../reference/compound_stmts.rst:386

msgid ""

">>> try:\n"

"... raise BlockingIOError\n"

"... except* BlockingIOError as e:\n"

"... print(repr(e))\n"

"...\n"

"ExceptionGroup('', (BlockingIOError(),))"

msgstr ""

#: ../../reference/compound_stmts.rst:393

msgid ""

":keyword:`break`, :keyword:`continue` and :keyword:`return` cannot appear in "

"an :keyword:`!except*` clause."

msgstr ""

":keyword:`break`, :keyword:`continue` e :keyword:`return` não podem aparecer "

"em uma cláusula :keyword:`!except*`."

#: ../../reference/compound_stmts.rst:406

msgid ":keyword:`!else` clause"

msgstr "Cláusula :keyword:`!else`"

#: ../../reference/compound_stmts.rst:408

msgid ""

"The optional :keyword:`!else` clause is executed if the control flow leaves "

"the :keyword:`try` suite, no exception was raised, and no :keyword:"

"`return`, :keyword:`continue`, or :keyword:`break` statement was executed. "

"Exceptions in the :keyword:`!else` clause are not handled by the preceding :"

"keyword:`except` clauses."

msgstr ""

"A cláusula opcional :keyword:`!else` é executada se o fluxo de controle "

"deixar o conjunto :keyword:`try`, nenhuma exceção foi levantada e nenhuma "

"instrução :keyword:`return`, :keyword:`continue` ou :keyword:`break` foi "

"executada. Exceções na cláusula :keyword:`!else` não são manipuladas pelas "

"cláusulas :keyword:`except` precedentes."

#: ../../reference/compound_stmts.rst:420

msgid ":keyword:`!finally` clause"

msgstr "Cláusula :keyword:`!finally`"

#: ../../reference/compound_stmts.rst:422

msgid ""

"If :keyword:`!finally` is present, it specifies a 'cleanup' handler. The :"

"keyword:`try` clause is executed, including any :keyword:`except` and :"

"keyword:`else <except_else>` clauses. If an exception occurs in any of the "

"clauses and is not handled, the exception is temporarily saved. The :keyword:"

"`!finally` clause is executed. If there is a saved exception it is re-"

"raised at the end of the :keyword:`!finally` clause. If the :keyword:`!"

"finally` clause raises another exception, the saved exception is set as the "

"context of the new exception. If the :keyword:`!finally` clause executes a :"

"keyword:`return`, :keyword:`break` or :keyword:`continue` statement, the "

"saved exception is discarded. For example, this function returns 42."

msgstr ""

"Se :keyword:`!finally` estiver presente, especifica um manipulador de "

"\"limpeza\". A cláusula :keyword:`try` é executada, incluindo quaisquer "

"cláusulas :keyword:`except` e :keyword:`else <except_else>`. Se uma exceção "

"ocorrer em qualquer uma das cláusulas e não for tratada, a exceção será "

"salva temporariamente. A cláusula :keyword:`!finally` é executada. Se houver "

"uma exceção salva, ela será levantada novamente no final da cláusula :"

"keyword:`!finally`. Se a cláusula :keyword:`!finally` levantar outra "

"exceção, a exceção salva será definida como o contexto da nova exceção. Se a "

"cláusula :keyword:`!finally` executar uma instrução :keyword:`return`, :"

"keyword:`break` ou :keyword:`continue`, a exceção salva será descartada. Por "

"exemplo, esta função retorna 42."

#: ../../reference/compound_stmts.rst:435

msgid ""

"def f():\n"

" try:\n"

" 1/0\n"

" finally:\n"

" return 42"

msgstr ""

"def f():\n"

" try:\n"

" 1/0\n"

" finally:\n"

" return 42"

#: ../../reference/compound_stmts.rst:443

msgid ""

"The exception information is not available to the program during execution "

"of the :keyword:`!finally` clause."

msgstr ""

"As informações de exceção não estão disponíveis para o programa durante a "

"execução da cláusula :keyword:`!finally`."

#: ../../reference/compound_stmts.rst:451

msgid ""

"When a :keyword:`return`, :keyword:`break` or :keyword:`continue` statement "

"is executed in the :keyword:`try` suite of a :keyword:`!try`...\\ :keyword:`!"

"finally` statement, the :keyword:`!finally` clause is also executed 'on the "

"way out.'"

msgstr ""

"Quando uma instrução :keyword:`return`, :keyword:`break` ou :keyword:"

"`continue` é executada no conjunto :keyword:`try` de uma instrução :keyword:"

"`!try`...\\ :keyword:`!finally`, a cláusula :keyword:`!finally` também é "

"executada \"na saída\"."

#: ../../reference/compound_stmts.rst:455

msgid ""

"The return value of a function is determined by the last :keyword:`return` "

"statement executed. Since the :keyword:`!finally` clause always executes, "

"a :keyword:`!return` statement executed in the :keyword:`!finally` clause "

"will always be the last one executed. The following function returns "

"'finally'."

msgstr ""

"O valor de retorno de uma função é determinado pela última instrução :"

"keyword:`return` executada. Como a cláusula :keyword:`!finally` sempre é "

"executada, uma instrução :keyword:`!return` executada na cláusula :keyword:`!"

"finally` sempre será a última executada. A função a seguir retorna "

"\"finally\"."

#: ../../reference/compound_stmts.rst:460

msgid ""

"def foo():\n"

" try:\n"

" return 'try'\n"

" finally:\n"

" return 'finally'"

msgstr ""

"def foo():\n"

" try:\n"

" return 'try'\n"

" finally:\n"

" return 'finally'"

#: ../../reference/compound_stmts.rst:468

msgid ""

"Prior to Python 3.8, a :keyword:`continue` statement was illegal in the :"

"keyword:`!finally` clause due to a problem with the implementation."

msgstr ""

"Antes do Python 3.8, uma instrução :keyword:`continue` era ilegal na "

"cláusula :keyword:`!finally` devido a um problema com a implementação."

#: ../../reference/compound_stmts.rst:472

msgid ""

"The compiler emits a :exc:`SyntaxWarning` when a :keyword:`return`, :keyword:"

"`break` or :keyword:`continue` appears in a :keyword:`!finally` block (see :"

"pep:`765`)."

msgstr ""

"O compilador emite uma exceção :exc:`SyntaxWarning` quando um :keyword:"

"`return`, :keyword:`break` ou :keyword:`continue` aparece em um bloco :"

"keyword:`!finally` (veja :pep:`765`)."

#: ../../reference/compound_stmts.rst:482

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

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

#: ../../reference/compound_stmts.rst:491

msgid ""

"The :keyword:`with` statement is used to wrap the execution of a block with "

"methods defined by a context manager (see section :ref:`context-managers`). "

"This allows common :keyword:`try`...\\ :keyword:`except`...\\ :keyword:"

"`finally` usage patterns to be encapsulated for convenient reuse."

msgstr ""

"A instrução :keyword:`with` envolve a execução de um bloco com métodos "

"definidos por um gerenciador de contexto (veja a seção :ref:`context-"

"managers`). Isso permite que padrões comuns de uso de :keyword:`try`...\\ :"

"keyword:`except`...\\ :keyword:`finally` sejam encapsulados para "

"reutilização conveniente."

#: ../../reference/compound_stmts.rst:501

msgid ""

"The execution of the :keyword:`with` statement with one \"item\" proceeds as "

"follows:"

msgstr ""

"A execução da instrução :keyword:`with` com um \"item\" ocorre da seguinte "

"maneira:"

#: ../../reference/compound_stmts.rst:503

msgid ""

"The context expression (the expression given in the :token:`~python-grammar:"

"with_item`) is evaluated to obtain a context manager."

msgstr ""

"A expressão de contexto (a expressão fornecida em :token:`~python-grammar:"

"with_item`) é avaliada para obter um gerenciador de contexto."

#: ../../reference/compound_stmts.rst:506

msgid ""

"The context manager's :meth:`~object.__enter__` is loaded for later use."

msgstr ""

"O método :meth:`~object.__enter__` do gerenciador de contexto é carregado "

"para uso posterior."

#: ../../reference/compound_stmts.rst:508

msgid "The context manager's :meth:`~object.__exit__` is loaded for later use."

msgstr ""

"O método :meth:`~object.__exit__` do gerenciador de contexto é carregado "

"para uso posterior."

#: ../../reference/compound_stmts.rst:510

msgid "The context manager's :meth:`~object.__enter__` method is invoked."

msgstr ""

"O método :meth:`~object.__enter__` do gerenciador de contexto é invocado."

#: ../../reference/compound_stmts.rst:512

msgid ""

"If a target was included in the :keyword:`with` statement, the return value "

"from :meth:`~object.__enter__` is assigned to it."

msgstr ""

"Se um alvo foi incluído na instrução :keyword:`with`, o valor de retorno de :"

"meth:`~object.__enter__` é atribuído a esse alvo."

#: ../../reference/compound_stmts.rst:517

msgid ""

"The :keyword:`with` statement guarantees that if the :meth:`~object."

"__enter__` method returns without an error, then :meth:`~object.__exit__` "

"will always be called. Thus, if an error occurs during the assignment to the "

"target list, it will be treated the same as an error occurring within the "

"suite would be. See step 7 below."

msgstr ""

"A instrução :keyword:`with` garante que, se o método :meth:`~object."

"__enter__` retornar sem erro, :meth:`~object.__exit__` sempre será chamado. "

"Assim, se ocorrer um erro durante a atribuição à lista de alvos, ele será "

"tratado da mesma forma que um erro ocorrendo dentro do conjunto seria. Veja "

"a etapa 7 abaixo."

#: ../../reference/compound_stmts.rst:523

msgid "The suite is executed."

msgstr "O conjunto *suite* é executado."

#: ../../reference/compound_stmts.rst:525

msgid ""

"The context manager's :meth:`~object.__exit__` method is invoked. If an "

"exception caused the suite to be exited, its type, value, and traceback are "

"passed as arguments to :meth:`~object.__exit__`. Otherwise, three :const:"

"`None` arguments are supplied."

msgstr ""

"O método :meth:`~object.__exit__` do gerenciador de contexto é invocado. Se "

"uma exceção fez com que o conjunto fosse encerrado, seu tipo, valor e "

"traceback são passados como argumentos para :meth:`~object.__exit__`. Caso "

"contrário, três argumentos :const:`None` são fornecidos."

#: ../../reference/compound_stmts.rst:530

msgid ""

"If the suite was exited due to an exception, and the return value from the :"

"meth:`~object.__exit__` method was false, the exception is reraised. If the "

"return value was true, the exception is suppressed, and execution continues "

"with the statement following the :keyword:`with` statement."

msgstr ""

"Se o conjunto foi encerrado devido a uma exceção, e o valor de retorno do "

"método :meth:`~object.__exit__` for falso, a exceção é levantada novamente. "

"Se o valor de retorno era verdadeiro, a exceção é suprimida, e a execução "

"continua com a instrução após a instrução :keyword:`with`."

#: ../../reference/compound_stmts.rst:535

msgid ""

"If the suite was exited for any reason other than an exception, the return "

"value from :meth:`~object.__exit__` is ignored, and execution proceeds at "

"the normal location for the kind of exit that was taken."

msgstr ""

"Se o conjunto foi encerrado por qualquer motivo diferente de uma exceção, o "

"valor de retorno de :meth:`~object.__exit__` é ignorado e a execução "

"prossegue no local normal para o tipo de saída que foi gerada."

#: ../../reference/compound_stmts.rst:539

#: ../../reference/compound_stmts.rst:1560

#: ../../reference/compound_stmts.rst:1601

msgid "The following code::"

msgstr "O seguinte código::"

#: ../../reference/compound_stmts.rst:541

msgid ""

"with EXPRESSION as TARGET:\n"

" SUITE"

msgstr ""

"with EXPRESSION as TARGET:\n"

" SUITE"

#: ../../reference/compound_stmts.rst:544

#: ../../reference/compound_stmts.rst:572

#: ../../reference/compound_stmts.rst:1606

msgid "is semantically equivalent to::"

msgstr "é semanticamente equivalente a::"

#: ../../reference/compound_stmts.rst:546

msgid ""

"manager = (EXPRESSION)\n"

"enter = manager.__enter__\n"

"exit = manager.__exit__\n"

"value = enter()\n"

"hit_except = False\n"

"\n"

"try:\n"

" TARGET = value\n"

" SUITE\n"

"except:\n"

" hit_except = True\n"

" if not exit(*sys.exc_info()):\n"

" raise\n"

"finally:\n"

" if not hit_except:\n"

" exit(None, None, None)"

msgstr ""

#: ../../reference/compound_stmts.rst:563

msgid ""

"except that implicit :ref:`special method lookup <special-lookup>` is used "

"for :meth:`~object.__enter__` and :meth:`~object.__exit__`."

msgstr ""

#: ../../reference/compound_stmts.rst:566

msgid ""

"With more than one item, the context managers are processed as if multiple :"

"keyword:`with` statements were nested::"

msgstr ""

"Com mais de um item, os gerenciadores de contexto são processados como se "

"várias instruções :keyword:`with` estivessem aninhadas::"

#: ../../reference/compound_stmts.rst:569

msgid ""

"with A() as a, B() as b:\n"

" SUITE"

msgstr ""

"with A() as a, B() as b:\n"

" SUITE"

#: ../../reference/compound_stmts.rst:574

msgid ""

"with A() as a:\n"

" with B() as b:\n"

" SUITE"

msgstr ""

"with A() as a:\n"

" with B() as b:\n"

" SUITE"

#: ../../reference/compound_stmts.rst:578

msgid ""

"You can also write multi-item context managers in multiple lines if the "

"items are surrounded by parentheses. For example::"

msgstr ""

"Você também pode escrever gerenciadores de contexto multi-item em várias "

"linhas se os itens estiverem entre parênteses. Por exemplo::"

#: ../../reference/compound_stmts.rst:581

msgid ""

"with (\n"

" A() as a,\n"

" B() as b,\n"

"):\n"

" SUITE"

msgstr ""

"with (\n"

" A() as a,\n"

" B() as b,\n"

"):\n"

" SUITE"

#: ../../reference/compound_stmts.rst:587

msgid "Support for multiple context expressions."

msgstr "Suporte para múltiplas expressões de contexto."

#: ../../reference/compound_stmts.rst:590

msgid ""

"Support for using grouping parentheses to break the statement in multiple "

"lines."

msgstr ""

"Suporte para usar parênteses de agrupamento para dividir a instrução em "

"várias linhas."

#: ../../reference/compound_stmts.rst:595

msgid ":pep:`343` - The \"with\" statement"

msgstr ":pep:`343` - A instrução \"with\""

#: ../../reference/compound_stmts.rst:596

msgid ""

"The specification, background, and examples for the Python :keyword:`with` "

"statement."

msgstr ""

"A especificação, o histórico e os exemplos da instrução Python :keyword:"

"`with`."

#: ../../reference/compound_stmts.rst:603

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

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

#: ../../reference/compound_stmts.rst:617

msgid "The match statement is used for pattern matching. Syntax:"

msgstr "A instrução match é usada para correspondência de padrões. Sintaxe:"

#: ../../reference/compound_stmts.rst:626

msgid ""

"This section uses single quotes to denote :ref:`soft keywords <soft-"

"keywords>`."

msgstr ""

"Esta seção usa aspas simples para denotar :ref:`palavras reservadas "