Hoe werken classes en objecten in Python?

Question

IT Interview Practice · Accepted Answer

A **class** is een blauwdruk voor het maken van **objects** (instances) die gegevens (attributes) en gedrag (methods) combineren. Python's OOP is flexibel en heeft enkele kenmerkende conventies, met name de expliciete `self`.

## Defining a class

```python
class Dog:
    species = "Canis familiaris"     # CLASS attribute (shared by all instances)

def __init__(self, name, age):   # the constructor — runs on creation
        self.name = name              # INSTANCE attributes (per object)
        self.age = age

def bark(self):                   # a method — `self` is the instance
        return f"{self.name} says woof"

d = Dog("Rex", 3)        # create an instance (calls __init__)
d.name                   # "Rex"
d.bark()                 # "Rex says woof"
```

## The explicit self

```python
def bark(self):          # `self` is ALWAYS the first parameter of a method
    return self.name      # access instance data through self
```

In tegenstelling tot veel talen met een impliciete `this`, vereist Python **`self`** als de expliciete eerste parameter van elke instance method — het verwijst naar de instantie waarop de method wordt aangeroepen. Je geeft het niet handmatig door; `d.bark()` geeft `d` automatisch als `self` door.

## Class vs instance attributes

```python
Dog.species          # "Canis familiaris" — shared by all dogs
d.species            # also accessible from an instance
d.name               # "Rex" — unique to this instance
```

Class attributes worden gedeeld tussen alle instances; instance attributes (ingesteld via `self.x =`) zijn per object.

## Method types

```python
class Circle:
    def area(self): ...                    # instance method — needs self

@classmethod
    def from_diameter(cls, d):             # class method — receives the CLASS (cls)
        return cls(d / 2)                   # often used as alternative constructors

@staticmethod
    def pi(): return 3.14159               # static — no self/cls, just namespaced
```

## Encapsulation conventions

```python
self.public                # public
self._protected            # "internal use" by convention (not enforced)
self.__private             # name-mangled to _ClassName__private (stronger hiding)
```

Python heeft geen echte private members — leading underscores zijn conventies die intentie signaleren ("raak dit niet aan"), geen harde afdwinging.

## Waarom het belangrijk is

Classes zijn hoe je entiteiten modelleert en code organiseert in object-oriented Python — gerelateerde gegevens en gedrag bundeling, veel gebruikt in frameworks, domain modeling en grote toepassingen.

De karakteristieke Python-conventies begrijpen — de expliciete `self`, `__init__` constructor, class vs instance attributes, de drie method types (`instance`/`@classmethod`/`@staticmethod`), en de underscore privacy-conventies — is essentieel voor het schrijven en lezen van object-oriented Python.

Ze verschillen genoeg van andere talen (expliciete self, conventie-gebaseerde privacy) dat het goed begrijpen ervan veel verwarring voorkomt.

Defining a class

The explicit self

Class vs instance attributes

Method types

Encapsulation conventions

Waarom het belangrijk is

Gerelateerde vragen