Muterbara och Omuterbara i Python

Den här artikeln förklarar muterbara och omuterbara i Python.

YouTube Video

Muterbara och Omuterbara i Python

"Muterbar" och "omuterbar" hänvisar till ett objekts muterbarhet. Att förstå detta hjälper till att undvika oväntade buggar och effektiv minneshantering.

Vad är muterbart?

Muterbara objekt kan få sitt interna tillstånd ändrat efter skapandet.

Viktigaste muterbara datatyperna

• list
• dict
• set
• Användardefinierade klasser (om deras attribut kan ändras)

Exempel: Modifiera en lista

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

En lista är ett muterbart objekt, och dess element kan ändras fritt.

Vad är omuterbart?

Omuterbara objekt kan inte ändras efter att de har skapats. Vid försök att ändra dem skapas ett nytt objekt.

Viktigaste omuterbara datatyperna

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

Exempel: Modifiera en sträng

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"

Strängar är omuterbara, så du kan inte ändra dem delvis.

Jämförelse mellan muterbara och omuterbara

 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

Som visas i exemplet ovan, muterbara objekt delas genom referens, vilket innebär att de kan påverka andra variabler. Å andra sidan, skapar immutabla objekt nya instanser vid omtilldelning, vilket lämnar det ursprungliga värdet opåverkat.

Inspektera internt beteende med id()

I Python kan du använda id()-funktionen för att kontrollera ett objekts ID. Objekt-ID:t är likt en minnesadress.

 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

Som visas, skapas ett nytt objekt för immutabla typer, medan muterbara typer ändras på plats.

Funktioner och försiktighet med mutabla och immutabla objekt

När ett mutabelt objekt skickas till en funktion, kan den ursprungliga datan ändras.

Exempel: En funktion som ändrar en lista

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]

Exempel: En funktion som ändrar ett tal

Å andra sidan resulterar ett försök att ändra ett immutabelt objekt i att ett nytt objekt skapas.

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

Praktiska överväganden

Undvik att använda mutabla objekt som standardargument

 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

Eftersom standardargument utvärderas endast en gång vid funktionsdefinition, kan användning av mutabla objekt leda till oväntade bieffekter.

Sammanfattning

För att verkligen förstå Pythons variabler och datatyper är det viktigt att förstå skillnaderna mellan mutabla och immutabla objekt. Genom att förstå dessa egenskaper kan du undvika oavsiktligt beteende i din kod och skriva mer robusta och läsbara program.

Du kan följa med i artikeln ovan med hjälp av Visual Studio Code på vår YouTube-kanal. Vänligen kolla även in YouTube-kanalen.

YouTube Video