Wyjątki w Pythonie: try, except, else, finally i raise

Błędy to po prostu wartości ze złym charakterem

Gdy w Pythonie coś idzie nie tak (dzielenie przez zero, odczyt brakującego pliku, parsowanie złej liczby), środowisko tworzy obiekt wyjątku i zaczyna zwijać stos wywołań, aż coś go złapie. Jeśli nic go nie złapie, program kończy działanie i wypisuje traceback.

Wyjątki same w sobie nie są złe. To sposób, w jaki Python sygnalizuje "nie mogę kontynuować tej operacji, a oto dlaczego". Twoim zadaniem jest decydować w każdym przypadku osobno, po których umiesz się pozbierać, a które należy przepuścić wyżej.

Podstawowy kształt

text = input("Type a number: ")

try:
    number = int(text)
    print(f"Doubled: {number * 2}")
except ValueError:
    print(f"That wasn't a valid number: {text!r}")

• try: otwiera blok ryzykownego kodu.
• except ValueError: łapie ten konkretny wyjątek, jeśli zostanie zgłoszony w try.
• Jeśli żaden wyjątek nie wystąpi, except jest całkowicie pomijany.

Uruchom fragment z 42: działa. Uruchom go z hello: wykonuje się obsługa błędu.

Łapanie konkretnych wyjątków

Python ma hierarchię typów wyjątków. Kilka, które spotkasz często:

• ValueError: wartość jest w jakiś sposób niepoprawna (int("abc"), argumenty spoza zakresu).
• TypeError: użyto złego typu ("hi" + 3).
• KeyError: nie znaleziono klucza w słowniku.
• IndexError: indeks sekwencji jest poza zakresem.
• FileNotFoundError: plik nie istnieje.
• ZeroDivisionError: próba dzielenia przez zero.
• AttributeError: obiekt nie ma żądanego atrybutu.

Łap ten konkretny, który umiesz obsłużyć:

data = {"count": 5}

try:
    print(data["missing"])
except KeyError:
    print("Key not found - using a default.")

Kilka wyjątków możesz złapać w jednej klauzuli, przekazując krotkę:

try:
    value = int(input("Number? "))
    result = 10 / value
except (ValueError, ZeroDivisionError) as e:
    print(f"Got bad input: {e}")

Zwróć uwagę na as e. To wiąże obiekt wyjątku z e, żeby można było sprawdzić jego komunikat albo atrybuty.

Nie łap wszystkiego

Gołe except: łapie dosłownie wszystko, łącznie z KeyboardInterrupt (twoim Ctrl-C) i wyjściem na poziomie systemu. Nie używaj go.

except Exception: jest trochę lepsze, ale nadal niebezpieczne: połyka nieprzewidziane błędy i ukrywa prawdziwe źródło problemów:

# Nie rób tego bez naprawdę dobrego powodu.
try:
    do_something()
except Exception:
    pass

Właściwy ruch to prawie zawsze łapanie konkretnego wyjątku, po którym umiesz się pozbierać. Jeśli nieoczekiwany wyjątek dotrze na szczyt programu, traceback powie ci dokładnie, co poszło nie tak, i to jest zaleta, a nie wada.

else i finally

Instrukcja try ma jeszcze dwie opcjonalne klauzule:

• else wykonuje się, jeśli blok try zakończył się bez wyjątku.
• finally wykonuje się zawsze, niezależnie od tego, czy był wyjątek.

def parse_line(line):
    try:
        key, value = line.strip().split("=", 1)
    except ValueError:
        print(f"Couldn't parse: {line!r}")
        return None
    else:
        print(f"Parsed: {key} = {value}")
        return (key.strip(), value.strip())
    finally:
        print("Done with this line.")

parse_line("host = localhost")
parse_line("missing equals sign")

else to najczystsze miejsce na kod "tylko przy sukcesie": blok try nie powinien robić więcej niż ta część, która naprawdę może zawieść. finally służy do sprzątania, które musi się wykonać nawet przy niepowodzeniu: zamknięcia zasobu, zwolnienia blokady, przywrócenia stanu.

Samodzielne zgłaszanie wyjątków

Użyj raise, by zasygnalizować błąd we własnym kodzie:

def discount(price, percent):
    if percent < 0 or percent > 100:
        raise ValueError(f"Percent must be 0–100, got {percent}")
    return price * (1 - percent / 100)

print(discount(100, 20))

try:
    discount(100, 150)
except ValueError as e:
    print(f"Caught: {e}")

Wybierz typ wyjątku pasujący do tego, co poszło źle. Najpierw sięgaj po wbudowane (ValueError, TypeError, FileNotFoundError), zanim zdefiniujesz własną klasę.

Definiowanie własnego wyjątku

Gdy wbudowane wyjątki nie oddają znaczenia, zdefiniuj własny:

class PaymentDeclined(Exception):
    """Raised when a payment provider declines the transaction."""

def charge(amount):
    # Wyobraź sobie, że to rozmawia z operatorem płatności.
    if amount > 1000:
        raise PaymentDeclined(f"Declined for ${amount}")
    print(f"Charged ${amount}")

try:
    charge(1500)
except PaymentDeclined as e:
    print("Payment failed:", e)

Dziedzicz po Exception (albo po bardziej konkretnym wbudowanym wyjątku) i dodaj klasie docstring. Zwykle tyle wystarczy. Własne wyjątki pozwalają wywołującym łapać tylko ten błąd, który ma znaczenie w ich dziedzinie.

raise ... from ...: łańcuchy wyjątków

Gdy jeden wyjątek wywołuje drugi, zachowaj łańcuch:

class ConfigError(Exception):
    pass

def load_config(path):
    try:
        with open(path) as f:
            return f.read()
    except FileNotFoundError as e:
        raise ConfigError(f"Missing config at {path}") from e

try:
    load_config("nonexistent.cfg")
except ConfigError as e:
    print("Top-level:", e)
    print("Caused by:", e.__cause__)

from e dołącza oryginalny błąd. Gdy traceback jest wypisywany, Python pokazuje oba: ConfigError, który wypłynął na wierzch, i FileNotFoundError, który go spowodował. Taki ślad jest bezcenny przy debugowaniu.

Menedżery kontekstu: czystszy sposób na sprzątanie

finally jest w porządku, ale dla zasobów takich jak pliki menedżer kontekstu (to, czego używa with) jest prawie zawsze lepszy:

# wersja z finally
f = open("data.txt")
try:
    data = f.read()
finally:
    f.close()

# wersja z with
with open("data.txt") as f:
    data = f.read()

Obie są bezpieczne. Forma z with jest krótsza i działa automatycznie. Po finally sięgaj tylko wtedy, gdy robisz coś, czego biblioteka standardowa nie opakowuje już w menedżer kontekstu.

Kiedy nie łapać

Złapanie wyjątku to decyzja: mówisz "umiem to obsłużyć". Jeśli nie umiesz, pozwól wyjątkowi się propagować. Taki kod to prawie zawsze błąd:

try:
    do_work()
except Exception:
    pass  # po cichu ignoruje wszystko

Uciszanie błędów sprawia, że stają się niewidoczne. Lepiej wyłożyć się głośno, niż kuśtykać dalej w niespójnym stanie.

Podsumowanie

• try/except pozwala obsłużyć błędy, po których da się pozbierać.
• Łap konkretne wyjątki, a nie Exception na ślepo.
• raise sygnalizuje błędy we własnym kodzie.
• Bloki with zastępują większość sprzątania w finally.
• W razie wątpliwości pozwól wyjątkowi się propagować.

Dalej: przegląd konkretnych błędów, które Python zgłasza najczęściej (KeyError, ValueError, ModuleNotFoundError i kilka innych), oraz nawyków debugowania, które pozwalają szybko je naprawić.