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

Tulad ng makikita mo sa halimbawang ito, ang mga nababagong bagay (mutable objects) ay naibabahagi sa pamamagitan ng reference, kaya maaari nilang maapektuhan ang ibang 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
15
16print(add_item(1))  # [1]
17print(add_item(2))  # [2]

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.

• Sa unang halimbawa, ang parehong list object ay ginagamit tuwing tumatawag ng add_item. Kapag tinawag muli ang add_item(2), ang dating idinagdag na 1 ay naroon pa rin sa listahan, kaya ang resulta ay [1, 2].
• Sa pinahusay na halimbawa, ang None ang ginagamit bilang default na halaga, at gumagawa ng bagong listahan sa loob ng function kung ang argumento ay None. Tinitiyak nito na may bagong listahan sa bawat pagtawag ng function, kaya hindi naaapektuhan ng mga nakaraang resulta ang mga susunod pang pagtawag.

Iwasan ang paggamit ng mga mutable object tulad ng mga list o dictionary bilang default argument; sa halip, gumamit ng None at i-initialize ito sa loob ng function. Ito ay isang pangunahing at mahalagang best practice sa Python.

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