Sebagai pemrogram pemula, wajar jika melakukan kesalahan. Namun, beberapa kesalahan terjadi karena kurangnya pemahaman tentang sifat bahasa pemrograman itu sendiri. Artikel ini mengulas beberapa kesalahan paling umum yang mungkin Anda lakukan saat memprogram di Python, memberikan penjelasan, dan solusi yang tepat.
1. Memodifikasi Daftar Saat Iterasi
Memodifikasi daftar (list) Python saat Anda mengulanginya mungkin terdengar seperti jalan pintas yang cerdas, tetapi ini adalah jebakan umum di Python. Kesalahan ini dapat menyebabkan perilaku tak terduga, seperti melewatkan elemen atau menghasilkan daftar yang kacau.
Misalnya, Anda memiliki daftar angka dan ingin menghapus semua angka yang kurang dari 5.
numbers = [1, 2, 6, 3, 7, 4, 8, 5]
print("Daftar asli:", numbers)
for number in numbers:
if number < 5:
numbers.remove(number)
print("Daftar yang dimodifikasi (salah!):", numbers)
Jika Anda menjalankan kode ini, Anda akan menemukan bahwa angka 2 masih ada dalam daftar. Ini terjadi karena saat Anda menghapus elemen, daftar menyusut, dan indeks elemen berikutnya bergeser. Ini dapat menyebabkan perulangan melewatkan elemen. Misalnya, ketika 1 dihapus, 2 berpindah ke posisi lama 1, tetapi penghitung internal perulangan sudah bergerak, berpotensi melewati 2.
Solusi:
Cara teraman dan paling umum untuk memodifikasi daftar berdasarkan elemennya adalah dengan mengulang salinan daftar atau membuat daftar baru dengan hanya elemen yang ingin Anda pertahankan.
Menggunakan Salinan Daftar
Anda dapat membuat salinan dangkal (shallow copy) dari daftar sebelum iterasi. Dengan cara ini, Anda dapat menghapus elemen dari daftar asli tanpa memengaruhi proses iterasi.
numbers = [1, 2, 6, 3, 7, 4, 8, 5]
print("Daftar asli:", numbers)
for number in numbers[:]: # Iterasi pada slice (salinan) daftar
if number < 5:
numbers.remove(number)
print("Daftar yang dimodifikasi (diperbaiki dengan salinan):", numbers)
Dengan menggunakan numbers[:], Anda membuat slice dari daftar numbers, yang merupakan salinan dangkal. Perulangan for kemudian beriterasi pada salinan ini, sepenuhnya independen dari modifikasi apa pun yang Anda lakukan pada daftar numbers asli.
Membuat Daftar Baru
Seringkali, cara yang lebih Pythonic untuk mencapai ini adalah dengan membuat daftar baru yang hanya berisi item yang ingin Anda simpan. Pendekatan ini menghindari modifikasi di tempat sama sekali dan seringkali lebih efisien.
numbers = [1, 2, 6, 3, 7, 4, 8, 5]
print("Daftar asli:", numbers)
filtered_numbers = [number for number in numbers if number >= 5]
print("Daftar yang difilter (metode daftar baru):", filtered_numbers)
Dalam kode ini, Anda menggunakan list comprehension untuk membuat daftar baru dari daftar asli yang berisi elemen yang Anda inginkan. Ini juga menjaga daftar asli tetap utuh.
2. Konflik Penamaan
Memilih nama variabel dan file mungkin tampak seperti detail kecil sampai Python menghasilkan kesalahan. Penamaan yang buruk dapat menyebabkan bug aneh, fungsionalitas yang ditutupi (shadowed functionality), dan kebingungan berjam-jam. Ini terjadi dalam dua cara umum: menggunakan kata kunci Python atau nama bawaan sebagai nama Anda sendiri, dan secara tidak sengaja menamai skrip Anda sama dengan modul Python yang sudah ada.
Menggunakan Kata Kunci atau Nama Bawaan:
Python tidak akan menghentikan Anda untuk menamai variabel list, str, atau bahkan sum. Namun, hanya karena Anda bisa, bukan berarti Anda harus melakukannya.
list = [1, 2, 3]
print(list)
list = list('123')
Kode ini akan berjalan tanpa masalah pada awalnya. Namun, jika Anda menambahkan baris lain yang berisi fungsi list() di Python, Anda akan mendapatkan kesalahan. Ini karena Anda telah menimpa fungsi list() bawaan dengan objek daftar Anda sendiri. Ketika Anda mencoba memanggil list(‘123’), Python mengira Anda mencoba memanggil daftar Anda sendiri, bukan fungsi bawaan.
Solusi: Selalu gunakan nama deskriptif yang tidak bertabrakan dengan fitur inti Python.
numbers = [1, 2, 3]
converted = list('123')
Ini tidak hanya membantu Anda menghindari penggunaan kata kunci yang dicadangkan, tetapi juga merupakan praktik yang baik untuk keterbacaan kode dan debugging.
Menamai Skrip Sama dengan Modul yang Ada:
Hal yang sama berlaku untuk menamai file skrip Anda. Misalkan Anda membuat file bernama random.py untuk bereksperimen dengan angka acak:
# random.py import random print(random.randint(1, 10))
Ketika Anda menjalankan ini, Anda kemungkinan akan melihat kesalahan yang mengeluh bahwa “module ‘random’ has no attribute ‘randint’.” Python mengimpor file Anda sendiri (random.py) alih-alih modul random yang sebenarnya dari pustaka standar. Ini adalah bug penutupan (shadowing bug) klasik.
Solusi: Hindari menamai skrip Anda sama dengan modul yang sudah ada seperti random.py, math.py, os.py, atau json.py. Dan jika Anda tidak sengaja melakukannya, jangan lupa untuk menghapus folder .pyc atau __pycache__ yang sesuai setelah mengganti nama.
3. Argumen Fungsi yang Dapat Diubah (Mutable)
Python memungkinkan Anda mengatur nilai default untuk argumen fungsi, yang sangat nyaman. Namun, ketika nilai default tersebut dapat diubah (seperti daftar atau kamus), Anda berjalan ke jebakan bug tersembunyi. Objek mutable default hanya dibuat sekali, saat fungsi didefinisikan, bukan setiap kali dipanggil. Itu berarti jika dimodifikasi, perubahan itu akan tetap ada untuk panggilan berikutnya.
def add_item_to_list(item, item_list=[]):
item_list.append(item)
return item_list
print(add_item_to_list("apple"))
print(add_item_to_list("banana"))
Ketika Anda menjalankan kode ini, Anda mungkin mengharapkan setiap panggilan ke add_item_to_list() untuk dimulai dengan daftar kosong yang baru jika Anda tidak menyediakannya. Namun, output akan menunjukkan sesuatu yang tidak terduga: “apple” masih ada pada panggilan kedua. Daftar item_list hanya dibuat sekali, jadi setiap panggilan ke fungsi terus memodifikasi daftar yang sama. Ini mengarah pada perilaku yang mengejutkan dan sangat bermasalah.
Solusi: Untuk memperbaikinya, Anda dapat menggunakan None sebagai default dan membuat daftar di dalam fungsi:
def add_item_to_list(item, item_list=None):
if item_list is None:
item_list = []
item_list.append(item)
return item_list
print(add_item_to_list("apple"))
print(add_item_to_list("banana"))
Dengan default ke None, daftar baru dibuat setiap kali fungsi dipanggil. Ini memastikan setiap panggilan ke fungsi dimulai dengan daftar yang bersih, seperti yang diharapkan.
4. Penanganan File yang Salah
Bekerja dengan file di Python cukup mudah. Tetapi ada kesalahan umum yang dapat menyelinap ke dalam kode Anda: tidak menutup file. Mungkin tampak tidak berbahaya, tetapi membiarkan file terbuka dapat menyebabkan kebocoran memori, kerusakan file, atau file terkunci yang tidak dapat diakses oleh program lain.
file = open('data.txt', 'r')
content = file.read()
print(content)
# Lupa menutup file!
Membiarkan file terbuka dapat menyebabkan masalah serius. Bahkan dapat mencegah file dihapus atau dimodifikasi oleh proses lain.
Solusi: Anda harus selalu memastikan untuk menutup file setelah Anda menyelesaikan operasi Anda. Anda dapat melakukannya dengan menggunakan fungsi close().
file = open('data.txt', 'r')
content = file.read()
print(content)
file.close()
Praktik terbaik lainnya adalah menggunakan pernyataan with Python, yang secara otomatis menangani penutupan file untuk Anda.
with open('data.txt', 'r') as file:
content = file.read()
print(content)
Blok with menangani semua pembersihan di balik layar. Segera setelah Anda keluar dari blok, Python menutup file untuk Anda. Ini memungkinkan Anda untuk tidak perlu khawatir menutup file secara manual.
5. Mengimpor Semuanya dari Modul
Sebagai pemula, sangat menggoda untuk hanya menempelkan from module import * di bagian atas skrip Anda. Tetapi seiring pertumbuhan kode Anda, jalan pintas ini menjadi resep bencana.
from math import * from custom_math import * print(sqrt(16))
Bagaimana jika math dan custom_math sama-sama mendefinisikan fungsi bernama sqrt()? Mana yang dipanggil? Python tidak memberi tahu Anda. Itu hanya secara diam-diam menimpa yang sebelumnya. Anda bisa menggunakan fungsi yang sama sekali berbeda tanpa menyadarinya. Selain itu, dalam basis kode besar, debugging menjadi mimpi buruk. Anda kehilangan jejak dari mana fungsi atau kelas berasal.
Solusi: Anda harus eksplisit dengan impor Anda.
import math import custom_math print(math.sqrt(16)) print(custom_math.sqrt(16))
Atau bahkan seperti ini:
from math import sqrt as m_sqrt from custom_math import sqrt as c_sqrt print(m_sqrt(16)) print(c_sqrt(16))
“Eksplisit lebih baik daripada implisit” adalah ide inti dari Zen of Python (lihat juga https://id.wikipedia.org/wiki/Zen_of_Python). Anda selalu tahu apa yang Anda gunakan dan dari mana asalnya.
6. Penanganan Pengecualian (Exception) yang Tepat
Bahkan kode yang paling hati-hati sekalipun dapat mengalami masalah yang tidak terduga. Ini disebut pengecualian (exceptions) di Python. Menanganinya dengan anggunlah yang membuat program Anda tangguh. Namun, banyak pemula mendekati penanganan pengecualian dengan mentalitas “tangkap semua”, menggunakan klausul except yang luas. Ini mungkin membungkam kesalahan untuk saat ini, tetapi membuat kode Anda rapuh, membingungkan, dan sulit untuk di-debug.
try:
result = 10 / 0
except:
print("Ada yang salah!")
Ini menangkap segalanya. Bahkan kesalahan yang tidak Anda duga atau ingin tangani. Kesalahan sintaks, interupsi keyboard, kesalahan ketik, impor yang rusak. Python akan menelan semuanya dengan except generik itu. Ini tidak ideal.
Solusi: Jadilah spesifik tentang apa yang Anda tangkap:
try:
result = 10 / 0
except ZeroDivisionError:
print("Anda tidak bisa membagi dengan nol!")
Anda hanya menangkap kesalahan yang Anda harapkan. Jika ada hal lain yang salah, Python akan tetap mengangkatnya. Jadi, Anda tidak akan secara diam-diam mengabaikan bug yang sebenarnya. Anda juga dapat menangani beberapa pengecualian dengan cerdas:
try:
value = int(input("Masukkan angka: "))
result = 10 / value
except ValueError:
print("Itu bukan angka yang valid!")
except ZeroDivisionError:
print("Anda tidak bisa membagi dengan nol!")
Hindari except: sendirian. Jika Anda harus menangkap semua pengecualian (jarang), gunakan except Exception: dan tetap tangani dengan hati-hati. Dengan menangani pengecualian secara spesifik, kode Anda menjadi lebih mudah diprediksi, lebih mudah di-debug, dan mampu memberikan umpan balik yang lebih berarti.