Muterbar og Uforanderlig i Python

Denne artikkelen forklarer muterbare og uforanderlige objekter i Python.

YouTube Video

Muterbar og Uforanderlig i Python

"Muterbar" og "uforanderlig" refererer til muligheten for å endre et objekt. Å forstå dette hjelper med å unngå uventede feil og effektiv minnehåndtering.

Hva er Muterbar?

Muterbare objekter kan endre sin interne tilstand etter opprettelse.

Hovedtyper av Muterbare Data

• list
• dict
• set
• Brukerdefinerte klasser (hvis deres attributter kan endres)

Eksempel: Endring av en Liste

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

En liste er et muterbart objekt, og elementene kan endres fritt.

Hva er Uforanderlig?

Uforanderlige objekter kan ikke endres etter at de er opprettet. Forsøk på å endre dem resulterer i opprettelsen av et nytt objekt.

Hovedtyper av Uforanderlige Data

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

Eksempel: Endring av en Streng

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"

Strenger er uforanderlige, så du kan ikke endre dem delvis.

Sammenligning av Muterbar og Uforanderlig

 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 fra dette eksempelet, deles mutable objekter ved referanse, så de kan påvirke andre variabler. På den annen side, ubrytelige objekter oppretter nye instanser ved tildeling på nytt, og etterlater den opprinnelige verdien uberørt.

Undersøke intern atferd ved hjelp av id()

I Python kan du bruke id()-funksjonen for å sjekke et objekts ID. Objektets ID er lik en minneadresse.

 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 vist, et nytt objekt opprettes for uforanderlige typer, mens foranderlige typer endres direkte på stedet.

Funksjoner og forsiktighet med endringsbare og ubrytelige objekter

Når et endringsbart objekt sendes til en funksjon, kan de opprinnelige dataene bli endret.

Eksempel: En funksjon som endrer en liste

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]

Eksempel: En funksjon som endrer et tall

På den annen side, resulterer et forsøk på å endre et ubrytelige objekt i at et nytt objekt opprettes.

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

Praktiske hensyn

Unngå å bruke endringsbare objekter som standardargumenter

 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]

Siden standardargumenter evalueres kun én gang når funksjonen defineres, kan bruk av endringsbare objekter føre til uventede bivirkninger.

• I det første eksempelet brukes det samme listeobjektet hver gang add_item kalles. Når du kaller add_item(2) for andre gang, er den tidligere lagte 1 fortsatt i listen, noe som gir [1, 2].
• I det forbedrede eksempelet brukes None som standardverdi, og en ny liste opprettes inni funksjonen hvis argumentet er None. Dette sikrer at en ny liste opprettes hver gang funksjonen kalles, slik at tidligere resultater ikke påvirker senere kall.

Unngå å bruke mutable objekter som lister eller ordbøker som standardargumenter; bruk heller None og initialiser dem inni funksjonen. Dette er en grunnleggende og viktig beste praksis i Python.

Sammendrag

For å forstå Pythons variabler og datatyper på et dypere nivå, er det avgjørende å forstå forskjellene mellom endringsbare og ubrytelige objekter. Å forstå disse egenskapene hjelper deg med å unngå utilsiktet atferd i koden din og skrive mer robuste og lesbare programmer.

Du kan følge med på artikkelen ovenfor ved å bruke Visual Studio Code på vår YouTube-kanal. Vennligst sjekk ut YouTube-kanalen.

YouTube Video