Mutable at Immutable sa Python

Ipinaliwanag ng artikulong ito ang mutable at immutable sa Python.

YouTube Video

Mutable at Immutable sa Python

Ang "Mutable" at "Immutable" ay tumutukoy sa pagiging mutable ng isang object. Ang pag-unawa dito ay nakakatulong sa pag-iwas sa di-inaasahang mga bug at mahusay na pamamahala ng memorya.

Ano ang Mutable?

Ang mga Mutable na object ay maaaring baguhin ang kanilang panloob na estado pagkatapos likhain.

Pangunahing Mga Uri ng Mutable na Data

• list
• dict
• set
• Mga klase na itinakda ng user (kung ang kanilang mga katangian ay maaaring baguhin)

Halimbawa: Pagbabago ng Isang Listahan

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

Ang isang listahan ay isang mutable na object, at ang mga elemento nito ay maaaring malayang baguhin.

Ano ang Immutable?

Ang mga Immutable na object ay hindi maaaring baguhin pagkatapos nilang malikha. Ang pagtatangkang baguhin ang mga ito ay nagreresulta sa paglikha ng bagong object.

Pangunahing Mga Uri ng Immutable na Data

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

Halimbawa: Pagbabago ng Isang 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"

Ang mga string ay immutable, kaya hindi mo maaaring baguhin ang mga ito nang bahagi lamang.

Paghahambing ng Mutable at 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

Gaya ng ipinakita sa halimbawa sa itaas, ang mga mutable na object ay ibinabahagi sa pamamagitan ng reference, kaya maaari nilang maapektuhan ang ibang mga variable. Sa kabilang banda, ang mga immutable na bagay ay lumilikha ng mga bagong instance kapag nire-reassign, naiiwan ang orihinal na halaga na hindi naapektuhan.

Pagsusuri ng Panloob na Pag-uugali Gamit ang id()

Sa Python, magagamit mo ang function na id() upang suriin ang ID ng isang bagay. Ang ID ng bagay ay kahalintulad ng isang memory address.

 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

Tulad ng ipinakita, isang bagong object ang nalilikha para sa mga immutable na uri, habang ang mga mutable na uri ay binabago sa lugar mismo.

Mga Function at Babala sa Paggamit ng Mutable at Immutable na Bagay

Kapag ipinasa ang mutable na bagay sa isang function, ang orihinal na data ay maaaring mabago.

Halimbawa: Isang Function na Nagbabago ng Listahan

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]

Halimbawa: Isang Function na Nagbabago ng Numero

Sa kabilang banda, ang pagtatangkang baguhin ang isang immutable na bagay ay nagreresulta sa paglikha ng bagong bagay.

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

Praktikal na Pagsasaalang-alang

Iwasan ang Paggamit ng Mutable na Bagay bilang Default na Argumento

 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

Dahil ang default na mga argumento ay ina-assess lamang ng isang beses sa paglalagay ng function, ang paggamit ng mutable na bagay ay maaaring humantong sa hindi inaasahang mga epekto.

Buod

Upang lubusang maunawaan ang mga variable at uri ng data ng Python, mahalagang maunawaan ang mga pagkakaiba ng mutable at immutable. Ang pag-unawa sa mga katangiang ito ay tumutulong sa iyo upang maiwasan ang hindi inaasahang asal sa iyong code at makasulat ng mas matatag at nababasang mga programa.

Maaari mong sundan ang artikulo sa itaas gamit ang Visual Studio Code sa aming YouTube channel. Paki-check din ang aming YouTube channel.

YouTube Video