Veranderlijk en Onveranderlijk in Python

Dit artikel legt veranderlijk en onveranderlijk uit in Python.

YouTube Video

Veranderlijk en Onveranderlijk in Python

"Veranderlijk" en "onveranderlijk" verwijzen naar de aanpasbaarheid van een object. Het begrijpen hiervan helpt bij het voorkomen van onverwachte bugs en efficiënt geheugenbeheer.

Wat is Veranderlijk?

Veranderlijke objecten kunnen na aanmaak hun interne status wijzigen.

Belangrijkste Veranderlijke Datatypes

• list
• dict
• set
• Door de gebruiker gedefinieerde klassen (als hun attributen kunnen worden gewijzigd)

Voorbeeld: Een Lijst Wijzigen

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

Een lijst is een veranderlijk object, en de elementen kunnen vrij worden gewijzigd.

Wat is Onveranderlijk?

Onveranderlijke objecten kunnen niet worden gewijzigd nadat ze zijn aangemaakt. Pogingen om ze te wijzigen, resulteren in het aanmaken van een nieuw object.

Belangrijkste Onveranderlijke Datatypes

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

Voorbeeld: Een String Wijzigen

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"

Strings zijn onveranderlijk, dus je kunt ze niet gedeeltelijk wijzigen.

Vergelijking van Veranderlijk en Onveranderlijk

 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

Zoals je kunt zien in dit voorbeeld, worden veranderbare objecten gedeeld door referentie, zodat ze *affect kunnen maken op andere variabelen *. Aan de andere kant, onveranderlijke objecten creëren nieuwe instanties bij hertoewijzing, waardoor de oorspronkelijke waarde onaangetast blijft.

Interne werking inspecteren met behulp van id()

In Python kun je de functie id() gebruiken om het ID van een object te controleren. Het object-ID lijkt op een geheugenadres.

 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

Zoals getoond, wordt een nieuw object gemaakt voor onveranderlijke typen, terwijl veranderlijke typen ter plaatse worden aangepast.

Functies en voorzichtigheid met veranderlijke en onveranderlijke objecten

Bij het doorgeven van een veranderlijk object aan een functie, kan de originele data worden aangepast.

Voorbeeld: Een functie die een lijst aanpast

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]

Voorbeeld: Een functie die een getal aanpast

Aan de andere kant resulteert een poging om een onveranderlijk object aan te passen in het creëren van een nieuw object.

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

Praktische overwegingen

Vermijd het gebruik van veranderlijke objecten als standaardargumenten

 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]

Omdat standaardargumenten slechts één keer worden geëvalueerd bij het definiëren van de functie, kan het gebruik van veranderlijke objecten tot onverwachte bijwerkingen leiden.

• In het eerste voorbeeld wordt hetzelfde list object elke keer gebruikt als heet. Bij het aanroepen van de tweede keer, de eerder toegevoegde.
• In het verbeterde voorbeeld wordt geen enkele waarde gebruikt als de standaard waarde, en een nieuwe lijst wordt binnen de functie aangemaakt als het argument geen enkele waarde heeft. Dit zorgt ervoor dat elke keer dat de functie wordt aangeroepen een nieuwe lijst wordt aangemaakt, zodat eerdere resultaten geen invloed hebben op volgende oproepen.

Vermijd het gebruik van veranderlijke objecten zoals lijsten of woordenboeken als standaardargumenten; in plaats daarvan, gebruik . Dit is een fundamentele en belangrijke beste praktijk in Python.

Samenvatting

Om Python's variabelen en datatypes grondig te begrijpen, is het essentieel om de verschillen tussen veranderlijk en onveranderlijk te doorzien. Het begrijpen van deze kenmerken helpt je om onbedoeld gedrag in je code te vermijden en robuustere en leesbaardere programma's te schrijven.

Je kunt het bovenstaande artikel volgen met Visual Studio Code op ons YouTube-kanaal. Bekijk ook het YouTube-kanaal.

YouTube Video