# Nakafa Learning Content

> For AI agents: use [llms.txt](https://nakafa.com/llms.txt) for the site index. Markdown versions are available by appending `.md` to content URLs or sending `Accept: text/markdown`.

URL: https://nakafa.com/id/materi/ai-ds/pemrograman-ai/immutable-mutable-dan-identity
Source: https://raw.githubusercontent.com/nakafaai/nakafa.com/refs/heads/main/packages/contents/material/lesson/ai-ds/ai-programming/immutable-mutable-identity/id.mdx

Mutabilitas, identitas, referensi list, dan manajemen memori objek Python lewat contoh praktis.

---

## List dan Mutabilitas

Dalam Python, list merupakan struktur data yang dapat diubah setelah dibuat. Mari kita pahami bagaimana perilaku list ketika kita melakukan operasi tertentu.

Ketika kamu membuat sebuah list dan menyimpannya dalam variabel, Python tidak menyalin isi list tersebut. Sebaliknya, variabel tersebut menyimpan referensi atau alamat memori tempat list berada. Bayangkan seperti alamat rumah, variabel hanya menyimpan alamat, bukan rumahnya sendiri.

File: list_reference.py
```python
# Membuat list dan memberikan referensi
list1 = [0, 1, 2]
list2 = ['a', list1, True]

print(list2)  # ['a', [0, 1, 2], True]

# Mengubah elemen dalam list1
list1[1] = [3, 4, 5]
print(list2)  # ['a', [0, [3, 4, 5], 2], True]
```

Perhatikan bagaimana perubahan pada `list1` juga mempengaruhi `list2`. Ini terjadi karena `list2` tidak menyimpan salinan `list1`, melainkan referensi ke objek list yang sama di memori.

### Operasi Slice Menciptakan Salinan Baru

Berbeda dengan assignment biasa, operasi slice pada list akan menciptakan objek list baru di memori. Kamu dapat membuktikan ini dengan menggunakan fungsi `id()` yang mengembalikan alamat memori objek.

File: slice_copy.py
```python
# Operasi slice menciptakan list baru
list1 = [0, 1, 2]
list2 = list1[:]  # Mengambil semua elemen dengan slice

print(id(list1))  # Contoh: 3104
print(id(list2))  # Contoh: 8864 (berbeda dari list1)

# Mengubah elemen di list2 tidak mempengaruhi list1
list2[0] = 'x'
print(list1)  # [0, 1, 2] (tidak berubah)
print(list2)  # ['x', 1, 2]
```

## Identitas, Tipe, dan Nilai Objek

Setiap objek dalam Python memiliki tiga karakteristik penting yang membedakannya dari objek lain.

Component: Mermaid
Props:
- title: Identitas Menunjukkan Objek yang Dipakai
- description: Pisahkan identity, type, dan value agar satu objek tidak tertukar dengan nama variabelnya.
```mermaid

  flowchart LR
      A[Objek Python] --> B[Identitas]
      A --> C[Tipe]
      A --> D[Nilai]

      B --> B1[Alamat memori unik]
      C --> C1[Menentukan operasi]
      D --> D1[Data yang disimpan]

```

### Identitas Objek

Identitas adalah alamat memori unik tempat objek disimpan. Python menyediakan fungsi `id()` untuk melihat identitas objek dan operator `is` untuk membandingkan identitas dua objek.

File: object_identity.py
```python
a = 300
print(a)          # 300
print(type(a))    # <class 'int'>
print(id(a))      # 10120

b = a  # b mereferensi objek yang sama dengan a
print(id(b))      # 10120 (sama dengan a)

a = a + 1  # Membuat objek baru
print(id(a))      # 10492 (berbeda dari sebelumnya)
```

### Perbandingan Identitas dan Nilai

Python memiliki optimisasi khusus untuk integer kecil (biasanya $$-5$$ sampai $$256$$). Integer dalam rentang ini menggunakan objek yang sama di memori untuk menghemat ruang.

Visible text: Python memiliki optimisasi khusus untuk integer kecil (biasanya sampai ). Integer dalam rentang ini menggunakan objek yang sama di memori untuk menghemat ruang.

File: identity_comparison.py
```python
# Integer besar mungkin menggunakan objek berbeda
a = 300
b = 300
print(a is b)      # Mungkin True atau False (tergantung implementasi)
print(a == b)      # True (nilai sama)

# Integer dalam rentang -5 sampai 256 biasanya sama
a = 100
b = 100
print(a is b)      # True (optimisasi untuk integer kecil)
print(a == b)      # True (nilai sama)
```

## Objek Mutable dan Immutable

Python mengklasifikasikan objek berdasarkan kemampuannya untuk diubah setelah dibuat.

### Objek Immutable

Objek immutable tidak dapat diubah setelah dibuat. Setiap operasi yang tampak mengubah objek sebenarnya menciptakan objek baru.

File: immutable_objects.py
```python
# Integer adalah immutable
a = 300
print(id(a))  # 10120

a = a + 1     # Membuat objek baru
print(id(a))  # 10492 (berbeda)

# String juga immutable
str_var = 'hello'
print(id(str_var))  # 75568

# Mencoba mengubah string akan menghasilkan error
# str_var[1] = 'a'  # TypeError
```

Tipe data immutable dalam Python meliputi:

- `bool` (boolean)
    - `int` (integer)
    - `float` (floating point)
    - `complex` (bilangan kompleks)
    - `str` (string)
    - `tuple` (tuple)

Visible text: - `bool` (boolean)
 - `int` (integer)
 - `float` (floating point)
 - `complex` (bilangan kompleks)
 - `str` (string)
 - `tuple` (tuple)

### Objek Mutable

Objek mutable dapat diubah setelah dibuat tanpa menciptakan objek baru. Identitas objek tetap sama meskipun nilainya berubah.

File: mutable_objects.py
```python
# List adalah mutable
list_var = [0, 1, 2]
print(id(list_var))  # 15296

# Mengubah elemen tidak mengubah identitas objek
list_var = [0, 0, 0]
print(id(list_var))  # 60960 (objek baru karena assignment)

# Modifikasi in-place mempertahankan identitas
list_var[:] = ['a', 'b', 'c']
print(id(list_var))  # 60960 (sama)
```

Tipe data mutable dalam Python meliputi:

- `list` (list)
    - `dict` (dictionary)
    - `set` (set)

Visible text: - `list` (list)
 - `dict` (dictionary)
 - `set` (set)

### Perilaku Assignment vs Modifikasi

Penting untuk membedakan antara assignment (pemberian nilai baru) dan modifikasi in-place.

File: assignment_vs_modification.py
```python
list1 = [0, 1, 2]
list2 = list1  # Kedua variabel mereferensi objek yang sama

print(id(list1))     # 700
print(id(list2))     # 700 (sama)

# Modifikasi in-place mempengaruhi kedua variabel
list1[1] = 'x'
print(list1)         # [0, 'x', 2]
print(list2)         # [0, 'x', 2] (ikut berubah)

# Assignment membuat referensi baru
list1 = [1, 2, 3]
print(list1)         # [1, 2, 3]
print(list2)         # [0, 'x', 2] (tidak berubah)
```

Component: Mermaid
Props:
- title: Assignment Mengganti Ikatan, Modifikasi Mengubah Isi
- description: Bandingkan assignment yang mengganti rujukan dengan modifikasi yang mengubah objek yang sama.
```mermaid

  flowchart TD
      subgraph Sebelum ["Sebelum Modifikasi"]
          A[list1] --> C["Objek list: 0, 1, 2"]
          B[list2] --> C
      end

      subgraph Sesudah ["Sesudah list1[1] = x"]
          D[list1] --> F["Objek list sama: 0, x, 2"]
          E[list2] --> F
      end

      Sebelum -.-> Sesudah

```

Pemahaman tentang mutabilitas sangat penting dalam pemrograman Python. Objek immutable lebih aman untuk digunakan dalam konteks multi-threading karena tidak dapat diubah, sedangkan objek mutable memberikan fleksibilitas untuk memodifikasi data secara efisien tanpa menciptakan objek baru setiap kali.