Python Namespaces & Variabele Scope

Ontdek hoe namen, namespaces en variabele scopes in Python werken, met duidelijke voorbeelden en best practices.

Wat is een Naam in Python?

In "The Zen of Python" (import this), luidt de laatste regel: "Namespaces are one honking great idea -- let's do more of those!" Wat zijn deze namespaces? Eerst definiëren we een naam.

Een naam, of identifier, is een label dat naar een object verwijst. Alles in Python is een object, en een naam biedt een handige manier om ertoe toegang te krijgen.

Bijvoorbeeld, wanneer we a = 2 uitvoeren, wordt de integer 2 in het geheugen opgeslagen en wordt a de referentie ernaar. De ingebouwde id() functie retourneert het geheugenadres van een object.

# Let op: Jouw id-waarden kunnen verschillen
a = 2
print('id(2) =', id(2))
print('id(a) =', id(a))

Output

id(2) = 9302208
id(a) = 9302208

Beide namen wijzen naar hetzelfde object, dus hun id() waarden matchen. Laten we zien wat er gebeurt wanneer we a herbinden:

# Let op: Jouw id-waarden kunnen verschillen
a = 2
print('id(a) =', id(a))
a = a + 1
print('id(a) =', id(a))
print('id(3) =', id(3))
b = 2
print('id(b) =', id(b))
print('id(2) =', id(2))

Output

id(a) = 9302208
id(a) = 9302240
id(3) = 9302240
id(b) = 9302208
id(2) = 9302208

Wanneer a = a + 1 uitgevoerd wordt, wordt een nieuw object 3 aangemaakt, en a refereert nu naar dat. Let op dat id(a) en id(3) identiek zijn. De opvolgende toewijzing b = 2 bindt b simpelweg aan het bestaande 2 object, wat dubbele opslag voorkomt.

Deze dynamische naam-binding is wat Python flexibel maakt: een enkele identifier kan naar waarden van elk type wijzen – inclusief functies.

def printHello():
    print("Hello")
a = printHello
a()

Output

Hello

De identifier a refereert nu naar de functie printHello, die we direct kunnen aanroepen.

Wat is een Namespace?

Een namespace is een mapping van namen naar objects. Denk ervan als een dictionary die elke identifier die je hebt gedefinieerd opslaat samen met het bijbehorende object.

Python ondersteunt meerdere namespaces tegelijkertijd, elk geïsoleerd van de anderen. De interpreter creëert een globale namespace met alle ingebouwde namen die voor de levensduur van de sessie persisteren. Elke module krijgt zijn eigen globale namespace, en elke functie- of classdefinitie introduceert een nieuwe lokale namespace.

Variabele Scope in Python

Terwijl namespaces bestaan, bepaalt de scope waar een naam benaderd kan worden zonder kwalificatie.

Op elk moment heeft een programma minstens drie geneste scopes:

1. De lokale scope van de momenteel uitvoerende functie.
2. De globale scope van de module.
3. De ingebouwde scope die altijd beschikbaar is.

Wanneer een naam binnen een functie gerefereerd wordt, zoekt Python eerst de lokale namespace, dan de globale, en tenslotte de ingebouwde namespace. Als een functie een andere functie bevat, introduceert de innerlijke een nieuwe, geneste scope.

Voorbeeld: Scope en Namespace Interactie

Bekijk de volgende code:

def outer_function():
    b = 20
    def inner_func():
        c = 30
    a = 10

Hier leeft a in de module's globale namespace. De variabele b is lokaal voor outer_function, en c behoort tot de geneste lokale namespace van inner_func.

Binnen inner_func is c lokaal, b is non-local, en a is globaal. Je kunt c lezen en schrijven, maar alleen b en a lezen tenzij je ze expliciet declareert met global of nonlocal.

Hier is een concretere illustratie:

def outer_function():
    a = 20
    def inner_function():
        a = 30
        print('a =', a)
    inner_function()
    print('a =', a)
a = 10
outer_function()
print('a =', a)

De output demonstreert drie distincte a bindingen:

a = 30
a = 20
a = 10

Om alle toewijzingen aan de globale a te forceren, gebruik het global keyword:

def outer_function():
    global a
    a = 20
    def inner_function():
        global a
        a = 30
        print('a =', a)
    inner_function()
    print('a =', a)
a = 10
outer_function()
print('a =', a)

De output weerspiegelt nu een enkele, globale a:

a = 30
a = 30
a = 30

Deze voorbeelden illustreren hoe Python's namespace en scope-regels zichtbaarheid en mutatie van variabelen regeren.