4.5 Funktionen, Klassen und Methoden

In diesem Kapitel lernen Sie, wie Sie Funktionen, Klassen und Methoden in Python verwenden, um Ihren Code besser zu strukturieren und wiederverwendbare Komponenten zu erstellen.

Übersicht Funktionen, Klassen und Methoden

Funktionen, Klassen und Methoden sind grundlegende Bausteine in Python, die es ermöglichen, Code zu strukturieren, wiederverwendbar zu machen und in kleinere, handhabbare Einheiten zu zerlegen.

Konzept Beschreibung
Funktion Eine wiederverwendbare Einheit von Code, die eine bestimmte Aufgabe ausführt.
Methode Eine Funktion, die innerhalb einer Klasse definiert ist.
Attribut Eine Variable, die in einer Klasse definiert wird und die Daten eines Objekts speichert.
Klasse Eine Vorlage zur Erzeugung von Objekten, die Variablen (Attribute) und Funktionen (Methoden) enthält.
Instanz Ein konkretes Objekt, das aus einer Klasse erzeugt wurde. Jede Instanz hat ihre eigenen Attributwerte.
Konstruktor Die Methode, die beim Instanzieren automatisch aufgerufen wird.

Spezifischere Anweisungen und Eigenschaften

Diese Tabelle beschreibt spezifischere Anweisungen und Eigenschaften, die im Zusammenhang mit Funktionen, Klassen und Methoden in Python verwendet werden.

Anweisung/Eigenschaft Beschreibung
class Schlüsselwort zur Definition einer Klasse.
def Schlüsselwort zur Definition einer Funktion oder Methode.
__init__ Der Konstruktor einer Klasse, der aufgerufen wird, wenn ein neues Objekt erstellt wird.
self Ermöglicht den Zugriff auf Attribute und andere Methoden der Klasse.
return Gibt einen Wert aus einer Funktion oder Methode zurück.

Funktionen

Funktionen sind Blöcke von wiederverwendbarem Code, die eine bestimmte Aufgabe ausführen. Funktionen helfen dabei, Code übersichtlich zu halten und die Wiederholung von Code zu vermeiden.

Beispiel: Einfache Funktion

1
2
3
4
5
6
7
# Einfache Funktion
# J. Thomaschewski, 04.09.2024
def begruessung(name):
    print("Hallo,", name)

# Aufruf der Funktion
begruessung("Jörg")

In diesem Beispiel wird eine Funktion begruessung() definiert, die eine Begrüßung für den übergebenen Namen ausgibt.

Parameter und Rückgabewerte

Funktionen können Parameter annehmen und Werte zurückgeben.

1
2
3
4
5
6
7
8
# Funktion mit zwei Parametern und return
# J. Thomaschewski, 04.09.2024
def addiere(a, b):
    return a + b

# Aufruf der Funktion
ergebnis = addiere(5, 3)
print("Das Ergebnis ist:", ergebnis)

Hier nimmt die Funktion addiere() zwei Parameter a und b und gibt ihre Summe zurück.

Klassen

Klassen sind Vorlagen zur Erstellung von Objekten. Sie kombinieren Daten (Attribute) und Funktionen (Methoden), die auf diesen Daten operieren.

Beispiel: Einfache Klasse - Ausgabe über print in der Methode

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
# Klasse Baum mit Hauptprogramm - print in Methode
# J. Thomaschewski, 04.09.2024
class Baum:
    def __init__(self, art, hoehe):
        self.art = art
        self.hoehe = hoehe

    def beschreibung(self):
        print(f"Baum: {self.art}, Höhe: {self.hoehe} Meter")

# Hauptprogramm
meinBaum = Baum("Eiche", 20)
meinBaum.beschreibung()

In diesem Beispiel wird eine Klasse Baum definiert, die die Attribute art und hoehe besitzt. Die Methode beschreibung() gibt die Details des Baumes aus, indem sie die Art und die Höhe des Baumes anzeigt.

Die Ausgabe erfolgt direkt in der Methode über den print-Befehl.

Beispiel: Einfache Klasse - Ausgabe über print im Hauptprogramm

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
# Klasse Baum mit Hauptprogramm - return
# J. Thomaschewski, 04.09.2024
class Baum:
    def __init__(self, art, hoehe):
        self.art = art
        self.hoehe = hoehe

    def beschreibung(self):
        return f"Baum: {self.art}, Höhe: {self.hoehe} Meter"

# Hauptprogramm
meinBaum = Baum("Eiche", 20)

beschreibung = meinBaum.beschreibung()
print(beschreibung)

Der String wird hier in der Methode mit return an das Hauptprogramm übergeben. Wenn eine Übergabe aus der MEthode erfolgt, dann muss diese im Hauptprogramm auch entgegengenommen werden. Dies erfolgt mit beschreibung =. Die Ausgabe erfolgt dann im Hauptprogramm über den print-Befehl.

Beispiel: Einfache Klasse - Der Baum wächst ja noch...

Im Konstrktor sollen nur "Werte" übergeben werden, die sich im Objekt nicht ändern. Die Höhe kann sich ja bei einer Eiche ber die Zeit noch ändern und ist damit kein gutes Klassenattribut.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
# Klasse Baum mit Hauptprogramm - return
# J. Thomaschewski, 04.09.2024
class Baum:
    def __init__(self, art):
        self.art = art


    def beschreibung(self, hoehe):
        return f"Baum: {self.art}, Höhe: {hoehe} Meter"

# Hauptprogramm
meinBaum = Baum("Eiche")

beschreibung = meinBaum.beschreibung(20)
print(beschreibung)

Der String wird hier in der Methode mit return an das Hauptprogramm übergeben. Wenn eine Übergabe aus der MEthode erfolgt, dann muss diese im Hauptprogramm auch entgegengenommen werden. Dies erfolgt mit beschreibung =. Die Ausgabe erfolgt dann im Hauptprogramm über den print-Befehl.

Konstruktoren

Der Konstruktor __init__ wird aufgerufen, wenn eine neue Instanz der Klasse erstellt wird. Er initialisiert die Attribute des Objekts.

Methoden

Methoden sind Funktionen, die innerhalb einer Klasse definiert sind und auf Objekte dieser Klasse angewendet werden. Sie können auf die Attribute des Objekts zugreifen und diese manipulieren.

Beispiel: Methode zur Berechnung

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
# Klasse Kreis mit Hauptprogramm
# J. Thomaschewski, 04.09.2024
class Kreis:
    def __init__(self, radius):
        self.radius = radius

    def flaeche(self):
        return 3.14159 * (self.radius ** 2)

# Erstellen eines Objekts der Klasse und Aufruf der Methode
meinKreis = Kreis(5)
print("Die Fläche des Kreises ist:", meinKreis.flaeche())

In diesem Beispiel wird die Methode flaeche() verwendet, um die Fläche eines Kreises zu berechnen, basierend auf dem Radius, der beim Erstellen des Objekts angegeben wurde.

Einfache Aufgabe

Frage den Radius interaktiv über input() ab.

Pi Pico Script: Verwendung von Funktionen und Klassen

In diesem Beispiel kombinieren wir die Verwendung von Funktionen und Klassen, um eine LED am Pi Pico zu steuern.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
# LED-Steuerung mit Funktionen und Klassen
# J. Thomaschewski, 04.09.2024
from machine import Pin
from time import sleep

class LedBlinker:
    def __init__(self, pinNumber):
        self.led = Pin(pinNumber, Pin.OUT)

    def blink(self, times, delay):
        for _ in range(times):
            self.led.on()
            sleep(delay)
            self.led.off()
            sleep(delay)

# Erstellen eines LED-Controllers
ledBlinker = LedBlinker('LED')

# LED blinken lassen
ledBlinker.blink(5, 0.5)

In diesem Beispiel wird eine Klasse LedBlinker erstellt, die eine LED steuern kann. Die Methode blink() lässt die LED eine bestimmte Anzahl von Malen blinken.

Wichtiger Hinweis

Die Besonderheit von for _ in diesem Kontext liegt darin, dass der Unterstrich (_) als Platzhalter für eine Variable verwendet wird, deren Wert im Schleifenrumpf nicht benötigt wird. Dies signalisiert, dass die Schleifenvariable ignoriert werden kann.

Aufgabe Funktionen zu Klassen

Nehmen Sie einen Sourcecode aus einem der Kapitel 3.1 - 3.6 und schreiben Sie den Sourcecode so um, dass eine Klasse genutzt wird.

Aufgabe

Erstellen Sie eine Klasse Ampel, die drei LEDs (rot, gelb, grün) steuert und die Farben entsprechend einer Ampelschaltung (rot -> gelb -> grün) umschaltet. Implementieren Sie eine Methode schalten(), die die Ampelschaltung durchführt.

Lösung 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
# Ampelsteuerung mit Klassen und Methoden
# Die Steuerung ist aber noch nicht "fertig". Hier nur rot -> grün
# J. Thomaschewski, 04.09.2024
from machine import Pin
from time import sleep

class Ampel:
    def __init__(self, rotPin, gelbPin, gruenPin):
        self.rot = Pin(rotPin, Pin.OUT)
        self.gelb = Pin(gelbPin, Pin.OUT)
        self.gruen = Pin(gruenPin, Pin.OUT)

    def schalten(self):
        self.rot.on()
        sleep(2)
        self.rot.off()
        self.gelb.on()
        sleep(1)
        self.gelb.off()
        self.gruen.on()
        sleep(2)
        self.gruen.off()

# Erstellen eines Ampel-Controllers
ampel = Ampel(15, 14, 13)

# Ampelschaltung durchführen
ampel.schalten()