ความแตกต่างระหว่างอ็อบเจกต์ที่เปลี่ยนแปลงได้และไม่เปลี่ยนแปลงได้คืออะไร?

Question

Accepted Answer

อ็อบเจกต์ที่ **ไม่เปลี่ยนแปลงได้** ไม่สามารถเปลี่ยนแปลงได้หลังจากการสร้าง อ็อบเจกต์ที่ **เปลี่ยนแปลงได้** สามารถเปลี่ยนแปลงได้ ความแตกต่างนี้เป็นหัวใจสำคัญของ Python และส่งผลกระทบต่อ aliasing, dict keys, function arguments, และบ้านของบัคที่สูบติดละเอียด

## สองหมวดหมู่

```text
Immutable: int, float, bool, str, tuple, frozenset, bytes, None
Mutable:   list, dict, set, bytearray, and most custom objects
```

## ไม่เปลี่ยนแปลงได้: "การเปลี่ยนแปลง" สร้างอ็อบเจกต์ใหม่

```python
x = "hello"
x.upper()       # returns a NEW string "HELLO" — x is unchanged
x += " world"   # rebinds x to a NEW string; the original "hello" is untouched

n = 5
n += 1          # creates a new int 6; doesn't modify the int object 5
```

กับไม่เปลี่ยนแปลงได้, การดำเนินการที่ดูเหมือนจะ "เปลี่ยนแปลง" ค่า จริง ๆ แล้วสร้างอ็อบเจกต์ใหม่และผูกตัวแปรใหม่ ต้นฉบับไม่เคยถูกเปลี่ยนแปลง

## เปลี่ยนแปลงได้: แก้ไขในที่

```python
lst = [1, 2, 3]
lst.append(4)   # modifies the SAME list object → [1, 2, 3, 4]
lst[0] = 99     # in-place change
```

## กับดักการเข้าถึง (อันตรายในทางปฏิบัติ)

```python
# mutable — two names point to the SAME object
a = [1, 2, 3]
b = a            # b is NOT a copy — it's the same list
b.append(4)
print(a)         # [1, 2, 3, 4] ← a changed too! (they're aliases)

# to actually copy:
b = a.copy()     # or list(a), or a[:]
```

การกำหนดอ็อบเจกต์ที่เปลี่ยนแปลงได้ไม่ได้สำเนา — ชื่อทั้งสองอ้างอิงถึงออบเจกต์เดียวกัน ดังนั้นการกลายเพศผ่านหนึ่งส่งผลกระทบต่ออีกชื่อ สิ่งนี้ทำให้หลายคนประหลาดใจและทำให้เกิดบัคจริง ๆ

## เหตุใดอ็อบเจกต์ที่ไม่เปลี่ยนแปลงได้จึงสามารถเป็น dict keys / set members

```python
d = {(1, 2): "point"}   # ✅ tuple key — immutable, hashable
d = {[1, 2]: "x"}       # ❌ TypeError — lists are unhashable (mutable)
```

Dict keys และ set members ต้องเป็น **hashable** ซึ่งต้องการความไม่เปลี่ยนแปลงได้ (คีย์ที่เปลี่ยนแปลงได้อาจเปลี่ยนแปลงและทำลายตารางแฮช)

## Function arguments

```python
def modify(lst): lst.append(99)   # mutates the caller's list (passed by reference)
def rebind(n): n += 1             # rebinds locally; caller's int unchanged
```

## ทำไมมันถึงสำคัญ

Mutability เป็นแนวคิดพื้นฐาน Python ที่อธิบายพฤติกรรมและบัคที่หลากหลาย: กับดักการเข้าถึง (การมอบหมายไม่สำเนาเปลี่ยนแปลงได้), เหตุใดฟังก์ชันจึงสามารถแก้ไขรายการที่ผ่านมา แต่ไม่ใช่ int, เหตุใดจึงเป็นอ็อบเจกต์ที่ไม่เปลี่ยนแปลงได้เท่านั้นที่สามารถเป็น dict keys/set members, และ mutable-default-argument pitfall

การเข้าใจประเภทใดที่เปลี่ยนแปลงได้กับไม่เปลี่ยนแปลงได้ — และการกลายเพศของอ็อบเจกต์ที่แชร์ส่งผลกระทบต่อการอ้างอิงทั้งหมด — เป็นสิ่งจำเป็นสำหรับการเขียน Python ที่ถูกต้องและหลีกเลี่ยงความประหลาดใจทั่วไปของ Python