Naarmate een script groeit, geef je uiteindelijk dezelfde groep variabelen door tussen functies, en wordt het moeilijk om te bepalen welke gegevens bij welke logica horen. Python-klassen en -objecten lossen dit op door gegevens en gedrag in één eenheid te bundelen.

In deze tutorial bouwen we stap voor stap een kleine bankrekening op en voegen we elk OOP-idee pas toe als het een probleem oplost. We hebben elk voorbeeld uitgevoerd op Python 3.13, en de getoonde uitvoer is afkomstig van die run. Als je nieuw bent in de taal, lees dan eerst onze Python-tutorial voor beginners.

Wat zijn klassen en objecten?

Een klasse beschrijft wat iets is en wat het kan doen. Een object, ook wel instance genoemd, is een specifiek object dat op basis van die beschrijving is gemaakt. “Account” is een klasse, terwijl Asha’s account en Ben’s account twee objecten zijn.

Je gebruikt al die tijd voorwerpen. In Python zijn strings, lijsten en zelfs functies objecten, daarom kun je "hello".upper() schrijven.

Je eerste les

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

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

a = Account("Asha", 100)
b = Account("Ben")

a.deposit(50)
print(a.balance, b.balance)

# 150 0

__init__ wordt automatisch uitgevoerd wanneer u een object maakt, en stelt de startstatus in. Het deponeren in a raakte b niet, omdat elk object zijn eigen gegevens heeft. Merk op dat de methode het saldo ook beschermt tegen een slechte waarde. In onze gids voor Python-uitzonderingsafhandeling wordt raise uitgebreider uitgelegd.

Wat is zelf?

self is eenvoudigweg het object waaraan een methode werkt. Wanneer je a.deposit(50) schrijft, roept Python in feite Account.deposit(a, 50) aan, waarbij het object als eerste argument wordt doorgegeven. Zo kan één methodedefinitie elk object dienen.

De naam self is eerder een sterke conventie dan een trefwoord, maar gebruik deze altijd. Het vergeten ervan in een methodedefinitie is de meest voorkomende beginnersfout en levert een verwarrende boodschap op over het aantal argumenten.

Klassekenmerken versus instantiekenmerken

Een attribuut dat rechtstreeks in de hoofdtekst van de klasse is ingesteld, wordt door alle objecten gedeeld. Eén set op self hoort alleen bij dat object. Dit voorbeeld laat zien hoe zoekopdrachten zich gedragen:

class Account:
    interest_rate = 0.04    # class attribute

    def __init__(self, owner, balance=0):
        self.owner = owner  # instance attribute
        self.balance = balance

a = Account("Asha", 100)
b = Account("Ben")
print(a.interest_rate, b.interest_rate)   # 0.04 0.04

Account.interest_rate = 0.05
print(a.interest_rate, b.interest_rate)   # 0.05 0.05

a.interest_rate = 0.09
print(a.interest_rate, b.interest_rate, Account.interest_rate)
# 0.09 0.05 0.05

Die laatste regel verrast mensen. Toewijzing via a veranderde de gedeelde waarde niet. Het creëerde een nieuw instance-attribuut op a dat klasse één verbergt. Python kijkt eerst naar het object en vervolgens naar de klasse.

Speciale (dunder)methoden

Methoden met dubbele onderstrepingstekens zorgen ervoor dat uw objecten kunnen werken met de ingebouwde functies van Python. Zonder deze geeft het afdrukken van een account een nutteloos geheugenadres weer. Door er twee toe te voegen, krijgt het een leesbare vorm:

    def __str__(self):
        return f"{self.owner}: {self.balance}"

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

print(a)        # Asha: 150
print([a, b])   # [Account('Asha', 150), Account('Ben', 0)]

Erfenis

Door overerving kan een nieuwe klasse een bestaande klasse hergebruiken en alleen veranderen wat verschilt. Hier is Savings een Account met een extra instelling:

class Savings(Account):
    def __init__(self, owner, balance=0, limit=3):
        super().__init__(owner, balance)
        self.limit = limit

    def __str__(self):
        return f"{super().__str__()} (savings)"

s = Savings("Chitra", 500)
s.deposit(100)
print(s, isinstance(s, Account), s.limit)

# Chitra: 600 (savings) True 3

super() roept de versie van de ouder aan, zodat de installatielogica niet wordt herhaald. deposit werd overgenomen zoals het was, en __str__ werd overschreven om een ​​label toe te voegen. Gebruik alleen overerving voor een echte ‘is een’-relatie. Als een klasse alleen maar iets nodig heeft, zoals een auto die een motor nodig heeft, geef hem dat object dan als attribuut. Dit staat bekend als compositie en is doorgaans flexibeler dan diepe overervingsketens.

Polymorfisme

Polymorfisme betekent dat verschillende objecten op hun eigen manier op dezelfde methodeaanroep kunnen reageren. De belcode hoeft niet het exacte type te kennen:

class Square:
    def __init__(self, side):
        self.side = side
    def area(self):
        return self.side ** 2

class Circle:
    def __init__(self, radius):
        self.radius = radius
    def area(self):
        return round(3.14159 * self.radius ** 2, 2)

for shape in [Square(3), Circle(2)]:
    print(type(shape).__name__, shape.area())

# Square 9
# Circle 12.57

Deze twee klassen delen niet eens een ouder. Het maakt Python alleen maar uit dat het object een area-methode heeft, een aanpak die bekend staat als duck-typing. Als u later een Triangle toevoegt, hoeft u de lus niet te wijzigen.

Inkapseling en eigenschappen

Python heeft geen echt privé-attributen en vertrouwt in plaats daarvan op conventies. Een enkel onderstrepingsteken, zoals in _price, vertelt andere ontwikkelaars “dit is intern, raak het niet aan”. Als u waarden wilt controleren wanneer ze zijn ingesteld, gebruikt u een property, die er van buitenaf uitziet als een gewoon attribuut:

class Product:
    def __init__(self, price):
        self.price = price

    @property
    def price(self):
        return self._price

    @price.setter
    def price(self, value):
        if value < 0:
            raise ValueError("price cannot be negative")
        self._price = value

p = Product(100)
p.price = 150
print(p.price)      # 150
p.price = -5        # ValueError: price cannot be negative

Dit betekent dat u kunt beginnen met een gewoon attribuut en later validatie kunt toevoegen zonder code te wijzigen die de klasse gebruikt. Schrijf de methoden get_price() en set_price() dus niet uit gewoonte, zoals in Java. De @ syntaxis hier is een decorateur, die we uitleggen in Python-decorateurs uitgelegd.

Klassemethoden en statische methoden

class Temperature:
    def __init__(self, celsius):
        self.celsius = celsius

    @classmethod
    def from_fahrenheit(cls, f):
        return cls(round((f - 32) * 5 / 9, 1))

    @staticmethod
    def is_freezing(celsius):
        return celsius <= 0

Temperature.from_fahrenheit(212).celsius   # 100.0
Temperature.is_freezing(-3)                # True

Dataklassen

Als een klas voornamelijk gegevens bevat, is het met de hand schrijven van __init__, __repr__ en __eq__ vervelend. @dataclass genereert ze op basis van typeannotaties:

from dataclasses import dataclass, field

@dataclass
class Item:
    name: str
    price: int
    tags: list = field(default_factory=list)

print(Item("Pen", 10))
print(Item("Pen", 10) == Item("Pen", 10))

# Item(name='Pen', price=10, tags=[])
# True

Veel voorkomende fouten

Een veranderlijk klassenattribuut gebruiken

Dit is een klassieke bug. De lijst is per klasse gedefinieerd, dus alle winkelwagens delen deze:

class Cart:
    items = []            # shared by every cart!

    def add(self, item):
        self.items.append(item)

c1, c2 = Cart(), Cart()
c1.add("pen")
print(c2.items)

# ['pen']

Maak het aan in __init__ met self.items = [], zodat elk object zijn eigen lijst krijgt.

Andere veel voorkomende fouten

• self vergeten. Schrijf self.balance, niet balance, interne methoden.
• Vergeten super().__init__(). Het kind mist dan attributen die door de ouder zijn ingesteld.
• Grote klassen bouwen. Een klasse die alles doet, is moeilijk te testen. Verdeel het op basis van verantwoordelijkheid.
• Diepe erfenis. Twee niveaus zijn meestal voldoende, en de compositie is vaak duidelijker.
• Geen tests schrijven. Klassen met regels zijn eenvoudig te testen, zoals onze pytest-tutorial laat zien met behulp van een klein karretje.

Tot slot

Objectgeoriënteerde Python komt neer op het groeperen van gegevens met het gedrag dat deze beschermt. Begin met __init__, methoden en __str__, en voeg vervolgens overerving en eigenschappen toe als je een probleem tegenkomt dat ze oplossen. Neem als volgende stap een script dat overal dezelfde paar variabelen doorgeeft en verander ze in één kleine klasse.

Veelgestelde vragen

Blijf leren