Menangkap Exception dengan try / except

try / except adalah mekanisme yang menangkap error yang muncul saat runtime dan menjaga program tetap berjalan alih-alih membiarkannya crash. Pakai untuk operasi yang diperkirakan kadang gagal — pengambilan data eksternal, validasi input pengguna, operasi file, dan sejenisnya.

Syntax error vs. runtime error

Python memiliki dua jenis error besar. Syntax error terjadi ketika kode melanggar tata bahasa Python dan ditangkap sebelum program berjalan. Runtime error (exception) secara tata bahasa sah tetapi muncul saat program berjalan. Hanya runtime error yang bisa ditangkap dengan try / except.

# Syntax error: titik dua hilang. Gagal bahkan sebelum baris itu berjalan
# if x > 0
#     print("positif")

# Runtime error: tata bahasa benar, tapi gagal saat runtime
x = 100
print(x / 0)   # ZeroDivisionError: division by zero
print("baris ini tidak pernah berjalan")

Ketika runtime error muncul, semuanya setelah baris itu dilewati. Jalankan snippet berikut dan kamu akan melihat print() terakhir tidak berjalan — program berhenti di IndexError.

# Mengonfirmasi runtime error: tanpa try, program berhenti
numbers = [10, 20, 30]
print(numbers[10])       # IndexError: list index out of range
print("baris ini tidak pernah berjalan")
# Output:
# Traceback (most recent call last):
#   File "...", line 3, in <module>
# IndexError: list index out of range

Dasar try / except

Letakkan kode berisiko di blok try: dan kode pemulihan di blok except ErrorClass:.

Begitu error muncul di try, sisa badan try dilewati dan kontrol melompat ke except yang cocok. Kode setelah except tetap berjalan bahkan ketika terjadi error.

# Membungkus dengan try menjaga program tetap jalan meski pembagian dengan nol muncul
a = 100
try:
    result = a / 0
    print(result)                   # tidak pernah tercapai
except ZeroDivisionError:
    print("Tidak bisa bagi dengan 0")  # kontrol melompat ke sini

print("setelah blok try")            # selalu berjalan setelah try / except
# Output: Tidak bisa bagi dengan 0
#        setelah blok try

Lindungi akses indeks di luar jangkauan pada daftar stok.

① Definisikan stock = [12, 8, 3] (jumlah di tiap rak).

② Pertama konfirmasi apa yang terjadi jika kamu memanggil stock[5] tanpa try. Jawabannya menyimpan baris ini sebagai komentar; uncomment untuk melihat program berhenti dengan IndexError.

③ Sekarang jalankan print(stock[5]) di dalam try dan cetak "Rak itu tidak ada" dari except IndexError:.

④ Setelah try / except, cetak "Melanjutkan…" untuk mengonfirmasi eksekusi berlanjut meski setelah exception.

(Penjelasan akan muncul setelah kamu menjalankan kode dengan benar.)

Menangkap objek exception dengan as e

Menulis except ErrorClass as e: memasukkan detail exception ke e. print(e) menampilkan pesan error, dan type(e) menampilkan kelas error-nya. Mencatat keduanya adalah titik awal yang solid untuk menelusuri masalah nanti.

user_input = "abc"   # seharusnya angka, tapi yang datang string

try:
    value = int(user_input)
except ValueError as e:
    print("Input bukan angka")
    print(f"Detail: {e}")
    print(f"Jenis: {type(e).__name__}")
# Output: Input bukan angka
#        Detail: invalid literal for int() with base 10: 'abc'
#        Jenis: ValueError

Pesan saja tidak memberitahumu di mana error muncul, jadi saat debugging standarnya adalah memasangkannya dengan import traceback. traceback.format_exc() mengembalikan jalur panggilan (stack trace) pada saat exception muncul, dan mencatatnya membuat analisis akar penyebab jauh lebih mudah.

import traceback

try:
    value = int("abc")
except ValueError as e:
    print(f"Detail: {e}")
    print(f"Jenis: {type(e).__name__}")
    print("--- traceback ---")
    print(traceback.format_exc())
# Output:
# Detail: invalid literal for int() with base 10: 'abc'
# Jenis: ValueError
# --- traceback ---
# Traceback (most recent call last):
#   File "...", line 4, in <module>
#     value = int("abc")
# ValueError: invalid literal for int() with base 10: 'abc'

Ketika input pengguna tidak bisa dikonversi ke angka, cetak pesan, jenis, dan stack trace sekaligus.

① Di atas, tulis import traceback dan set user_input = "Jakarta".

② Di try, panggil int(user_input), dan tangkap dengan except ValueError as e:.

③ Di dalam except, cetak "Pesan: {e} / Jenis: {type(e).__name__}" dalam satu baris, lalu print(traceback.format_exc()).

Beberapa blok except dan Exception sebagai payung

Kamu bisa menumpuk beberapa blok except pada satu try. Yang cocok pertama akan berjalan, jadi idiomnya adalah menuliskannya dari paling spesifik ke paling umum.

Setiap runtime error mewarisi dari Exception, jadi except Exception as e: menangkap apa pun, termasuk error yang tidak terduga.

numbers = [10, 20, 30]
index = 1
divisor = 0

try:
    value = numbers[index]
    print(value / divisor)
except IndexError as e:
    print(f"Indeks di luar jangkauan: {e}")
except ZeroDivisionError as e:
    print(f"Tidak bisa bagi dengan 0: {e}")
except Exception as e:
    print(f"Error lain: {type(e).__name__}: {e}")
# Output: Tidak bisa bagi dengan 0: division by zero

Jangan letakkan Exception di depan

Exception adalah parent hampir semua exception, jadi meletakkannya di atas mencegah except yang lebih spesifik setelahnya berjalan. Pakai ia sebagai jaring pengaman terakhir untuk error yang tidak terduga.

Ambil sejumlah item dari riwayat pembelian pengguna, jumlahkan, dan hitung rata-ratanya.

① Definisikan history = [1200, 800, 1500] (jumlah pembelian) dan take = 10 (banyak yang diambil).

② Di dalam try, hitung total = sum(history[:take]), lalu avg = total / len(history[:take]) dan print(f"Rata-rata: {avg}").

③ Tambahkan penangkap umum: except ZeroDivisionError as e: mencetak "Tidak ada data", dan except Exception as e: mencetak "Tak terduga: {e}". (Di jalur happy path rata-rata dicetak normal.)

Menjalankan cleanup dengan finally

Blok finally: adalah slot cleanup yang selalu berjalan, apakah exception muncul atau tidak. Pakai untuk melepaskan sumber daya yang harus ditutup — file, koneksi DB, dan sejenisnya.

Blok else: berjalan hanya ketika tidak ada exception. Tidak terlalu sering dipakai, tapi ia membuat jalur "hanya saat sukses, lanjutkan" menjadi eksplisit.

# Jalur happy: else dan finally berjalan
a, b = 10, 2
try:
    result = a / b
except ZeroDivisionError:
    print("Tertangkap bagi dengan nol")
else:
    print(f"Sukses: {result}")
finally:
    print("Menjalankan cleanup")
# Output: Sukses: 5.0
#        Menjalankan cleanup

print("---")

# Jalur error: except dan finally berjalan
a, b = 10, 0
try:
    result = a / b
except ZeroDivisionError:
    print("Tertangkap bagi dengan nol")
else:
    print(f"Sukses: {result}")
finally:
    print("Menjalankan cleanup")
# Output: Tertangkap bagi dengan nol
#        Menjalankan cleanup

Simulasikan panggilan API dan catat sukses, gagal, dan cleanup di setiap jalur.

① Definisikan user_ids = [101, 102, 103] dan target = 0.

② Di try, ambil user = user_ids[target] (jangan print dulu).

③ Di except IndexError:, cetak "Pengguna tidak ditemukan".

④ Di else:, cetak f"Diambil: {user}" sehingga ia berjalan hanya saat tidak ada exception.

⑤ Di finally:, cetak "Koneksi ditutup" sehingga ia berjalan di kedua jalur.

Di artikel ini kamu belajar dasar penanganan exception dengan try / except, cara menangkap info exception dengan as e, cara menumpuk beberapa blok except dan memakai Exception sebagai penangkap umum, dan cara menjalankan cleanup dengan finally. Berikutnya: memunculkan exception sendiri dengan raise, dan mendefinisikan kelas exception kustom.