Exception di Python: try, except, else, finally, raise dan exception buatan sendiri

Exception di Python adalah objek yang menandai terjadinya error dan menghentikan jalannya program biasa. Jika tidak ada yang menangkapnya, Python mencetak traceback dan program berhenti. Exception ditangkap dengan konstruksi try/except, dan dimunculkan dengan instruksi raise. Berikut dibahas cara kerjanya, error yang paling sering muncul, dan cara menangani error tanpa menyembunyikannya.

Apa itu exception di Python

Ketika suatu operasi tidak bisa dijalankan — pembagian dengan nol, mengakses kunci yang tidak ada, mengubah kata menjadi angka — Python membuat objek exception dan «melemparkannya». Eksekusi fungsi saat itu berhenti, exception naik melalui rantai pemanggilan sampai menemukan penangan yang cocok. Jika tidak ada, program berhenti.

>>> 10 / 0
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero

Jawaban untuk pertanyaan yang sering muncul: pembagian dengan nol di Python memunculkan exception ZeroDivisionError. Ini berlaku untuk /, //, dan %.

Cara membaca traceback

Traceback adalah laporan tentang bagaimana program sampai pada error. Membacanya lebih mudah dari bawah ke atas. Baris terakhir adalah yang terpenting: jenis exception dan pesannya. Di atasnya ada baris kode tempat kejadian, dan di atas itu lagi siapa yang memanggilnya, sampai titik masuk program.

Traceback (most recent call last):
  File "tracker.py", line 9, in <module>
    total = parse_amount(row)
  File "tracker.py", line 4, in parse_amount
    return float(raw.strip())
           ~~~~~^^^^^^^^^^^^^
ValueError: could not convert string to float: 'seratus'

Sejak Python 3.11, di bawah baris kode digambar tanda ~~~^^^ (PEP 657): tanda ini menunjukkan bagian mana dari ekspresi yang gagal. Ini sangat membantu ketika beberapa pemanggilan ditulis berurutan dalam satu baris.

Saran «Did you mean»

Sejak Python 3.10, jika ada salah ketik pada nama, error menawarkan nama yang mirip. Di Python 3.15 saran ini menjadi lebih pintar: interpreter mengenali kebiasaan dari bahasa lain. Pemanggilan list.push akan menyarankan append, dan "kopi".toUpperCase() akan menyarankan metode upper. Saran juga memeriksa field bersarang: jika dict ada di atribut totals dari sebuah objek, lalu Anda memanggil items() langsung pada objek itu, saran akan menyebut .totals.items. Nama-nama yang mirip juga kini disarankan oleh delattr().

Jenis exception di Python

Ada puluhan exception bawaan, tetapi di awal belajar Anda paling sering menemui yang berikut:

Ada juga SyntaxError (dan kasus khususnya IndentationError): ini muncul saat berkas diurai, sebelum kode dijalankan, sehingga tidak bisa ditangkap dengan try di berkas yang sama.

Hierarki exception

Exception adalah kelas, dan kelas-kelas itu tersusun dalam hierarki. Di puncaknya ada BaseException. Dari situ turun Exception (hampir semua error «biasa») dan beberapa exception sistem: KeyboardInterrupt, SystemExit, GeneratorExit.

BaseException
 ├── KeyboardInterrupt
 ├── SystemExit
 └── Exception
      ├── ArithmeticError
      │    └── ZeroDivisionError
      ├── LookupError
      │    ├── KeyError
      │    └── IndexError
      ├── OSError
      │    └── FileNotFoundError
      ├── TypeError
      └── ValueError

Hierarki ini penting saat menangkap: except LookupError juga menangkap KeyError dan IndexError. Sementara KeyboardInterrupt bukan error dalam kode: ia menandakan bahwa pengguna menekan Ctrl+C. Ia sengaja tidak diturunkan dari Exception, supaya except Exception tidak menghalangi penghentian program.

Penanganan exception: try/except/else/finally

Kode yang mungkin gagal ditaruh di blok try. Di blok except ditulis jenis error dan apa yang harus dilakukan. except adalah blok yang dipakai Python untuk menangani exception.

def parse_amount(raw):
    try:
        value = float(raw)
    except ValueError as e:
        print(f"Melewati baris: {e}")
        return None
    else:
        return value          # dijalankan jika tidak ada error
    finally:
        print("parsing selesai")   # selalu dijalankan

print(parse_amount("250"))

Urutan keluarannya: pertama «parsing selesai», lalu 250.0. return di blok else menyimpan nilainya, lalu Python pasti menjalankan finally dan baru setelah itu mengembalikan hasil. Karena itu finally bisa diandalkan untuk bersih-bersih: menutup berkas, melepas koneksi.

Jika di dalam finally ditulis return sendiri, ia akan menimpa yang sebelumnya dan bahkan «menelan» exception. Sejak Python 3.14, kode seperti ini menghasilkan SyntaxWarning (PEP 765) — jangan menulis return di dalam finally.

Beberapa exception sekaligus

Anda bisa menulis beberapa blok except untuk jenis yang berbeda, atau menyebutkan beberapa jenis dalam satu tuple:

try:
    amount = int(data["amount"])
except KeyError:
    amount = 0
except (ValueError, TypeError) as e:
    print("Jumlah tidak valid:", e)
    amount = 0

Blok diperiksa dari atas ke bawah, dan yang pertama cocok akan dijalankan, sehingga jenis yang lebih spesifik diletakkan di atas jenis yang lebih umum. Sejak Python 3.14 (PEP 758), beberapa jenis bisa ditulis tanpa tanda kurung — except ValueError, TypeError: — tetapi jika ada as, tanda kurung tetap wajib.

Cara menampilkan teks error dan mengetahui jenisnya

Objek exception tersedia lewat as e. str(e) memberikan pesannya, type(e).__name__ memberikan nama jenisnya:

try:
    int("seratus")
except ValueError as e:
    print(type(e).__name__)   # ValueError
    print(e)                  # invalid literal for int() with base 10: 'seratus'

Modul traceback: teks error lengkap

Kadang error perlu ditangkap, tetapi traceback lengkapnya tetap harus disimpan — untuk log atau laporan. Untuk itu ada modul traceback:

import traceback

try:
    1 / 0
except ZeroDivisionError:
    traceback.print_exc()             # mencetak traceback ke stderr
    text = traceback.format_exc()     # teks yang sama dalam bentuk string

Jika Anda menulis log dengan modul logging, lebih mudah memanggil logging.exception("gagal menghitung") di dalam except — traceback otomatis ikut dicatat.

raise di Python: memunculkan exception

Instruksi raise melemparkan exception secara manual. Dengan begitu fungsi menyatakan bahwa ia tidak bisa mengerjakan tugasnya dengan data tersebut:

def add_expense(amount):
    if amount < 0:
        raise ValueError(f"Jumlah tidak boleh negatif: {amount}")
    ...

add_expense(-5)
# ValueError: Jumlah tidak boleh negatif: -5

raise di Python adalah instruksi, bukan fungsi, jadi tidak ada tanda kurung setelah kata raise: argumen dalam kurung diberikan kepada konstruktor exception. Pilih jenisnya sesuai maknanya: nilai yang salah — ValueError, tipe yang salah — TypeError.

raise tanpa argumen dan raise from

Di dalam except, raise tanpa argumen meneruskan exception yang sedang ditangani tanpa perubahan. Ini berguna ketika Anda ingin mencatat sesuatu ke log, tetapi penanganannya diserahkan ke kode pemanggil.

Jika Anda mengganti satu exception dengan exception lain, gunakan raise ... from e — error asli tetap tersimpan dalam rantai, dan traceback memperlihatkan keduanya:

def load_config(path):
    try:
        with open(path) as f:
            return f.read()
    except FileNotFoundError as e:
        raise RuntimeError(f"Konfigurasi {path} tidak ditemukan") from e

add_note: menambahkan konteks pada error

Sejak Python 3.11 (PEP 678), exception bisa diberi catatan dengan metode add_note() lalu diteruskan lagi. Jenis error tidak berubah, dan catatan dicetak di bawah pesannya:

def parse(raw, line_no):
    try:
        return float(raw)
    except ValueError as e:
        e.add_note(f"berkas expenses.csv, baris {line_no}")
        raise

parse("seratus", 17)
# ValueError: could not convert string to float: 'seratus'
# berkas expenses.csv, baris 17

Cara membuat exception sendiri di Python

Exception buatan sendiri diperlukan untuk error dari domain aplikasi: anggaran terlampaui, pesanan sudah dibayar, pengguna diblokir. Cukup buat kelas turunan Exception:

class BudgetExceeded(Exception):
    def __init__(self, category, limit, spent):
        super().__init__(f"{category}: batas {limit}, sudah dipakai {spent}")
        self.category = category
        self.limit = limit
        self.spent = spent

def check_budget(category, limit, spent):
    if spent > limit:
        raise BudgetExceeded(category, limit, spent)

try:
    check_budget("Makan", 10000, 12500)
except BudgetExceeded as e:
    print("Peringatan:", e)   # Peringatan: Makan: batas 10000, sudah dipakai 12500

Dengan begitu kode pemanggil menangkap tepat kasus anggaran terlampaui dan tidak mencampurnya dengan salah ketik. Dalam proyek besar, berguna untuk membuat kelas dasar bersama (class TrackerError(Exception)) dan menurunkan semua exception sendiri darinya — sehingga semuanya bisa ditangkap dengan satu except TrackerError. Turunkan dari Exception, bukan dari BaseException.

Grup exception dan except*

Kadang error terjadi bersamaan, misalnya saat memeriksa seluruh berkas atau pada tugas paralel di asyncio.TaskGroup. Sejak Python 3.11, error-error itu bisa dikumpulkan dalam ExceptionGroup, dan ditangani per jenis dengan except*:

def check_all(rows):
    errors = []
    for r in rows:
        try:
            float(r)
        except ValueError as e:
            errors.append(e)
    if errors:
        raise ExceptionGroup("error dalam berkas", errors)

try:
    check_all(["1", "a", "b"])
except* ValueError as eg:
    print(f"Baris rusak: {len(eg.exceptions)}")   # Baris rusak: 2

Python try except semua error: mengapa itu tidak dianjurkan

Kebiasaan paling berbahaya adalah menangkap semuanya: except: pass. Program «tidak lagi jatuh», tetapi sebenarnya tidak lagi melaporkan masalah. except tanpa jenis menangkap bahkan KeyboardInterrupt dan SystemExit, sehingga program tidak bisa dihentikan dengan Ctrl+C. except Exception: pass sedikit lebih baik, tetapi tetap menelan diam-diam salah ketik nama dan kesalahan logika.

Cara menangani exception di Python dengan benar:

• tangkap hanya jenis yang bisa Anda tangani, misalnya except ValueError, bukan semuanya;
• buat blok try sependek mungkin — hanya baris yang memang bisa gagal dengan cara itu;
• jika menangkap secara luas (except Exception) di level atas program, pastikan traceback dicatat ke log;
• jangan memakai exception untuk percabangan biasa jika pengecekan sudah cukup: di kasus sederhana, dict.get() lebih baik daripada try/except KeyError;
• untuk sumber daya, gunakan with — ia akan menutup berkas bahkan ketika terjadi error.

Ringkasan

Exception di Python adalah mekanisme yang wajar untuk melaporkan error, bukan alasan untuk menyembunyikannya. Baca traceback dari bawah ke atas, tangkap jenis yang spesifik dalam try/except, gunakan else untuk kode «jika semuanya berhasil», dan finally untuk bersih-bersih. raise dipakai untuk melaporkan error sendiri, raise from dan add_note menjaga konteks, dan exception buatan sendiri diturunkan dari Exception. Topik ini dipraktikkan dalam kursus Python: pencatat pengeluaran tidak lagi jatuh karena satu baris CSV yang rusak, dan kelebihan anggaran dinyatakan dengan exception tersendiri.