# Hoe Python-klassen en -objecten maken

Python-klassen zijn als **bouwplannen of sjablonen**. Je kunt ze gebruiken om herbruikbare code te schrijven in de vorm van klasse-attributen en -methoden.

## Wat zijn Python-klassen?

Een klasse is een **abstract concept** dat attributen en methoden voor objecten beschrijft. Een Python-klasse fungeert als een sjabloon voor het maken van concrete objecten, die instanties van de klasse zijn. Een klasse `Car` zou bijvoorbeeld attributen zoals kleur en merk kunnen definiëren, samen met methoden zoals `__drive__` of `__brake__`.

Hoewel elk object van een klasse unieke attribuutwaarden kan hebben, **delen** objecten van dezelfde klasse **methoden en een basisgedragskader met andere instanties** in de klasse. Het object `my_car` van de klasse `Car` kan bijvoorbeeld worden aangemaakt met de kleur `__red__` en het merk `__Toyota__`, maar de methoden `__drive__` en `__brake__` worden automatisch overgedragen naar de instantie.

## Hoe Python-klassen maken

In Python definieer je klassen met behulp van het sleutelwoord `class`.

```python
class MyClass:
    # Constructor method called when creating an object
    def __init__(self, attribute1, attribute2):
        self.attribute1 = attribute1
        self.attribute2 = attribute2
    
    # Method defined within the class
    def my_method(self):
        return f"Attribute 1: {self.attribute1}, Attribute 2: {self.attribute2}"
```

De bovenstaande code definieert een klasse met de naam `MyClass`. Deze heeft een **constructor** `__init__`, die wordt aangeroepen bij het aanmaken van een object en twee attributen initialiseert: `attribute1` en `attribute2`. De methode `my_method` retourneert een opgemaakte tekenreeks met de waarden van deze attributen.

Om een object van deze klasse af te leiden, gebruik je de klassenaam gevolgd door haakjes:

```python
object1 = MyClass("Value 1", "Value 2")
# Calling a method of the object
result = object1.my_method()
```

## Voorbeelden van het gebruik van Python-klassen

Python-klassen kunnen complexe systemen en relaties tussen verschillende entiteiten creëren. In de volgende secties laten we u zien hoe u met Python-klassen kunt werken.

### `__str()__` functie

De functie `__str__()` in Python is een speciale methode die u binnen Python-klassen kunt definiëren. Wanneer deze wordt geïmplementeerd, retourneert deze een tekenreeks die een **gebruiksvriendelijke weergave van een object** vertegenwoordigt. U kunt de functie `str()` rechtstreeks op een object gebruiken of deze combineren met een `print()` instructie.

```python
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def __str__(self):
        return f"Name: {self.name}, Age: {self.age}"
person1 = Person("Alice", 30)
print(person1) # Output: Name: Alice, Age: 30
```

In de bovenstaande code maakt de methode `__str__()` binnen de klasse `Person` een **opgemaakte tekenreeks die** de naam en leeftijd van een persoon weergeeft. Wanneer `print(person1)` wordt uitgevoerd, roept deze automatisch de methode `__str__()` van het object `person1` aan en voert de tekenreeks uit die door de methode wordt geretourneerd.

### Methoden definiëren in Python-klassen

In Python kun je **methoden binnen een klasse** definiëren om bewerkingen op de objecten van de klasse uit te voeren. Deze methoden kunnen vervolgens worden aangeroepen door de objecten die worden aangemaakt.

```python
class Rectangle:
    def __init__(self, length, width):
        self.length = length
        self.width = width
    
    def area(self):
        return self.length * self.width
    def perimeter(self):
        return 2 * (self.length + self.width)
# Creating an object of the class
my_rectangle = Rectangle(5, 10)
# Calling methods of the object
area = my_rectangle.area()
perimeter = my_rectangle.perimeter()
# Printing the calculated values
print("Area =", area) # Output: Area = 50
print("Perimeter =", perimeter) # Output: Perimeter = 30
```

In het Python-voorbeeld definiëren we de klasse `Rectangle` met twee methoden `area()` en `perimeter()`, die de oppervlakte en omtrek van de rechthoek berekenen aan de hand van de lengte en breedte die tijdens de initialisatie van het object zijn opgegeven. In Python fungeert `self` in een klassemethode als een **verwijzing naar het object** waarop de methode momenteel wordt toegepast.

Het object `my_rectangle` wordt aangemaakt met een lengte van 5 en een breedte van 10. Vervolgens roepen we de methoden `area()` en `perimeter()` aan op dit object om de bijbehorende waarden te berekenen.

### De eigenschappen van objecten wijzigen

De `.` -puntoperator kan worden gebruikt om toegang te krijgen tot de **specifieke attributen van het object** en hun waarden bij te werken. U kunt rechtstreeks nieuwe waarden toewijzen aan het attribuut.

```python
person1.name = "Sarah"
person1.age = 35
```

Het trefwoord `del` wordt gebruikt om de eigenschappen van een object te verwijderen.

```python
del person1.name
```

Opmerking Onthoud dat instantievariabelen verschillen van [Python-klassevariabelen](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/python-klassenvariabelen/). Klassevariabelen worden **buiten de constructor** gedefinieerd en kunnen alleen worden gewijzigd met behulp van de klassenaam.


This is a markdown version of: [https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/python-klassen/](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/python-klassen/) for AI/LLM consumption.