Re: Shared references

[Martijn Faassen <m.faassen@vet.uu.nl>]

Egbert Bouwman wrote:
> 
> Hallo,
> Inmiddels heb ik wat meer gevoel gekregen voor shared references.
> Ik bleek met het legacy-misverstand te zitten dat constantes,
> en ook lists met constantes, altijd 'by value' zouden worden
> overgenomen. Dat is dus duidelijk niet zo.
> 
> Wel knaagt aan mij nog steeds de vraag of het snel gebruik maken
> van shared references, zoals python dat doet, een nuttig iets is.
> Naar mijn gevoel zou het eerder uitzondering dan regel moeten zijn.
> Of is dat iets waar ik pas later de voordelen van ga zien ?
> En in welke richting zou ik dan ongeveer moeten kijken ?

Ik vind het zelf erg handig; *alles* variabelen in Python zijn
references naar de objecten zelf, zonder uitzondering, dus dat is simpel
om over na te denken (als je het eenmaal door hebt).

In Python is er dan het concept van 'mutability'; sommige objecten zijn
immutable. Dit zijn bijvoorbeeld integer en string objecten. Hoewel deze
gedeeld kunnen worden zoals ieder ander object, voelt het precies zo aan
alsof het gekopieerd wordt, omdat er geen verschil is tussen het
kopieren van een reference of van het object zelf, als het object zelf
niet kan worden gewijzigd.

Een apart geval is de tuple; die is immutable maar kan mutable objecten
bevatten. Een tuple die alleen immutable objecten bevat (inclusief
tuples die zelf alleen immutable objecten bevatten :) kan worden
behandeld als een integer of string (en bijvoorbeel als dictionary key,
erg handig soms!), maar een tuple dat mutable objecten (bijv een lijst)
bevat, niet helemaal.

Het kopieeren van een reference is erg snel; het kopieren van een object
zelf kan erg lang duren. Da's een belangrijk voordeel van references; je
kopieert alleen als het moet (en verreweg in de meeste gevallen hoeft
het niet).

In talen zoals C en C++ die standaard 'by value' werken begin je vaak
met een boel pointers te slingeren om toch met references te kunnen
werken, da's lang zo gemakkelijk niet.

Verder is een voordeel dat het garbage collecting gedrag redelijk simpel
is in de simpele gevallen; zogauw een object geen references meer heeft
van variabelen, verdwijnt het. Er zijn echter ook nadelen als er
circulaire verwijzingen zijn (objecten worden dan niet vernietigd totdat
deze circulaire verwijzing is doorbroken).

Wat maakt references eigenlijk moeilijk voor jou? is mijn vraag terug.
:)

Groeten,

Martijn

Nederlandse Python mailinglist, python@nl.linux.org
archief: http://mail.nl.linux.org/python/