Exception di Python: try, except, else, finally, dan raise

Error hanyalah nilai yang bersikap buruk

Saat ada yang salah di Python, misalnya membagi dengan nol, membaca file yang tidak ada, atau mengurai angka yang salah, runtime membuat sebuah objek exception lalu mulai membongkar call stack sampai ada yang menangkapnya. Kalau tidak ada yang menangkap, programmu berhenti dan mencetak traceback.

Exception sendiri bukan hal buruk. Exception adalah cara Python memberi tanda "aku tidak bisa melanjutkan operasi ini; ini alasannya." Tugasmu adalah memutuskan, kasus demi kasus, exception mana yang kamu tahu cara memulihkannya dan mana yang sebaiknya dibiarkan naik.

Bentuk dasarnya

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: membuka blok kode yang berisiko.
• except ValueError: menangkap exception tertentu itu kalau dimunculkan di dalam try.
• Kalau tidak ada exception, except dilewati sepenuhnya.

Jalankan potongan kode itu dengan 42: berhasil. Jalankan dengan hello: handler-nya yang berjalan.

Menangkap exception tertentu

Python punya hierarki tipe exception. Beberapa yang akan sering kamu temui:

• ValueError: ada nilai yang salah dalam suatu hal (int("abc"), argumen di luar rentang).
• TypeError: tipe yang dipakai salah ("hi" + 3).
• KeyError: key dict tidak ditemukan.
• IndexError: indeks deretan di luar rentang.
• FileNotFoundError: sebuah file tidak ada.
• ZeroDivisionError: mencoba membagi dengan nol.
• AttributeError: sebuah objek tidak punya atribut yang diminta.

Tangkap exception tertentu yang kamu tahu cara menanganinya:

data = {"count": 5}

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

Kamu bisa menangkap beberapa exception dalam satu klausa dengan memberikan tuple:

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

Perhatikan as e. Itu mengikat objek exception ke e sehingga kamu bisa memeriksa pesan atau atributnya.

Hindari menangkap semuanya

except: tanpa tipe menangkap benar-benar apa saja, termasuk KeyboardInterrupt (Ctrl-C milikmu) dan perintah keluar di level sistem. Jangan pakai.

except Exception: sedikit lebih baik, tapi tetap berbahaya: ia menelan bug yang tidak kamu duga dan menyembunyikan sumber masalah yang sebenarnya:

# Don't do this without a really good reason.
try:
    do_something()
except Exception:
    pass

Langkah yang tepat hampir selalu menangkap exception tertentu yang kamu tahu cara memulihkannya. Kalau exception yang tidak terduga sampai ke puncak programmu, traceback akan memberi tahu persis apa yang salah, dan itu fitur, bukan bug.

else dan finally

Pernyataan try punya dua klausa opsional lagi:

• else berjalan kalau blok try selesai tanpa memunculkan exception.
• finally berjalan apa pun yang terjadi, ada exception atau tidak.

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 adalah tempat paling rapi untuk kode "hanya saat berhasil": kamu tidak ingin blok try melakukan lebih dari bagian yang memang bisa gagal. finally untuk pembersihan yang harus tetap berjalan walaupun try gagal: menutup resource, melepas lock, mengembalikan state.

Memunculkan exception sendiri

Pakai raise untuk memberi tanda error di kodemu sendiri:

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}")

Pilih tipe exception yang sesuai dengan apa yang salah. Pakai dulu yang bawaan, seperti ValueError, TypeError, FileNotFoundError, sebelum mendefinisikan class sendiri.

Mendefinisikan exception sendiri

Kalau yang bawaan tidak bisa menangkap maknanya, definisikan exception khusus:

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

def charge(amount):
    # Imagine this talks to a payment processor.
    if amount > 1000:
        raise PaymentDeclined(f"Declined for ${amount}")
    print(f"Charged ${amount}")

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

Wariskan dari Exception (atau tipe bawaan yang lebih spesifik) dan beri class itu sebuah docstring. Biasanya hanya itu yang kamu butuhkan. Exception khusus membuat pemanggil bisa menangkap hanya error yang bermakna bagi domain mereka.

raise ... from ...: exception berantai

Saat satu exception memicu exception lain, pertahankan rantainya:

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 menempelkan error aslinya. Saat traceback dicetak, Python menampilkan keduanya: ConfigError yang muncul dan FileNotFoundError yang menyebabkannya. Jejak seperti itu sangat berharga saat debugging.

Context manager: cara membersihkan yang lebih rapi

finally tidak masalah, tapi untuk resource seperti file, context manager (yang dipakai with) hampir selalu lebih baik:

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

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

Keduanya aman. Bentuk with lebih singkat dan berlaku otomatis. Pakai finally hanya kalau kamu melakukan sesuatu yang belum dibungkus standard library dalam sebuah context manager.

Kapan tidak menangkap

Menangkap exception adalah sebuah keputusan: kamu sedang bilang "aku bisa menangani ini." Kalau tidak bisa, biarkan exception itu merambat. Kode seperti ini hampir selalu keliru:

try:
    do_work()
except Exception:
    pass  # silently ignore everything

Membungkam error membuat bug tidak terlihat. Lebih baik program crash dengan jelas daripada terus berjalan tertatih-tatih dalam keadaan yang tidak konsisten.

Rangkuman

• try/except memungkinkan kamu menangani error yang bisa dipulihkan.
• Tangkap exception tertentu, bukan Exception secara membabi buta.
• raise memberi tanda error di kodemu sendiri.
• Blok with menggantikan sebagian besar pembersihan dengan finally.
• Kalau ragu, biarkan exception-nya merambat.

Berikutnya: tur error spesifik yang paling sering dimunculkan Python, seperti KeyError, ValueError, ModuleNotFoundError, dan beberapa lainnya, beserta kebiasaan debugging yang memperbaikinya dengan cepat.