Mutable vs Immutable Objects di Python: Konsep Dasar yang Sering Diremehkan

Mutable vs Immutable Objects di Python: Konsep Dasar yang Sering Diremehkan

Di Python, semua variabel sebenarnya hanyalah referensi ke sebuah objek. Ini poin penting yang sering terlewat, terutama oleh pemula yang datang dari bahasa lain seperti C atau Java. Variabel di Python tidak menyimpan nilai secara langsung, melainkan menunjuk ke sebuah objek di memori. Setiap objek tersebut memiliki identity (id), type, dan value.

Python membagi objek menjadi dua kategori besar: mutable dan immutable. Perbedaan ini bukan sekadar teori, tapi sangat berpengaruh pada cara Python bekerja, cara fungsi berperilaku, hingga munculnya bug yang sulit dilacak.

Secara sederhana:

• Immutable→ objek tidak bisa diubah setelah dibuat
• Mutable→ objek bisa diubah tanpa membuat objek baru

Memahami perbedaan ini adalah salah satu fondasi penting untuk naik level sebagai Python programmer.

Apa Itu Immutable Objects ?

Immutable objects adalah objek yang state-nya tidak bisa diubah setelah objek tersebut dibuat. Jika kita “mengubah” nilainya, Python sebenarnya membuat objek baru, bukan memodifikasi objek lama.

Tipe data bawaan Python yang termasuk immutable antara lain:

• int
• float
• bool
• str
• tuple
• frozenset

Mari kita lihat contoh klasik menggunakan tuple.

Contoh: Tuple Bersifat Immutable

tuple1 = (0, 1, 2, 3)
tuple1[0] = 4

Kode di atas akan menghasilkan error:

• TypeError: 'tuple' object does not support item assignment

Ini terjadi karena tuple tidak menyediakan mekanisme untuk mengubah isi internalnya. Begitu tuple dibuat, strukturnya bersifat tetap.

Baca Juga

• Plotting Graph Menggunakan Seaborn
• Kenpa Bug Di Python Sulit Terlihat ?

 

String Juga Immutable (Dan Ini Sering Mengecoh)

String di Python terlihat seperti array karakter, tapi sebenarnya bukan. Setiap kali kita memodifikasi string, Python akan membuat objek string baru.

Contoh: String Tidak Bisa Diubah

message = "Welcome to GeeksforGeeks"
message[0] = 'p'

Hasilnya:

• TypeError: 'str' object does not support item assignment

Kalau kita ingin “mengubah” string, caranya adalah dengan membuat string baru:

message = "p" + message[1:]
print(message)

Ini bukan mengedit string lama, tapi membuat objek string baru di memori.

 

Apa Itu Mutable Objects ?

Berbeda dengan immutable, mutable objects memungkinkan kita mengubah isi internalnya tanpa membuat objek baru. Identitas objek (id) tetap sama, tapi nilainya berubah.

Tipe mutable yang paling umum di Python:

• list
• dict
• set
• custom class (umumnya mutable)

Mutable object sangat berguna ketika kita perlu:

• Menambah atau menghapus data
• Mengubah struktur data
• Menyimpan state yang dinamis

 

List di Python Bersifat Mutable

List adalah contoh paling populer dari mutable object.

Contoh: Menambah dan Menghapus Elemen List

my_list = [1, 2, 3]
my_list.append(4)
print(my_list)


my_list.insert(1, 5)
print(my_list)


my_list.remove(2)
print(my_list)


popped_element = my_list.pop(0)
print(my_list)
print(popped_element)

Output:

[1, 2, 3, 4]
[1, 5, 2, 3, 4]
[1, 5, 3, 4]
[5, 3, 4]
1

Di sini, my_list tetap objek yang sama, hanya isinya yang berubah.

 

Dictionary: Mutable dan Sering Jadi Sumber Bug

Dictionary (dict) juga bersifat mutable. Masalah muncul ketika kita menyalin referensi, bukan menyalin objeknya.

Contoh: Reference vs Copy pada Dictionary

my_dict = {"name": "Ram", "age": 25}
new_dict = my_dict
new_dict["age"] = 37


print(my_dict)
print(new_dict)

Output:

{'name': 'Ram', 'age': 37}
{'name': 'Ram', 'age': 37}

Banyak pemula kaget melihat hasil ini. Mereka mengira new_dict adalah salinan, padahal sebenarnya kedua variabel menunjuk ke objek yang sama.

Kalau ingin benar-benar menyalin:

new_dict = my_dict.copy()

 

Set Juga Mutable

Set memungkinkan kita menambah dan menghapus elemen.

my_set = {1, 2, 3}
new_set = my_set
new_set.add(4)


print(my_set)
print(new_set)

Output:

{1, 2, 3, 4}
{1, 2, 3, 4}

Sekali lagi, perubahan pada new_set memengaruhi my_set karena mereka menunjuk ke objek yang sama.

 

Perbedaan Fundamental: Identity vs Value

Untuk benar-benar memahami mutable dan immutable, kita perlu mengenal fungsi id().

Contoh Perbandingan

a = 10
print(id(a))


a = 20
print(id(a))

ID akan berbeda karena integer bersifat immutable.

Bandingkan dengan list:

lst = [1, 2, 3]
print(id(lst))


lst.append(4)
print(id(lst))

ID tetap sama, meskipun isinya berubah.

 

Kenapa Immutable Lebih Aman?

Immutable objects:

• Lebih aman dari side effect
• Cocok untuk key dictionary
• Lebih mudah diprediksi
• Cocok untuk pemrograman fungsional

Itulah alasan kenapa tuple bisa jadi key dictionary, tapi list tidak.

my_dict = {(1, 2): "valid"}     # OK
my_dict = {[1, 2]: "error"}    # TypeError

 

Mutable Object dan Bug yang “Tak Terlihat”

Banyak bug Python muncul bukan karena syntax error, tapi karena mutability.

Contoh Bug Halus

def add_item(lst):
    lst.append(100)


data = [1, 2, 3]
add_item(data)


print(data)

Output:

[1, 2, 3, 100]

Jika kita tidak sadar bahwa list bersifat mutable, efek samping ini bisa merusak data di banyak tempat.

Solusi aman:

def add_item(lst):
    new_lst = lst.copy()
    new_lst.append(100)
    return new_lst

Exception: Tuple Bisa “Berisi” Mutable Object

Ini bagian yang sering bikin bingung.

tup = ([3, 4, 5], 'myname')
tup[0].append(6)
print(tup)

Output:

([3, 4, 5, 6], 'myname')

Tuple-nya tetap immutable, tapi ia menyimpan referensi ke list, dan list tersebut mutable. Yang berubah bukan tuple-nya, tapi objek di dalamnya.

Rule of Thumb yang Perlu Diingat

Sebagai pedoman praktis:

• Tipe primitive-like→ biasanya immutable
• Tipe container-like→ biasanya mutable
• Kalau ragu, cek dokumentasi atau coba id()

 

Kapan Pakai Mutable, Kapan Pakai Immutable ?

Pemilihan antara mutable dan immutable bukan sekadar soal gaya penulisan kode, tapi soal kontrol terhadap perubahan data. Tipe immutable seperti tuple, frozenset, atau str sangat cocok dipakai ketika data memang tidak boleh berubah sepanjang program berjalan. Ini penting untuk menjaga konsistensi logika, menghindari bug tersembunyi akibat perubahan tak sengaja, dan membuat alur data lebih mudah diprediksi. Karena sifatnya yang stabil, immutable juga aman digunakan sebagai key dictionary atau dikirim lintas fungsi tanpa khawatir terjadi side effect. Dalam sistem yang kompleks, immutable membantu developer berpikir lebih deklaratif: data adalah fakta, bukan objek yang bisa berubah seenaknya.

Sebaliknya, mutable seperti list, dict, atau set lebih masuk akal ketika data memang perlu dimodifikasi secara bertahap. Misalnya saat mengolah data yang ukurannya dinamis, menyimpan state sementara, atau bekerja sebagai buffer yang terus diperbarui. Mutable unggul dari sisi fleksibilitas dan efisiensi, karena tidak perlu membuat objek baru setiap kali ada perubahan. Namun, konsekuensinya adalah developer harus ekstra hati-hati terhadap referensi dan perubahan tak terduga. Intinya sederhana: gunakan immutable untuk keamanan dan kejelasan, gunakan mutable untuk fleksibilitas dan performa. Developer yang matang bukan yang fanatik pada satu jenis, tapi yang tahu kapan harus memilih yang tepat

 

Penutup: Kenapa Topik Ini Penting Banget ?

Mutable vs immutable bukan sekadar teori Python dasar. Ini adalah konsep yang:

• Menjelaskan kenapa bug muncul “tanpa sebab”
• Menentukan desain fungsi yang bersih
• Membantu memahami performa dan memory
• Jadi fondasi untuk memahami concurrency dan async

Kalau kamu sudah benar-benar paham perbedaan ini—bukan cuma hafal definisinya, tapi ngerti dampaknya—berarti kamu sudah naik level dari “bisa pakai Python” ke “mengerti cara Python berpikir”.

Published on March 16, 2026
Last updated on June 03, 2026