# Python Classes und Objekte erstellen

Python-Klassen sind wie **Baupläne oder Schablonen**. Mit ihnen können Sie wiederverwendbaren Code in Form von Klassenattributen und -methoden schreiben.

## Was sind Python Classes?

Eine Klasse ist ein **abstraktes Konzept**, das Attribute und Methoden definiert, die ein Objekt haben kann. Python-Klassen dienen als Vorlage für die Erzeugung von konkreten Objekten, die Instanzen dieser Klasse sind. Zum Beispiel kann eine Klasse `Auto` heißen, die Attribute wie Farbe und Marke sowie die Methoden `__fahren__` oder `__bremsen__` besitzt.

Jedes Objekt einer Klasse darf seine eigenen Werte für die Attribute haben, aber **teilt sich die Methoden und den grundlegenden Verhaltensrahmen mit anderen Instanzen** derselben Klasse. Beispielsweise kann ein Objekt `mein_auto` der Klasse `Auto` mit der Farbe `__Rot__` und der Marke `__Toyota__` erstellt werden, wobei automatisch die Methoden `__fahren__` oder `__bremsen__` der Klasse auf die Instanz übertragen werden.

## So erstellen Sie Python Classes

In Python definieren Sie Klassen mithilfe des Schlüsselworts `class`.

```python
lass 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}"
```

In diesem Python-Code erzeugen wir eine Klasse namens `MyClass`. Diese hat einen **Konstruktor** `__init__`, der beim Erstellen eines Objekts aufgerufen wird und zwei Attribute, `attribute1` und `attribute2`, initialisiert. Die Methode `my_method` gibt eine formatierte Zeichenfolge zurück, die die Werte dieser Attribute enthält.

Um ein Objekt aus dieser Klasse abzuleiten, verwenden Sie den Klassennamen, gefolgt von Klammern:

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

## Beispiele für die Anwendung von Python Classes

Python-Klassen können komplexe Systeme und Beziehungen zwischen verschiedenen Entitäten herstellen. Im Folgenden stellen wir Ihnen Möglichkeiten zum Arbeiten mit Python Classes vor.

### Die `__str()__`- Funktion

Die `__str__()`-Funktion in Python ist eine spezielle Methode, die Sie innerhalb von Python Classes definieren können. Wenn sie implementiert wird, gibt sie eine Zeichenfolge zurück, die eine **benutzerfreundliche Darstellung eines Objekts** repräsentiert. Die `str()`-Funktion können Sie direkt auf das Objekt anwenden oder mit einer `print()`-Anweisung kombinieren.

```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 unserem Code kreiert die `__str__()`-Methode innerhalb der `Person`-Klasse eine **formatierte Zeichenfolge**, die den Namen und das Alter einer Person enthält. Wenn `print(person1)` ausgeführt wird, ruft diese automatisch die `__str__()`-Methode des `person1`-Objekts auf und gibt die von dieser Methode zurückgegebene Zeichenfolge aus.

### Methoden in Python Classes definieren

Sie haben die Möglichkeit, in Python **Methoden innerhalb einer Klasse festzulegen**, um Operationen auf den Objekten dieser Klasse auszuführen. Diese Methoden können dann von den erstellten Objekten aufgerufen werden.

```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
```

Im Python-Beispiel erstellen wir die Klasse `Rectangle`, die die zwei Methoden `area()` und `perimeter()` umfasst. Diese dienen dazu, die Fläche und den Umfang eines Rechtecks zu berechnen, basierend auf den Längen- und Breitenwerten, die bei der Initialisierung des Objekts übergeben wurden. In Python repräsentiert `self` in einer Klassenmethode eine **Referenz auf das aktuelle Objekt**, auf das die Methode angewendet wird.

Das Objekt `my_rectangle` wird mit einer Länge von 5 und einer Breite von 10 erstellt. Anschließend rufen wir die Methoden `area()` und `perimeter()` auf diesem Objekt auf, um die entsprechenden Werte zu berechnen.

### Eigenschaften von Objekten ändern

Der Punktoperator `.` kann benutzt werden, um auf die **spezifischen Attribute des Objekts zuzugreifen** und deren Werte zu aktualisieren. Sie können dem Attribut neue Werte direkt zuweisen.

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

Das Schlüsselwort `del` dient zum Löschen von Eigenschaften eines Objekts.

```python
del person1.name
```

Hinweis Sie sollten berücksichtigen, dass sich Instanzvariablen von [Python Class Variables](https://www.ionos.com/de-ch/digitalguide/websites/web-entwicklung/python-class-variables/) unterscheiden. Klassenvariablen werden **außerhalb des Konstruktors definiert** und können nur über den Klassennamen geändert werden.


This is a markdown version of: [https://www.ionos.com/de-ch/digitalguide/websites/web-entwicklung/python-classes/](https://www.ionos.com/de-ch/digitalguide/websites/web-entwicklung/python-classes/) for AI/LLM consumption.