Mede mogelijk gemaakt door: Karuna Kumari

In de programmeerwereld is het begrijpen van de concepten van veranderlijkheid en onveranderlijkheid cruciaal, vooral bij het werken met Python. Omdat Python een dynamisch getypeerde taal is, kunnen we objecten manipuleren en hun status wijzigen tijdens de uitvoering van het programma. Niet alle objecten in Python gedragen zich echter op dezelfde manier als het gaat om modificatie. Sommige objecten kunnen worden gewijzigd, terwijl andere constant blijven als ze eenmaal zijn gemaakt. Dit fundamentele onderscheid tussen veranderlijke en onveranderlijke objecten vormt de hoeksteen van de ontwerpfilosofie van Python. Door de concepten veranderlijkheid en onveranderlijkheid te begrijpen, kunnen ontwikkelaars efficiëntere, betrouwbaardere en bugvrije code schrijven. In dit artikel zullen we het concept van veranderlijkheid en onveranderlijkheid in Python onderzoeken, hun verschillen begrijpen en hun implicaties onderzoeken in praktische programmeerscenario's.

Veranderlijk en onveranderlijk in Python

In Python verwijzen de termen "veranderlijk" en "onveranderlijk" naar het vermogen van een object om te worden gewijzigd nadat het is gemaakt.

Een object wordt als veranderlijk beschouwd als de status of waarde kan worden gewijzigd nadat het is gemaakt. Dit betekent dat u de interne gegevens of attributen kunt wijzigen zonder een nieuw object te maken. Voorbeelden van veranderlijke objecten in Python zijn lijsten, woordenboeken en sets. Als u een veranderlijk object wijzigt, zullen alle verwijzingen naar dat object de wijzigingen weerspiegelen.

Beide toestanden zijn een integraal onderdeel van de datastructuur van Python. Als je meer kennis wilt opdoen van de volledige Python Data Structure, neem dan dit gratis cursus die meerdere datastructuren in Python behandelt inclusief tuple-gegevensstructuur die onveranderlijk is. U ontvangt ook een certificaat bij voltooiing dat zeker een waarde toevoegt aan uw portfolio.

Wat is veranderlijk?

Veranderlijk is wanneer iets veranderlijk is of het vermogen heeft om te veranderen. In Python is 'veranderlijk' het vermogen van objecten om hun waarden te veranderen. Dit zijn vaak de objecten waarin een verzameling gegevens is opgeslagen.

Wat is onveranderlijk?

Onveranderlijk is wanneer er in de loop van de tijd geen verandering mogelijk is. Als in Python de waarde van een object niet in de loop van de tijd kan worden gewijzigd, staat het bekend als onveranderlijk. Eenmaal gemaakt, is de waarde van deze objecten permanent.

Lijst met veranderlijke en onveranderlijke objecten

Objecten van het ingebouwde type die veranderlijk zijn, zijn:

• lijsten
• Sets
• Woordenboeken
• Door de gebruiker gedefinieerde klassen (het hangt puur van de gebruiker af om de kenmerken te definiëren) 

Objecten van het ingebouwde type die onveranderlijk zijn, zijn:

• Getallen (geheel getal, rationaal, zwevend, decimaal, complex en booleans)
• Strings
• tuples
• Bevroren sets
• Door de gebruiker gedefinieerde klassen (het hangt puur van de gebruiker af om de kenmerken te definiëren)

Objectveranderlijkheid is een van de kenmerken die Python tot een dynamisch getypeerde taal maakt. Hoewel veranderlijk en onveranderlijk in Python is een heel basaal concept, het kan soms een beetje verwarrend zijn vanwege de intransitieve aard van onveranderlijkheid.

Objecten in Python

In Python wordt alles behandeld als een object. Elk object heeft deze drie kenmerken:

• Identiteit – Dit verwijst naar het adres waarnaar het object verwijst in het geheugen van de computer.
• Type - Dit verwijst naar het soort object dat is gemaakt. Bijvoorbeeld: integer, lijst, string etc. 
• Waarde - Dit verwijst naar de waarde die door het object is opgeslagen. Bijvoorbeeld – Lijst=[1,2,3] zou de nummers 1,2 en 3 bevatten

Hoewel ID en Type niet kunnen worden gewijzigd nadat het is gemaakt, kunnen waarden voor Mutable-objecten worden gewijzigd.

Check out deze gratis python-certificaatcursus om aan de slag te gaan met Python.

Veranderlijke objecten in Python

Ik geloof dat, in plaats van diep in de theoretische aspecten van veranderlijk en onveranderlijk in Python te duiken, een eenvoudige code de beste manier zou zijn om weer te geven wat het betekent in Python. Laten we daarom de onderstaande code stap voor stap bespreken:

#Een lijst maken met namen van Indiase steden  

cities = [‘Delhi’, ‘Mumbai’, ‘Kolkata’]

# Afdrukken van de elementen uit de lijst met steden, gescheiden door een komma & spatie

for city in cities: print(city, end=’, ’) Output [1]: Delhi, Mumbai, Kolkata

#De locatie afdrukken van het object dat in het geheugenadres is gemaakt in hexadecimaal formaat

print(hex(id(cities))) Output [2]: 0x1691d7de8c8

#Een nieuwe stad toevoegen aan de lijst met steden

cities.append(‘Chennai’)

#De elementen uit de lijststeden afdrukken, gescheiden door een komma en spatie 

for city in cities: print(city, end=’, ’) Output [3]: Delhi, Mumbai, Kolkata, Chennai

#De locatie afdrukken van het object dat in het geheugenadres is gemaakt in hexadecimaal formaat

print(hex(id(cities))) Output [4]: 0x1691d7de8c8

Het bovenstaande voorbeeld laat zien dat we de interne status van het object 'steden' konden wijzigen door er nog een stad 'Chennai' aan toe te voegen, maar het geheugenadres van het object veranderde niet. Dit bevestigt dat we geen nieuw object hebben gemaakt, maar dat hetzelfde object is gewijzigd of gemuteerd. Daarom kunnen we zeggen dat het object dat een type lijst is met de referentievariabele 'steden' een VERWISSELBAAR OBJECT is.

Laten we nu de term IMMUTABLE bespreken. Gezien het feit dat we begrepen waar veranderlijk voor staat, is het duidelijk dat de definitie van onveranderlijk 'NIET' bevat. Hier is de eenvoudigste definitie van onveranderlijk: een object waarvan de interne status NIET kan worden gewijzigd, is ONVERanderlijk.

Nogmaals, als je je probeert te concentreren op verschillende foutmeldingen, ben je tegengekomen, veroorzaakt door de respectievelijke IDE; u gebruikt, zou u de onveranderlijke objecten in Python kunnen identificeren. Bekijk bijvoorbeeld de onderstaande code en bijbehorende foutmelding, terwijl u probeert de waarde van een Tuple op index 0 te wijzigen. 

#Een Tuple maken met de variabele naam 'foo'

foo = (1, 2)

#De index[0]-waarde wijzigen van 1 in 3

foo[0] = 3 TypeError: 'tuple' object does not support item assignment 

Onveranderlijke objecten in Python

Nogmaals, een eenvoudige code zou de beste manier zijn om weer te geven waar onveranderlijk voor staat. Laten we daarom de onderstaande code stap voor stap bespreken:

#Een Tuple maken die de Engelse naam van weekdagen bevat

weekdays = ‘Sunday’, ‘Monday’, ‘Tuesday’, ‘Wednesday’, ‘Thursday’, ‘Friday’, ‘Saturday’

# De elementen van tuple weekdagen afdrukken

print(weekdays) Output [1]: (‘Sunday’, ‘Monday’, ‘Tuesday’, ‘Wednesday’, ‘Thursday’, ‘Friday’, ‘Saturday’)

#De locatie afdrukken van het object dat in het geheugenadres is gemaakt in hexadecimaal formaat

print(hex(id(weekdays))) Output [2]: 0x1691cc35090

#tuples zijn onveranderlijk, dus je kunt geen nieuwe elementen toevoegen, dus gebruik samenvoeging van tuples met de # + operator om een ​​nieuwe denkbeeldige dag toe te voegen in de tuple 'weekdagen'

weekdays += ‘Pythonday’,

#De elementen van tuple weekdagen afdrukken

print(weekdays) Output [3]: (‘Sunday’, ‘Monday’, ‘Tuesday’, ‘Wednesday’, ‘Thursday’, ‘Friday’, ‘Saturday’, ‘Pythonday’)

#De locatie afdrukken van het object dat in het geheugenadres is gemaakt in hexadecimaal formaat

print(hex(id(weekdays))) Output [4]: 0x1691cc8ad68 

Dit bovenstaande voorbeeld laat zien dat we dezelfde variabelenaam konden gebruiken die verwijst naar een object dat een soort tuple is met zeven elementen erin. De ID of de geheugenlocatie van de oude & nieuwe tupel is echter niet hetzelfde. We konden de interne status van het object 'weekdagen' niet wijzigen. De Python-programmamanager creëerde een nieuw object in het geheugenadres en de variabelenaam 'weekdays' begon te verwijzen naar het nieuwe object met acht elementen erin. Daarom kunnen we zeggen dat het object dat een type tuple is met de naam 'weekdagen' van de referentievariabele, een ONVERANDERBAAR OBJECT is.

Lees ook: Inzicht in de verkennende gegevensanalyse (EDA) in Python

Waar kunt u veranderlijke en onveranderlijke objecten gebruiken:

Wijzigbare objecten kunnen worden gebruikt waar u updates wilt toestaan. U hebt bijvoorbeeld een lijst met namen van werknemers in uw organisatie en die moet elke keer dat er een nieuw lid wordt aangenomen, worden bijgewerkt. U kunt een veranderlijke lijst maken en deze kan eenvoudig worden bijgewerkt.

Onveranderlijkheid biedt veel nuttige toepassingen voor verschillende gevoelige taken die we uitvoeren in een netwerkgecentreerde omgeving waar we parallelle verwerking mogelijk maken. Door onveranderlijke objecten te maken, verzegelt u de waarden en zorgt u ervoor dat geen enkele thread een beroep kan doen op het overschrijven/bijwerken van uw gegevens. Dit is ook handig in situaties waarin u een stuk code wilt schrijven dat niet kan worden gewijzigd. Bijvoorbeeld een foutopsporingscode die probeert de waarde van een onveranderlijk object te vinden.

Let op: niet-transitieve aard van onveranderlijkheid:

OK! Nu begrijpen we wat veranderlijke en onveranderlijke objecten in Python zijn. Laten we doorgaan en de combinatie van deze twee bespreken en de mogelijkheden verkennen. Laten we bespreken hoe het zich zal gedragen als je een onveranderlijk object hebt dat het veranderlijke object(en) bevat? Of vice versa? Laten we opnieuw een code gebruiken om dit gedrag te begrijpen–

#een tuple (onveranderlijk object) maken die 2 lijsten (veranderlijk) als elementen bevat

#De elementen (lijsten) bevatten de naam, leeftijd en geslacht 

person = (['Ayaan', 5, 'Male'], ['Aaradhya', 8, 'Female'])

#printen van de tuple

print(person) Output [1]: (['Ayaan', 5, 'Male'], ['Aaradhya', 8, 'Female']) 

#de locatie afdrukken van het object dat is gemaakt in het geheugenadres in hexadecimaal formaat

print(hex(id(person))) Output [2]: 0x1691ef47f88

#De leeftijd voor het 1e element wijzigen. 1 selecteren^st element van tuple door indexering [0] en vervolgens 2 te gebruiken^nd element van de lijst door indexering [1] te gebruiken en een nieuwe waarde voor leeftijd toe te wijzen als 4

person[0][1] = 4

#de bijgewerkte tuple afdrukken

print(person) Output [3]: (['Ayaan', 4, 'Male'], ['Aaradhya', 8, 'Female'])

#de locatie afdrukken van het object dat is gemaakt in het geheugenadres in hexadecimaal formaat

print(hex(id(person))) Output [4]: 0x1691ef47f88

In de bovenstaande code kun je zien dat het object 'persoon' onveranderlijk is omdat het een type tupel is. Het heeft echter twee lijsten als elementen, en we kunnen de status van lijsten wijzigen (lijsten zijn veranderlijk). Dus hier hebben we de objectreferentie in de Tuple niet gewijzigd, maar het object waarnaar wordt verwezen is gemuteerd.

Lees ook: Realtime objectdetectie met behulp van TensorFlow

Laten we op dezelfde manier eens kijken hoe het zich zal gedragen als je een veranderlijk object hebt dat een onveranderlijk object bevat? Laten we opnieuw een code gebruiken om het gedrag te begrijpen–

#een lijst (veranderlijk object) maken die tuples (onveranderlijk) als elementen bevat

list1 = [(1, 2, 3), (4, 5, 6)]

#de lijst afdrukken

print(list1) Output [1]: [(1, 2, 3), (4, 5, 6)] 

#de locatie afdrukken van het object dat is gemaakt in het geheugenadres in hexadecimaal formaat

print(hex(id(list1))) Output [2]: 0x1691d5b13c8	

#objectreferentie wijzigen bij index 0

list1[0] = (7, 8, 9)

#de lijst afdrukken

Output [3]: [(7, 8, 9), (4, 5, 6)]

#de locatie afdrukken van het object dat is gemaakt in het geheugenadres in hexadecimaal formaat

print(hex(id(list1))) Output [4]: 0x1691d5b13c8

Als individu hangt het volledig van u en uw vereisten af ​​wat voor soort gegevensstructuur u wilt creëren met een combinatie van veranderlijke en onveranderlijke objecten. Ik hoop dat deze informatie u zal helpen bij het bepalen van het type object dat u in de toekomst wilt selecteren.

Voordat ik onze discussie over IMMUTABILITY beëindig, sta me toe het woord 'CAVITE' te gebruiken wanneer we de String en Integers bespreken. Er is een uitzondering en u kunt enkele verrassende resultaten tegenkomen bij het controleren van de waarheidsgetrouwheid op onveranderlijkheid. Bijvoorbeeld:
#een object van het type geheel getal maken met waarde 10 en referentievariabele naam 'x' 

x = 10

#de waarde van 'x' afdrukken

print(x) Output [1]: 10

#De locatie afdrukken van het object dat in het geheugenadres is gemaakt in hexadecimaal formaat

print(hex(id(x))) Output [2]: 0x538fb560 

#een object van het type geheel getal maken met waarde 10 en referentievariabele naam 'y'

y = 10

#de waarde van 'y' afdrukken

print(y) Output [3]: 10

#De locatie afdrukken van het object dat in het geheugenadres is gemaakt in hexadecimaal formaat

print(hex(id(y))) Output [4]: 0x538fb560

Volgens onze discussie en begrip had het geheugenadres voor x & y tot nu toe anders moeten zijn, aangezien 10 een instantie is van de Integer-klasse die onveranderlijk is. Zoals getoond in de bovenstaande code, heeft het echter hetzelfde geheugenadres. Dit is niet iets dat we hadden verwacht. Het lijkt erop dat wat we hebben begrepen en besproken, ook een uitzondering heeft.

Snelle check - Python-gegevensstructuren

Onveranderlijkheid van Tuple

Tuples zijn onveranderlijk en kunnen daarom geen wijzigingen meer bevatten als ze eenmaal in Python zijn gemaakt. Dit komt omdat ze dezelfde reeksbewerkingen ondersteunen als tekenreeksen. We weten allemaal dat strings onveranderlijk zijn. De indexoperator selecteert een element uit een tuple, net als in een string. Daarom zijn ze onveranderlijk.

Uitzonderingen in onveranderlijkheid

Zoals alles zijn er ook uitzonderingen in de onveranderlijkheid in python. Niet alle onveranderlijke objecten zijn echt veranderlijk. Dit zal leiden tot veel twijfels in je hoofd. Laten we een voorbeeld nemen om dit te begrijpen.

Beschouw een tuple 'tup'.

Als we nu kijken naar tuple tup = ('Geweldig leren',[4,3,1,2]) ;

We zien dat de tuple elementen bevat van verschillende datatypes. Het eerste element hier is een string die, zoals we allemaal weten, onveranderlijk van aard is. Het tweede element is een lijst waarvan we allemaal weten dat deze veranderlijk is. Nu weten we allemaal dat de tuple zelf een onveranderlijk gegevenstype is. Het kan de inhoud ervan niet wijzigen. Maar de lijst erin kan de inhoud ervan wijzigen. De waarde van de onveranderlijke objecten kan dus niet worden gewijzigd, maar de samenstellende objecten wel. verander de waarde ervan.

Conclusie

Het begrijpen van de concepten van veranderlijkheid en onveranderlijkheid in Python is essentieel voor elke ontwikkelaar die robuuste en efficiënte code wil schrijven. Door de verschillen tussen veranderlijke en onveranderlijke objecten te herkennen, kunnen programmeurs weloverwogen beslissingen nemen over objectmanipulatie, geheugenbeheer en code-optimalisatie. Wijzigbare objecten kunnen na creatie worden gewijzigd, wat flexibiliteit en gemak mogelijk maakt en potentiële risico's met zich meebrengt, zoals onbedoelde bijwerkingen of onverwacht gedrag. Aan de andere kant blijven onveranderlijke objecten constant als ze eenmaal zijn gemaakt, wat zorgt voor voorspelbaarheid, draadveiligheid en de mogelijkheid om ze te gebruiken als sleutels in woordenboeken. Door gebruik te maken van de voordelen van veranderlijke en onveranderlijke objecten, kunnen ontwikkelaars schonere, beter onderhoudbare code ontwerpen en veelvoorkomende valkuilen vermijden die verband houden met de veranderlijkheid van objecten. Uiteindelijk stelt een goed begrip van veranderlijkheid en onveranderlijkheid in Python ontwikkelaars in staat om efficiënte, foutloze code te schrijven die voldoet aan de eisen van hun applicaties.

Inzicht in veranderlijk en onveranderlijk in Python Veelgestelde vragen

1. Verschil tussen veranderlijk versus onveranderlijk in Python?

2. Wat zijn de veranderlijke en onveranderlijke datatypes in Python?

• Enkele veranderlijke gegevenstypen in Python zijn:

lijst, woordenboek, set, door de gebruiker gedefinieerde klassen.

• Enkele onveranderlijke gegevenstypen zijn: 

int, float, decimaal, bool, string, tuple, bereik.

3. Zijn lijsten veranderlijk in Python?

Lijsten in Python zijn veranderlijke gegevenstypen omdat de elementen van de lijst kunnen worden gewijzigd, individuele elementen kunnen worden vervangen en de volgorde van elementen kan worden gewijzigd, zelfs nadat de lijst is gemaakt.
(Voorbeelden met betrekking tot lijsten zijn eerder in deze blog besproken.)

4. Waarom worden tuples onveranderlijke typen genoemd?

Tupel- en lijstgegevensstructuren lijken erg op elkaar, maar een groot verschil tussen de gegevenstypen is dat lijsten veranderlijk zijn, terwijl tupels onveranderlijk zijn. De reden voor de onveranderlijkheid van de tuple is dat zodra de elementen aan de tuple zijn toegevoegd en de tuple is gemaakt; het blijft ongewijzigd.

Een programmeur zou altijd liever een code bouwen die hergebruikt kan worden in plaats van het hele data-object opnieuw te maken. Hoewel tuples onveranderlijk zijn, zoals lijsten, kunnen ze elk Python-object bevatten, inclusief veranderlijke objecten.

5. Zijn sets veranderlijk in Python?

Een set is een herhaalde ongeordende verzameling van gegevenstypes die kan worden gebruikt om wiskundige bewerkingen uit te voeren (zoals vereniging, kruising, verschil enz.). Elk element in een set is uniek en onveranderlijk, dwz er mogen geen dubbele waarden zijn en de waarden kunnen niet worden gewijzigd. We kunnen echter items aan de set toevoegen of verwijderen, aangezien de set zelf veranderlijk is.

6. Zijn strings veranderlijk in Python?

Strings zijn niet veranderlijk in Python. Tekenreeksen zijn onveranderlijke gegevenstypen, wat betekent dat de waarde ervan niet kan worden bijgewerkt.

Doe mee met de gratis online cursussen van Great Learning Academy en verbeter vandaag nog uw vaardigheden.

• Door SEO aangedreven content en PR-distributie. Word vandaag nog versterkt.
• EVM Financiën. Uniforme interface voor gedecentraliseerde financiën. Toegang hier.
• Quantum Media Groep. IR/PR versterkt. Toegang hier.
• PlatoAiStream. Web3 gegevensintelligentie. Kennis versterkt. Toegang hier.
• Bron: https://www.mygreatlearning.com/blog/understanding-mutable-and-immutable-in-python/