# 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
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.11\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-03-23 17:42+0000\n"
"PO-Revision-Date: 2025-09-22 16:51+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"

#: ../../tutorial/errors.rst:5
msgid "Errors and Exceptions"
msgstr "Erros e exceções"

#: ../../tutorial/errors.rst:7
msgid ""
"Until now error messages haven't been more than mentioned, but if you have "
"tried out the examples you have probably seen some.  There are (at least) "
"two distinguishable kinds of errors: *syntax errors* and *exceptions*."
msgstr ""
"Até agora mensagens de erro foram apenas mencionadas, mas se você testou os "
"exemplos, talvez tenha esbarrado em algumas. Existem pelo menos dois tipos "
"distintos de erros: *erros de sintaxe* e *exceções*."

#: ../../tutorial/errors.rst:15
msgid "Syntax Errors"
msgstr "Erros de sintaxe"

#: ../../tutorial/errors.rst:17
msgid ""
"Syntax errors, also known as parsing errors, are perhaps the most common "
"kind of complaint you get while you are still learning Python::"
msgstr ""
"Erros de sintaxe, também conhecidos como erros de parse, são provavelmente "
"os mais frequentes entre aqueles que ainda estão aprendendo Python::"

#: ../../tutorial/errors.rst:26
msgid ""
"The parser repeats the offending line and displays little 'arrow's pointing "
"at the token in the line where the error was detected.  The error may be "
"caused by the absence of a token *before* the indicated token.  In the "
"example, the error is detected at the function :func:`print`, since a colon "
"(``':'``) is missing before it.  File name and line number are printed so "
"you know where to look in case the input came from a script."
msgstr ""
"O analisador sintático repete a linha inválida e apresenta uma pequena "
"'seta' apontando para o ponto da linha em que o erro foi detectado. O erro "
"deve ter sido causado pela ausência do símbolo que *precede* a seta. No "
"exemplo, o erro foi detectado na função :func:`print`, uma vez que um dois-"
"pontos (``':'``) está faltando antes dela. O nome de arquivo e número de "
"linha são exibidos para que você possa rastrear o erro no texto do script."

#: ../../tutorial/errors.rst:37
msgid "Exceptions"
msgstr "Exceções"

#: ../../tutorial/errors.rst:39
msgid ""
"Even if a statement or expression is syntactically correct, it may cause an "
"error when an attempt is made to execute it. Errors detected during "
"execution are called *exceptions* and are not unconditionally fatal: you "
"will soon learn how to handle them in Python programs.  Most exceptions are "
"not handled by programs, however, and result in error messages as shown "
"here::"
msgstr ""
"Mesmo que um comando ou expressão estejam sintaticamente corretos, talvez "
"ocorra um erro na hora de sua execução. Erros detectados durante a execução "
"são chamados *exceções* e não são necessariamente fatais: logo veremos como "
"tratá-las em programas Python. A maioria das exceções não são tratadas pelos "
"programas e acabam resultando em mensagens de erro::"

#: ../../tutorial/errors.rst:58
msgid ""
"The last line of the error message indicates what happened. Exceptions come "
"in different types, and the type is printed as part of the message: the "
"types in the example are :exc:`ZeroDivisionError`, :exc:`NameError` and :exc:"
"`TypeError`. The string printed as the exception type is the name of the "
"built-in exception that occurred.  This is true for all built-in exceptions, "
"but need not be true for user-defined exceptions (although it is a useful "
"convention). Standard exception names are built-in identifiers (not reserved "
"keywords)."
msgstr ""
"A última linha da mensagem de erro indica o que aconteceu. Exceções surgem "
"com diferentes tipos, e o tipo é exibido como parte da mensagem: os tipos no "
"exemplo são :exc:`ZeroDivisionError`, :exc:`NameError` e :exc:`TypeError`. A "
"string exibida como sendo o tipo da exceção é o nome da exceção embutida que "
"ocorreu. Isso é verdade para todas exceções pré-definidas em Python, mas não "
"é necessariamente verdade para exceções definidas pelo usuário (embora seja "
"uma convenção útil). Os nomes das exceções padrões são identificadores "
"embutidos (não palavras reservadas)."

#: ../../tutorial/errors.rst:66
msgid ""
"The rest of the line provides detail based on the type of exception and what "
"caused it."
msgstr ""
"O resto da linha é um detalhamento que depende do tipo da exceção ocorrida e "
"sua causa."

#: ../../tutorial/errors.rst:69
msgid ""
"The preceding part of the error message shows the context where the "
"exception occurred, in the form of a stack traceback. In general it contains "
"a stack traceback listing source lines; however, it will not display lines "
"read from standard input."
msgstr ""
"A parte anterior da mensagem de erro apresenta o contexto onde ocorreu a "
"exceção. Essa informação é denominada *stack traceback* (situação da pilha "
"de execução). Em geral, contém uma lista de linhas do código-fonte, sem "
"apresentar, no entanto, linhas lidas da entrada padrão."

#: ../../tutorial/errors.rst:74
msgid ""
":ref:`bltin-exceptions` lists the built-in exceptions and their meanings."
msgstr ""
":ref:`bltin-exceptions` lista as exceções pré-definidas e seus significados."

#: ../../tutorial/errors.rst:80
msgid "Handling Exceptions"
msgstr "Tratamento de exceções"

#: ../../tutorial/errors.rst:82
msgid ""
"It is possible to write programs that handle selected exceptions. Look at "
"the following example, which asks the user for input until a valid integer "
"has been entered, but allows the user to interrupt the program (using :kbd:"
"`Control-C` or whatever the operating system supports); note that a user-"
"generated interruption is signalled by raising the :exc:`KeyboardInterrupt` "
"exception. ::"
msgstr ""
"É possível escrever programas que tratam exceções específicas. Observe o "
"exemplo seguinte, que pede dados ao usuário até que um inteiro válido seja "
"fornecido, ainda permitindo que o programa seja interrompido (utilizando :"
"kbd:`Control-C` ou seja lá o que o sistema operacional suporte); note que "
"uma interrupção gerada pelo usuário será sinalizada pela exceção :exc:"
"`KeyboardInterrupt`. ::"

#: ../../tutorial/errors.rst:96
msgid "The :keyword:`try` statement works as follows."
msgstr "A instrução :keyword:`try` funciona da seguinte maneira:"

#: ../../tutorial/errors.rst:98
msgid ""
"First, the *try clause* (the statement(s) between the :keyword:`try` and :"
"keyword:`except` keywords) is executed."
msgstr ""
"Primeiramente, a *cláusula try* (o conjunto de instruções entre as palavras "
"reservadas :keyword:`try` e :keyword:`except` ) é executada."

#: ../../tutorial/errors.rst:101
msgid ""
"If no exception occurs, the *except clause* is skipped and execution of the :"
"keyword:`try` statement is finished."
msgstr ""
"Se nenhuma exceção ocorrer, a *cláusula except* é ignorada e a execução da "
"instrução :keyword:`try` é finalizada."

#: ../../tutorial/errors.rst:104
msgid ""
"If an exception occurs during execution of the :keyword:`try` clause, the "
"rest of the clause is skipped.  Then, if its type matches the exception "
"named after the :keyword:`except` keyword, the *except clause* is executed, "
"and then execution continues after the try/except block."
msgstr ""
"Se ocorrer uma exceção durante a execução de uma cláusula :keyword:`try`, as "
"instruções remanescentes nela são ignoradas. Se o tipo da exceção ocorrida "
"tiver sido previsto em algum :keyword:`except`, essa *cláusula except* é "
"executada, e então depois a execução continua após o bloco try/except."

#: ../../tutorial/errors.rst:109
msgid ""
"If an exception occurs which does not match the exception named in the "
"*except clause*, it is passed on to outer :keyword:`try` statements; if no "
"handler is found, it is an *unhandled exception* and execution stops with an "
"error message."
msgstr ""
"Se a exceção levantada não corresponder a nenhuma exceção listada na "
"*cláusula de exceção*, ela é encaminhada a uma instrução :keyword:`try` mais "
"externa. Se não houver nenhum tratador previsto para essa exceção, trata-se "
"de uma *exceção não tratada* e a execução do programa termina com uma "
"mensagem de erro."

#: ../../tutorial/errors.rst:113
msgid ""
"A :keyword:`try` statement may have more than one *except clause*, to "
"specify handlers for different exceptions.  At most one handler will be "
"executed. Handlers only handle exceptions that occur in the corresponding "
"*try clause*, not in other handlers of the same :keyword:`!try` statement.  "
"An *except clause* may name multiple exceptions as a parenthesized tuple, "
"for example::"
msgstr ""
"A instrução :keyword:`try` pode ter uma ou mais *cláusula de exceção*, para "
"especificar múltiplos tratadores para diferentes exceções. No máximo um "
"único tratador será executado. Tratadores só são sensíveis às exceções "
"levantadas no interior da *cláusula de tentativa*, e não às que tenham "
"ocorrido no interior de outro tratador numa mesma instrução :keyword:`!try`. "
"Uma *cláusula de exceção* pode ser sensível a múltiplas exceções, desde que "
"as especifique em uma tupla, por exemplo::"

#: ../../tutorial/errors.rst:122
msgid ""
"A class in an :keyword:`except` clause is compatible with an exception if it "
"is the same class or a base class thereof (but not the other way around --- "
"an *except clause* listing a derived class is not compatible with a base "
"class). For example, the following code will print B, C, D in that order::"
msgstr ""
"Uma classe em uma cláusula :keyword:`except` é compatível com uma exceção se "
"ela é da mesma classe ou de uma classe base desta (mas o contrário não é "
"válido --- uma *cláusula de exceção* listando uma classe derivada não é "
"compatível com uma classe base). Por exemplo, o seguinte código irá mostrar "
"B, C, D nesta ordem::"

#: ../../tutorial/errors.rst:146
msgid ""
"Note that if the *except clauses* were reversed (with ``except B`` first), "
"it would have printed B, B, B --- the first matching *except clause* is "
"triggered."
msgstr ""
"Se a ordem das *cláusulas de exceção* fosse invertida (``except B`` no "
"início), seria exibido B, B, B --- somente a primeira *cláusula de exceção* "
"compatível é ativada."

#: ../../tutorial/errors.rst:149
msgid ""
"When an exception occurs, it may have associated values, also known as the "
"exception's *arguments*. The presence and types of the arguments depend on "
"the exception type."
msgstr ""
"Quando uma exceção ocorre, ela pode estar associada a valores chamados "
"*argumentos* da exceção. A presença e os tipos dos argumentos dependem do "
"tipo da exceção."

#: ../../tutorial/errors.rst:153
msgid ""
"The *except clause* may specify a variable after the exception name.  The "
"variable is bound to the exception instance which typically has an ``args`` "
"attribute that stores the arguments. For convenience, builtin exception "
"types define :meth:`~object.__str__` to print all the arguments without "
"explicitly accessing ``.args``.  ::"
msgstr ""
"A *cláusula except* pode especificar uma variável após o nome da exceção. A "
"variável está vinculada à instância de exceção que normalmente possui um "
"atributo ``args`` que armazena os argumentos. Por conveniência, os tipos de "
"exceção embutidos definem :meth:`~object.__str__` para exibir todos os "
"argumentos sem acessar explicitamente ``.args``. ::"

#: ../../tutorial/errors.rst:176
msgid ""
"The exception's :meth:`~object.__str__` output is printed as the last part "
"('detail') of the message for unhandled exceptions."
msgstr ""
"A saída :meth:`~object.__str__` da exceção é exibida como a última parte "
"(\"detalhe\") da mensagem para exceções não tratadas."

#: ../../tutorial/errors.rst:179
msgid ""
":exc:`BaseException` is the common base class of all exceptions. One of its "
"subclasses, :exc:`Exception`, is the base class of all the non-fatal "
"exceptions. Exceptions which are not subclasses of :exc:`Exception` are not "
"typically handled, because they are used to indicate that the program should "
"terminate. They include :exc:`SystemExit` which is raised by :meth:`sys."
"exit` and :exc:`KeyboardInterrupt` which is raised when a user wishes to "
"interrupt the program."
msgstr ""
":exc:`BaseException` é a classe base comum de todas as exceções. Uma de suas "
"subclasses, :exc:`Exception`, é a classe base de todas as exceções não "
"fatais. Exceções que não são subclasses de :exc:`Exception` normalmente não "
"são tratadas, pois são usadas para indicar que o programa deve terminar. "
"Elas incluem :exc:`SystemExit`, levantada por :meth:`sys.exit`, e :exc:"
"`KeyboardInterrupt`, levantada quando um usuário deseja interromper o "
"programa."

#: ../../tutorial/errors.rst:187
msgid ""
":exc:`Exception` can be used as a wildcard that catches (almost) everything. "
"However, it is good practice to be as specific as possible with the types of "
"exceptions that we intend to handle, and to allow any unexpected exceptions "
"to propagate on."
msgstr ""
":exc:`Exception` pode ser usada como um curinga que captura (quase) tudo. No "
"entanto, é uma boa prática ser o mais específico possível quanto aos tipos "
"de exceções que pretendemos manipular, evitando que quaisquer exceções "
"inesperadas se propaguem."

#: ../../tutorial/errors.rst:192
msgid ""
"The most common pattern for handling :exc:`Exception` is to print or log the "
"exception and then re-raise it (allowing a caller to handle the exception as "
"well)::"
msgstr ""
"O padrão mais comum para lidar com :exc:`Exception` é imprimir ou registrar "
"a exceção e então levantá-la novamente (permitindo que um chamador lide com "
"a exceção também)::"

#: ../../tutorial/errors.rst:210
msgid ""
"The :keyword:`try` ... :keyword:`except` statement has an optional *else "
"clause*, which, when present, must follow all *except clauses*.  It is "
"useful for code that must be executed if the *try clause* does not raise an "
"exception. For example::"
msgstr ""
"A construção :keyword:`try` ... :keyword:`except` possui uma *cláusula else* "
"opcional que, quando presente, deve ser colocada após todas as demais "
"cláusulas. É útil para um código que precisa ser executado se nenhuma "
"exceção foi levantada. Por exemplo::"

#: ../../tutorial/errors.rst:224
msgid ""
"The use of the :keyword:`!else` clause is better than adding additional code "
"to the :keyword:`try` clause because it avoids accidentally catching an "
"exception that wasn't raised by the code being protected by the :keyword:`!"
"try` ... :keyword:`!except` statement."
msgstr ""
"É melhor usar a cláusula :keyword:`!else` do que colocar código adicional na "
"cláusula :keyword:`try`, porque ela evita que, acidentalmente, seja tratada "
"uma exceção que não foi levantada pelo código protegido pela construção com "
"as instruções :keyword:`!try` ... :keyword:`!except`."

#: ../../tutorial/errors.rst:229
msgid ""
"Exception handlers do not handle only exceptions that occur immediately in "
"the *try clause*, but also those that occur inside functions that are called "
"(even indirectly) in the *try clause*. For example::"
msgstr ""
"Os manipuladores de exceção não tratam apenas exceções que ocorrem "
"imediatamente na *cláusula try*, mas também as que ocorrem dentro de funções "
"chamadas (mesmo indiretamente) na *cláusula try*. Por exemplo::"

#: ../../tutorial/errors.rst:247
msgid "Raising Exceptions"
msgstr "Levantando exceções"

#: ../../tutorial/errors.rst:249
msgid ""
"The :keyword:`raise` statement allows the programmer to force a specified "
"exception to occur. For example::"
msgstr ""
"A instrução :keyword:`raise` permite ao programador forçar a ocorrência de "
"um determinado tipo de exceção. Por exemplo::"

#: ../../tutorial/errors.rst:257
msgid ""
"The sole argument to :keyword:`raise` indicates the exception to be raised. "
"This must be either an exception instance or an exception class (a class "
"that derives from :class:`BaseException`, such as :exc:`Exception` or one of "
"its subclasses).  If an exception class is passed, it will be implicitly "
"instantiated by calling its constructor with no arguments::"
msgstr ""
"O argumento de :keyword:`raise` indica a exceção a ser levantada. Esse "
"argumento deve ser uma instância de exceção ou uma classe de exceção (uma "
"classe que deriva de :class:`BaseException`, tal como :exc:`Exception` ou "
"uma de suas subclasses). Se uma classe de exceção for passada, será "
"implicitamente instanciada invocando o seu construtor sem argumentos::"

#: ../../tutorial/errors.rst:265
msgid ""
"If you need to determine whether an exception was raised but don't intend to "
"handle it, a simpler form of the :keyword:`raise` statement allows you to re-"
"raise the exception::"
msgstr ""
"Caso você precise determinar se uma exceção foi levantada ou não, mas não "
"quer manipular o erro, uma forma simples de instrução :keyword:`raise` "
"permite que você levante-a novamente::"

#: ../../tutorial/errors.rst:284
msgid "Exception Chaining"
msgstr "Encadeamento de exceções"

#: ../../tutorial/errors.rst:286
msgid ""
"If an unhandled exception occurs inside an :keyword:`except` section, it "
"will have the exception being handled attached to it and included in the "
"error message::"
msgstr ""
"Se uma exceção não tratada ocorrer dentro de uma seção :keyword:`except`, "
"ela terá a exceção sendo tratada anexada a ela e incluída na mensagem de "
"erro::"

#: ../../tutorial/errors.rst:305
msgid ""
"To indicate that an exception is a direct consequence of another, the :"
"keyword:`raise` statement allows an optional :keyword:`from<raise>` clause::"
msgstr ""
"Para indicar que uma exceção é uma consequência direta de outra, a "
"instrução :keyword:`raise` permite uma cláusula opcional :keyword:`from "
"<raise>`::"

#: ../../tutorial/errors.rst:311
msgid "This can be useful when you are transforming exceptions. For example::"
msgstr ""
"Isso pode ser útil quando você está transformando exceções. Por exemplo::"

#: ../../tutorial/errors.rst:332
msgid ""
"It also allows disabling automatic exception chaining using the ``from "
"None`` idiom::"
msgstr ""
"Ele também permite desabilitar o encadeamento automático de exceções usando "
"o idioma ``from None``::"

#: ../../tutorial/errors.rst:344
msgid ""
"For more information about chaining mechanics, see :ref:`bltin-exceptions`."
msgstr ""
"Para mais informações sobre os mecanismos de encadeamento, veja :ref:`bltin-"
"exceptions`."

#: ../../tutorial/errors.rst:350
msgid "User-defined Exceptions"
msgstr "Exceções definidas pelo usuário"

#: ../../tutorial/errors.rst:352
msgid ""
"Programs may name their own exceptions by creating a new exception class "
"(see :ref:`tut-classes` for more about Python classes).  Exceptions should "
"typically be derived from the :exc:`Exception` class, either directly or "
"indirectly."
msgstr ""
"Programas podem definir novos tipos de exceções, através da criação de uma "
"nova classe (veja :ref:`tut-classes` para mais informações sobre classes "
"Python). Exceções devem ser derivadas da classe :exc:`Exception`, direta ou "
"indiretamente."

#: ../../tutorial/errors.rst:356
msgid ""
"Exception classes can be defined which do anything any other class can do, "
"but are usually kept simple, often only offering a number of attributes that "
"allow information about the error to be extracted by handlers for the "
"exception."
msgstr ""
"As classes de exceção podem ser definidas para fazer qualquer coisa que "
"qualquer outra classe pode fazer, mas geralmente são mantidas simples, "
"geralmente oferecendo apenas um número de atributos que permitem que "
"informações sobre o erro sejam extraídas por manipuladores para a exceção."

#: ../../tutorial/errors.rst:360
msgid ""
"Most exceptions are defined with names that end in \"Error\", similar to the "
"naming of the standard exceptions."
msgstr ""
"É comum que novas exceções sejam definidas com nomes terminando em "
"\"Error\", semelhante a muitas exceções embutidas."

#: ../../tutorial/errors.rst:363
msgid ""
"Many standard modules define their own exceptions to report errors that may "
"occur in functions they define."
msgstr ""
"Muitos módulos padrão definem suas próprias exceções para relatar erros que "
"podem ocorrer nas funções que definem."

#: ../../tutorial/errors.rst:370
msgid "Defining Clean-up Actions"
msgstr "Definindo ações de limpeza"

#: ../../tutorial/errors.rst:372
msgid ""
"The :keyword:`try` statement has another optional clause which is intended "
"to define clean-up actions that must be executed under all circumstances.  "
"For example::"
msgstr ""
"A instrução :keyword:`try` possui outra cláusula opcional, cuja finalidade é "
"permitir a implementação de ações de limpeza, que sempre devem ser "
"executadas independentemente da ocorrência de exceções. Como no exemplo::"

#: ../../tutorial/errors.rst:386
msgid ""
"If a :keyword:`finally` clause is present, the :keyword:`!finally` clause "
"will execute as the last task before the :keyword:`try` statement completes. "
"The :keyword:`!finally` clause runs whether or not the :keyword:`!try` "
"statement produces an exception. The following points discuss more complex "
"cases when an exception occurs:"
msgstr ""
"Se uma cláusula :keyword:`finally` estiver presente, a cláusula :keyword:`!"
"finally` será executada como a última tarefa antes da conclusão da "
"instrução :keyword:`try`. A cláusula :keyword:`!finally` executa se a "
"instrução :keyword:`!try` produz uma exceção. Os pontos a seguir discutem "
"casos mais complexos quando ocorre uma exceção:"

#: ../../tutorial/errors.rst:392
msgid ""
"If an exception occurs during execution of the :keyword:`!try` clause, the "
"exception may be handled by an :keyword:`except` clause. If the exception is "
"not handled by an :keyword:`!except` clause, the exception is re-raised "
"after the :keyword:`!finally` clause has been executed."
msgstr ""
"Se ocorrer uma exceção durante a execução da cláusula :keyword:`!try`, a "
"exceção poderá ser tratada por uma cláusula :keyword:`except`. Se a exceção "
"não for tratada por uma cláusula :keyword:`!except`, a exceção será gerada "
"novamente após a execução da cláusula :keyword:`!finally`."

#: ../../tutorial/errors.rst:398
msgid ""
"An exception could occur during execution of an :keyword:`!except` or :"
"keyword:`!else` clause. Again, the exception is re-raised after the :keyword:"
"`!finally` clause has been executed."
msgstr ""
"Uma exceção pode ocorrer durante a execução de uma cláusula :keyword:`!"
"except` ou :keyword:`!else`. Novamente, a exceção é re-levantada depois que :"
"keyword:`!finally` é executada."

#: ../../tutorial/errors.rst:402
msgid ""
"If the :keyword:`!finally` clause executes a :keyword:`break`, :keyword:"
"`continue` or :keyword:`return` statement, exceptions are not re-raised."
msgstr ""
"Se a cláusula :keyword:`!finally` executa uma instrução :keyword:`break`, :"
"keyword:`continue` ou :keyword:`return`, as exceções não são levantadas "
"novamente."

#: ../../tutorial/errors.rst:406
msgid ""
"If the :keyword:`!try` statement reaches a :keyword:`break`, :keyword:"
"`continue` or :keyword:`return` statement, the :keyword:`!finally` clause "
"will execute just prior to the :keyword:`!break`, :keyword:`!continue` or :"
"keyword:`!return` statement's execution."
msgstr ""
"Se a instrução :keyword:`!try` atingir uma instrução :keyword:`break`, :"
"keyword:`continue` ou :keyword:`return`, a cláusula :keyword:`!finally` será "
"executada imediatamente antes da execução da instrução :keyword:`!break`, :"
"keyword:`!continue` ou :keyword:`!return`."

#: ../../tutorial/errors.rst:412
msgid ""
"If a :keyword:`!finally` clause includes a :keyword:`!return` statement, the "
"returned value will be the one from the :keyword:`!finally` clause's :"
"keyword:`!return` statement, not the value from the :keyword:`!try` "
"clause's :keyword:`!return` statement."
msgstr ""
"Se uma cláusula :keyword:`!finally` incluir uma instrução :keyword:`!"
"return`, o valor retornado será aquele da instrução :keyword:`!return` da "
"cláusula :keyword:`!finally`, não o valor da instrução :keyword:`!return` da "
"cláusula :keyword:`!try`."

#: ../../tutorial/errors.rst:418
msgid "For example::"
msgstr "Por exemplo::"

#: ../../tutorial/errors.rst:429
msgid "A more complicated example::"
msgstr "Um exemplo mais complicado::"

#: ../../tutorial/errors.rst:454
msgid ""
"As you can see, the :keyword:`finally` clause is executed in any event.  "
"The :exc:`TypeError` raised by dividing two strings is not handled by the :"
"keyword:`except` clause and therefore re-raised after the :keyword:`!"
"finally` clause has been executed."
msgstr ""
"Como você pode ver, a cláusula :keyword:`finally` é executada em todos os "
"casos. A exceção :exc:`TypeError` levantada pela divisão de duas strings não "
"é tratada pela cláusula :keyword:`except` e portanto é re-levantada depois "
"que a cláusula :keyword:`!finally` é executada."

#: ../../tutorial/errors.rst:459
msgid ""
"In real world applications, the :keyword:`finally` clause is useful for "
"releasing external resources (such as files or network connections), "
"regardless of whether the use of the resource was successful."
msgstr ""
"Em aplicação do mundo real, a cláusula :keyword:`finally` é útil para "
"liberar recursos externos (como arquivos ou conexões de rede), "
"independentemente do uso do recurso ter sido bem sucedido ou não."

#: ../../tutorial/errors.rst:467
msgid "Predefined Clean-up Actions"
msgstr "Ações de limpeza predefinidas"

#: ../../tutorial/errors.rst:469
msgid ""
"Some objects define standard clean-up actions to be undertaken when the "
"object is no longer needed, regardless of whether or not the operation using "
"the object succeeded or failed. Look at the following example, which tries "
"to open a file and print its contents to the screen. ::"
msgstr ""
"Alguns objetos definem ações de limpeza padrões para serem executadas quando "
"o objeto não é mais necessário, independentemente da operação que estava "
"usando o objeto ter sido ou não bem sucedida. Veja o exemplo a seguir, que "
"tenta abrir um arquivo e exibir seu conteúdo na tela. ::"

#: ../../tutorial/errors.rst:477
msgid ""
"The problem with this code is that it leaves the file open for an "
"indeterminate amount of time after this part of the code has finished "
"executing. This is not an issue in simple scripts, but can be a problem for "
"larger applications. The :keyword:`with` statement allows objects like files "
"to be used in a way that ensures they are always cleaned up promptly and "
"correctly. ::"
msgstr ""
"O problema com esse código é que ele deixa o arquivo aberto um período "
"indeterminado depois que o código é executado. Isso não chega a ser problema "
"em scripts simples, mas pode ser um problema para grandes aplicações. A "
"palavra reservada :keyword:`with` permite que objetos como arquivos sejam "
"utilizados com a certeza de que sempre serão prontamente e corretamente "
"finalizados. ::"

#: ../../tutorial/errors.rst:487
msgid ""
"After the statement is executed, the file *f* is always closed, even if a "
"problem was encountered while processing the lines. Objects which, like "
"files, provide predefined clean-up actions will indicate this in their "
"documentation."
msgstr ""
"Depois que a instrução é executada, o arquivo *f* é sempre fechado, mesmo se "
"ocorrer um problema durante o processamento das linhas. Outros objetos que, "
"como arquivos, fornecem ações de limpeza predefinidas as indicarão em suas "
"documentações."

#: ../../tutorial/errors.rst:495
msgid "Raising and Handling Multiple Unrelated Exceptions"
msgstr "Criando e tratando várias exceções não relacionadas"

#: ../../tutorial/errors.rst:497
msgid ""
"There are situations where it is necessary to report several exceptions that "
"have occurred. This is often the case in concurrency frameworks, when "
"several tasks may have failed in parallel, but there are also other use "
"cases where it is desirable to continue execution and collect multiple "
"errors rather than raise the first exception."
msgstr ""
"Existem situações em que é necessário relatar várias exceções que ocorreram. "
"Isso geralmente ocorre em estruturas de simultaneidade, quando várias "
"tarefas podem ter falhado em paralelo, mas também há outros casos de uso em "
"que é desejável continuar a execução e coletar vários erros em vez de "
"levantar a primeira exceção."

#: ../../tutorial/errors.rst:503
msgid ""
"The builtin :exc:`ExceptionGroup` wraps a list of exception instances so "
"that they can be raised together. It is an exception itself, so it can be "
"caught like any other exception. ::"
msgstr ""
"O :exc:`ExceptionGroup` integrado envolve uma lista de instâncias de exceção "
"para que elas possam ser levantadas juntas. É uma exceção em si, portanto, "
"pode ser capturada como qualquer outra exceção. ::"

#: ../../tutorial/errors.rst:529
msgid ""
"By using ``except*`` instead of ``except``, we can selectively handle only "
"the exceptions in the group that match a certain type. In the following "
"example, which shows a nested exception group, each ``except*`` clause "
"extracts from the group exceptions of a certain type while letting all other "
"exceptions propagate to other clauses and eventually to be reraised. ::"
msgstr ""
"Usando ``except*`` em vez de ``except``, podemos manipular seletivamente "
"apenas as exceções no grupo que correspondem a um determinado tipo. No "
"exemplo a seguir, que mostra um grupo de exceção aninhado, cada cláusula "
"``except*`` extrai do grupo exceções de um certo tipo enquanto permite que "
"todas as outras exceções se propaguem para outras cláusulas e eventualmente "
"sejam levantadas novamente. ::"

#: ../../tutorial/errors.rst:572
msgid ""
"Note that the exceptions nested in an exception group must be instances, not "
"types. This is because in practice the exceptions would typically be ones "
"that have already been raised and caught by the program, along the following "
"pattern::"
msgstr ""
"Observe que as exceções aninhadas em um grupo de exceções devem ser "
"instâncias, não tipos. Isso ocorre porque, na prática, as exceções "
"normalmente seriam aquelas que já foram levantadas e capturadas pelo "
"programa, seguindo o seguinte padrão::"

#: ../../tutorial/errors.rst:592
msgid "Enriching Exceptions with Notes"
msgstr "Enriquecendo exceções com notas"

#: ../../tutorial/errors.rst:594
msgid ""
"When an exception is created in order to be raised, it is usually "
"initialized with information that describes the error that has occurred. "
"There are cases where it is useful to add information after the exception "
"was caught. For this purpose, exceptions have a method ``add_note(note)`` "
"that accepts a string and adds it to the exception's notes list. The "
"standard traceback rendering includes all notes, in the order they were "
"added, after the exception. ::"
msgstr ""
"Quando uma exceção é criada para ser levantada, geralmente é inicializada "
"com informações que descrevem o erro ocorrido. Há casos em que é útil "
"adicionar informações após a captura da exceção. Para este propósito, as "
"exceções possuem um método ``add_note(note)`` que aceita uma string e a "
"adiciona à lista de notas da exceção. A renderização de traceback padrão "
"inclui todas as notas, na ordem em que foram adicionadas, após a exceção. ::"

#: ../../tutorial/errors.rst:615
msgid ""
"For example, when collecting exceptions into an exception group, we may want "
"to add context information for the individual errors. In the following each "
"exception in the group has a note indicating when this error has occurred. ::"
msgstr ""
"Por exemplo, ao coletar exceções em um grupo de exceções, podemos querer "
"adicionar informações de contexto para os erros individuais. A seguir, cada "
"exceção no grupo tem uma nota indicando quando esse erro ocorreu. ::"