Klassen en objecten in Python: objectgeoriënteerd programmeren

Je hebt al objecten gebruikt wanneer je met een getal, string, lijst of dictionary werkte. Een object heeft een type, een waarde of toestand en bewerkingen die het ondersteunt. Zelfs functies en None zijn objecten. Als je je eigen klasse schrijft, breid je dit bekende systeem uit.

Zoek het type en de methoden van een object

type("hello") geeft <class 'str'> terug; type([1, 2]) geeft <class 'list'> terug. De woorden type en klasse beschrijven hier dezelfde rol. isinstance(3.5, float) is True, terwijl isinstance("3.5", float) False is: de tweede waarde is tekst, ook al lijkt die op een getal.

Een methode is een functie die een type biedt. In "ada lovelace".title() is de string vóór de punt het object, is title de methode en roepen de ronde haakjes die aan. Het resultaat is "Ada Lovelace". dir(value) geeft een lijst met namen die een object biedt; namen zoals __len__ zijn speciale methoden die objecten verbinden met Pythonbewerkingen zoals len(value).

Volg het resultaat en het oorspronkelijke object

Een methodeaanroep kan een resultaat teruggeven, een object wijzigen of beide doen. Controleer het gedrag van de methode voordat je beslist wat je toekent.

word = "level"
print(word.count("l"))  # 2
print(word.upper())     # LEVEL
print(word)             # level

nums = [3, 1, 2]
result = nums.sort()
print(nums)             # [1, 2, 3]
print(result)           # None

Strings zijn onwijzigbaar: hun inhoud kan niet veranderen. upper() geeft een andere string terug, dus word behoudt zijn oorspronkelijke waarde. Om het resultaat in hoofdletters onder die naam te bewaren, schrijf je word = word.upper().

Lijsten zijn wijzigbaar. sort() wijzigt de lijst zelf en geeft None terug. Als je nums = nums.sort() schrijft, verliest nums de referentie naar de lijst en krijgt het de waarde None. Gebruik nums.sort() op een eigen regel of nums = sorted(nums) om een nieuwe gesorteerde lijst te krijgen. Bij een dictionary geeft {"a": 1}.get("b", 0) 0 terug omdat de gevraagde sleutel ontbreekt.

Ook ronde haakjes zijn van belang. word.upper is een methodeobject; word.upper() voert het uit. Veel objecten kunnen hetzelfde gedrag bieden: "cat".upper() en "dog".upper() gebruiken dezelfde soort methode met verschillende stringgegevens.

Maak onderscheid tussen gelijkheid en identiteit

Gelijkheid gaat over de vraag of waarden overeenkomen. Identiteit gaat over de vraag of twee namen naar één object verwijzen.

a = [1, 2]
b = [1, 2]
c = a
print(a == b)  # True
print(a is b)  # False
print(c is a)  # True
c.append(3)
print(a)       # [1, 2, 3]
print(b)       # [1, 2]

a en b beginnen met een gelijke inhoud, maar zijn afzonderlijke lijsten. c = a maakt een alias, een andere naam voor dezelfde lijst. Toevoegen via c wijzigt het object waar ook a naar verwijst. Het wijzigt niet de afzonderlijke lijst die b bevat. Teken bij het volgen van een programma één vak per object en een pijl van elke naam naar het bijbehorende vak.

Een klasse definieert een type dat je in je eigen programma kunt gebruiken. Elk object dat ervan wordt gemaakt, is een instantie. Eén klasse beschrijft de soort; instanties bevatten de gegevens van afzonderlijke dingen. Een leeg formulier en de ingevulde exemplaren zijn een bruikbare vergelijking.

Schrijf een klasse en roep die aan

Een klasse-instructie heeft het gereserveerde woord class, een naam, een dubbele punt en een ingesprongen inhoud. Met pass geef je een lege inhoud op terwijl je de structuur uitprobeert.

class Book:
    pass

b1 = Book()
b2 = Book()
print(b1 is b2)           # False
print(isinstance(b1, Book))  # True

Elke aanroep van Book() maakt een afzonderlijke instantie. In een script toont type(b1) <class '__main__.Book'>. De klasse-instructie moet worden uitgevoerd voordat code Book probeert te gebruiken. Je kunt een klasse ook in een module definiëren en met from library import Book importeren, waarna je instanties maakt in het aanroepende programma.

Volg de naamgevingsconventies van Python: Book, BankAccount en ShoppingCart gebruiken CapWords, waarbij elk woord met een hoofdletter begint. Namen van variabelen en methoden gebruiken kleine letters met lage streepjes tussen de woorden, zoals book_count en add_item. Gebruik vier spaties voor elk inspringniveau.

Sla gegevens op elke instantie op

Een attribuut is een benoemde waarde die je met een punt benadert. Door een waarde aan een attribuut toe te kennen, sla je die op; door dezelfde naam te lezen, haal je die op.

b1.title = "Dune"
b2.title = "Emma"
b1.pages = 412
print(b1.title)  # Dune
print(b2.title)  # Emma
print(b1.pages)  # 412

De gegevens horen bij de gekozen instantie. Als je b1 een attribuut pages geeft, krijgt b2 dat niet. Het lezen van b2.pages werpt nu AttributeError op, omdat dat object geen attribuut met de naam pages heeft.

Toekenningen kunnen nieuwe namen maken zonder te controleren wat je bedoelde. Na b1.titel = "X" bevat het oorspronkelijke b1.title nog steeds "Dune"; het object heeft er een tweede attribuut met een verkeerd gespelde naam bij gekregen. Als een waarde niet lijkt te veranderen, vergelijk dan de spelling op de plek waar de waarde is toegekend en waar die wordt gelezen.

Houd de klasse en haar instanties uit elkaar

b = Book geeft de klasse een andere naam. Het maakt geen boek. Als titels alleen op instanties zijn ingesteld, werpt het opvragen van Book.title AttributeError op; er is geen enkele titel die door het type wordt gedeeld.

Geef elk object een betrouwbaar begin

Attributen van buitenaf instellen is mogelijk, maar daardoor raakt de inrichting verspreid over het programma. Het ene boek krijgt misschien een titel en een aantal pagina’s, terwijl het andere alleen een titel krijgt. Latere code kan er niet veilig van uitgaan dat beide pages hebben.

Een inrichtingsmethode met de naam __init__ plaatst de begintoekenningen binnen de klasse. Elke aanroep om een object te maken volgt dan hetzelfde inrichtingsproces. De klasse kan een titel verplicht stellen en andere attributen met zinvolle beginwaarden maken, zodat de aanroepende code geen afzonderlijke reeks toekenningen hoeft te onthouden.

Elke nieuw gemaakte rekening heeft een eigenaar en een beginsaldo nodig. Door die inrichting in __init__ te zetten, krijgt elk object de attributen die latere methoden verwachten. Python maakt eerst de instantie en roept daarna __init__ aan om die te initialiseren.

Verbind argumenten met attributen

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance
        self.transactions = []

acct = BankAccount("Maya", 50)
other = BankAccount("Leo")

Bij de eerste aanroep geeft Python de nieuwe rekening door als self, "Maya" als owner en 50 als balance. Door de toekenningen wordt acct.owner gelijk aan "Maya" en acct.balance aan 50. De tweede aanroep gebruikt het standaardsaldo, dus other.balance is 0.

self is de parameter die het huidige object ontvangt. Het is een conventie, geen gereserveerd woord in Python. Gebruik deze naam zodat lezers het object meteen herkennen. Aanroepende code laat deze parameter weg: BankAccount("Maya", 50) geeft twee argumenten door, geen drie.

Houd lokale namen en opgeslagen gegevens apart

In self.owner = owner is de naam rechts een lokale parameter. De naam links is een attribuut dat op het object wordt opgeslagen. Wanneer de initialisatie eindigt, kunnen andere methoden self.owner nog steeds gebruiken.

Als je balance = balance schrijft, ken je alleen opnieuw een waarde toe aan de lokale naam. Er ontstaat geen attribuut, dus het latere lezen van acct.balance mislukt. Zet self. vóór elk attribuut dat deel van het object moet blijven.

Plan de initialisatie door op een rij te zetten wat elke instantie nodig heeft. Verplichte waarden worden parameters na self; optionele waarden kunnen standaardwaarden krijgen. Waarden die altijd hetzelfde beginnen, kun je in de inhoud toekennen, zoals self.visits = 0. Een lijst die met self.transactions = [] wordt gemaakt, wordt bij elke aanroep opnieuw aangemaakt.

Voorkom een gedeelde standaardlijst

Een standaardargument wordt geëvalueerd wanneer Python de methode definieert. Met def __init__(self, items=[]) ontvangen aanroepen die items weglaten dezelfde lijst. Als de initialisatiemethode die lijst rechtstreeks opslaat, verandert een wijziging van de elementen van het ene object ook de elementen die een ander object ziet.

Gebruik None als standaardwaarde en maak bij elke aanroep een nieuwe lijst:

class Cart:
    def __init__(self, items=None):
        self.items = [] if items is None else list(items)

a = Cart()
b = Cart()
a.items.append("pen")
print(b.items)  # []

list(items) maakt ook een nieuwe buitenlijst wanneer de aanroepende code een lijst doorgeeft. De objecten in die lijst worden nog steeds via referenties gedeeld; door de lijst te maken, wordt niet elk element opnieuw gemaakt.

Lees fouten bij de inrichting

Bij BankAccount() ontbreekt het verplichte argument owner en wordt TypeError opgeworpen. Vergelijk de aanroep met de parameters na self.

De spelling __init__ heeft aan beide kanten twee lage streepjes. _init_ is een gewone methodenaam en voert deze inrichting niet automatisch uit. __init__ moet None teruggeven, dus laat je een return-instructie normaal gesproken weg. Als je een saldo teruggeeft, wordt TypeError opgeworpen; de klasseaanroep zelf geeft de nieuwe instantie aan de aanroepende code.

Sommige waarden beschrijven één object; andere beschrijven het type als geheel. De grootte van een pizza hoort bij die pizza. Een maximum voor het beleg of een telling van gemaakte pizza’s kan bij de klasse horen. De plaats van een toekenning bepaalt welk soort attribuut die maakt.

Zet de waarde op de juiste plek

class Pizza:
    MAX_TOPPINGS = 5
    count = 0

    def __init__(self, size):
        self.size = size
        self.toppings = []
        Pizza.count += 1

p1 = Pizza("large")
p2 = Pizza("small")

size en toppings zijn instantieattributen, ingesteld op self. Elke pizza heeft zijn eigen waarden. MAX_TOPPINGS en count zijn klasseattributen, toegekend in de klasse-inhoud buiten een methode. Hoofdletters markeren een waarde die als constante is bedoeld; ze voorkomen geen hernieuwde toekenning.

Na deze aanroepen is Pizza.count gelijk aan 2. Elke initialisatiemethode werkt hetzelfde klasseattribuut bij. p1.size is "large", terwijl p2.size "small" is.

Volg opzoeking en naamverhulling

Bij gewone gegevensattributen zoals deze controleert Python bij het lezen van p1.MAX_TOPPINGS eerst de instantie en daarna de klasse. Omdat op p1 geen waarde is opgeslagen, vindt Python Pizza.MAX_TOPPINGS, met de waarde 5.

Een toekenning via een instantie heeft een ander effect:

p1.MAX_TOPPINGS = 8
Pizza.MAX_TOPPINGS = 6
print(p1.MAX_TOPPINGS)     # 8
print(p2.MAX_TOPPINGS)     # 6
print(Pizza.MAX_TOPPINGS)  # 6

De eerste regel maakt een instantieattribuut op p1. Dat verhult de klassewaarde voor dat object. Een latere wijziging van de klassewaarde bereikt p2, dat nog steeds van de klasse leest, maar vervangt de eigen waarde van p1 niet.

Let op twee vormen van onbedoeld delen

Als de initialisatiemethode self.count += 1 zou gebruiken, zou Python de 0 van de klasse lezen, er één bij optellen en een instantieattribuut opslaan. Elke nieuwe pizza zou zijn eigen count van 1 krijgen, terwijl Pizza.count 0 bleef. Gebruik de klassenaam wanneer je een teller voor de hele klasse bijwerkt.

Een lijst in de klasse-inhoud veroorzaakt een ander probleem. Met toppings = [] vinden instanties die geen afzonderlijk attribuut voor beleg hebben allemaal dezelfde lijst. p1.toppings.append("olives") wijzigt die gedeelde lijst; het kent geen nieuw instantieattribuut toe. Zet self.toppings = [] in __init__ wanneer elke pizza zijn eigen beleg nodig heeft.

Bekijk de eigen gegevens van een object

Voor de oorspronkelijke p2 geeft vars(p2) {'size': 'small', 'toppings': []}. De klassewaarden ontbreken omdat ze op Pizza staan. Dit is nuttig bij het debuggen van een onverwacht opzoekresultaat: controleer of de instantie een eigen waarde heeft en bekijk daarna de klassewaarde. Een gedeelde instelling hoort op de klasse; een naam, grootte, saldo of persoonlijke collectie hoort op de instantie.

Een object moet beginnen in een toestand die zijn methoden kunnen gebruiken. Een rechthoek met een negatieve breedte kan de bedoelde vorm niet voorstellen. Een regel die voor elk object van een klasse waar moet blijven, is een invariant. Validatie controleert die regels voordat gegevens worden geaccepteerd.

Controleer vóór het opslaan

class Rectangle:
    def __init__(self, width, height):
        if width <= 0:
            raise ValueError("width must be positive")
        if height <= 0:
            raise ValueError("height must be positive")
        self.width = width
        self.height = height

Rectangle(3, 4) doorstaat beide controles en geeft een geïnitialiseerd object terug. Rectangle(-2, 4) werpt bij de eerste controle ValueError op. De latere toekenningen worden niet uitgevoerd. Als het programma die exceptie niet opvangt, stopt de uitvoering daar.

Stel dat r al naar een geldige rechthoek verwijst. In r = Rectangle(-2, 4) mislukt de aanroep rechts vóór de toekenning. r behoudt zijn eerdere waarde. Als r vóór de mislukte aanroep geen waarde had, maakt de toekenning er ook geen aan.

Kies een bruikbare exceptie

Een negatieve numerieke breedte is een waardefout. Tekst die wordt doorgegeven waar een getal nodig is, is een typefout. De vergelijking met 0 in dit voorbeeld werpt voor tekst al TypeError op. Een klasse kan een type ook expliciet met isinstance controleren als een duidelijkere melding nodig is.

Schrijf meldingen die de regel noemen, zoals "width must be positive". Bij een melding met alleen "bad input" moet de aanroepende code raden welke waarde moet worden hersteld.

Laat de aanroepende code het herstel afhandelen

while True:
    try:
        width = float(input("Width: "))
        room = Rectangle(width, 3)
        break
    except ValueError as error:
        print("Try again:", error)

Invoer van abc mislukt bij float; invoer van -2 doorstaat de conversie maar mislukt in Rectangle. Beide werpen ValueError op, dus deze lus handelt beide af. De klasse stelt haar gegevensregel vast, terwijl de aanroepende code beslist om opnieuw om invoer te vragen.

Een waarschuwing afdrukken binnen __init__ wijst de aanroep niet af. Als de uitvoering doorgaat, kan het programma een ongeldig object ontvangen en later bij het gebruik ervan mislukken. Een exceptie opwerpen stopt de mislukte inrichting waar het probleem optreedt.

Schoon gegevens bewust op en handhaaf de regel

Een gedocumenteerde opschoning kan nuttig zijn. self.name = name.strip() verwijdert spaties aan de randen; valideer de opgeschoonde naam als lege namen verboden zijn. self.items = list(items) maakt een afzonderlijke buitenlijst, zodat toevoegen aan de lijst van de aanroepende code niets aan deze lijst toevoegt. Een ongeldige breedte veranderen in haar absolute waarde zou de betekenis van de invoer veranderen en vereist dus een expliciete ontwerpregel.

Initialisatiecontroles worden uitgevoerd bij het maken van het object. Een gewone toekenning zoals r.width = -5 omzeilt ze later nog steeds. Methoden die een breedte wijzigen, moeten die opnieuw controleren. Een property kan een controle op de attribuuttoekenning zelf plaatsen, zodat dezelfde regel tijdens de inrichting en bij latere wijzigingen wordt uitgevoerd.

Een instantiemethode is een functie die binnen een klasse is gedefinieerd en werkt met het object dat als self wordt doorgegeven. Het object levert zijn opgeslagen gegevens; extra parameters leveren eventuele aanvullende informatie die voor de actie nodig is.

Lees attributen via self

Voeg deze methoden toe binnen de gevalideerde klasse Rectangle, op hetzelfde inspringniveau als __init__:

    def area(self):
        return self.width * self.height

    def perimeter(self):
        return 2 * (self.width + self.height)

    def is_square(self):
        return self.width == self.height

Met r = Rectangle(3, 4) geeft r.area() 12 terug, geeft r.perimeter() 14 terug en geeft r.is_square() False terug. Elke methode leest de attributen van hetzelfde object. Een tweede rechthoek gebruikt dezelfde methodedefinities met zijn eigen breedte en hoogte.

Binnen een methode duidt self.width een attribuut aan. Een losse width duidt een lokale of andere toegankelijke variabele aan; Python zoekt die niet automatisch op het huidige object. Als zo’n variabele niet bestaat, werpt return width * height NameError op. Door self. te schrijven, maak je expliciet bij welk object de bedoelde gegevens horen.

Volg de aanroep

Voor deze klasse werkt r.area() als Rectangle.area(r). Python vindt de functie op de klasse en levert r als eerste argument. Een methodereferentie zoals r.area is een gebonden methode: die onthoudt de functie en deze rechthoek. Door () toe te voegen, voer je de aanroep uit.

Als een methode is gedefinieerd als def resize(self, factor), roep je die aan als r.resize(2). r vult self in en 2 vult factor in. Je geeft r niet nogmaals door. Als een instantiemethode per ongeluk als def area(): is geschreven, werpt een aanroep op r TypeError op, omdat Python het object nog steeds doorgeeft aan een functie die geen argumenten accepteert.

De ene methode kan via self een andere gebruiken:

    def double_area(self):
        return self.area() * 2

Hier berekent self.area() met dezelfde rechthoek. Als je self. weglaat, vraag je om een afzonderlijke functie met de naam area, niet om de methode van het object.

Geef resultaten terug aan de aanroepende code

Een berekeningsmethode hoort haar resultaat normaal gesproken terug te geven. Zo krijgt de aanroepende code een waarde om op te slaan, te combineren, te toetsen of weer te geven:

r1 = Rectangle(3, 4)
r2 = Rectangle(2, 5)
total = r1.area() + r2.area()
print(total)  # 22

Als area het antwoord alleen zou afdrukken, zou elke aanroep None teruggeven. De optelling zou dan mislukken met TypeError, ook al waren er twee getallen op het scherm verschenen. Afdrukken is een actie; teruggeven levert een waarde aan de expressie die de aanroep bevat.

Gebruik methodenamen die de taak laten zien. deposit en resize duiden acties aan; is_square en has_room suggereren booleaanse controles. Een methode heeft geen parameters nodig voor gegevens die al op haar object zijn opgeslagen. Ze heeft wel parameters nodig voor nieuwe invoer, zoals een vergrotingsfactor of een stortingsbedrag.

De toestand van een object is de huidige verzameling waarden in zijn attributen. Een uitleesmethode geeft informatie over die toestand. Een wijzigingsmethode verandert die. Een bruikbare wijzigingsmethode controleert haar invoer en houdt alle bijbehorende attributen bij, zodat de aanroepende code niet meerdere wijzigingen hoeft te coördineren.

Valideer eerst de hele wijziging

Voeg deze methoden toe binnen de klasse BankAccount met haar eigenaar, saldo en transactielijst:

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("deposit must be positive")
        self.balance += amount
        self.transactions.append(("deposit", amount))

    def withdraw(self, amount):
        if amount <= 0:
            raise ValueError("withdrawal must be positive")
        if amount > self.balance:
            raise ValueError("insufficient funds")
        self.balance -= amount
        self.transactions.append(("withdraw", amount))

Een storting wijzigt het saldo en legt de gebeurtenis vast. Een opname controleert zowel het teken van het bedrag als het beschikbare saldo voordat het bedrag wordt afgetrokken. Deze controles voorkomen dat een afgewezen opname het saldo of de transactiegeschiedenis wijzigt.

Als je begint met BankAccount("Maya", 50), geeft een storting van 25 het saldo 75 en een opname van 30 het saldo 45. Een latere poging om 100 op te nemen werpt ValueError op; het saldo blijft 45 en er wordt geen transactie toegevoegd. Als de aftrekking vóór de saldocontrole zou staan, zou de toestand ook bij een fout veranderen.

Maak onderscheid tussen een wijziging en een retourwaarde

Deze wijzigingsmethoden hebben geen return-instructie, dus geven ze None terug. Na new_balance = acct.deposit(25) heeft de storting plaatsgevonden, maar is new_balance gelijk aan None. Lees daarna acct.balance om het bijgewerkte getal te krijgen.

Een klasse kan ook een ander soort methode bieden die een nieuw object teruggeeft. resize suggereert dat een rechthoek wordt gewijzigd; resized kan worden gekozen voor een methode die een nieuwe rechthoek teruggeeft en het oorspronkelijke object ongemoeid laat. Lees het contract van de methode: de naam helpt, maar de definitie bepaalt het gedrag.

Volg gedeelde referenties

a = BankAccount("Maya", 50)
b = a
b.deposit(10)
print(a.balance)  # 60
print(a is b)     # True

Een toekenning bindt een naam aan een object; ze kopieert dat object niet. Beide namen verwijzen naar de rekening waarvan het saldo is gewijzigd. Als je a aan een functie doorgeeft, geef je ook toegang tot dat object door. Een functie die account.withdraw(5) aanroept, kan daardoor de rekening wijzigen die de aanroepende code ziet.

Maak voor een onafhankelijke rekening met dezelfde eigenaar en hetzelfde saldo BankAccount(a.owner, a.balance). Die constructor levert ook een nieuwe, lege transactiegeschiedenis. Het is een nieuwe rekening, geen volledige kopie van de geschiedenis.

copy.copy(a) maakt een nieuw buitenste object, maar behoudt referenties naar dezelfde binnenliggende objecten, waaronder de transactielijst. copy.deepcopy(a) kopieert ook geneste objecten. Als onafhankelijkheid van belang is, controleer dan zowel de objecten binnen de attributen als de buitenste instantie.

Een rechtstreekse toekenning acct.balance = -500 slaat de controles in de twee methoden over. Conventies voor interne attributen en properties helpen om duidelijk te maken hoe wijzigingen bedoeld zijn en om validatie dicht bij toestandswijzigingen te houden.

Aanroepende code heeft een duidelijke manier nodig om een object te lezen en te wijzigen. Inkapseling houdt de regels voor de gegevens bij de methoden die ze beheren. Python gebruikt conventies en properties om die interface vorm te geven.

Markeer interne opslag

Een laag streepje aan het begin van _balance duidt een intern attribuut aan. Aanroepende code hoort de methoden van de rekening te gebruiken, maar Python staat rechtstreekse toegang nog steeds toe. Er is geen gereserveerd woord private dat de waarde afschermt.

Een naam zoals __balance, met twee lage streepjes aan het begin en geen dubbele lage streepjes aan het einde, leidt tot naamvervorming. Binnen class Acc wordt self.__balance opgeslagen onder _Acc__balance. Buiten de klasse mislukt obj.__balance, maar obj._Acc__balance kan nog steeds werken. Naamvervorming voorkomt botsingen tussen namen; ze beveiligt geen gevoelige gegevens.

Voer een methode uit via attribuutsyntaxis

Een property voert een methode uit wanneer een attribuut wordt gelezen. De regel @property is een decorator: die verandert hoe Python de methode beschikbaar maakt. Een property zonder setter staat lezen toe, maar wijst toekenning af.

class Account:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self._balance = balance

    @property
    def balance(self):
        return self._balance

Lees na acct = Account("Maya", 50) de waarde van acct.balance zonder ronde haakjes. De toekenning acct.balance = 10 werpt AttributeError op omdat deze property geen setter heeft. Een stortingsmethode binnen de klasse zou _balance na haar controles kunnen bijwerken.

Controleer toekenning met een setter

class Student:
    def __init__(self, name, score):
        self.name = name
        self.score = score

    @property
    def score(self):
        return self._score

    @score.setter
    def score(self, value):
        if not 0 <= value <= 100:
            raise ValueError("score must be between 0 and 100")
        self._score = value

De getter en setter delen de naam score; de opgeslagen waarde gebruikt _score. Bij het maken van het object voert self.score = score de setter uit.

Voor s = Student("Ana", 88) slaat de toekenning s.score = 92 de waarde 92 op. De toekenning s.score = -1 werpt vóór het opslaan ValueError op, dus de score blijft 92. Student("Ana", 105) mislukt tijdens de initialisatie.

Binnen de setter zou self.score = value de setter opnieuw aanroepen, en dat herhaalt zich tot RecursionError. De getter loopt hetzelfde risico als die self.score teruggeeft. Gebruik de afzonderlijke opslagnaam _score in beide methode-inhouden.

Bereken waarden wanneer ze worden gelezen

Een property kan een waarde uit andere attributen berekenen:

    @property
    def area(self):
        return self.width * self.height

Als deze property binnen een rechthoekklasse staat, kun je r.area gebruiken. Bij breedte 3 en hoogte 4 is de waarde 12. Als je de breedte wijzigt in 5, geeft de volgende leesactie 20 terug. Als je tijdens de initialisatie één keer een oppervlakte zou opslaan, blijft na een wijziging van de breedte een oude waarde staan.

Begin met een gewoon attribuut als eenvoudige opslag volstaat.

Een object is gemakkelijker te onderzoeken als het zijn eigen gegevens kan beschrijven. Speciale methoden laten Python die beschrijving opvragen via bekende acties zoals print, str en repr. Hun namen beginnen en eindigen met twee lage streepjes en worden vaak dunder-namen genoemd.

Kies tekst voor twee doelgroepen

__str__ levert leesbare tekst voor gebruikers van een programma. __repr__ levert een nauwkeurige beschrijving voor programmeurs. Beide geven strings terug; geen van beide hoort het resultaat af te drukken in plaats van terug te geven.

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        return f"({self.x}, {self.y})"

    def __repr__(self):
        return f"Point({self.x}, {self.y})"

p = Point(3, 4)
print(p)        # (3, 4)
print(repr(p))  # Point(3, 4)

str(p) geeft de string "(3, 4)" terug. repr(p) geeft "Point(3, 4)" terug. Waar mogelijk lijkt een representatie op een klasseaanroep waarmee je de waarde opnieuw zou maken. Het blijft tekst: de aanroep van repr maakt zelf geen ander punt.

Zonder zelf gedefinieerde representatie toont een gewone instantie doorgaans een klassenaam en een identificatie die op een adres lijkt. Dat helpt om objecten uit elkaar te houden, maar toont hun bruikbare gegevens niet. Je roept deze speciale methoden zelden rechtstreeks aan; definieer ze één keer en gebruik de gewone weergavebewerkingen van Python.

Voorspel wat een container weergeeft

Met de klasse hierboven toont print([Point(3, 4), Point(0, 0)]) [Point(3, 4), Point(0, 0)]. De lijst gebruikt de representaties van haar elementen, ook al heeft elk element ook __str__.

Als je alleen __repr__ definieert, gebruikt de standaardversie van __str__ die ook. Als je alleen __str__ definieert, verandert de weergave van repr of containers niet. Als je maar één weergavemethode toevoegt, is __repr__ daarom in meer situaties bruikbaar om objecten te onderzoeken.

Maak stringvelden ondubbelzinnig

Voor een boek dat title, author en year al opslaat, geven deze methoden verschillende bruikbare weergaven:

    def __str__(self):
        return f"{self.title} by {self.author} ({self.year})"

    def __repr__(self):
        return f"Book({self.title!r}, {self.author!r}, {self.year})"

Voor het boek met titel "Dune", auteur "Frank Herbert" en jaar 1965 geeft de eerste methode "Dune by Frank Herbert (1965)". De tweede geeft "Book('Dune', 'Frank Herbert', 1965)". !r vraagt de representaties van de stringvelden op, inclusief aanhalingstekens.

Een methode-inhoud met alleen print(self.x) geeft None terug, dus mislukt str(p) met TypeError. Ook een geheel getal teruggeven mislukt. Stel de vereiste tekst samen en geef die string terug.

Speciale methoden verbinden een klasse met operatoren en ingebouwde functies. Definieer alleen bewerkingen die een duidelijke betekenis hebben voor dat type: vectoren optellen is begrijpelijk; een speler aan een team toevoegen is duidelijker als team.add_player(player).

Vergelijk waarden en houd hashes veilig

Twee afzonderlijke gewone instanties zijn standaard ongelijk bij een vergelijking. Voeg waardegelijkheid toe aan een puntklasse met:

    def __eq__(self, other):
        if not isinstance(other, Point):
            return NotImplemented
        return self.x == other.x and self.y == other.y

Nu zijn twee punten op (3, 4) bij vergelijking gelijk, ook al verschilt hun identiteit. in, count, index en remove kunnen bij lijsten zulke gelijke waarden vinden. Het gebruikelijke resultaat van != volgt uit __eq__.

NotImplemented is een retourwaarde waarmee Python de andere operand of een terugvalmogelijkheid kan proberen. Het is geen exceptie die je moet opwerpen. Wanneer geen van beide operanden waardegelijkheid ondersteunt, valt == terug op identiteit; een punt en de string "3,4" zijn bij vergelijking ongelijk.

Als je __eq__ zonder __hash__ definieert, worden instanties niet-hashbaar. Ze kunnen dan geen elementen van een verzameling of sleutels in een dictionary zijn. Gelijke objecten moeten gelijke hashes hebben en de hash van een sleutel moet stabiel blijven. Als de vergeleken attributen nooit veranderen, kan een passende hashmethode hash((self.x, self.y)) teruggeven. Houd wijzigbare waardeobjecten niet-hashbaar wanneer hun gelijkheidsvelden kunnen veranderen.

Definieer een ordening

__lt__ levert <. Een studentklasse kan scores vergelijken met return self.score < other.score. De scores 88, 72 en 95 worden dan gesorteerd als 72, 88, 95. min kiest de laagste; max kiest de hoogste met > en de gespiegelde vergelijking met <.

Met alleen __lt__ kan a > b gebruikmaken van b < a. Python leidt <= of >= niet uit die definitie af; die hebben hun eigen methoden nodig. Als een volgorde alleen voor één taak nuttig is, geef je in plaats daarvan een sleutelfunctie door:

def by_score(student):
    return student.score

ordered = sorted(students, key=by_score)

Geef nieuwe resultaten van rekenbewerkingen terug

Binnen een vectorklasse met de attributen x en y:

    def __add__(self, other):
        if not isinstance(other, Vector):
            return NotImplemented
        return Vector(self.x + other.x, self.y + other.y)

    def __mul__(self, factor):
        if not isinstance(factor, (int, float)):
            return NotImplemented
        return Vector(self.x * factor, self.y * factor)

    def __rmul__(self, factor):
        return self * factor

Vector(1, 2) + Vector(3, 4) levert een nieuwe vector (4, 6) op. Als je de eerste vector met 3 vermenigvuldigt, krijg je (3, 6) en blijft de oorspronkelijke vector ongewijzigd. __mul__ handelt de vector links af; __rmul__ ondersteunt een getal links. Python gaat er niet van uit dat de twee volgordes hetzelfde betekenen.

Lever een zinvolle lengte

Definieer voor een afspeellijst die self.songs opslaat __len__ om len(self.songs) terug te geven. Het resultaat moet een niet-negatief geheel getal zijn. len(playlist) telt dan de nummers. In deze klasse maakt lengte nul ook if playlist: onwaar; een zelf gedefinieerde __bool__ krijgt bij het toetsen van de waarheidswaarde voorrang op de lengte.

De attributen van een object kunnen naar andere objecten verwijzen. Een winkelwagen bevat artikelen, een bibliotheek bevat boeken en een cursus heeft cursisten. Compositie bouwt via deze heeft-een-relatie een groter object op uit kleinere objecten.

Geef elk object zijn eigen verantwoordelijkheid

class Item:
    def __init__(self, name, price, quantity):
        self.name = name
        self.price = price
        self.quantity = quantity

    def subtotal(self):
        return self.price * self.quantity

class ShoppingCart:
    def __init__(self):
        self.items = []

    def add(self, item):
        if not isinstance(item, Item):
            raise TypeError("a cart holds Item objects")
        self.items.append(item)

    def total(self):
        total = 0
        for item in self.items:
            total += item.subtotal()
        return total

De winkelwagen heeft een afzonderlijke lijst die tijdens de initialisatie wordt gemaakt. De methode add controleert het binnenkomende object voordat ze het toevoegt. cart.add("pen") werpt TypeError op in plaats van tekst op te slaan die tot een fout leidt wanneer een subtotaal wordt opgevraagd.

Maak de artikelen vóór of tijdens de aanroepen:

cart = ShoppingCart()
cart.add(Item("notebook", 2.50, 4))
cart.add(Item("pen", 1.25, 3))
print(cart.total())         # 13.75
print(cart.items[0].name)   # notebook

De subtotalen zijn 10.0 en 3.75; de winkelwagen telt ze op tot 13.75. De keten cart.items[0].name bereikt eerst de lijst van de winkelwagen, dan het eerste object daarin en daarna de naam van dat object.

Draag werk over aan het object dat het kent

De winkelwagen vraagt elk artikel om subtotal(). Dit is delegatie: één object roept voor een deel van een taak de methode van een ander object aan. Als een kwantumkorting verandert hoe een subtotaal wordt berekend, hoort die regel in Item.subtotal. De winkelwagen kan de teruggegeven subtotalen blijven optellen zonder prijsregels te herhalen.

Als je Item doorgeeft in plaats van Item(...), geef je de klasse door, geen gekocht artikel. De typecontrole wijst dat klasseobject af. Laat alle toevoegingen via de gecontroleerde route lopen; rechtstreekse toegang via cart.items.append(...) zou add omzeilen.

Zoek een object

Voeg deze methode toe binnen ShoppingCart:

    def find(self, name):
        for item in self.items:
            if item.name == name:
                return item
        return None

Bij de eerste overeenkomst wordt het bestaande artikel teruggegeven. Zonder overeenkomst wordt None teruggegeven. Controleer found is None voordat je found.name gebruikt; None heeft dat attribuut niet. Een methode __len__ die len(self.items) teruggeeft, kan er ook voor zorgen dat len(cart) de opgeslagen artikelobjecten telt, terwijl __str__ artikelregels kan samenvoegen tot een bon.

Volg referenties binnen collecties

Een lijst slaat referenties op, dus als je hetzelfde artikel in twee winkelwagens plaatst, wordt het niet gekopieerd. Een wijziging van de prijs van dat artikel beïnvloedt het volgende totaal dat beide winkelwagens berekenen. Afzonderlijke winkelwagenlijsten voorkomen dat de lijst onbedoeld wordt gedeeld, maar maken de objecten erin niet onafhankelijk. Maak afzonderlijke artikelen wanneer de winkelwagens onafhankelijke gegevens moeten bevatten.

Objecten kunnen net als getallen of strings argumenten en retourwaarden van methoden zijn. Volg het ontvangende object, de argumenten en het resultaat afzonderlijk: een methode kan een bestaand object wijzigen, een nieuw object teruggeven of alleen een waarde melden.

Gebruik een ander object als invoer

Binnen een puntklasse met x en y kan een methode beide punten lezen:

    def midpoint(self, other):
        return Point((self.x + other.x) / 2,
                     (self.y + other.y) / 2)

Voor p = Point(3, 4) en q = Point(1, 0) maakt middle = p.midpoint(q) een derde punt op (2.0, 2.0). Tijdens de aanroep verwijst self naar p en other naar q. De methode berekent coördinaten en maakt een nieuw punt; ze kent niets toe aan de oorspronkelijke punten.

Met import math kan een afstandsmethode math.hypot(self.x - other.x, self.y - other.y) teruggeven. Point(0, 0).distance_to(Point(3, 4)) geeft dan 5.0. Deze aanroep geeft een getal terug, terwijl midpoint een object teruggeeft.

Laat elk ontvangend object zijn wijzigingen beheren

Binnen een rekeningklasse met gecontroleerde methoden withdraw en deposit:

    def transfer_to(self, other, amount):
        self.withdraw(amount)
        other.deposit(amount)

Als Maya 100 heeft en Leo 20, neemt maya.transfer_to(leo, 30) eerst geld op van Maya, zodat 70 overblijft, en stort het daarna bij Leo, die dan 50 heeft. In de eerste aanroep is self Maya’s rekening. In de stortingsaanroep is de eigen self Leo’s rekening.

Een latere overboeking van 500 mislukt in withdraw, omdat Maya nog maar 70 heeft. De uitvoering stopt vóór deposit, dus beide saldi behouden hun eerdere waarden. De volgorde van de aanroepen is van belang. Python maakt een eerdere toestandswijziging niet ongedaan als een latere aanroep een exceptie opwerpt; deze korte methode hangt ervan af dat de ontvangende rekening het bedrag kan accepteren.

De aanroep other.deposit(amount) voert de regels van de ontvangende rekening op één plek uit. Als je other.balance rechtstreeks zou wijzigen, zou je die regels overslaan.

Volg de objecten, niet alleen de variabelenamen

Teken elke instantie als een vak met haar attributen. Teken een pijl van elke variabele naar het bijbehorende vak. Bepaal bij een aanroep welk vak self ontvangt en welke vakken als argumenten worden doorgegeven. Werk het betreffende vak bij na elke geslaagde regel die de toestand wijzigt. Twee pijlen naar één vak betekenen dat een wijziging via beide namen hetzelfde object bereikt.

Een gewone functie kan ook met meerdere objecten werken. total_balance(accounts) kan rekeningen doorlopen en hun saldi optellen. Die berekening over de hele lijst hoeft niet bij één rekening te horen.

Geef een ontbrekende relatie weer

Een boek kan beginnen met self.borrower = None en later een lidobject opslaan. Controleer de relatie voordat je een attribuut van het lid leest:

if book.borrower is not None:
    print(book.borrower.name)

Anders mislukt book.borrower.name wanneer het boek geen lener heeft. Klassen kunnen boven een functie main() worden gedefinieerd die de objecten maakt en verbindt. Door main() aan te roepen onder if __name__ == "__main__": voorkom je dat die acties worden uitgevoerd wanneer de klassen worden geïmporteerd.

Een klasse is op haar plaats wanneer samenhangende gegevens en herhaalde bewerkingen samen gemakkelijker te begrijpen zijn. Je hoeft niet elke functie of elk record in een klasse om te zetten. Kies de structuur die de verantwoordelijkheden van het programma duidelijk maakt.

Zoek gegevens en gedrag die samen voorkomen

Klassen helpen wanneer meerdere functies steeds dezelfde groep waarden ontvangen, veel records een structuur delen en toestandswijzigingen gemeenschappelijke regels moeten volgen. Meerdere rekeningen die allemaal stortingen en opnames ondersteunen, passen hier goed bij. Eén berekening kan een functie blijven. Een vast record dat alleen wordt gelezen, kan een tuple of dictionary blijven.

Een klasse met alleen inrichting en een eenmalige bewerking voegt vaak meer omslachtigheid dan nuttige structuur toe. Vraag je af wat één instantie voorstelt en welke terugkerende acties erbij horen. Als je die vragen niet eenvoudig kunt beantwoorden, heroverweeg dan het ontwerp.

Zet een bewerking bij haar gegevens

Een rekening met een dictionary kan zo beginnen:

account = {"owner": "Maya", "balance": 50}

def deposit(account, amount):
    account["balance"] += amount

De klasseversie kan dezelfde bewerking bij haar toestand en regels plaatsen:

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("deposit must be positive")
        self.balance += amount

    def __repr__(self):
        return f"BankAccount({self.owner!r}, {self.balance})"

Na acct = BankAccount("Maya", 50) en acct.deposit(25) is de representatie BankAccount('Maya', 75). De regel dat stortingen positief moeten zijn, wordt nu uitgevoerd telkens wanneer aanroepende code die methode gebruikt. Het lezen van account["balence"] zou KeyError opwerpen; het lezen van acct.balence werpt AttributeError op. Een klasse neemt spelfouten niet weg, maar geeft de gegevens en hun bewerkingen een plek met een naam.

Ontwerp op basis van een korte beschrijving

Bij “Een bibliotheek leent boeken uit aan leden. Een lid kan maximaal 3 boeken lenen” suggereren de zelfstandige naamwoorden Book, Member en Library. De werkwoorden suggereren methoden voor uitlenen en terugbrengen.

1. Noteer wat elke instantie weet: de titel, auteur en lener van een boek; de naam en geleende boeken van een lid; de boeken en leden van een bibliotheek.
2. Bepaal de regels: een boek mag niet al zijn uitgeleend en een lid mag MAX_LOANS = 3 niet overschrijden.
3. Zet elke regel in de bewerking die de relatie wijzigt, zoals Library.check_out(book, member).
4. Schrijf de initialisatie en een bruikbare representatie en voeg daarna steeds één actie toe en test die.

Verschillende titels hebben verschillende instanties van Book nodig, geen afzonderlijke klassen die naar elke titel zijn genoemd. Gebruik zelfstandige naamwoorden in het enkelvoud voor afzonderlijke objecten, zoals Book; noem een collectie naar de collectie, zoals Library. Houd de taak van elke klasse duidelijk genoeg om die in één zin te beschrijven.

Test waarneembaar gedrag

acct = BankAccount("Maya", 50)
acct.deposit(25)
assert acct.balance == 75

assert werpt AssertionError op als de voorwaarde onwaar is. Test ook afgewezen acties: vang de verwachte exceptie op en controleer dat de toestand niet is veranderd. Gebruik expliciete validatie met raise voor invoer van aanroepende code; asserties zijn controles tijdens de ontwikkeling en kunnen worden uitgeschakeld wanneer Python met optimalisatie wordt uitgevoerd.