Exceções e tratamento de erros

Quando algo dá errado

Quando o Python não consegue fazer o que você pediu, ele levanta uma exceção: float("abc") levanta ValueError, {}["x"] levanta KeyError, 1 / 0 levanta ZeroDivisionError, abrir um arquivo ausente levanta FileNotFoundError. Se nada a tratar, o programa para e imprime um traceback, a cadeia de chamadas que levou até ali, lida de baixo para cima. Esse é o resultado certo para um bug de verdade. Para problemas previsíveis, como um preço ruim digitado por um usuário, você trata a exceção com try e except.

# Handle an expected problem
def to_price(text):
    try:
        return float(text)
    except ValueError:
        return None

print(to_price("184.25"))  # 184.25
print(to_price("abc"))     # None

# An unhandled one stops the program with a traceback
# print(int("abc"))        # ValueError: invalid literal for int()...

Capture só o que espera

Nomeie o tipo de exceção: except ValueError:. Um except: sozinho ou except Exception: também engole bugs que você não queria esconder, como um TypeError causado por passar None, e o programa segue com dados errados. Vários tipos podem compartilhar um tratador, except (ValueError, KeyError):, ou ter tratadores separados. O Python testa os tratadores em ordem e executa o primeiro que corresponde. Você pode guardar o erro com except ValueError as error: e examiná-lo.

# Specific handlers, tried in order
def read_quantity(text):
    try:
        return int(text)
    except ValueError as error:
        print("not a whole number:", error)
        return 0
    except TypeError:
        print("expected text, got something else")
        return 0

print(read_quantity("200"))  # 200
print(read_quantity("2.5"))  # prints the message, then 0
print(read_quantity(None))   # prints the message, then 0

else e finally

Duas partes opcionais completam a instrução. else: roda só quando o bloco try não levantou nada, o que mantém curta a linha arriscada e deixa o código seguinte fora da proteção. finally: roda sempre, com erro ou não, mesmo depois de um return: use-o para limpeza. Muitas vezes um bloco with já faz a limpeza por você, como nos arquivos.

# else runs on success, finally runs always
def describe(text):
    try:
        price = float(text)
    except ValueError:
        print("bad price")
    else:
        print("price is", price)
    finally:
        print("done with", repr(text))

describe("184.25")
# price is 184.25
# done with '184.25'
describe("abc")
# bad price
# done with 'abc'

Levantar seus próprios erros

Uma função que recebe um valor que não pode aceitar deve recusar com clareza usando raise, e não devolver algo errado em silêncio: raise ValueError("price must be positive"). Escolha o tipo embutido adequado (ValueError para tipo certo mas valor ruim, TypeError para tipo errado) e escreva uma mensagem que diga o que houve. Quem chama decide se captura. Dentro de um bloco except, um raise sozinho relança o erro que acabou de ser capturado, útil quando você só queria registrá-lo.

# Refuse bad input, let the caller decide
def parse_price(text):
    price = float(text)           # may raise ValueError itself
    if not price > 0:
        raise ValueError("price must be positive")
    return price

for text in ["184.25", "-5", "abc"]:
    try:
        print(parse_price(text))
    except ValueError as error:
        print("rejected:", error)
# 184.25
# rejected: price must be positive
# rejected: could not convert string to float: 'abc'

• try / except SpecificError: trate os problemas esperados, nada mais.
• else roda se nada foi levantado; finally sempre roda.
• raise ValueError("message") recusa claramente uma entrada inválida.

A seguir: módulos e imports, como reutilizar código da biblioteca padrão e dos seus próprios arquivos.

Lab: o que é avaliado

• Converter texto sem quebrar com safe_float25 pts
• Recusar um preço inválido com parse_price25 pts
• Pular entradas inválidas com first_valid_price25 pts
• Tratar um arquivo ausente ou danificado com read_quantity25 pts