# 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

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

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

#

#, fuzzy

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2026-04-15 15:01+0000\n"

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

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

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

msgid ""

">>> while True print('Hello world')\n"

" File \"<stdin>\", line 1\n"

" while True print('Hello world')\n"

" ^^^^^\n"

"SyntaxError: invalid syntax"

msgstr ""

">>> while True print('Olá mundo')\n"

" File \"<stdin>\", line 1\n"

" while True print('Olá mundo')\n"

" ^^^^^\n"

"SyntaxError: invalid syntax"

#: ../../tutorial/errors.rst:26

msgid ""

"The parser repeats the offending line and displays little arrows pointing at "

"the place where the error was detected. Note that this is not always the "

"place that needs to be fixed. In the example, the error is detected at the "

"function :func:`print`, since a colon (``':'``) is missing just before it."

msgstr ""

"O analisador sintático repete a linha ofensiva e exibe pequenas setas "

"apontando para o local onde o erro foi detectado. Note que esse nem sempre é "

"o local que precisa ser corrigido. No exemplo, o erro é detectado na função :"

"func:`print`, já que dois pontos (``':'``) estão faltando logo antes dele."

#: ../../tutorial/errors.rst:31

msgid ""

"The file name (``<stdin>`` in our example) and line number are printed so "

"you know where to look in case the input came from a file."

msgstr ""

"O nome do arquivo (``<stdin>`` no nosso exemplo) e o número da linha são "

"impressos para que você saiba onde procurar caso a entrada tenha vindo de um "

"arquivo."

#: ../../tutorial/errors.rst:38

msgid "Exceptions"

msgstr "Exceções"

#: ../../tutorial/errors.rst:40

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

msgid ""

">>> 10 * (1/0)\n"

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

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

" 10 * (1/0)\n"

" ~^~\n"

"ZeroDivisionError: division by zero\n"

">>> 4 + spam*3\n"

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

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

" 4 + spam*3\n"

" ^^^^\n"

"NameError: name 'spam' is not defined\n"

">>> '2' + 2\n"

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

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

" '2' + 2\n"

" ~~~~^~~\n"

"TypeError: can only concatenate str (not \"int\") to str"

msgstr ""

">>> 10 * (1/0)\n"

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

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

" 10 * (1/0)\n"

" ~^~\n"

"ZeroDivisionError: division by zero\n"

">>> 4 + spam*3\n"

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

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

" 4 + spam*3\n"

" ^^^^\n"

"NameError: name 'spam' is not defined\n"

">>> '2' + 2\n"

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

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

" '2' + 2\n"

" ~~~~^~~\n"

"TypeError: can only concatenate str (not \"int\") to str"

#: ../../tutorial/errors.rst:65

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

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

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

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

msgid "Handling Exceptions"

msgstr "Tratamento de exceções"

#: ../../tutorial/errors.rst:89

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

msgid ""

">>> while True:\n"

"... try:\n"

"... x = int(input(\"Please enter a number: \"))\n"

"... break\n"

"... except ValueError:\n"

"... print(\"Oops! That was no valid number. Try again...\")\n"

"..."

msgstr ""

">>> while True:\n"

"... try:\n"

"... x = int(input(\"Insira um número: \"))\n"

"... break\n"

"... except ValueError:\n"

"... print(\"Ops! Esse não é um número válido. Tente novamente...\")\n"

"..."

#: ../../tutorial/errors.rst:103

msgid "The :keyword:`try` statement works as follows."

msgstr "A instrução :keyword:`try` funciona da seguinte maneira:"

#: ../../tutorial/errors.rst:105

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

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

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

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

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, for example::"

msgstr ""

"A instrução :keyword:`try` pode ter uma ou mais *cláusulas 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, por "

"exemplo::"

#: ../../tutorial/errors.rst:126

msgid ""

"... except RuntimeError, TypeError, NameError:\n"

"... pass"

msgstr ""

"... except RuntimeError, TypeError, NameError:\n"

"... pass"

#: ../../tutorial/errors.rst:129

msgid ""

"A class in an :keyword:`except` clause matches exceptions which are "

"instances of the class itself or one of its derived classes (but not the "

"other way around --- an *except clause* listing a derived class does not "

"match instances of its base classes). For example, the following code will "

"print B, C, D in that order::"

msgstr ""

"Uma classe em uma cláusula :keyword:`except` corresponde a exceções que são "

"instâncias da própria classe ou de uma de suas classes derivadas (mas o "

"contrário não é válido --- uma *cláusula except* listando uma classe "

"derivada não corresponde a instâncias de suas classes base). Por exemplo, o "

"seguinte código irá mostrar B, C, D nessa ordem::"

#: ../../tutorial/errors.rst:134

msgid ""

"class B(Exception):\n"

" pass\n"

"\n"

"class C(B):\n"

" pass\n"

"\n"

"class D(C):\n"

" pass\n"

"\n"

"for cls in [B, C, D]:\n"

" try:\n"

" raise cls()\n"

" except D:\n"

" print(\"D\")\n"

" except C:\n"

" print(\"C\")\n"

" except B:\n"

" print(\"B\")"

msgstr ""

"class B(Exception):\n"

" pass\n"

"\n"

"class C(B):\n"

" pass\n"

"\n"

"class D(C):\n"

" pass\n"

"\n"

"for cls in [B, C, D]:\n"

" try:\n"

" raise cls()\n"

" except D:\n"

" print(\"D\")\n"

" except C:\n"

" print(\"C\")\n"

" except B:\n"

" print(\"B\")"

#: ../../tutorial/errors.rst:153

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

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

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

msgid ""

">>> try:\n"

"... raise Exception('spam', 'eggs')\n"

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

"... print(type(inst)) # the exception type\n"

"... print(inst.args) # arguments stored in .args\n"

"... print(inst) # __str__ allows args to be printed directly,\n"

"... # but may be overridden in exception "

"subclasses\n"

"... x, y = inst.args # unpack args\n"

"... print('x =', x)\n"

"... print('y =', y)\n"

"...\n"

"<class 'Exception'>\n"

"('spam', 'eggs')\n"

"('spam', 'eggs')\n"

"x = spam\n"

"y = eggs"

msgstr ""

">>> try:\n"

"... raise Exception('spam', 'ovos')\n"

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

"... print(type(inst)) # o tipo da exceção\n"

"... print(inst.args) # argumentos armazenados em .args\n"

"... print(inst) # __str__ permite imprimir args diretamente,\n"

"... # mas pode ser substituído em subclasses de "

"exceção\n"

"... x, y = inst.args # desempacota args\n"

"... print('x =', x)\n"

"... print('y =', y)\n"

"...\n"

"<class 'Exception'>\n"

"('spam', 'ovos')\n"

"('spam', 'ovos')\n"

"x = spam\n"

"y = ovos"

#: ../../tutorial/errors.rst:183

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

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

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

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

msgid ""

"import sys\n"

"\n"

"try:\n"

" f = open('myfile.txt')\n"

" s = f.readline()\n"

" i = int(s.strip())\n"

"except OSError as err:\n"

" print(\"OS error:\", err)\n"

"except ValueError:\n"

" print(\"Could not convert data to an integer.\")\n"

"except Exception as err:\n"

" print(f\"Unexpected {err=}, {type(err)=}\")\n"

" raise"

msgstr ""

"import sys\n"

"\n"

"try:\n"

" f = open('meuarquivo.txt')\n"

" s = f.readline()\n"

" i = int(s.strip())\n"

"except OSError as err:\n"

" print(\"Erro de E/S:\", err)\n"

"except ValueError:\n"

" print(\"Não foi possível converter dados para um inteiro.\")\n"

"except Exception as err:\n"

" print(f\"Não esperava {err=}, {type(err)=}\")\n"

" raise"

#: ../../tutorial/errors.rst:217

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

msgid ""

"for arg in sys.argv[1:]:\n"

" try:\n"

" f = open(arg, 'r')\n"

" except OSError:\n"

" print('cannot open', arg)\n"

" else:\n"

" print(arg, 'has', len(f.readlines()), 'lines')\n"

" f.close()"

msgstr ""

"for arg in sys.argv[1:]:\n"

" try:\n"

" f = open(arg, 'r')\n"

" except OSError:\n"

" print('não foi possível abrir', arg)\n"

" else:\n"

" print(arg, 'tem', len(f.readlines()), 'linhas')\n"

" f.close()"

#: ../../tutorial/errors.rst:231

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

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

msgid ""

">>> def this_fails():\n"

"... x = 1/0\n"

"...\n"

">>> try:\n"

"... this_fails()\n"

"... except ZeroDivisionError as err:\n"

"... print('Handling run-time error:', err)\n"

"...\n"

"Handling run-time error: division by zero"

msgstr ""

">>> def this_fails():\n"

"... x = 1/0\n"

"...\n"

">>> try:\n"

"... isso_aqui_falha()\n"

"... except ZeroDivisionError as err:\n"

"... print('Tratando o erro de tempo de execução:', err)\n"

"...\n"

"Tratando o erro de tempo de execução: division by zero"

#: ../../tutorial/errors.rst:254

msgid "Raising Exceptions"

msgstr "Levantando exceções"

#: ../../tutorial/errors.rst:256

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

msgid ""

">>> raise NameError('HiThere')\n"

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

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

" raise NameError('HiThere')\n"

"NameError: HiThere"

msgstr ""

">>> raise NameError('Olá')\n"

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

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

" raise NameError('Olá')\n"

"NameError: Olá"

#: ../../tutorial/errors.rst:265

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

msgid "raise ValueError # shorthand for 'raise ValueError()'"

msgstr "raise ValueError # abreviação para 'raise ValueError()'"

#: ../../tutorial/errors.rst:273

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

msgid ""

">>> try:\n"

"... raise NameError('HiThere')\n"

"... except NameError:\n"

"... print('An exception flew by!')\n"

"... raise\n"

"...\n"

"An exception flew by!\n"

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

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

" raise NameError('HiThere')\n"

"NameError: HiThere"

msgstr ""

">>> try:\n"

"... raise NameError('Olá')\n"

"... except NameError:\n"

"... print('Uma exceção passou por aqui!')\n"

"... raise\n"

"...\n"

"Uma exceção passou por aqui!\n"

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

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

" raise NameError('Olá')\n"

"NameError: Olá"

#: ../../tutorial/errors.rst:293

msgid "Exception Chaining"

msgstr "Encadeamento de exceções"

#: ../../tutorial/errors.rst:295

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

msgid ""

">>> try:\n"

"... open(\"database.sqlite\")\n"

"... except OSError:\n"

"... raise RuntimeError(\"unable to handle error\")\n"

"...\n"

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

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

" open(\"database.sqlite\")\n"

" ~~~~^^^^^^^^^^^^^^^^^^^\n"

"FileNotFoundError: [Errno 2] No such file or directory: 'database.sqlite'\n"

"\n"

"During handling of the above exception, another exception occurred:\n"

"\n"

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

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

" raise RuntimeError(\"unable to handle error\")\n"

"RuntimeError: unable to handle error"

msgstr ""

">>> try:\n"

"... open(\"bancodedados.sqlite\")\n"

"... except OSError:\n"

"... raise RuntimeError(\"não foi possível tratar o erro\")\n"

"...\n"

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

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

" open(\"bancodedados.sqlite\")\n"

" ~~~~^^^^^^^^^^^^^^^^^^^\n"

"FileNotFoundError: [Errno 2] No such file or directory: 'bancodedados."

"sqlite'\n"

"\n"

"During handling of the above exception, another exception occurred:\n"

"\n"

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

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

"RuntimeError: não foi possível tratar o erro"

#: ../../tutorial/errors.rst:317

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

msgid ""

"# exc must be exception instance or None.\n"

"raise RuntimeError from exc"

msgstr ""

"# exc deve ser uma instância de exceção ou None.\n"

"raise RuntimeError from exc"

#: ../../tutorial/errors.rst:323

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

msgid ""

">>> def func():\n"

"... raise ConnectionError\n"

"...\n"

">>> try:\n"

"... func()\n"

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

"... raise RuntimeError('Failed to open database') from exc\n"

"...\n"

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

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

" func()\n"

" ~~~~^^\n"

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

"ConnectionError\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('Failed to open database') from exc\n"

"RuntimeError: Failed to open database"

msgstr ""

">>> def func():\n"

"... raise ConnectionError\n"

"...\n"

">>> try:\n"

"... func()\n"

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

"... raise RuntimeError('Falha ao abrir banco de dados') from exc\n"

"...\n"

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

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

" func()\n"

" ~~~~^^\n"

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

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

"RuntimeError: Falha ao abrir banco de dados"

#: ../../tutorial/errors.rst:347

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

msgid ""

">>> try:\n"

"... open('database.sqlite')\n"

"... except OSError:\n"

"... raise RuntimeError from None\n"

"...\n"

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

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

" raise RuntimeError from None\n"

"RuntimeError"

msgstr ""

">>> try:\n"

"... open('bancodedados.sqlite')\n"

"... except OSError:\n"

"... raise RuntimeError from None\n"

"...\n"

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

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

" raise RuntimeError from None\n"

"RuntimeError"

#: ../../tutorial/errors.rst:360

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

msgid "User-defined Exceptions"

msgstr "Exceções definidas pelo usuário"

#: ../../tutorial/errors.rst:368

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

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

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

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

msgid "Defining Clean-up Actions"

msgstr "Definindo ações de limpeza"

#: ../../tutorial/errors.rst:388

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

msgid ""

">>> try:\n"

"... raise KeyboardInterrupt\n"

"... finally:\n"

"... print('Goodbye, world!')\n"

"...\n"

"Goodbye, world!\n"

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

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

" raise KeyboardInterrupt\n"

"KeyboardInterrupt"

msgstr ""

">>> try:\n"

"... raise KeyboardInterrupt\n"

"... finally:\n"

"... print('Adeus, mundo!')\n"

"...\n"

"Adeus, mundo!\n"

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

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

" raise KeyboardInterrupt\n"

"KeyboardInterrupt"

#: ../../tutorial/errors.rst:403

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

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

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

msgid ""

"If the :keyword:`!finally` clause executes a :keyword:`break`, :keyword:"

"`continue` or :keyword:`return` statement, exceptions are not re-raised. "

"This can be confusing and is therefore discouraged. From version 3.14 the "

"compiler emits a :exc:`SyntaxWarning` for it (see :pep:`765`)."

msgstr ""

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

"keyword:`continue` ou :keyword:`return`, as exceções não serão levantadas "

"novamente. Isso pode ser confuso e, portanto, não é recomendado. A partir da "

"versão 3.14, o compilador emite um :exc:`SyntaxWarning` para isso (consulte :"

"pep:`765`)."

#: ../../tutorial/errors.rst:425

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

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. This can be confusing and is "

"therefore discouraged. From version 3.14 the compiler emits a :exc:"

"`SyntaxWarning` for it (see :pep:`765`)."

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`. A partir da versão 3.14, o compilador emite um :"

"exc:`SyntaxWarning` para ela (veja :pep:`765`)."

#: ../../tutorial/errors.rst:439

msgid "For example::"

msgstr "Por exemplo::"

#: ../../tutorial/errors.rst:441

msgid ""

">>> def bool_return():\n"

"... try:\n"

"... return True\n"

"... finally:\n"

"... return False\n"

"...\n"

">>> bool_return()\n"

"False"

msgstr ""

">>> def retorna_booleano():\n"

"... try:\n"

"... return True\n"

"... finally:\n"

"... return False\n"

"...\n"

">>> retorna_booleano()\n"

"False"

#: ../../tutorial/errors.rst:450

msgid "A more complicated example::"