Cara menggunakan raise valueerror python 3

Semakin komplek fungsi dan program yang dibuat, maka semakin banyak celah yang memungkinkan program terdapat kesalahan. Sebagai contoh, berikut ini adalah error-error yang pernah terjadi di saat menjalankan beberapa kode di module-module sebelumnya:

Table of Contents Show

Defensive Programming
Exception Handling
Black box testing
Menjalankan testing
Glass box testing
Debugging dengan Print
Debugger pada IDLE
Apa penyebab terjadinya suatu pengecualian exceptions di suatu program?
Di dalam statement try apa arti dari except?
Apa itu Exception pada python?

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
 in ()
     11 segi4_1 = luas_segiempat(1, 1, 3, 3)
     12 segi4_2 = luas_segiempat(2, 4, 3, 3)
---> 13 print(segi4_1 + segi4_2)

TypeError: unsupported operand type(s) for +: 'int' and 'NoneType'

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
 in ()
     11 segi4_1 = luas_segiempat(1, 1, 3, 3)
     12 segi4_2 = luas_segiempat(2, 4, 3, 3)
---> 13 print(segi4_1 + segi4_2)

TypeError: unsupported operand type(s) for +: 'int' and 'NoneType'

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
 in ()
     11 segi4_1 = luas_segiempat(1, 1, 3, 3)
     12 segi4_2 = luas_segiempat(2, 4, 3, 3)
---> 13 print(segi4_1 + segi4_2)

TypeError: unsupported operand type(s) for +: 'int' and 'NoneType'

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
 in ()
     11 segi4_1 = luas_segiempat(1, 1, 3, 3)
     12 segi4_2 = luas_segiempat(2, 4, 3, 3)
---> 13 print(segi4_1 + segi4_2)

TypeError: unsupported operand type(s) for +: 'int' and 'NoneType'

```
assert , 
```
0
```
assert , 
```
1
```
assert , 
```
2
```
assert , 
```
3
```
assert , 
```
4

Di python, setidaknya ada 2 jenis error, yaitu syntax error dan exception.

Syntax Error : jenis error yang timbul karena kesalahan pada syntax yang tidak mengikuti aturan bahasa pemrograman. Error jenis ini bisa ditemukan letaknya oleh parser sebelum program tersebut dieksekusi. Misalnya saat menggunakan
```
assert , 
```
5 atau
```
assert , 
```
6 sebagai nama variable.
Exception : meskipun secara syntax sudah tidak terdapat error, namun instruksi tertentu mungkin menimbulkan error saat dieksekusi. Sebagai contoh ketika kita ingin menggunakan nilai variable
```
assert , 
```
7 yang ternyata belum pernah di-assign sebelumnya, maka akan muncul error bahwa variable belum didefinisikan (
```
assert , 
```
8).

Kedua jenis error tersebut termasuk yang mudah ditemukan dan diperbaiki, karena biasanya Python bisa menunjukkan lokasi error sebelum atau setelah program gagal dieksekusi. Ada jenis error yang lain yang paling sulit untuk ditemukan, yaitu logic error.

Logic Error : logic error adalah yang paling sulit dikarenakan program yang dibuat seperti berjalan dengan baik tanpa error yang membuat program berhenti, namun output atau perilaku program tidak seperti yang seharusnya. Misalnya anda membuat program konversi nilai dari angka ke index, program berjalan dengan lancar, namun nilai 100 ternyata dikonversikan ke “E”, padahal harusnya “A”. Python tidak bisa menunjuk baris kode yang menyebabkan kesalahan output tersebut, sehingga programmer sendiri yang harus menelusuri kode yang telah dibuatnya. Semakin kompleks program, maka akan semakin sulit mencari letak kode yang menyebabkan logic error.

Error pada software juga biasa disebut sebagai bug. Dalam sejarah, bug pada software dapat menyebabkan hal yang sangat fatal, misalnya:

Tahun 2004: Toyota harus me-recall 170.000 mobil Prius karena bug pada program smart car-nya yang menyebabkan lampu-lampu indikator menyala tanpa sebab.
Tahun 2000: bug pada perhitungan dosis radiasi untuk terapi kanker menyebabkan setidaknya 8 pasien meninggal di National Cancer Institute, Panama City.
Tahun 1996: roket Ariana 5 meledak saat peluncuran diakibatkan kesalahan dalam konversi data floating point.

Oleh sebab itu, meskipun kita tidak sedang membuat program seperti contoh di atas, kehati-hatian dalam programming sangat penting. Bahkan walaupun kita yakin program yang kita buat sudah benar, namun pada saat dijalankan banyak situasi tidak ideal yang sebelumnya kita anggap tidak akan terjadi ternyata terjadi. Sebagai contoh kerusakan hardware, user yang mengakses program kita secara bersamaan terlalu banyak, user memasukkan input yang diluar dugaan, dan sebagainya, yang pada akhirnya membuat program kita menjadi error.

Selanjutnya mari kita lihat bagaimana langkah-langkah dalam menghindari dan mengatasi bug pada program.

Defensive Programming

Defensive programming adalah sebuah pendekatan dalam memprogram dimana programmer selalu berhati-hati dan memikirkan berbagai kondisi yang memungkinkan terjadinya kesalahan, serta berusaha mengantisipasinya. Mindset defensive programming juga mencari cara paling efektif membangun kode yang memudahkan pencarian dan perbaikan bug jika suatu saat terjadi, terutama bug yang terkait logic error.

Berikut adalah beberapa langkah umum dalam defensive programming:

Menerapkan modularisasi pada program melalui fungsi. Memecah program yang besar menjadi modul-modul kecil seharusnya sudah dipikirkan sejak proses mendesain program. Hal ini akan memudahkan pengujian program, serta pencarian bug jika suatu saat terjadi.
Menuliskan spesifikasi fungsi dengan jelas pada docstring. Spesifikasi yang jelas tentang input dan output yang diharapkan akan menghindari kesalahpahaman oleh programmer lain atau pun user yang akan memakai fungsi yang kita buat. Spesifikasi harus dibuat ketika membuat sebuah fungsi. Spesifikasi juga akan menjadi acuan oleh orang yang akan menguji program kita (tester) dengan memberikan input dan memeriksa kesesuaian outputnya.
Mengecek kondisi input/output pada fungsi dengan assertion. Untuk memastikan output sesuai harapan, maka input harus selalu sesuai dengan asumsi programmer. Untuk itu, jika terjadi input yang tidak sesuai, maka programmer bisa memilih untuk menghentikan program sehingga user menyadari terdapat kesalahan. Hal ini lebih baik daripada meneruskan program namun hasilnya tidak benar. Begitu juga dengan output fungsi.

Assertion

Assertion adalah suatu pengecekan untuk memastikan suatu kondisi harus benar untuk bisa melakukan proses berikutnya. Mirip seperti if-statement, namun bedanya, jika kondisi

assert ,

9, maka program akan dihentikan. Sehingga assertion digunakan hanya untuk pengecekan yang krusial, yang jika

assert ,

9 maka program sebaiknya dihentikan.

Sebagai contoh ada sebuah fungsi untuk menghitung luas sebuah segi empat berdasarkan koordinat dua buah titik, yaitu titik pojok kiri bawah, dan titik pojok kanan atas. Berikut kira-kira fungsi menghitung luas tersebut.

def luas_segiempat(x0, y0, x1, y1):
    """ Menghitung luas segi empat berdasarkan koordinat 2 titik: pojok kiri bawah (x0, y0), dan kanan atas (x1, y1).
    """

    deltax = x1 - x0
    deltay = y1 - y0
    return deltax * deltay

segi4_1 = luas_segiempat(1, 1, 3, 3)
segi4_2 = luas_segiempat(2, 4, 3, 3)
print(segi4_1 + segi4_2)

Terlihat bahwa ketika kode di atas dijalankan, maka akan tertampil nilai 3 yang merupakan penjumlahan luas kedua segi. Sekilas tidak ada yang aneh, namun jika dilihat dengan teliti akan ditemukan logic error.

def luas_segiempat(x0, y0, x1, y1):
    """ Menghitung luas segi empat berdasarkan koordinat 2 titik: pojok kiri bawah (x0, y0), dan kanan atas (x1, y1).
    """

    # untuk memastikan koordinat input sudah sesuai asumsi
    assert x0 < x1 and y0 < y1, "koordinat tidak valid"

    deltax = x1 - x0
    deltay = y1 - y0
    return deltax * deltay

segi4_1 = luas_segiempat(1, 1, 3, 3)
segi4_2 = luas_segiempat(2, 4, 3, 3)
print(segi4_1 + segi4_2)

1 saja harusnya memiliki luas

def luas_segiempat(x0, y0, x1, y1):
    """ Menghitung luas segi empat berdasarkan koordinat 2 titik: pojok kiri bawah (x0, y0), dan kanan atas (x1, y1).
    """

    # untuk memastikan koordinat input sudah sesuai asumsi
    assert x0 < x1 and y0 < y1, "koordinat tidak valid"

    deltax = x1 - x0
    deltay = y1 - y0
    return deltax * deltay

segi4_1 = luas_segiempat(1, 1, 3, 3)
segi4_2 = luas_segiempat(2, 4, 3, 3)
print(segi4_1 + segi4_2)

2, karena panjangnya

def luas_segiempat(x0, y0, x1, y1):
    """ Menghitung luas segi empat berdasarkan koordinat 2 titik: pojok kiri bawah (x0, y0), dan kanan atas (x1, y1).
    """

    # untuk memastikan koordinat input sudah sesuai asumsi
    assert x0 < x1 and y0 < y1, "koordinat tidak valid"

    deltax = x1 - x0
    deltay = y1 - y0
    return deltax * deltay

segi4_1 = luas_segiempat(1, 1, 3, 3)
segi4_2 = luas_segiempat(2, 4, 3, 3)
print(segi4_1 + segi4_2)

3 dan lebarnya

def luas_segiempat(x0, y0, x1, y1):
    """ Menghitung luas segi empat berdasarkan koordinat 2 titik: pojok kiri bawah (x0, y0), dan kanan atas (x1, y1).
    """

    # untuk memastikan koordinat input sudah sesuai asumsi
    assert x0 < x1 and y0 < y1, "koordinat tidak valid"

    deltax = x1 - x0
    deltay = y1 - y0
    return deltax * deltay

segi4_1 = luas_segiempat(1, 1, 3, 3)
segi4_2 = luas_segiempat(2, 4, 3, 3)
print(segi4_1 + segi4_2)

3. Namun totalnya penjumlahan malah berkurang menjadi

def luas_segiempat(x0, y0, x1, y1):
    """ Menghitung luas segi empat berdasarkan koordinat 2 titik: pojok kiri bawah (x0, y0), dan kanan atas (x1, y1).
    """

    # untuk memastikan koordinat input sudah sesuai asumsi
    assert x0 < x1 and y0 < y1, "koordinat tidak valid"

    deltax = x1 - x0
    deltay = y1 - y0
    return deltax * deltay

segi4_1 = luas_segiempat(1, 1, 3, 3)
segi4_2 = luas_segiempat(2, 4, 3, 3)
print(segi4_1 + segi4_2)

5. Hal ini dikarenakan

def luas_segiempat(x0, y0, x1, y1):
    """ Menghitung luas segi empat berdasarkan koordinat 2 titik: pojok kiri bawah (x0, y0), dan kanan atas (x1, y1).
    """

    # untuk memastikan koordinat input sudah sesuai asumsi
    assert x0 < x1 and y0 < y1, "koordinat tidak valid"

    deltax = x1 - x0
    deltay = y1 - y0
    return deltax * deltay

segi4_1 = luas_segiempat(1, 1, 3, 3)
segi4_2 = luas_segiempat(2, 4, 3, 3)
print(segi4_1 + segi4_2)

6 ternyata bernilai

def luas_segiempat(x0, y0, x1, y1):
    """ Menghitung luas segi empat berdasarkan koordinat 2 titik: pojok kiri bawah (x0, y0), dan kanan atas (x1, y1).
    """

    # untuk memastikan koordinat input sudah sesuai asumsi
    assert x0 < x1 and y0 < y1, "koordinat tidak valid"

    deltax = x1 - x0
    deltay = y1 - y0
    return deltax * deltay

segi4_1 = luas_segiempat(1, 1, 3, 3)
segi4_2 = luas_segiempat(2, 4, 3, 3)
print(segi4_1 + segi4_2)

7, yang merupakan penyebab terjadinya logic error. Setelah diperhatikan lebih lanjut, penyebab sebenarnya adalah input yang tidak sesuai asumsi,

def luas_segiempat(x0, y0, x1, y1):
    """ Menghitung luas segi empat berdasarkan koordinat 2 titik: pojok kiri bawah (x0, y0), dan kanan atas (x1, y1).
    """

    # untuk memastikan koordinat input sudah sesuai asumsi
    assert x0 < x1 and y0 < y1, "koordinat tidak valid"

    deltax = x1 - x0
    deltay = y1 - y0
    return deltax * deltay

segi4_1 = luas_segiempat(1, 1, 3, 3)
segi4_2 = luas_segiempat(2, 4, 3, 3)
print(segi4_1 + segi4_2)

8 ternyata lebih besar dari

def luas_segiempat(x0, y0, x1, y1):
    """ Menghitung luas segi empat berdasarkan koordinat 2 titik: pojok kiri bawah (x0, y0), dan kanan atas (x1, y1).
    """

    # untuk memastikan koordinat input sudah sesuai asumsi
    assert x0 < x1 and y0 < y1, "koordinat tidak valid"

    deltax = x1 - x0
    deltay = y1 - y0
    return deltax * deltay

segi4_1 = luas_segiempat(1, 1, 3, 3)
segi4_2 = luas_segiempat(2, 4, 3, 3)
print(segi4_1 + segi4_2)

9, sehingga titik

---------------------------------------------------------------------------
AssertionError                            Traceback (most recent call last)
 in ()
     11 
     12 segi4_1 = luas_segiempat(1, 1, 3, 3)
---> 13 segi4_2 = luas_segiempat(2, 4, 3, 3)
     14 print(segi4_1 + segi4_2)
     15 

 in luas_segiempat(x0, y0, x1, y1)
      4 
      5     # untuk memastikan koordinat input sudah sesuai asumsi
----> 6     assert x0 < x1 and y0 < y1, "koordinat tidak valid"
      7 
      8     deltax = x1 - x0

AssertionError: koordinat tidak valid

0 bukanlah titik pojok kiri bawah, melainkan kiri atas.

Opsi Solusi

Mari kita bahas beberapa opsi yang bisa digunakan untuk menghindari hal tersebut.

Seharusnya sebelum pemanggilan fungsi sudah ada pengecekan nilai koordinat yang akan diberikan ke fungsi, misalnya:

x0 = 2
y0 = 4
x1 = 3
y1 = 3

# cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
if x0 < x1 and y0 < y1: 
        # panggil fungsi
else:
        # jangan panggil fungsi, keluarkan info ke user nilai salah

Meskipun bisa dilakukan, tetapi tentu hal ini bukanlah solusi terbaik, karena orang kita sendiri atau orang lain mungkin saja lupa untuk menambahkan pengecekan tersebut, dan akhirnya berakibat fatal.

Tambahkan pengecekan di dalam fungsi. Jika kondisi tidak terpenuhi maka jangan lakukan apa-apa, misalnya:

def luas_segiempat(x0, y0, x1, y1):
    """ Menghitung luas segi empat berdasarkan koordinat 2 titik: pojok kiri bawah (x0, y0), dan kanan atas (x1, y1).
    """

    # cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
    if x0 < x1 and y0 < y1:
        deltax = x1 - x0
        deltay = y1 - y0
        return deltax * deltay

segi4_1 = luas_segiempat(1, 1, 3, 3)
segi4_2 = luas_segiempat(2, 4, 3, 3)
print(segi4_1 + segi4_2)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
 in ()
     11 segi4_1 = luas_segiempat(1, 1, 3, 3)
     12 segi4_2 = luas_segiempat(2, 4, 3, 3)
---> 13 print(segi4_1 + segi4_2)

TypeError: unsupported operand type(s) for +: 'int' and 'NoneType'

Ketika kondisi salah, maka fungsi luas_segiempat tidak mengeksekusi

---------------------------------------------------------------------------
AssertionError                            Traceback (most recent call last)
 in ()
     11 
     12 segi4_1 = luas_segiempat(1, 1, 3, 3)
---> 13 segi4_2 = luas_segiempat(2, 4, 3, 3)
     14 print(segi4_1 + segi4_2)
     15 

 in luas_segiempat(x0, y0, x1, y1)
      4 
      5     # untuk memastikan koordinat input sudah sesuai asumsi
----> 6     assert x0 < x1 and y0 < y1, "koordinat tidak valid"
      7 
      8     deltax = x1 - x0

AssertionError: koordinat tidak valid

1, sehingga nilai defaultnya adalah

---------------------------------------------------------------------------
AssertionError                            Traceback (most recent call last)
 in ()
     11 
     12 segi4_1 = luas_segiempat(1, 1, 3, 3)
---> 13 segi4_2 = luas_segiempat(2, 4, 3, 3)
     14 print(segi4_1 + segi4_2)
     15 

 in luas_segiempat(x0, y0, x1, y1)
      4 
      5     # untuk memastikan koordinat input sudah sesuai asumsi
----> 6     assert x0 < x1 and y0 < y1, "koordinat tidak valid"
      7 
      8     deltax = x1 - x0

AssertionError: koordinat tidak valid

2. Hal ini menyebabkan error saat ditambahkan dengan integer. Error ini akan menyulitkan kita atau orang lain, karena penyebab sebenarnya belum terlihat, yaitu koordinat tidak valid. Sehingga untuk memperbaikinya perlu penelusuran yang lebih lanjut, dan ini adalah salah satu hal yang coba dihindari pada prinsip defensive programming.

Mengeset

---------------------------------------------------------------------------
AssertionError                            Traceback (most recent call last)
 in ()
     11 
     12 segi4_1 = luas_segiempat(1, 1, 3, 3)
---> 13 segi4_2 = luas_segiempat(2, 4, 3, 3)
     14 print(segi4_1 + segi4_2)
     15 

 in luas_segiempat(x0, y0, x1, y1)
      4 
      5     # untuk memastikan koordinat input sudah sesuai asumsi
----> 6     assert x0 < x1 and y0 < y1, "koordinat tidak valid"
      7 
      8     deltax = x1 - x0

AssertionError: koordinat tidak valid

1 dengan 0 tentu saja bisa menghindari TypeError tersebut, tapi malah menimbulkan error yang lebih berbahaya, yaitu LogicError seperti sebelumnya.

Penggunaan Assertion

Salah satu solusi yang lebih baik adalah menggunakan assertion. Sebelumnya kita lihat dulu bentuk statement assertion pada python berikut ini:

assert ,

---------------------------------------------------------------------------
AssertionError                            Traceback (most recent call last)
 in ()
     11 
     12 segi4_1 = luas_segiempat(1, 1, 3, 3)
---> 13 segi4_2 = luas_segiempat(2, 4, 3, 3)
     14 print(segi4_1 + segi4_2)
     15 

 in luas_segiempat(x0, y0, x1, y1)
      4 
      5     # untuk memastikan koordinat input sudah sesuai asumsi
----> 6     assert x0 < x1 and y0 < y1, "koordinat tidak valid"
      7 
      8     deltax = x1 - x0

AssertionError: koordinat tidak valid

4 adalah keyword

---------------------------------------------------------------------------
AssertionError                            Traceback (most recent call last)
 in ()
     11 
     12 segi4_1 = luas_segiempat(1, 1, 3, 3)
---> 13 segi4_2 = luas_segiempat(2, 4, 3, 3)
     14 print(segi4_1 + segi4_2)
     15 

 in luas_segiempat(x0, y0, x1, y1)
      4 
      5     # untuk memastikan koordinat input sudah sesuai asumsi
----> 6     assert x0 < x1 and y0 < y1, "koordinat tidak valid"
      7 
      8     deltax = x1 - x0

AssertionError: koordinat tidak valid

5 adalah ekspresi boolean seperti pada

---------------------------------------------------------------------------
AssertionError                            Traceback (most recent call last)
 in ()
     11 
     12 segi4_1 = luas_segiempat(1, 1, 3, 3)
---> 13 segi4_2 = luas_segiempat(2, 4, 3, 3)
     14 print(segi4_1 + segi4_2)
     15 

 in luas_segiempat(x0, y0, x1, y1)
      4 
      5     # untuk memastikan koordinat input sudah sesuai asumsi
----> 6     assert x0 < x1 and y0 < y1, "koordinat tidak valid"
      7 
      8     deltax = x1 - x0

AssertionError: koordinat tidak valid

6 dan

---------------------------------------------------------------------------
AssertionError                            Traceback (most recent call last)
 in ()
     11 
     12 segi4_1 = luas_segiempat(1, 1, 3, 3)
---> 13 segi4_2 = luas_segiempat(2, 4, 3, 3)
     14 print(segi4_1 + segi4_2)
     15 

 in luas_segiempat(x0, y0, x1, y1)
      4 
      5     # untuk memastikan koordinat input sudah sesuai asumsi
----> 6     assert x0 < x1 and y0 < y1, "koordinat tidak valid"
      7 
      8     deltax = x1 - x0

AssertionError: koordinat tidak valid

---------------------------------------------------------------------------
AssertionError                            Traceback (most recent call last)
 in ()
     11 
     12 segi4_1 = luas_segiempat(1, 1, 3, 3)
---> 13 segi4_2 = luas_segiempat(2, 4, 3, 3)
     14 print(segi4_1 + segi4_2)
     15 

 in luas_segiempat(x0, y0, x1, y1)
      4 
      5     # untuk memastikan koordinat input sudah sesuai asumsi
----> 6     assert x0 < x1 and y0 < y1, "koordinat tidak valid"
      7 
      8     deltax = x1 - x0

AssertionError: koordinat tidak valid

5 adalah pesan yang akan ditampilkan ketika kondisi

assert ,

9 dan program berhenti

Mari kita lihat penggunaannya pada fungsi.

def luas_segiempat(x0, y0, x1, y1):
    """ Menghitung luas segi empat berdasarkan koordinat 2 titik: pojok kiri bawah (x0, y0), dan kanan atas (x1, y1).
    """

    # untuk memastikan koordinat input sudah sesuai asumsi
    assert x0 < x1 and y0 < y1, "koordinat tidak valid"

    deltax = x1 - x0
    deltay = y1 - y0
    return deltax * deltay

segi4_1 = luas_segiempat(1, 1, 3, 3)
segi4_2 = luas_segiempat(2, 4, 3, 3)
print(segi4_1 + segi4_2)

---------------------------------------------------------------------------
AssertionError                            Traceback (most recent call last)
 in ()
     11 
     12 segi4_1 = luas_segiempat(1, 1, 3, 3)
---> 13 segi4_2 = luas_segiempat(2, 4, 3, 3)
     14 print(segi4_1 + segi4_2)
     15 

 in luas_segiempat(x0, y0, x1, y1)
      4 
      5     # untuk memastikan koordinat input sudah sesuai asumsi
----> 6     assert x0 < x1 and y0 < y1, "koordinat tidak valid"
      7 
      8     deltax = x1 - x0

AssertionError: koordinat tidak valid

Terlihat bahwa program akan memunculkan Assertion Error beserta pesannya. Dengan demikian maka siapapun yang menggunakan fungsi tersebut akan segera menyadari adanya kesalahan dan tau secara persis di mana letak kesalahan tersebut.

Sekali lagi perlu diperhatikan, Assertion akan membuat program berhenti, untuk itu pastikan hanya menggunakan assertion di saat tidak ada opsi lain yang lebih baik tanpa harus membuat program berhenti.

Exception Handling

Sebelumnya kita telah membahas tentang perbedaan syntax error dengan exception, dimana exception muncul saat program sedang dieksekusi.

Ada banyak jenis exception bawaan Python (built-in exception), di antaranya:

NameError
TypeError
ValueError
ZeroDivisionError

Untuk lengkapnya bisa dilihat pada: https://docs.python.org/3/library/exceptions.html

Dalam membuat program, selain correctness (seperti yang ditekankan pada penggunaan assertion) kita juga perlu memperhatikan aspek robustness atau ketangguhan. Program yang robust artinya tidak mudah crash atau terhenti walau terjadi error. Sekilas kedua prinsip tersebut terasa bertentangan, namun sebenarnya, masing-masing dapat diterapkan pada kondisi yang tepat.

Sebagai contoh, anggaplah kita membuat program yang meminta inputan user berupa 4 buah integer sebagai representasi 2 koordinat titik pojok (kiri bawah dan kanan atas) pada segi empat, yaitu x0, y0, x1, y1.

x0 = int(input("Koordinat x0:"))
y0 = int(input("Koordinat y0:"))
x1 = int(input("Koordinat x1:"))
y1 = int(input("Koordinat y1:"))

luas = luas_segiempat(x0, y0, x1, y1)
print("Luas segi empat adalah:", luas)

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
 in ()
----> 1 x0 = int(input("Koordinat x0:"))
      2 y0 = int(input("Koordinat y0:"))
      3 x1 = int(input("Koordinat x1:"))
      4 y1 = int(input("Koordinat y1:"))
      5 

ValueError: invalid literal for int() with base 10: ''

Ternyata, saat dijalankan user yang niat awalnya memasukkan nilai

x0 = int(input("Koordinat x0:"))
y0 = int(input("Koordinat y0:"))
x1 = int(input("Koordinat x1:"))
y1 = int(input("Koordinat y1:"))

luas = luas_segiempat(x0, y0, x1, y1)
print("Luas segi empat adalah:", luas)

0 ternyata tidak sengaja memasukkan

x0 = int(input("Koordinat x0:"))
y0 = int(input("Koordinat y0:"))
x1 = int(input("Koordinat x1:"))
y1 = int(input("Koordinat y1:"))

luas = luas_segiempat(x0, y0, x1, y1)
print("Luas segi empat adalah:", luas)

1, sehingga akan muncul exception berupa

x0 = int(input("Koordinat x0:"))
y0 = int(input("Koordinat y0:"))
x1 = int(input("Koordinat x1:"))
y1 = int(input("Koordinat y1:"))

luas = luas_segiempat(x0, y0, x1, y1)
print("Luas segi empat adalah:", luas)

2. Kesalahan user seperti ini sangat mungkin terjadi, baik disengaja maupun tidak disengaja. Oleh karena itu, akan lebih baik jika kesalahan ini bisa ditangani sehingga program tidak langsung terhenti, melainkan dapat tetap berjalan dengan memberikan informasi kepada user untuk memperbaikinya.

Penanganan exception, agar program tidak terhenti biasa disebut dengan exception handling.

Penggunaan Exception Handling

try:
    # kode yang mungkin menimbulkan exception
except:
    # apa yang dilakukan jika terjadi exception
else:
    # dijalankan jika kode pada try tidak menimbulkan exception

body

x0 = int(input("Koordinat x0:"))
y0 = int(input("Koordinat y0:"))
x1 = int(input("Koordinat x1:"))
y1 = int(input("Koordinat y1:"))

luas = luas_segiempat(x0, y0, x1, y1)
print("Luas segi empat adalah:", luas)

3 berisi kode yang mungkin menimbulkan eksepsi yang ingin kita tangani agar program tidak crash. Jika

x0 = int(input("Koordinat x0:"))
y0 = int(input("Koordinat y0:"))
x1 = int(input("Koordinat x1:"))
y1 = int(input("Koordinat y1:"))

luas = luas_segiempat(x0, y0, x1, y1)
print("Luas segi empat adalah:", luas)

3 berhasil (tidak muncul exception), maka eksekusi akan dilanjutkan ke block

x0 = int(input("Koordinat x0:"))
y0 = int(input("Koordinat y0:"))
x1 = int(input("Koordinat x1:"))
y1 = int(input("Koordinat y1:"))

luas = luas_segiempat(x0, y0, x1, y1)
print("Luas segi empat adalah:", luas)

5 (jika ada), atau ke statemen setelah

x0 = int(input("Koordinat x0:"))
y0 = int(input("Koordinat y0:"))
x1 = int(input("Koordinat x1:"))
y1 = int(input("Koordinat y1:"))

luas = luas_segiempat(x0, y0, x1, y1)
print("Luas segi empat adalah:", luas)

x0 = int(input("Koordinat x0:"))
y0 = int(input("Koordinat y0:"))
x1 = int(input("Koordinat x1:"))
y1 = int(input("Koordinat y1:"))

luas = luas_segiempat(x0, y0, x1, y1)
print("Luas segi empat adalah:", luas)

7 bertugas menangkap jenis exception yang muncul pada block

x0 = int(input("Koordinat x0:"))
y0 = int(input("Koordinat y0:"))
x1 = int(input("Koordinat x1:"))
y1 = int(input("Koordinat y1:"))

luas = luas_segiempat(x0, y0, x1, y1)
print("Luas segi empat adalah:", luas)

3, lalu mengeksekusi statement di body

x0 = int(input("Koordinat x0:"))
y0 = int(input("Koordinat y0:"))
x1 = int(input("Koordinat x1:"))
y1 = int(input("Koordinat y1:"))

luas = luas_segiempat(x0, y0, x1, y1)
print("Luas segi empat adalah:", luas)

x0 = int(input("Koordinat x0:"))
y0 = int(input("Koordinat y0:"))
x1 = int(input("Koordinat x1:"))
y1 = int(input("Koordinat y1:"))

luas = luas_segiempat(x0, y0, x1, y1)
print("Luas segi empat adalah:", luas)

5 bersifat opsional, dan body

x0 = int(input("Koordinat x0:"))
y0 = int(input("Koordinat y0:"))
x1 = int(input("Koordinat x1:"))
y1 = int(input("Koordinat y1:"))

luas = luas_segiempat(x0, y0, x1, y1)
print("Luas segi empat adalah:", luas)

5 hanya dijalankan ketika semua kode di dalam

x0 = int(input("Koordinat x0:"))
y0 = int(input("Koordinat y0:"))
x1 = int(input("Koordinat x1:"))
y1 = int(input("Koordinat y1:"))

luas = luas_segiempat(x0, y0, x1, y1)
print("Luas segi empat adalah:", luas)

3 berhasil dieksekusi tanpa memunculkan exception.

Berikut ini contoh penggunaan

x0 = int(input("Koordinat x0:"))
y0 = int(input("Koordinat y0:"))
x1 = int(input("Koordinat x1:"))
y1 = int(input("Koordinat y1:"))

luas = luas_segiempat(x0, y0, x1, y1)
print("Luas segi empat adalah:", luas)

6 untuk menghindari error akibat kesalahan input.

x0 = 2
y0 = 4
x1 = 3
y1 = 3

# cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
if x0 < x1 and y0 < y1: 
        # panggil fungsi
else:
        # jangan panggil fungsi, keluarkan info ke user nilai salah

x0 = 2
y0 = 4
x1 = 3
y1 = 3

# cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
if x0 < x1 and y0 < y1: 
        # panggil fungsi
else:
        # jangan panggil fungsi, keluarkan info ke user nilai salah

x0 = 2
y0 = 4
x1 = 3
y1 = 3

# cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
if x0 < x1 and y0 < y1: 
        # panggil fungsi
else:
        # jangan panggil fungsi, keluarkan info ke user nilai salah

Terlihat bahwa jika diinputkan seperti sebelumnya, yaitu

x0 = int(input("Koordinat x0:"))
y0 = int(input("Koordinat y0:"))
x1 = int(input("Koordinat x1:"))
y1 = int(input("Koordinat y1:"))

luas = luas_segiempat(x0, y0, x1, y1)
print("Luas segi empat adalah:", luas)

1 maka program tetap akan terhenti, namun sekarang program berhenti bukan saat mengeksekusi statement assignment

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
 in ()
----> 1 x0 = int(input("Koordinat x0:"))
      2 y0 = int(input("Koordinat y0:"))
      3 x1 = int(input("Koordinat x1:"))
      4 y1 = int(input("Koordinat y1:"))
      5 

ValueError: invalid literal for int() with base 10: ''

5 yang diberikan input tidak valid berupa

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
 in ()
----> 1 x0 = int(input("Koordinat x0:"))
      2 y0 = int(input("Koordinat y0:"))
      3 x1 = int(input("Koordinat x1:"))
      4 y1 = int(input("Koordinat y1:"))
      5 

ValueError: invalid literal for int() with base 10: ''

6. Hal ini menunjukkan bahwa exception yang timbul pada bagian tersebut sudah bisa ditangani oleh

x0 = int(input("Koordinat x0:"))
y0 = int(input("Koordinat y0:"))
x1 = int(input("Koordinat x1:"))
y1 = int(input("Koordinat y1:"))

luas = luas_segiempat(x0, y0, x1, y1)
print("Luas segi empat adalah:", luas)

Error yang terjadi sekarang yaitu dikarenakan saat memanggil fungsi

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
 in ()
----> 1 x0 = int(input("Koordinat x0:"))
      2 y0 = int(input("Koordinat y0:"))
      3 x1 = int(input("Koordinat x1:"))
      4 y1 = int(input("Koordinat y1:"))
      5 

ValueError: invalid literal for int() with base 10: ''

8, argument

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
 in ()
----> 1 x0 = int(input("Koordinat x0:"))
      2 y0 = int(input("Koordinat y0:"))
      3 x1 = int(input("Koordinat x1:"))
      4 y1 = int(input("Koordinat y1:"))
      5 

ValueError: invalid literal for int() with base 10: ''

5 tidak memiliki nilai. Hal ini dikarenakan statement assignment

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
 in ()
----> 1 x0 = int(input("Koordinat x0:"))
      2 y0 = int(input("Koordinat y0:"))
      3 x1 = int(input("Koordinat x1:"))
      4 y1 = int(input("Koordinat y1:"))
      5 

ValueError: invalid literal for int() with base 10: ''

5 tidak berhasil dieksekusi, walau program tidak berhenti saat itu. Salah satu solusinya, kita bisa menggunakan

x0 = int(input("Koordinat x0:"))
y0 = int(input("Koordinat y0:"))
x1 = int(input("Koordinat x1:"))
y1 = int(input("Koordinat y1:"))

luas = luas_segiempat(x0, y0, x1, y1)
print("Luas segi empat adalah:", luas)

5 agar pemanggilan fungsi dan print luas hanya dilakukan jika kode

x0 = int(input("Koordinat x0:"))
y0 = int(input("Koordinat y0:"))
x1 = int(input("Koordinat x1:"))
y1 = int(input("Koordinat y1:"))

luas = luas_segiempat(x0, y0, x1, y1)
print("Luas segi empat adalah:", luas)

3 dapat dieksekusi dengan sempurna.

x0 = 2
y0 = 4
x1 = 3
y1 = 3

# cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
if x0 < x1 and y0 < y1: 
        # panggil fungsi
else:
        # jangan panggil fungsi, keluarkan info ke user nilai salah

x0 = 2
y0 = 4
x1 = 3
y1 = 3

# cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
if x0 < x1 and y0 < y1: 
        # panggil fungsi
else:
        # jangan panggil fungsi, keluarkan info ke user nilai salah

Program di atas jika diberikan input yang tidak valid maka tidak akan mengeluarkan error.

Sebagai tambahan, bagaimana jika kita ingin memberikan kesempatan kepada user untuk mengulangi input maksimal sebanyak 3 kali? Anda bisa menggunakan contoh kode di bawah ini.

x0 = 2
y0 = 4
x1 = 3
y1 = 3

# cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
if x0 < x1 and y0 < y1: 
        # panggil fungsi
else:
        # jangan panggil fungsi, keluarkan info ke user nilai salah

x0 = 2
y0 = 4
x1 = 3
y1 = 3

# cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
if x0 < x1 and y0 < y1: 
        # panggil fungsi
else:
        # jangan panggil fungsi, keluarkan info ke user nilai salah

Ketika anda selesai membuat sebuah fungsi atau program, dan sudah melakukan prinsip-prinsip defensive programming di atas, maka langkah selanjutnya adalah menguji kebenaran fungsi atau program tersebut dengan berbagai kemungkinan input.

Pada umumnya, pengujian dilakukan dengan tahapan berikut:

membuat test-case, yaitu sejumlah pasangan data input beserta output yang diharapkan.
untuk setiap input pada test-case, jalankan fungsi, lalu bandingkan output fungsi dengan output yang diharapkan pada test-case.

Ada 2 pendekatan dalam melakukan testing:

black box testing: penyusunan test-case dan pengujian hanya berdasarkan spesifikasi fungsi atau program, tanpa melihat atau mengerti tentang kode fungsi tersebut. Pengujian ini biasanya bersifat high-level dan dilakukan oleh software tester.
glass box testing: penyusunan test-case dan pengujian berdasarkan penelusuran kode dan melihat berbagai kemungkinan jalur eksekusi (misalnya kondisional dan looping). Pengujian ini bersifat low-level dan dilakukan oleh software developer.

Black box testing

Mari kita lihat contoh spesifikasi fungsi yang akan dilakukan pengetesan.

x0 = 2
y0 = 4
x1 = 3
y1 = 3

# cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
if x0 < x1 and y0 < y1: 
        # panggil fungsi
else:
        # jangan panggil fungsi, keluarkan info ke user nilai salah

Sebelum menguji, maka kita perlu membuat test-case berdasarkan spesifikasi fungsi di atas. Beberapa panduan dalam menyusun test-cases menggunakan black-box testing adalah:

Carilah batasan-batasan (partition) input yang memberikan output yang berbeda-beda.
Jika tidak ada batasan yang jelas, maka bisa menggunakan random testing. Semakin banyak random input-output yang dibuat, semakin besar meningkat kemungkinan keakuratan kode yang diuji.
Pertimbangkan keadaan ekstrim, misalnya nilai sangat besar, sangat kecil, list kosong.

Berdasarkan panduan tersebut, maka dari spesifikasi fungsi di atas, kita dapat menemukan partisi input yang memberikan hasil berbeda, yaitu 50 dan 80. Sementara kita juga perlu mengecek nilai ekstrim, yaitu 0 dan 100, serta nilai yang tidak valid. Berikut contoh test-cases yang bisa digunakan untuk menguji fungsi

try:
    # kode yang mungkin menimbulkan exception
except:
    # apa yang dilakukan jika terjadi exception
else:
    # dijalankan jika kode pada try tidak menimbulkan exception

case

nilai

return

perbatasan

“B”

perbatasan

80.01

“A”

perbatasan

“E”

perbatasan

50.01

“B”

ekstrim

100

“A”

ekstrim

“E”

invalid

100.01

Error

invalid

-1

Error

Menjalankan testing

Berikut ini adalah implementasi fungsi

try:
    # kode yang mungkin menimbulkan exception
except:
    # apa yang dilakukan jika terjadi exception
else:
    # dijalankan jika kode pada try tidak menimbulkan exception

3 yang akan di-test.

x0 = 2
y0 = 4
x1 = 3
y1 = 3

# cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
if x0 < x1 and y0 < y1: 
        # panggil fungsi
else:
        # jangan panggil fungsi, keluarkan info ke user nilai salah

Setelah menyusun test-case, langkah selanjutnya adalah menjalankan proses testing. Ada berbagai cara untuk melakukan ini, namun kita bisa mulai dengan yang paling sederhana, yaitu dengan print perbandingan output fungsi dengan output pada test-case seperti di bawah ini.

x0 = 2
y0 = 4
x1 = 3
y1 = 3

# cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
if x0 < x1 and y0 < y1: 
        # panggil fungsi
else:
        # jangan panggil fungsi, keluarkan info ke user nilai salah

def luas_segiempat(x0, y0, x1, y1):
    """ Menghitung luas segi empat berdasarkan koordinat 2 titik: pojok kiri bawah (x0, y0), dan kanan atas (x1, y1).
    """

    # cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
    if x0 < x1 and y0 < y1:
        deltax = x1 - x0
        deltay = y1 - y0
        return deltax * deltay

segi4_1 = luas_segiempat(1, 1, 3, 3)
segi4_2 = luas_segiempat(2, 4, 3, 3)
print(segi4_1 + segi4_2)

Ternyata dari 8 test case yang kita ajukan, ada 4 yang gagal. Coba anda temukan letak kesalahannya, dan perbaiki agar bisa lulus di semua test case tersebut.

Berikut versi fungsi

try:
    # kode yang mungkin menimbulkan exception
except:
    # apa yang dilakukan jika terjadi exception
else:
    # dijalankan jika kode pada try tidak menimbulkan exception

3 yang sudah diperbaiki.

def luas_segiempat(x0, y0, x1, y1):
    """ Menghitung luas segi empat berdasarkan koordinat 2 titik: pojok kiri bawah (x0, y0), dan kanan atas (x1, y1).
    """

    # cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
    if x0 < x1 and y0 < y1:
        deltax = x1 - x0
        deltay = y1 - y0
        return deltax * deltay

segi4_1 = luas_segiempat(1, 1, 3, 3)
segi4_2 = luas_segiempat(2, 4, 3, 3)
print(segi4_1 + segi4_2)

x0 = 2
y0 = 4
x1 = 3
y1 = 3

# cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
if x0 < x1 and y0 < y1: 
        # panggil fungsi
else:
        # jangan panggil fungsi, keluarkan info ke user nilai salah

def luas_segiempat(x0, y0, x1, y1):
    """ Menghitung luas segi empat berdasarkan koordinat 2 titik: pojok kiri bawah (x0, y0), dan kanan atas (x1, y1).
    """

    # cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
    if x0 < x1 and y0 < y1:
        deltax = x1 - x0
        deltay = y1 - y0
        return deltax * deltay

segi4_1 = luas_segiempat(1, 1, 3, 3)
segi4_2 = luas_segiempat(2, 4, 3, 3)
print(segi4_1 + segi4_2)

Cara lainnya kita bisa menggunakan assertion dan fungsi, serta membuat file khusus yang berisi semua testing. Misalnya kita membuat file baru bernama my_test.py yang isinya adalah sebagai berikut:

def luas_segiempat(x0, y0, x1, y1):
    """ Menghitung luas segi empat berdasarkan koordinat 2 titik: pojok kiri bawah (x0, y0), dan kanan atas (x1, y1).
    """

    # cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
    if x0 < x1 and y0 < y1:
        deltax = x1 - x0
        deltay = y1 - y0
        return deltax * deltay

segi4_1 = luas_segiempat(1, 1, 3, 3)
segi4_2 = luas_segiempat(2, 4, 3, 3)
print(segi4_1 + segi4_2)

def luas_segiempat(x0, y0, x1, y1):
    """ Menghitung luas segi empat berdasarkan koordinat 2 titik: pojok kiri bawah (x0, y0), dan kanan atas (x1, y1).
    """

    # cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
    if x0 < x1 and y0 < y1:
        deltax = x1 - x0
        deltay = y1 - y0
        return deltax * deltay

segi4_1 = luas_segiempat(1, 1, 3, 3)
segi4_2 = luas_segiempat(2, 4, 3, 3)
print(segi4_1 + segi4_2)

Glass box testing

Pembuatan test-case pada glass box testing dilakukan berdasarkan kode program. Tujuannya adalah memastikan bahwa setiap jalur yang ada pada kode pernah dieksekusi minimal satu kali. Beberapa panduan antara lain:

Kondisional: Memastikan bahwa semua kemungkinan yang ada pada kondisional telah tercover dalam test-case
Looping: Memastikan test-case meliputi kemungkinan:
- tidak masuk looping,
- body looping dieksekusi hanya sekali,
- body looping dieksekusi lebih dari sekali,
- kasus yang mengharuskan keluar looping segera

x0 = 2
y0 = 4
x1 = 3
y1 = 3

# cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
if x0 < x1 and y0 < y1: 
        # panggil fungsi
else:
        # jangan panggil fungsi, keluarkan info ke user nilai salah

Berdasarkan fungsi konversi_nilai asli di atas, maka beberapa test-case yang bisa dibuat adalah:

case

nilai

return

if nilai >= 80

“A”

elif nilai >= 50

“B”

else

“E”

Kita sudah melihat bahwa, jika test-case tersebut diberikan pada fungsi

try:
    # kode yang mungkin menimbulkan exception
except:
    # apa yang dilakukan jika terjadi exception
else:
    # dijalankan jika kode pada try tidak menimbulkan exception

3 yang masih salah di atas, maka akan terlihat semua baik-baik saja, tanpa terlihat adanya bug. Hal ini dikarenakan kita tidak memasukkan nilai-nilai perbatasan pada test-case seperti yang dilakukan pada Black box testing. Ini adalah kelemahan pada glass box testing, yaitu meskipun semua kemungkinan jalur eksekusi sudah tercover, kita masih mungkin melewatkan beberapa bug. Di sisi lain, dengan Black box testing saja terkadang kita kesulitan untuk membuat test-case yang meng-cover semua kemungkinan jalur eksekusi, terutama untuk program yang komplek yang melibatkan looping dan kondisional. Untuk itu, sebaiknya dalam membuat test-case, kedua cara tersebut dipertimbangkan.

Testing vs Debugging

Testing dan debugging sama-sama terkait dengan usaha agar kode kita tidak memiliki bug, namun keduanya adalah proses yang berbeda. Berikut perbedaannya:

Testing: memastikan apakah ada bug atau tidak dalam program/fungsi
Debugging: mencari di mana letak bug, dan mencari tau apa yang salah

Cara-cara dalam melakukan debugging:

Menggunakan statement print untuk mengoutputkan isi variable atau sekedar memastikan bagian kode tertentu dieksekusi oleh program
Menggunakan tool debugger seperti pada IDLE yang memiliki fitur khusus yang membantu mencari posisi bug

Debugging dengan Print

Pertama-tama, mari kita lihat contoh program di bawah ini. Fungsi

try:
    # kode yang mungkin menimbulkan exception
except:
    # apa yang dilakukan jika terjadi exception
else:
    # dijalankan jika kode pada try tidak menimbulkan exception

7 manerima sebuah input non-negatif integer

try:
    # kode yang mungkin menimbulkan exception
except:
    # apa yang dilakukan jika terjadi exception
else:
    # dijalankan jika kode pada try tidak menimbulkan exception

8, lalu akan mengembalikan dua buah nilai, yaitu jumlah bilangan ganjil yang terdapat pada deret 1 sampai n, dan jumlah bilangan genapnya.

def luas_segiempat(x0, y0, x1, y1):
    """ Menghitung luas segi empat berdasarkan koordinat 2 titik: pojok kiri bawah (x0, y0), dan kanan atas (x1, y1).
    """

    # cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
    if x0 < x1 and y0 < y1:
        deltax = x1 - x0
        deltay = y1 - y0
        return deltax * deltay

segi4_1 = luas_segiempat(1, 1, 3, 3)
segi4_2 = luas_segiempat(2, 4, 3, 3)
print(segi4_1 + segi4_2)

Pertama-tama, mari kita buat beberapa test-case untuk menguji fungsi tersebut.

case

return

perbatasan

(0, 0)

perbatasan

(1, 0)

perbatasan

(1, 2)

random

(9, 6)

random

(9, 12)

def luas_segiempat(x0, y0, x1, y1):
    """ Menghitung luas segi empat berdasarkan koordinat 2 titik: pojok kiri bawah (x0, y0), dan kanan atas (x1, y1).
    """

    # cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
    if x0 < x1 and y0 < y1:
        deltax = x1 - x0
        deltay = y1 - y0
        return deltax * deltay

segi4_1 = luas_segiempat(1, 1, 3, 3)
segi4_2 = luas_segiempat(2, 4, 3, 3)
print(segi4_1 + segi4_2)

def luas_segiempat(x0, y0, x1, y1):
    """ Menghitung luas segi empat berdasarkan koordinat 2 titik: pojok kiri bawah (x0, y0), dan kanan atas (x1, y1).
    """

    # cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
    if x0 < x1 and y0 < y1:
        deltax = x1 - x0
        deltay = y1 - y0
        return deltax * deltay

segi4_1 = luas_segiempat(1, 1, 3, 3)
segi4_2 = luas_segiempat(2, 4, 3, 3)
print(segi4_1 + segi4_2)

Terlihat bahwa masih terdapat bug pada fungsi tersebut sehingga dari 5 test-case hanya 1 yang benar. Mari kita coba debug menggunakan fungsi

try:
    # kode yang mungkin menimbulkan exception
except:
    # apa yang dilakukan jika terjadi exception
else:
    # dijalankan jika kode pada try tidak menimbulkan exception

9. Pertama-tama, mari kita lihat output fungsi terhadap salah satu test-case, misalnya

x0 = 2
y0 = 4
x1 = 3
y1 = 3

# cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
if x0 < x1 and y0 < y1: 
        # panggil fungsi
else:
        # jangan panggil fungsi, keluarkan info ke user nilai salah

00.

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
 in ()
     11 segi4_1 = luas_segiempat(1, 1, 3, 3)
     12 segi4_2 = luas_segiempat(2, 4, 3, 3)
---> 13 print(segi4_1 + segi4_2)

TypeError: unsupported operand type(s) for +: 'int' and 'NoneType'

Saat

x0 = 2
y0 = 4
x1 = 3
y1 = 3

# cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
if x0 < x1 and y0 < y1: 
        # panggil fungsi
else:
        # jangan panggil fungsi, keluarkan info ke user nilai salah

00 output fungsi adalah

x0 = 2
y0 = 4
x1 = 3
y1 = 3

# cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
if x0 < x1 and y0 < y1: 
        # panggil fungsi
else:
        # jangan panggil fungsi, keluarkan info ke user nilai salah

02, padahal seharusnya

x0 = 2
y0 = 4
x1 = 3
y1 = 3

# cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
if x0 < x1 and y0 < y1: 
        # panggil fungsi
else:
        # jangan panggil fungsi, keluarkan info ke user nilai salah

03. Maka terdapat bug pada penjumlahan bilangan ganjil. Mari kita inspeksi menggunakan

try:
    # kode yang mungkin menimbulkan exception
except:
    # apa yang dilakukan jika terjadi exception
else:
    # dijalankan jika kode pada try tidak menimbulkan exception

9. Kita bisa tambahkan beberapa statement

try:
    # kode yang mungkin menimbulkan exception
except:
    # apa yang dilakukan jika terjadi exception
else:
    # dijalankan jika kode pada try tidak menimbulkan exception

9 untuk mengoutputkan nilai variable yang mungkin ada kaitannya dengan kesalahan. Dalam hal ini, kesalahan jelas terjadi pada variable

x0 = 2
y0 = 4
x1 = 3
y1 = 3

# cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
if x0 < x1 and y0 < y1: 
        # panggil fungsi
else:
        # jangan panggil fungsi, keluarkan info ke user nilai salah

06 yang menyimpan jumlah ganjil. Agar lebih detil melihat waktu eksekusi

x0 = 2
y0 = 4
x1 = 3
y1 = 3

# cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
if x0 < x1 and y0 < y1: 
        # panggil fungsi
else:
        # jangan panggil fungsi, keluarkan info ke user nilai salah

06, maka kita tambahkan statement

try:
    # kode yang mungkin menimbulkan exception
except:
    # apa yang dilakukan jika terjadi exception
else:
    # dijalankan jika kode pada try tidak menimbulkan exception

9 setelah perubahan pada

x0 = 2
y0 = 4
x1 = 3
y1 = 3

# cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
if x0 < x1 and y0 < y1: 
        # panggil fungsi
else:
        # jangan panggil fungsi, keluarkan info ke user nilai salah

06. Selain itu kita juga perlu curigai jumlah perulangan, apakah sudah sesuai atau tidak, sehingga variable

x0 = 2
y0 = 4
x1 = 3
y1 = 3

# cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
if x0 < x1 and y0 < y1: 
        # panggil fungsi
else:
        # jangan panggil fungsi, keluarkan info ke user nilai salah

10 juga perlu dioutputkan. Hasilnya adalah seperti berikut ini:

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
 in ()
     11 segi4_1 = luas_segiempat(1, 1, 3, 3)
     12 segi4_2 = luas_segiempat(2, 4, 3, 3)
---> 13 print(segi4_1 + segi4_2)

TypeError: unsupported operand type(s) for +: 'int' and 'NoneType'

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
 in ()
     11 segi4_1 = luas_segiempat(1, 1, 3, 3)
     12 segi4_2 = luas_segiempat(2, 4, 3, 3)
---> 13 print(segi4_1 + segi4_2)

TypeError: unsupported operand type(s) for +: 'int' and 'NoneType'

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
 in ()
     11 segi4_1 = luas_segiempat(1, 1, 3, 3)
     12 segi4_2 = luas_segiempat(2, 4, 3, 3)
---> 13 print(segi4_1 + segi4_2)

TypeError: unsupported operand type(s) for +: 'int' and 'NoneType'

Dari output di atas, kita bisa melihat beberapa kesalahan.

x0 = 2
y0 = 4
x1 = 3
y1 = 3

# cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
if x0 < x1 and y0 < y1: 
        # panggil fungsi
else:
        # jangan panggil fungsi, keluarkan info ke user nilai salah

11 dieksekusi, namun nilainya adalah 0. Padahal seharusnya saat ini nilainya adalah

x0 = 2
y0 = 4
x1 = 3
y1 = 3

# cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
if x0 < x1 and y0 < y1: 
        # panggil fungsi
else:
        # jangan panggil fungsi, keluarkan info ke user nilai salah

12, karena

x0 = 2
y0 = 4
x1 = 3
y1 = 3

# cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
if x0 < x1 and y0 < y1: 
        # panggil fungsi
else:
        # jangan panggil fungsi, keluarkan info ke user nilai salah

13. Maka kita perlu curigai statement

x0 = 2
y0 = 4
x1 = 3
y1 = 3

# cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
if x0 < x1 and y0 < y1: 
        # panggil fungsi
else:
        # jangan panggil fungsi, keluarkan info ke user nilai salah

14 mengandung kesalahan. Jika kita teliti lebih jauh, kesalahan ada di penggunaan nama variable yang berbeda antara

x0 = 2
y0 = 4
x1 = 3
y1 = 3

# cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
if x0 < x1 and y0 < y1: 
        # panggil fungsi
else:
        # jangan panggil fungsi, keluarkan info ke user nilai salah

06 (sum dan angka 1), dengan

x0 = 2
y0 = 4
x1 = 3
y1 = 3

# cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
if x0 < x1 and y0 < y1: 
        # panggil fungsi
else:
        # jangan panggil fungsi, keluarkan info ke user nilai salah

16 (sum dan huruf l).

x0 = 2
y0 = 4
x1 = 3
y1 = 3

# cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
if x0 < x1 and y0 < y1: 
        # panggil fungsi
else:
        # jangan panggil fungsi, keluarkan info ke user nilai salah

10 yang terakhir bernilai

def luas_segiempat(x0, y0, x1, y1):
    """ Menghitung luas segi empat berdasarkan koordinat 2 titik: pojok kiri bawah (x0, y0), dan kanan atas (x1, y1).
    """

    # untuk memastikan koordinat input sudah sesuai asumsi
    assert x0 < x1 and y0 < y1, "koordinat tidak valid"

    deltax = x1 - x0
    deltay = y1 - y0
    return deltax * deltay

segi4_1 = luas_segiempat(1, 1, 3, 3)
segi4_2 = luas_segiempat(2, 4, 3, 3)
print(segi4_1 + segi4_2)

2, padahal karena

x0 = 2
y0 = 4
x1 = 3
y1 = 3

# cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
if x0 < x1 and y0 < y1: 
        # panggil fungsi
else:
        # jangan panggil fungsi, keluarkan info ke user nilai salah

00 maka seharusnya nilai

x0 = 2
y0 = 4
x1 = 3
y1 = 3

# cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
if x0 < x1 and y0 < y1: 
        # panggil fungsi
else:
        # jangan panggil fungsi, keluarkan info ke user nilai salah

10 terakhir adalah

x0 = 2
y0 = 4
x1 = 3
y1 = 3

# cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
if x0 < x1 and y0 < y1: 
        # panggil fungsi
else:
        # jangan panggil fungsi, keluarkan info ke user nilai salah

21. Maka kondisi perulangan menjadi hal yang perlu dicurigai. Dalam hal ini penggunaan

x0 = 2
y0 = 4
x1 = 3
y1 = 3

# cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
if x0 < x1 and y0 < y1: 
        # panggil fungsi
else:
        # jangan panggil fungsi, keluarkan info ke user nilai salah

22 harusnya

x0 = 2
y0 = 4
x1 = 3
y1 = 3

# cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
if x0 < x1 and y0 < y1: 
        # panggil fungsi
else:
        # jangan panggil fungsi, keluarkan info ke user nilai salah

23.

Berikut adalah fungsi yang telah diperbaiki:

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
 in ()
     11 segi4_1 = luas_segiempat(1, 1, 3, 3)
     12 segi4_2 = luas_segiempat(2, 4, 3, 3)
---> 13 print(segi4_1 + segi4_2)

TypeError: unsupported operand type(s) for +: 'int' and 'NoneType'

Mari kita lakukan testing kembali.

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
 in ()
     11 segi4_1 = luas_segiempat(1, 1, 3, 3)
     12 segi4_2 = luas_segiempat(2, 4, 3, 3)
---> 13 print(segi4_1 + segi4_2)

TypeError: unsupported operand type(s) for +: 'int' and 'NoneType'

Terkadang error terjadi karena hal yang sepele, misalnya karena typo. Namun jika kita tidak menggunakan cara yang tepat dalam mendebug, misalnya hanya dengan membaca kembali kode, mungkin kita akan kesulitan menemukan kesalahannya.

Debugger pada IDLE

Fitur standard sebuah debugger:

Mengatur kecepatan eksekusi, sehingga kita bisa mengeksekusi dan memeriksa kode step by step
Mengatur breakpoints agar eksekusi hanya pause di titik tertentu yang ingin kita perhatikan lebih jauh, untuk selanjutnya kita mulai eksekusi step by step.
Memperlihatkan isi local dan global variable yang sedang digunakan

Mengaktifkan Debugger

Pada python Shell, klik menu Debug -> Debugger

Akan muncul Debugger window seperti di bawah ini:

Menu Debug Control IDLE

Go: Mengeksekusi kode, dan hanya berhenti pada breakpoint
Step: Mengeksekusi kode step by step
Over: Saat eksekusi dengan step, kita mungkin ingin mempercepat dengan tidak memperhatikan step by step suatu fungsi, dan langsung ingin outputnya saja
Out: Ketika kita sudah masuk ke dalam suatu fungsi, dan tidak tertarik melihat detailnya, lalu ingin langsung keluar ke 1 level di atasnya
Quit: Stop eksekusi program

Menjalankan Debug Program

Setelah mengaktifkan Debug Mode pada Python Shell, kita langsung run file program yang diikuti step by step
Atau bisa juga kita set breakpoint terlebih dahulu, agar nanti program running normal dan baru pause pada bagian breakpoint untuk dilanjutkan dengan Step.

Ceklist pada bagian Source untuk melihat alur eksekusi pada source code/editor. Ceklist pada bagian Hlobal untuk menampilkan global variable.
Klik Go untuk memulai, dan eksekusi akan berhenti di breakpoint, lalu lanjutkan pelan-pelan dengan Step

Terlihat bahwa ada yang aneh saat program eksekusi baris

x0 = 2
y0 = 4
x1 = 3
y1 = 3

# cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
if x0 < x1 and y0 < y1: 
        # panggil fungsi
else:
        # jangan panggil fungsi, keluarkan info ke user nilai salah

24, yaitu muncul variable tambahan yaitu

x0 = 2
y0 = 4
x1 = 3
y1 = 3

# cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
if x0 < x1 and y0 < y1: 
        # panggil fungsi
else:
        # jangan panggil fungsi, keluarkan info ke user nilai salah

16. Sehingga hal ini bisa menyadarkan kita bahwa kita menggunakan nama variable yang salah. Jika diteruskan sampai akhir, akan terlihat juga bahwa nilai

x0 = 2
y0 = 4
x1 = 3
y1 = 3

# cek (x0, y0) kiri bawah, dan (x1, y1) kanan atas
if x0 < x1 and y0 < y1: 
        # panggil fungsi
else:
        # jangan panggil fungsi, keluarkan info ke user nilai salah

10 terakhir adalah 4.

Apa penyebab terjadinya suatu pengecualian exceptions di suatu program?

Exception dipicu oleh runtime error, yaitu error atau kesalahan yang terjadi saat program dieksekusi oleh interpreter.

Di dalam statement try apa arti dari except?

except untuk menangani error yang mungkin kita sendiri tidak mengetahuinya. Biasanya try.. except ini digunakan untuk menangani error saat penggunaan IO, operasi database, atau pengaksesan indeks suatu list atau dictionary, dan berbagai kasus lainnya.