Encapsulation in Python: een complete gids

Encapsulation is een fundamenteel objectgeoriënteerd principe in Python. Het beschermt je classes tegen per ongeluk wijzigen of verwijderen en bevordert hergebruik en onderhoudbaarheid van code. Bekijk deze eenvoudige class-definitie:

class Smartphone:
   def __init__(self, brand, os):
       self.brand = brand
       self.os = os

iphone = Smartphone("Apple", "iOS 17")

Veel Python-programmeurs definiëren classes zoals deze. Maar dit is verre van de best practices die pro-Pythonistas volgen. Het probleem met deze class wordt duidelijk zodra je de data probeert te wijzigen:

iphone.os = "Android"
print(iphone.os)

Android

Stel je een iPhone voor die op Android draait — wat een gotspe! We moeten duidelijk grenzen stellen binnen onze class zodat gebruikers de attributen niet naar believen kunnen veranderen.

Als ze ze toch willen wijzigen, dan moet dat onder onze voorwaarden en volgens onze regels. Maar we willen wel dat de attributen .os of .brand aan de buitenkant hetzelfde blijven.

Al dit soort zaken kun je bevorderen met encapsulation en in deze tutorial leer je er alles over. Laten we beginnen!

Hoe bereik je encapsulation in Python?

Python ondersteunt encapsulation via conventies en programmeerpraktijken in plaats van afgedwongen access modifiers. Het achterliggende uitgangspunt van veel Python-codeontwerp is: “We zijn hier allemaal volwassenen.” We kunnen encapsulation alleen als conventie toepassen en verwachten dat andere Python-ontwikkelaars onze code respecteren.

In andere OOP-talen zoals Java en C++ wordt encapsulation strikt afgedwongen met access modifiers zoals public, private of protected, maar Python heeft die niet:

Dus de meeste, zo niet alle, technieken voor encapsulation die ik je ga laten zien, zijn Python-conventies. Je kunt ze eenvoudig negeren als je dat wilt. Maar ik ga ervan uit dat je ze respecteert en volgt in je eigen projecten.

Access modifiers in Python

Stel, we hebben deze eenvoudige class:

class Tree:
   def __init__(self, height):
       self.height = height

pine = Tree(20)
print(pine.height)

20

Er is één attribuut height dat we kunnen printen. Het probleem is dat we het ook naar willekeur kunnen veranderen:

pine.height = 50
pine.height

50

pine.height = "Grandma"
pine.height

'Grandma'

Hoe laten we gebruikers weten dat height veranderen niet is toegestaan? We kunnen er een protected member van maken door één voorafgaande underscore toe te voegen:

class Tree:
   def __init__(self, height):
       self._height = height

pine = Tree(20)
pine._height

20

Mensen die deze conventie kennen, begrijpen nu dat ze het attribuut alleen mogen benaderen en dat we het gebruik en wijzigen ervan sterk afraden. Maar als ze willen, kunnen ze het toch aanpassen, jazeker.

Hoe voorkomen we dat dan? Door nog een conventie te gebruiken — maak van het attribuut een private member door twee voorafgaande underscores toe te voegen:

class Tree:
   def __init__(self, height):
       self.__height = height


pine = Tree(20)
pine.__height

AttributeError: 'Tree' object has no attribute '__height'

Nu zal Python een fout geven als iemand het attribuut probeert te benaderen, laat staan te wijzigen.

Maar zie je wat we net deden? We hebben de enige informatie over onze objecten verstopt voor gebruikers. Onze class is nu nutteloos geworden omdat hij geen publieke attributen heeft.

Hoe geven we de boomhoogte dan wel bloot aan gebruikers, maar houden we controle over hoe die wordt benaderd en gewijzigd? Bijvoorbeeld, we willen dat boomhoogtes binnen een specifiek bereik liggen en alleen gehele waarden hebben. Hoe dwingen we dat af?

Op dit punt zal je Java-vriend waarschijnlijk voorstellen om getter- en setter-methoden te gebruiken. Laten we dat eerst proberen:

class Tree:
   def __init__(self, height):
       self.__height = height

   def get_height(self):
       return self.__height

   def set_height(self, new_height):
       if not isinstance(new_height, int):
           raise TypeError("Tree height must be an integer")
       if 0 < new_height <= 40:
           self.__height = new_height
       else:
           raise ValueError("Invalid height for a pine tree")


pine = Tree(20)
pine.get_height()

20

Zo maak je een privaat attribuut __height, maar laat je gebruikers het gecontroleerd benaderen en wijzigen via de methoden get_height en set_height.

pine.set_height(25)

pine.get_height()

25

Voor het instellen van een nieuwe waarde zorgt set_height ervoor dat de hoogte numeriek is en binnen een bepaald bereik valt.

pine.set_height("Password")

TypeError: Tree height must be an integer

Maar deze methoden voelen als overkill voor een eenvoudige handeling. Bovendien is het lelijk om code als deze te schrijven:

# Increase height by 5
pine.set_height(pine.get_height() + 5)

Zou het niet mooier en leesbaarder zijn als we deze code konden schrijven:

pine.height += 5

en toch het juiste datatype en bereik voor height afdwingen? Het antwoord is ja, en in de volgende sectie leer je precies hoe.

De @property-decorator gebruiken in Python-classes

We introduceren een nieuwe techniek — properties maken voor attributen:

class Tree:
   def __init__(self, height):
       # First, create a private or protected attribute
       self.__height = height

   @property
   def height(self):
       return self.__height

pine = Tree(17)
pine.height

17

We willen dat gebruikers een verborgen attribuut met de naam __height kunnen benaderen alsof het een normaal attribuut height is. Om dat te bereiken, definiëren we een methode height die self.__height teruggeeft en we decoreren die met @property.

Nu kunnen we height aanroepen en het private attribuut benaderen:

pine.height

17

Maar het mooiste is: gebruikers kunnen het niet wijzigen:

pine.height = 15

AttributeError: can't set attribute 'height'
Dus voegen we een andere methode toe, height(self, new_height), die is omwikkeld met een height.setter-decorator. In deze methode implementeren we de logica die het gewenste datatype en bereik voor height afdwingt:
class Tree:
   def __init__(self, height):
       self.__height = height

   @property
   def height(self):
       return self.__height

   @height.setter
   def height(self, new_height):
       if not isinstance(new_height, int):
           raise TypeError("Tree height must be an integer")
       if 0 < new_height <= 40:
           self.__height = new_height
       else:
           raise ValueError("Invalid height for a pine tree")

Nu, wanneer een gebruiker het attribuut height probeert te wijzigen, wordt @height.setter aangeroepen, waardoor de juiste waarde wordt afgedwongen:
pine = Tree(10)

pine.height = 33  # Calling @height.setter
pine.height = 45  # An error is raised

ValueError: Invalid height for a pine tree

We kunnen ook aanpassen hoe het attribuut height via puntnotatie wordt benaderd met @height.getter:
class Tree:
   def __init__(self, height):
       self.__height = height

   @property
   def height(self):
       return self.__height

   @height.getter
   def height(self):
       # You can return a custom version of height
       return f"This tree is {self.__height} meters"


pine = Tree(33)

pine.height

'This tree is 33 meters'
Hoewel we pine met een gehele hoogte hebben gemaakt, konden we de waarde aanpassen met @height.getter.
Dit waren voorbeelden van hoe we encapsulation in een Python-class kunnen bevorderen. Onthoud: encapsulation blijft een conventie, want we kunnen het interne private member __height nog steeds omzeilen:
pine._Tree__height = "Gotcha!"

pine.height

'This tree is Gotcha! meters'
Alles in Python-classes is publiek, en dat geldt ook voor private methoden. Het is geen ontwerpfout, maar een uiting van de “We zijn hier allemaal volwassenen”-benadering.
Hier is een overzicht van de Python-accessmodifiers die we zojuist hebben besproken:



Modifier/Conventie
Beschrijving
Voorbeeld




Public
Standaardtoegang; attributen en methoden zijn toegankelijk buiten de class
self.attribute


Protected
Aangegeven met een enkele underscore; een conventie die gedeeltelijk beperkte toegang aanduidt
self._attribute


Private
Aangegeven met dubbele underscores; name mangling biedt beperkte toegangsbeperking
self.__attribute


Properties
Biedt gecontroleerde toegang tot private attributen met de @property decorator
@property def attribute(self):


Read-only properties
Geen @attribute.setter; staat alleen-lezen toegang tot een attribuut toe
@property def attribute(self):



Best practices bij het implementeren van encapsulation
Er zijn een aantal best practices die je kunt volgen om te zorgen dat je code goed aansluit bij die van andere ervaren OOP-ontwikkelaars:

Maak protected of private attributen of methoden als ze alleen door jou worden gebruikt. Protected of private members worden uitgesloten van documentatie en signaleren aan anderen dat jij, de ontwikkelaar, ze zonder aankondiging kunt wijzigen, wat het gebruik ervan ontmoedigt.
Je hoeft niet voor elk class-attribuut properties te maken. Voor grote classes met veel attributen kunnen attr.getter- en attr.setter-methoden een hoofdpijndossier worden.
Overweeg een waarschuwing te geven telkens wanneer een gebruiker een protected member (_) benadert.
Gebruik private members spaarzaam, omdat ze code onleesbaar kunnen maken voor wie niet bekend is met de conventie.
Geef prioriteit aan duidelijkheid boven verhulling. Omdat encapsulation gericht is op onderhoudbaarheid en databeveiliging, moet je belangrijke implementatiedetails van je class niet volledig verbergen.
Als je alleen-lezen properties wilt maken, implementeer dan geen @attr.setter-methode. Gebruikers kunnen de property dan wel benaderen, maar niet wijzigen.
Onthoud altijd dat encapsulation een conventie is, geen afgedwongen onderdeel van de Python-syntaxis.
Overweeg voor eenvoudige classes dataclasses, waarmee je encapsulation met één regel code kunt inschakelen. Dataclasses zijn echter bedoeld voor eenvoudigere classes met voorspelbare attributen en methoden. Bekijk deze dataclasses-tutorial voor meer informatie.

Conclusie en verdere bronnen
In deze tutorial hebben we een van de kernelementen van objectgeoriënteerd programmeren in Python geleerd: encapsulation.
Encapsulation stelt je in staat om gecontroleerde toegang te definiëren tot data die in objecten van je class is opgeslagen. Zo schrijf je schone, leesbare en efficiënte code en voorkom je onbedoelde wijzigingen of verwijdering van je class-data.
Hier zijn nog enkele verwante bronnen om je OOP-kennis te verdiepen:

Python OOP-tutorial
Object-oriented Programming in Python
How to Master Python — an Expert Guide