Mutable dan Immutable dalam Python

Artikel ini menjelaskan tentang mutable dan immutable dalam Python.

YouTube Video

Mutable dan Immutable dalam Python

"Mutable" dan "immutable" merujuk pada kemutabilan suatu objek. Memahami hal ini membantu dalam menghindari bug yang tak terduga dan pengelolaan memori yang efisien.

Apa itu Mutable?

Objek mutable dapat mengubah keadaan internalnya setelah dibuat.

Tipe Data Mutable Utama

• list
• dict
• set
• Kelas yang didefinisikan oleh pengguna (jika atributnya dapat dimodifikasi)

Contoh: Memodifikasi Sebuah List

1numbers = [1, 2, 3]
2numbers[0] = 100
3print(numbers)  # [100, 2, 3]

List adalah objek mutable, dan elemen-elemennya dapat dimodifikasi secara bebas.

Apa itu Immutable?

Objek immutable tidak dapat diubah setelah dibuat. Mencoba mengubahnya akan menghasilkan pembuatan objek baru.

Tipe Data Immutable Utama

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

Contoh: Memodifikasi Sebuah String

1text = "hello"
2# text[0] = "H"  # TypeError: 'str' object does not support item assignment
3
4text = "H" + text[1:]  # Creates a new string
5print(text)  # "Hello"

String adalah immutable, sehingga Anda tidak dapat memodifikasinya secara parsial.

Perbandingan antara Mutable dan Immutable

 1# Mutable example
 2a = [1, 2, 3]
 3b = a
 4b[0] = 100
 5print(a)  # [100, 2, 3] -> a is also changed
 6
 7# Immutable example
 8x = 10
 9y = x
10y = 20
11print(x)  # 10 -> x is unchanged

Seperti yang dapat Anda lihat dari contoh ini, objek yang dapat diubah dibagikan melalui referensi, sehingga mereka dapat mempengaruhi variabel lain. Di sisi lain, objek yang tidak dapat diubah (immutable) akan membuat instance baru saat dilakukan penugasan ulang, sehingga nilai aslinya tidak terpengaruh.

Memeriksa Perilaku Internal Menggunakan id()

Di Python, Anda dapat menggunakan fungsi id() untuk memeriksa ID sebuah objek. ID objek mirip dengan alamat memori.

 1# Immutable int behavior
 2a = 10
 3print(id(a))  # e.g., 140715920176592
 4a += 1
 5print(id(a))  # e.g., 140715920176624 -> ID has changed
 6
 7# Mutable list behavior
 8b = [1, 2, 3]
 9print(id(b))  # e.g., 2819127951552
10b.append(4)
11print(id(b))  # Same ID -> only the content has changed

Seperti yang ditunjukkan, objek baru dibuat untuk tipe yang tidak dapat diubah (immutable), sedangkan tipe yang dapat diubah (mutable) dimodifikasi langsung di tempat.

Fungsi dan Kehati-hatian dengan Objek Mutable dan Immutable

Saat meneruskan objek yang dapat diubah (mutable) ke fungsi, data aslinya mungkin akan dimodifikasi.

Contoh: Fungsi yang Memodifikasi Sebuah List

1def modify_list(lst):
2    lst.append(100)
3
4my_list = [1, 2, 3]
5modify_list(my_list)
6print(my_list)  # [1, 2, 3, 100]

Contoh: Fungsi yang Memodifikasi Sebuah Angka

Di sisi lain, upaya untuk memodifikasi objek yang tidak dapat diubah (immutable) akan menghasilkan objek baru yang dibuat.

1def modify_number(n):
2    n += 10
3
4my_number = 5
5modify_number(my_number)
6print(my_number)  # 5 -> unchanged

Pertimbangan Praktis

Hindari Menggunakan Objek Mutable sebagai Argumen Default

 1# Bad example
 2def add_item(item, container=[]):
 3    container.append(item)
 4    return container
 5
 6print(add_item(1))  # [1]
 7print(add_item(2))  # [1, 2] -> unintended behavior
 8
 9# Good example
10def add_item(item, container=None):
11    if container is None:
12        container = []
13    container.append(item)
14    return container
15
16print(add_item(1))  # [1]
17print(add_item(2))  # [2]

Karena argumen default hanya dievaluasi sekali saat pendefinisian fungsi, penggunaan objek mutable dapat menyebabkan efek samping yang tidak terduga.

• Pada contoh pertama, objek daftar (list) yang sama digunakan setiap kali add_item dipanggil. Saat memanggil add_item(2) untuk kedua kalinya, 1 yang sebelumnya ditambahkan masih ada di dalam daftar, sehingga menghasilkan [1, 2].
• Pada contoh yang sudah diperbaiki, None digunakan sebagai nilai default, dan daftar baru dibuat di dalam fungsi jika argumennya adalah None. Ini memastikan bahwa daftar baru dibuat setiap kali fungsi dipanggil, sehingga hasil sebelumnya tidak mempengaruhi pemanggilan berikutnya.

Hindari menggunakan objek yang dapat diubah seperti daftar (list) atau kamus (dictionary) sebagai argumen default; sebaiknya gunakan None dan inisialisasi di dalam fungsi. Ini adalah praktik terbaik yang mendasar dan penting dalam Python.

Ringkasan

Untuk memahami secara mendalam variabel dan tipe data di Python, sangat penting untuk memahami perbedaan antara mutable dan immutable. Memahami karakteristik ini membantu Anda menghindari perilaku yang tidak diinginkan dalam kode Anda dan menulis program yang lebih kuat dan mudah dibaca.

Anda dapat mengikuti artikel di atas menggunakan Visual Studio Code di saluran YouTube kami. Silakan periksa juga saluran YouTube kami.

YouTube Video