8. Erros e exceções
*******************

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*.


8.1. Erros de sintaxe
=====================

Erros de sintaxe, também conhecidos como erros de parse, são
provavelmente os mais frequentes entre aqueles que ainda estão
aprendendo Python:

   >>> while True print('Hello world')
     File "<stdin>", line 1
       while True print('Hello world')
                  ^^^^^
   SyntaxError: invalid syntax

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


8.2. Exceções
=============

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:

   >>> 10 * (1/0)
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   ZeroDivisionError: division by zero
   >>> 4 + spam*3
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   NameError: name 'spam' is not defined
   >>> '2' + 2
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   TypeError: can only concatenate str (not "int") to str

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 "ZeroDivisionError", "NameError" e
"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).

O resto da linha é um detalhamento que depende do tipo da exceção
ocorrida e sua causa.

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.

Exceções embutidas lista as exceções pré-definidas e seus
significados.


8.3. Tratamento de exceções
===========================

É 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 "Control-C" ou seja lá o que for que o
sistema operacional suporte); note que uma interrupção gerada pelo
usuário será sinalizada pela exceção "KeyboardInterrupt".

   >>> while True:
   ...     try:
   ...         x = int(input("Please enter a number: "))
   ...         break
   ...     except ValueError:
   ...         print("Oops!  That was no valid number.  Try again...")
   ...

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

* Primeiramente, a *cláusula try* (o conjunto de instruções entre as
  palavras reservadas "try" e "except" ) é executada.

* Se nenhuma exceção ocorrer, a *cláusula except* é ignorada e a
  execução da instrução "try" é finalizada.

* Se ocorrer uma exceção durante a execução de uma cláusula "try", as
  instruções remanescentes na cláusula são ignoradas. Se o tipo da
  exceção ocorrida tiver sido previsto em algum "except", essa
  *cláusula except* é executada, e então depois a execução continua
  após o bloco try/except.

* Se a exceção levantada não corresponder a nenhuma exceção listada na
  *cláusula de exceção*, então ela é entregue a uma instrução "try"
  mais externa. Se não existir nenhum tratador previsto para tal
  exceção, trata-se de uma *exceção não tratada* e a execução do
  programa termina com uma mensagem de erro.

A instrução "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
"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:

   ... except (RuntimeError, TypeError, NameError):
   ...     pass

Uma classe em uma cláusula "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:

   class B(Exception):
       pass

   class C(B):
       pass

   class D(C):
       pass

   for cls in [B, C, D]:
       try:
           raise cls()
       except D:
           print("D")
       except C:
           print("C")
       except B:
           print("B")

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.

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.

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 "__str__()" para
exibir todos os argumentos sem acessar explicitamente ".args".

   >>> try:
   ...     raise Exception('spam', 'eggs')
   ... except Exception as inst:
   ...     print(type(inst))    # the exception type
   ...     print(inst.args)     # arguments stored in .args
   ...     print(inst)          # __str__ allows args to be printed directly,
   ...                          # but may be overridden in exception subclasses
   ...     x, y = inst.args     # unpack args
   ...     print('x =', x)
   ...     print('y =', y)
   ...
   <class 'Exception'>
   ('spam', 'eggs')
   ('spam', 'eggs')
   x = spam
   y = eggs

A saída "__str__()" da exceção é exibida como a última parte
("detalhe") da mensagem para exceções não tratadas.

"BaseException" é a classe base comum de todas as exceções. Uma de
suas subclasses, "Exception", é a classe base de todas as exceções não
fatais. Exceções que não são subclasses de "Exception" normalmente não
são tratadas, pois são usadas para indicar que o programa deve
terminar. Elas incluem "SystemExit" que é levantada por "sys.exit()" e
"KeyboardInterrupt" que é levantada quando um usuário deseja
interromper o programa.

"Exception" pode ser usada como um curinga que captura (quase) tudo.
No entanto, é uma boa prática ser o mais específico possível com os
tipos de exceções que pretendemos manipular e permitir que quaisquer
exceções inesperadas se propaguem.

O padrão mais comum para lidar com "Exception" é imprimir ou registrar
a exceção e então levantá-la novamente (permitindo que um chamador
lide com a exceção também):

   import sys

   try:
       f = open('myfile.txt')
       s = f.readline()
       i = int(s.strip())
   except OSError as err:
       print("OS error:", err)
   except ValueError:
       print("Could not convert data to an integer.")
   except Exception as err:
       print(f"Unexpected {err=}, {type(err)=}")
       raise

A construção "try" ... "except" possui uma *cláusula else* opcional,
que quando presente, deve ser colocada depois de todas as outras
cláusulas. É útil para um código que precisa ser executado se nenhuma
exceção foi levantada. Por exemplo:

   for arg in sys.argv[1:]:
       try:
           f = open(arg, 'r')
       except OSError:
           print('cannot open', arg)
       else:
           print(arg, 'has', len(f.readlines()), 'lines')
           f.close()

É melhor usar a cláusula "else" do que adicionar código adicional à
cláusula "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 "try" ... "except".

Os manipuladores de exceção não tratam apenas exceções que ocorrem
imediatamente na *cláusula try*, mas também aquelas que ocorrem dentro
de funções que são chamadas (mesmo indiretamente) na *cláusula try*.
Por exemplo:

   >>> def this_fails():
   ...     x = 1/0
   ...
   >>> try:
   ...     this_fails()
   ... except ZeroDivisionError as err:
   ...     print('Handling run-time error:', err)
   ...
   Handling run-time error: division by zero


8.4. Levantando exceções
========================

A instrução "raise" permite ao programador forçar a ocorrência de um
determinado tipo de exceção. Por exemplo:

   >>> raise NameError('HiThere')
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   NameError: HiThere

O argumento de "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 "BaseException", tal como "Exception" ou uma
de suas subclasses). Se uma classe de exceção for passada, será
implicitamente instanciada invocando o seu construtor sem argumentos:

   raise ValueError  # shorthand for 'raise ValueError()'

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 "raise"
permite que você levante-a novamente:

   >>> try:
   ...     raise NameError('HiThere')
   ... except NameError:
   ...     print('An exception flew by!')
   ...     raise
   ...
   An exception flew by!
   Traceback (most recent call last):
     File "<stdin>", line 2, in <module>
   NameError: HiThere


8.5. Encadeamento de exceções
=============================

Se uma exceção não tratada ocorrer dentro de uma seção "except", ela
terá a exceção sendo tratada anexada a ela e incluída na mensagem de
erro:

   >>> try:
   ...     open("database.sqlite")
   ... except OSError:
   ...     raise RuntimeError("unable to handle error")
   ...
   Traceback (most recent call last):
     File "<stdin>", line 2, in <module>
   FileNotFoundError: [Errno 2] No such file or directory: 'database.sqlite'

   During handling of the above exception, another exception occurred:

   Traceback (most recent call last):
     File "<stdin>", line 4, in <module>
   RuntimeError: unable to handle error

Para indicar que uma exceção é uma consequência direta de outra, a
instrução "raise" permite uma cláusula opcional "from":

   # exc must be exception instance or None.
   raise RuntimeError from exc

Isso pode ser útil quando você está transformando exceções. Por
exemplo:

   >>> def func():
   ...     raise ConnectionError
   ...
   >>> try:
   ...     func()
   ... except ConnectionError as exc:
   ...     raise RuntimeError('Failed to open database') from exc
   ...
   Traceback (most recent call last):
     File "<stdin>", line 2, in <module>
     File "<stdin>", line 2, in func
   ConnectionError

   The above exception was the direct cause of the following exception:

   Traceback (most recent call last):
     File "<stdin>", line 4, in <module>
   RuntimeError: Failed to open database

Ele também permite desabilitar o encadeamento automático de exceções
usando o idioma "from None":

   >>> try:
   ...     open('database.sqlite')
   ... except OSError:
   ...     raise RuntimeError from None
   ...
   Traceback (most recent call last):
     File "<stdin>", line 4, in <module>
   RuntimeError

Para mais informações sobre os mecanismos de encadeamento, veja
Exceções embutidas.


8.6. Exceções definidas pelo usuário
====================================

Programas podem definir novos tipos de exceções, através da criação de
uma nova classe (veja Classes para mais informações sobre classes
Python). Exceções devem ser derivadas da classe "Exception", direta ou
indiretamente.

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.

É comum que novas exceções sejam definidas com nomes terminando em
"Error", semelhante a muitas exceções embutidas.

Muitos módulos padrão definem suas próprias exceções para relatar
erros que podem ocorrer nas funções que definem.


8.7. Definindo ações de limpeza
===============================

A instrução "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:

   >>> try:
   ...     raise KeyboardInterrupt
   ... finally:
   ...     print('Goodbye, world!')
   ...
   Goodbye, world!
   Traceback (most recent call last):
     File "<stdin>", line 2, in <module>
   KeyboardInterrupt

Se uma cláusula "finally" estiver presente, a cláusula "finally" será
executada como a última tarefa antes da conclusão da instrução "try".
A cláusula "finally" executa se a instrução "try" produz uma exceção.
Os pontos a seguir discutem casos mais complexos quando ocorre uma
exceção:

* Se ocorrer uma exceção durante a execução da cláusula "try", a
  exceção poderá ser tratada por uma cláusula "except". Se a exceção
  não for tratada por uma cláusula "except", a exceção será gerada
  novamente após a execução da cláusula "finally".

* Uma exceção pode ocorrer durante a execução de uma cláusula "except"
  ou "else". Novamente, a exceção é re-levantada depois que "finally"
  é executada.

* Se a cláusula "finally" executa uma instrução "break", "continue" ou
  "return", as exceções não são levantadas novamente.

* Se a instrução "try" atingir uma instrução "break", "continue" ou
  "return", a cláusula "finally" será executada imediatamente antes da
  execução da instrução "break", "continue" ou "return".

* Se uma cláusula "finally" incluir uma instrução "return", o valor
  retornado será aquele da instrução "return" da cláusula "finally",
  não o valor da instrução "return" da cláusula "try".

Por exemplo:

   >>> def bool_return():
   ...     try:
   ...         return True
   ...     finally:
   ...         return False
   ...
   >>> bool_return()
   False

Um exemplo mais complicado:

   >>> def divide(x, y):
   ...     try:
   ...         result = x / y
   ...     except ZeroDivisionError:
   ...         print("division by zero!")
   ...     else:
   ...         print("result is", result)
   ...     finally:
   ...         print("executing finally clause")
   ...
   >>> divide(2, 1)
   result is 2.0
   executing finally clause
   >>> divide(2, 0)
   division by zero!
   executing finally clause
   >>> divide("2", "1")
   executing finally clause
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
     File "<stdin>", line 3, in divide
   TypeError: unsupported operand type(s) for /: 'str' and 'str'

Como você pode ver, a cláusula "finally" é executada em todos os
casos. A exceção "TypeError" levantada pela divisão de duas strings
não é tratada pela cláusula "except" e portanto é re-levantada depois
que a cláusula "finally" é executada.

Em aplicação do mundo real, a cláusula "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.


8.8. Ações de limpeza predefinidas
==================================

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.

   for line in open("myfile.txt"):
       print(line, end="")

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 "with" permite que objetos como
arquivos sejam utilizados com a certeza de que sempre serão
prontamente e corretamente finalizados.

   with open("myfile.txt") as f:
       for line in f:
           print(line, end="")

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.


8.9. Criando e tratando várias exceções não relacionadas
========================================================

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.

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

   >>> def f():
   ...     excs = [OSError('error 1'), SystemError('error 2')]
   ...     raise ExceptionGroup('there were problems', excs)
   ...
   >>> f()
     + Exception Group Traceback (most recent call last):
     |   File "<stdin>", line 1, in <module>
     |   File "<stdin>", line 3, in f
     | ExceptionGroup: there were problems
     +-+---------------- 1 ----------------
       | OSError: error 1
       +---------------- 2 ----------------
       | SystemError: error 2
       +------------------------------------
   >>> try:
   ...     f()
   ... except Exception as e:
   ...     print(f'caught {type(e)}: e')
   ...
   caught <class 'ExceptionGroup'>: e
   >>>

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.

   >>> def f():
   ...     raise ExceptionGroup(
   ...         "group1",
   ...         [
   ...             OSError(1),
   ...             SystemError(2),
   ...             ExceptionGroup(
   ...                 "group2",
   ...                 [
   ...                     OSError(3),
   ...                     RecursionError(4)
   ...                 ]
   ...             )
   ...         ]
   ...     )
   ...
   >>> try:
   ...     f()
   ... except* OSError as e:
   ...     print("There were OSErrors")
   ... except* SystemError as e:
   ...     print("There were SystemErrors")
   ...
   There were OSErrors
   There were SystemErrors
     + Exception Group Traceback (most recent call last):
     |   File "<stdin>", line 2, in <module>
     |   File "<stdin>", line 2, in f
     | ExceptionGroup: group1
     +-+---------------- 1 ----------------
       | ExceptionGroup: group2
       +-+---------------- 1 ----------------
         | RecursionError: 4
         +------------------------------------
   >>>

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:

   >>> excs = []
   ... for test in tests:
   ...     try:
   ...         test.run()
   ...     except Exception as e:
   ...         excs.append(e)
   ...
   >>> if excs:
   ...    raise ExceptionGroup("Test Failures", excs)
   ...


8.10. Enriquecendo exceções com notas
=====================================

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.

   >>> try:
   ...     raise TypeError('bad type')
   ... except Exception as e:
   ...     e.add_note('Add some information')
   ...     e.add_note('Add some more information')
   ...     raise
   ...
   Traceback (most recent call last):
     File "<stdin>", line 2, in <module>
   TypeError: bad type
   Add some information
   Add some more information
   >>>

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.

   >>> def f():
   ...     raise OSError('operation failed')
   ...
   >>> excs = []
   >>> for i in range(3):
   ...     try:
   ...         f()
   ...     except Exception as e:
   ...         e.add_note(f'Happened in Iteration {i+1}')
   ...         excs.append(e)
   ...
   >>> raise ExceptionGroup('We have some problems', excs)
     + Exception Group Traceback (most recent call last):
     |   File "<stdin>", line 1, in <module>
     | ExceptionGroup: We have some problems (3 sub-exceptions)
     +-+---------------- 1 ----------------
       | Traceback (most recent call last):
       |   File "<stdin>", line 3, in <module>
       |   File "<stdin>", line 2, in f
       | OSError: operation failed
       | Happened in Iteration 1
       +---------------- 2 ----------------
       | Traceback (most recent call last):
       |   File "<stdin>", line 3, in <module>
       |   File "<stdin>", line 2, in f
       | OSError: operation failed
       | Happened in Iteration 2
       +---------------- 3 ----------------
       | Traceback (most recent call last):
       |   File "<stdin>", line 3, in <module>
       |   File "<stdin>", line 2, in f
       | OSError: operation failed
       | Happened in Iteration 3
       +------------------------------------
   >>>
