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 du kan se i det här exemplet delas ändringsbara objekt genom referens, så 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
15
16print(add_item(1))  # [1]
17print(add_item(2))  # [2]

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

• I det första exemplet används samma listobjekt varje gång add_item anropas. När add_item(2) anropas för andra gången finns den tidigare tillagda 1 fortfarande kvar i listan, vilket ger [1, 2].
• I det förbättrade exemplet används None som standardvärde, och en ny lista skapas inuti funktionen om argumentet är None. Detta säkerställer att en ny lista skapas varje gång funktionen anropas, så tidigare resultat påverkar inte efterföljande anrop.

Undvik att använda ändringsbara objekt som listor eller ordböcker som standardargument; använd istället None och initiera dem inuti funktionen. Detta är en grundläggande och viktig bästa praxis i Python.

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