MENU
  1. Startseite
  2. Python
  3. Eine vollständige Anleitung zu Ereignisbehandlung und Callback in Python

Eine vollständige Anleitung zu Ereignisbehandlung und Callback in Python

Python

Python ist eine beliebte Programmiersprache, die für ihre Einfachheit und leistungsstarken Funktionen bekannt ist. Die Konzepte der Ereignisbehandlung und Callbacks sind jedoch wichtige Themen, die man verstehen sollte, um fortgeschrittenere Programmierung zu betreiben. In diesem Artikel werden wir die grundlegenden Konzepte der Ereignisbehandlung und Callbacks in Python sowie praktische Anwendungsbeispiele ausführlich erklären. Dadurch können die Leser lernen, wie sie mit Python-Klassen effizient Ereignisse verarbeiten können.

Inhaltsverzeichnis

Was ist Ereignisbehandlung?

Ereignisbehandlung ist der Mechanismus, durch den ein Programm bestimmte „Ereignisse“ erkennt und entsprechende Aktionen ausführt. Ein Ereignis bezieht sich auf Aktionen oder Vorkommnisse, die im Programm auftreten, wie z.B. Benutzereingaben oder Änderungen des Systemstatus. Die Ereignisbehandlung spielt insbesondere bei der Entwicklung von GUI-Anwendungen oder Spielen eine wichtige Rolle.

Durch das Verständnis der Ereignisbehandlung können Entwickler die Reaktionsfähigkeit der Benutzeroberfläche verbessern und intuitivere und interaktivere Anwendungen erstellen. Konkret ermöglicht es, geeignete Aktionen für Ereignisse wie das Klicken auf Schaltflächen, Mausbewegungen oder das Drücken von Tasten auszuführen.

Grundlagen der Ereignisbehandlung in Python

In Python werden zur Implementierung der Ereignisbehandlung üblicherweise Klassen und Methoden verwendet. Nachfolgend sind die grundlegenden Schritte zur Implementierung einer einfachen Ereignisbehandlung in Python aufgeführt.

Erstellen eines einfachen Ereignishandlers

Zuerst wird eine Handler-Funktion definiert, die das Ereignis verarbeitet. Diese Funktion ist eine Methode, die aufgerufen wird, wenn ein bestimmtes Ereignis eintritt.

def on_event(event):  
    print(f"Ereignis {event} ist aufgetreten")

Auslösen eines Ereignisses

Als nächstes wird die Methode zum Auslösen des Ereignisses definiert. Normalerweise geschieht dies innerhalb einer anderen Methode oder Funktion.

def trigger_event():  
    event = "TestEreignis"  
    on_event(event)

Ereignisbehandlung mit Klassen

Ereignisbehandlung kann mithilfe von Klassen auf eine strukturiertere Weise implementiert werden. Nachfolgend ist ein einfaches Beispiel für die Verwendung einer Klasse zur Ereignisbehandlung dargestellt.

class EreignisHandler:  
    def __init__(self):  
        self.event_listeners = []  

    def add_listener(self, listener):  
        self.event_listeners.append(listener)  

    def trigger_event(self, event):  
        for listener in self.event_listeners:  
            listener(event)  

def on_event(event):  
    print(f"Ereignis {event} ist aufgetreten")  

handler = EreignisHandler()  
handler.add_listener(on_event)  
handler.trigger_event("TestEreignis")

In diesem Beispiel verwaltet die EreignisHandler-Klasse die Ereignis-Listener und ruft sie auf, wenn ein Ereignis eintritt. Auf diese Weise können mehrere Ereignis-Listener verwaltet werden, die bei Eintreten eines Ereignisses entsprechende Aktionen ausführen.

Was ist eine Callback-Funktion?

Eine Callback-Funktion ist eine Funktion, die aufgerufen wird, wenn ein bestimmtes Ereignis eintritt. Callbacks werden an andere Funktionen übergeben und später innerhalb dieser Funktionen ausgeführt. Durch die Verwendung von Callback-Funktionen kann der Code flexibler und wiederverwendbarer gestaltet werden.

Ein einfaches Beispiel für eine Callback-Funktion

Im folgenden Beispiel wird eine Callback-Funktion callback an die Funktion process_event übergeben, die sie aufruft, wenn ein Ereignis eintritt.

def callback(event):  
    print(f"Callback wurde mit Ereignis aufgerufen: {event}")  

def process_event(event, callback):  
    # Ereignis verarbeiten  
    print(f"Verarbeite Ereignis: {event}")  
    # Callback aufrufen  
    callback(event)  

event = "TestEreignis"  
process_event(event, callback)

In diesem Beispiel verarbeitet die Funktion process_event das Ereignis und ruft anschließend die Callback-Funktion auf. Dadurch können die zugehörigen Aktionen flexibel definiert werden.

Vorteile von Callback-Funktionen

Die Hauptvorteile der Verwendung von Callback-Funktionen sind:

  • Erhöhte Flexibilität: Da das Verhalten der Funktion von außen gesteuert werden kann, können unterschiedliche Aktionen einfach ausgeführt werden.
  • Erhöhte Wiederverwendbarkeit: Callback-Funktionen werden als unabhängige Funktionen definiert und können in anderen Teilen des Programms wiederverwendet werden.
  • Vereinfachung asynchroner Verarbeitung: Bei der Verarbeitung von asynchronen Aufgaben können Callback-Funktionen verwendet werden, um eine bestimmte Funktion nach Abschluss einer Aufgabe auszuführen.

Auf diese Weise spielen Callback-Funktionen eine wichtige Rolle in ereignisgesteuerter Programmierung und asynchroner Verarbeitung.

Implementierung von Callback-Funktionen in Python

Die Implementierung von Callback-Funktionen in Python ist sehr einfach. Eine Funktion wird als Argument übergeben und bei Eintreten eines bestimmten Ereignisses aufgerufen. Im Folgenden wird anhand eines Beispiels gezeigt, wie Callback-Funktionen in Python implementiert werden können.

Grundlegende Implementierung einer Callback-Funktion

Im folgenden Beispiel wird gezeigt, wie eine Callback-Funktion aufgerufen wird, wenn ein Ereignis eintritt.

def my_callback(event):  
    print(f"Callback wurde mit Ereignis aufgerufen: {event}")  

def trigger_event(callback):  
    event = "TestEreignis"  
    print(f"Ereignis auslösen: {event}")  
    callback(event)  

trigger_event(my_callback)

In diesem Beispiel löst die Funktion trigger_event ein Ereignis aus und ruft die Funktion my_callback auf. Wenn das Ereignis eintritt, wird die Callback-Funktion ausgeführt und die Ereignisinformationen werden ausgegeben.

Implementierung von Callback-Funktionen mit Klassen

Im nächsten Beispiel wird gezeigt, wie Callback-Funktionen mithilfe von Klassen implementiert werden können. Durch die Verwendung von Klassen wird eine strukturiertere Ereignisbehandlung ermöglicht.

class EreignisVerarbeiter:  
    def __init__(self):  
        self.callback = None  

    def register_callback(self, callback):  
        self.callback = callback  

    def process_event(self, event):  
        print(f"Verarbeite Ereignis: {event}")  
        if self.callback:  
            self.callback(event)  

def my_callback(event):  
    print(f"Callback wurde mit Ereignis aufgerufen: {event}")  

processor = EreignisVerarbeiter()  
processor.register_callback(my_callback)  
processor.process_event("TestEreignis")

In diesem Beispiel verwaltet die EreignisVerarbeiter-Klasse die Callback-Funktion. Mit der Methode register_callback wird die Callback-Funktion registriert, und die Methode process_event verarbeitet das Ereignis. Wenn das Ereignis eintritt, wird die registrierte Callback-Funktion aufgerufen.

Praktisches Beispiel: Verwenden von Callback-Funktionen beim Datei-Handling

Callback-Funktionen sind besonders nützlich bei asynchroner Verarbeitung und ereignisgesteuerten Programmen. Im folgenden Beispiel wird eine Callback-Funktion beim Abschluss des Datei-Ladevorgangs verwendet.

def read_file_async(filename, callback):  
    import threading  

    def read_file():  
        with open(filename, 'r') as file:  
            data = file.read()  
        callback(data)  

    thread = threading.Thread(target=read_file)  
    thread.start()  

def on_file_read(data):  
    print("Dateiinhalte erhalten:")  
    print(data)  

read_file_async('beispiel.txt', on_file_read)

In diesem Beispiel lädt die Funktion read_file_async eine Datei asynchron und ruft beim Abschluss der Dateioperation die Callback-Funktion on_file_read auf. Auf diese Weise kann eine bestimmte Aktion nach Abschluss der asynchronen Verarbeitung ausgeführt werden.

Auf diese Weise kann die Implementierung von Callback-Funktionen in Python in verschiedenen Szenarien eingesetzt werden.

Ereignisbehandlung mit Klassen

Die Ereignisbehandlung mithilfe von Klassen nutzt die Vorteile der objektorientierten Programmierung und verbessert die Wiederverwendbarkeit und Wartbarkeit des Codes. In diesem Abschnitt wird erläutert, wie man die Ereignisbehandlung in Python mit Klassen implementieren kann.

Grundlagen der Ereignisbehandlung

Zunächst wird eine Klasse definiert, die den Ereignishandler verwaltet. Diese Klasse ermöglicht das Registrieren von Ereignis-Listenern und ruft diese bei Eintreten eines Ereignisses auf.

class EreignisHandler:  
    def __init__(self):  
        self.listeners = []  

    def add_listener(self, listener):  
        self.listeners.append(listener)  

    def remove_listener(self, listener):  
        self.listeners.remove(listener)  

    def notify_listeners(self, event):  
        for listener in self.listeners:  
            listener(event)

Verwendung der Ereignisbehandlung in einer Klasse

Als nächstes wird eine Klasse erstellt, die den Ereignishandler verwendet. Diese Klasse löst bei bestimmten Ereignissen den Ereignishandler aus.

class Button:  
    def __init__(self):  
        self.event_handler = EreignisHandler()  

    def click(self):  
        event = "Schaltfläche geklickt"  
        print(event)  
        self.event_handler.notify_listeners(event)  

    def add_click_listener(self, listener):  
        self.event_handler.add_listener(listener)  

    def remove_click_listener(self, listener):  
        self.event_handler.remove_listener(listener)

Implementierung des Ereignis-Listeners

Als nächstes wird der Ereignis-Listener implementiert, der ausgeführt wird, wenn ein bestimmtes Ereignis eintritt.

def on_button_click(event):  
    print(f"Ereignis erhalten: {event}")

Registrierung und Verwendung des Ereignishandlers

Zum Schluss wird gezeigt, wie man den Listener für das Klickereignis der Schaltfläche registriert und bei einem Klick das Ereignis auslöst.

button = Button()  
button.add_click_listener(on_button_click)  
button.click()  # "Schaltfläche geklickt" und "Ereignis erhalten: Schaltfläche geklickt" werden angezeigt

Durch die Implementierung der Ereignisbehandlung mit Klassen kann der Code flexibler und erweiterbarer gestaltet werden. Ein gut konzipierter Ereignishandler ermöglicht die Verwaltung mehrerer Listener und das Ausführen verschiedener Aktionen bei einem Ereignis.

Praktisches Beispiel: Einfache Ereignisbehandlung

Hier wird ein einfaches Beispiel für die Erstellung eines Ereignishandlers Schritt für Schritt beschrieben. In diesem Beispiel wird ein einfaches System zur Verarbeitung des Klickereignisses einer Schaltfläche erstellt.

Schritt 1: Erstellen der Ereignishandler-Klasse

Zunächst wird eine grundlegende Ereignishandler-Klasse erstellt, die die Listener verwaltet.

class EinfacherEreignisHandler:  
    def __init__(self):  
        self.listeners = []  

    def add_listener(self, listener):  
        self.listeners.append(listener)  

    def notify_listeners(self, event):  
        for listener in self.listeners:  
            listener(event)

Schritt 2: Erstellen der Button-Klasse

Als nächstes wird eine Klasse erstellt, die eine Schaltfläche darstellt. Diese Klasse löst das Klickereignis aus und ruft den Ereignishandler auf.

class Button:  
    def __init__(self):  
        self.click_event_handler = EinfacherEreignisHandler()  

    def click(self):  
        print("Schaltfläche wurde geklickt!")  
        self.click_event_handler.notify_listeners("Schaltfläche geklickt")  

    def add_click_listener(self, listener):  
        self.click_event_handler.add_listener(listener)

Schritt 3: Erstellen der Listener-Funktion

Nun wird eine Listener-Funktion erstellt, um das Klickereignis der Schaltfläche zu verarbeiten.

def on_button_click(event):  
    print(f"Ereignis erhalten: {event}")

Schritt 4: Registrieren des Listeners bei der Schaltfläche

Zuletzt wird die Listener-Funktion für das Klickereignis der Schaltfläche registriert und die Schaltfläche wird geklickt, um das Ereignis auszulösen.

button = Button()  
button.add_click_listener(on_button_click)  
button.click()  # "Schaltfläche wurde geklickt!" und "Ereignis erhalten: Schaltfläche geklickt" werden angezeigt

Dieses Schritt-für-Schritt-Beispiel hilft dabei, die grundlegende Struktur und Funktionsweise der Ereignisbehandlung zu verstehen. Auf Basis dieses einfachen Beispiels können komplexere Ereignisverarbeitungssysteme aufgebaut werden. Indem man die Grundlagen der Ereignisbehandlung beherrscht, kann man interaktivere und reaktionsschnellere Anwendungen entwickeln.

Anwendungsbeispiel: Ereignisbehandlung in GUI-Anwendungen

In diesem Abschnitt wird ein Anwendungsbeispiel für die Ereignisbehandlung in einer GUI-Anwendung vorgestellt. Wir verwenden die Tkinter-Bibliothek in Python, um eine einfache GUI-Anwendung zu erstellen und das Klickereignis einer Schaltfläche zu verarbeiten.

Schritt 1: Importieren der Tkinter-Bibliothek und Grundkonfiguration

Zuerst wird die Tkinter-Bibliothek importiert und ein grundlegendes Fenster konfiguriert.

import tkinter as tk  

# Erstellen des Fensters  
root = tk.Tk()  
root.title("Beispiel für Ereignisbehandlung")  
root.geometry("300x200")

Schritt 2: Definition des Ereignishandlers

Als nächstes wird ein Ereignishandler definiert, um das Klickereignis der Schaltfläche zu verarbeiten.

def on_button_click():  
    print("Schaltfläche wurde geklickt!")  
    label.config(text="Schaltfläche geklickt!")

Schritt 3: Erstellen und Platzieren der Schaltfläche

Jetzt wird eine Schaltfläche erstellt und im Fenster platziert. Diese Schaltfläche wird mit dem Ereignishandler für das Klickereignis verbunden.

button = tk.Button(root, text="Klick mich", command=on_button_click)  
button.pack(pady=20)

Schritt 4: Erstellen und Platzieren des Labels

Ein Label wird erstellt und im Fenster platziert, um später durch den Ereignishandler aktualisiert zu werden.

label = tk.Label(root, text="Schaltfläche wurde noch nicht geklickt")  
label.pack(pady=20)

Schritt 5: Starten der Ereignisschleife

Zum Schluss wird die Ereignisschleife von Tkinter gestartet, um die GUI-Anwendung auszuführen.

# Starten der Ereignisschleife  
root.mainloop()

Komplettes Codebeispiel

Das vollständige Codebeispiel, das alle oben genannten Schritte umfasst, sieht wie folgt aus:

import tkinter as tk  

def on_button_click():  
    print("Schaltfläche wurde geklickt!")  
    label.config(text="Schaltfläche geklickt!")  

# Erstellen des Fensters  
root = tk.Tk()  
root.title("Beispiel für Ereignisbehandlung")  
root.geometry("300x200")  

# Erstellen und Platzieren der Schaltfläche  
button = tk.Button(root, text="Klick mich", command=on_button_click)  
button.pack(pady=20)  

# Erstellen und Platzieren des Labels  
label = tk.Label(root, text="Schaltfläche wurde noch nicht geklickt")  
label.pack(pady=20)  

# Starten der Ereignisschleife  
root.mainloop()

In diesem Beispiel erstellen wir mit Tkinter eine einfache GUI-Anwendung, die das Klickereignis einer Schaltfläche verarbeitet. Wenn die Schaltfläche geklickt wird, wird der Ereignishandler aufgerufen und der Text des Labels aktualisiert. Auf diese Weise verbessert die Ereignisbehandlung in GUI-Anwendungen die Reaktionsfähigkeit der Benutzeroberfläche und das Benutzererlebnis.

Häufige Probleme und deren Lösungen

Bei der Verwendung von Ereignisbehandlung und Callbacks können häufig auftretende Probleme auftreten. In diesem Abschnitt werden diese Probleme und ihre Lösungen erläutert, um robusteren und fehlerärmeren Code zu schreiben.

Problem 1: Speicherleck

Wenn Ereignis-Listener registriert, aber nicht entfernt werden, wenn sie nicht mehr benötigt werden, können unnötige Listener weiterhin Speicher belegen. Dies kann zu einem Speicherleck führen.

Lösung

Stellen Sie sicher, dass die Ereignis-Listener ordnungsgemäß verwaltet und bei Nichtgebrauch entfernt werden.

class EreignisHandler:  
    def __init__(self):  
        self.listeners = []  

    def add_listener(self, listener):  
        self.listeners.append(listener)  

    def remove_listener(self, listener):  
        self.listeners.remove(listener)  

    def notify_listeners(self, event):  
        for listener in self.listeners:  
            listener(event)  

handler = EreignisHandler()  

def on_event(event):  
    print(f"Ereignis erhalten: {event}")  

handler.add_listener(on_event)  
# Entfernen des Listeners, wenn er nicht mehr benötigt wird  
handler.remove_listener(on_event)

Problem 2: Ausführungsreihenfolge von Callbacks

Wenn mehrere Callbacks registriert sind, kann die Reihenfolge ihrer Ausführung wichtig sein. Eine unerwartete Reihenfolge kann Fehler verursachen.

Lösung

Kontrollieren Sie die Ausführungsreihenfolge der Callbacks explizit oder legen Sie bei Bedarf Prioritäten fest.

class PrioritätsEreignisHandler:  
    def __init__(self):  
        self.listeners = []  

    def add_listener(self, listener, priority=0):  
        self.listeners.append((priority, listener))  
        self.listeners.sort(reverse=True)  # Nach Priorität sortieren  

    def notify_listeners(self, event):  
        for _, listener in self.listeners:  
            listener(event)  

handler = PrioritätsEreignisHandler()  

def high_priority_listener(event):  
    print(f"Hohe Priorität: {event}")  

def low_priority_listener(event):  
    print(f"Niedrige Priorität: {event}")  

handler.add_listener(low_priority_listener, priority=1)  
handler.add_listener(high_priority_listener, priority=10)  

handler.notify_listeners("TestEreignis")

Problem 3: Ausnahmebehandlung

Wenn innerhalb der Callback-Funktion eine Ausnahme auftritt, kann das gesamte Programm abstürzen.

Lösung

Führen Sie die Ausnahmebehandlung innerhalb der Callback-Funktion durch, damit das Programm auch bei Fehlern weiterhin funktioniert.

def safe_callback(event):  
    try:  
        # Verarbeitung der Callback-Funktion  
        print(f"Verarbeite Ereignis: {event}")  
        # Hier kann eine Ausnahme auftreten  
    except Exception as e:  
        print(f"Fehler bei der Verarbeitung des Ereignisses: {e}")  

handler = EreignisHandler()  
handler.add_listener(safe_callback)  
handler.notify_listeners("TestEreignis")

Problem 4: Starke Kopplung

Wenn der Ereignishandler und die Listener stark gekoppelt sind, wird es schwierig, den Code zu ändern.

Lösung

Schaffen Sie eine Schnittstelle zwischen dem Ereignishandler und den Listenern, um eine lose Kopplung zu erreichen.

class EreignisListener:  
    def on_event(self, event):  
        pass  

class KonkreterListener(EreignisListener):  
    def on_event(self, event):  
        print(f"Ereignis erhalten: {event}")  

listener = KonkreterListener()  
handler.add_listener(listener.on_event)  
handler.notify_listeners("TestEreignis")

Durch die Umsetzung dieser Lösungen können häufig auftretende Probleme bei der Implementierung von Ereignisbehandlung und Callback-Funktionen vermieden werden, um robusteren Code zu erstellen.

Übungsaufgaben

Durch die folgenden Übungsaufgaben können Sie Ihr Verständnis für Ereignisbehandlung und Callback-Funktionen in Python vertiefen. Das Schreiben von Code hilft dabei, Theorie in die Praxis umzusetzen.

Übung 1: Implementierung eines einfachen Ereignishandlers

Implementieren Sie einen einfachen Ereignishandler gemäß den folgenden Schritten.

  1. Erstellen Sie eine Klasse EinfacherEreignisHandler, um Ereignis-Listener zu verwalten.
  2. Erstellen Sie eine Klasse Button, um das Klickereignis auszulösen.
  3. Erstellen Sie eine Listener-Funktion, um das Klickereignis zu verarbeiten.
  4. Registrieren Sie den Listener bei der Schaltfläche und lösen Sie das Klickereignis aus.

Erwartete Ausgabe:

Schaltfläche wurde geklickt!  
Ereignis erhalten: Schaltfläche geklickt
# Ihre Implementierung hier

Übung 2: Implementierung eines Prioritätsereignishandlers

Implementieren Sie einen Prioritätsereignishandler gemäß den folgenden Schritten.

  1. Erstellen Sie eine Klasse PrioritätsEreignisHandler, um die Listener nach Priorität zu verwalten.
  2. Erstellen Sie Listener-Funktionen für hohe und niedrige Prioritäten.
  3. Registrieren Sie die Listener beim Ereignishandler und lösen Sie das Ereignis aus.

Erwartete Ausgabe:

Hohe Priorität: TestEreignis  
Niedrige Priorität: TestEreignis
# Ihre Implementierung hier

Übung 3: Implementierung einer Callback-Funktion mit Ausnahmebehandlung

Implementieren Sie eine Callback-Funktion mit Ausnahmebehandlung gemäß den folgenden Schritten.

  1. Erstellen Sie eine Funktion safe_callback, die eine Ausnahmebehandlung enthält.
  2. Registrieren Sie safe_callback beim Ereignishandler und lösen Sie ein Ereignis aus, das eine Ausnahme verursacht.

Erwartete Ausgabe:

Verarbeite Ereignis: TestEreignis  
Fehler bei der Verarbeitung des Ereignisses: simulierte Ausnahme
# Ihre Implementierung hier

Übung 4: Ereignisbehandlung in einer GUI-Anwendung

Erstellen Sie eine GUI-Anwendung mit Tkinter gemäß den folgenden Schritten.

  1. Erstellen Sie ein Fenster und platzieren Sie eine Schaltfläche darin.
  2. Erstellen Sie einen Listener für das Klickereignis der Schaltfläche, der den Text eines Labels aktualisiert.

Erwartete Ausgabe:

  • Beim Klicken auf die Schaltfläche wird das Label aktualisiert.
  • Die Konsole zeigt „Schaltfläche wurde geklickt!“ an.
# Ihre Implementierung hier

Durch diese Übungen können Sie praktische Erfahrungen mit Ereignisbehandlung und Callback-Funktionen in Python sammeln. Durch das Lösen der Aufgaben können Sie Ihre Fähigkeiten verbessern und dieses Wissen für die Entwicklung komplexerer Anwendungen nutzen.

Zusammenfassung

In diesem Artikel haben wir die grundlegenden Konzepte der Ereignisbehandlung und Callback-Funktionen in Python sowie konkrete Implementierungsmethoden und Anwendungsbeispiele ausführlich erläutert. Die wichtigsten Punkte sind zusammengefasst:

  • Grundlagen der Ereignisbehandlung: Ereignisse sind Aktionen oder Zustandsänderungen im Programm, die mit Ereignisbehandlung verarbeitet werden.
  • Callback-Funktionen: Diese werden aufgerufen, wenn ein bestimmtes Ereignis eintritt und erhöhen die Flexibilität und Wiederverwendbarkeit des Codes.
  • Implementierung mit Klassen: Durch die Verwaltung von Ereignis-Handlern und Callback-Funktionen in Klassen wird der Code besser strukturiert und wartbarer.
  • Praktische Beispiele und Anwendungsfälle: Wir haben einfache Implementierungen sowie Beispiele für GUI-Anwendungen mit Tkinter vorgestellt.
  • Häufige Probleme und Lösungen: Speicherlecks, Ausnahmebehandlung und Reihenfolge der Callback-Ausführung wurden behandelt.
  • Übungsaufgaben: Diese halfen dabei, das theoretische Wissen in die Praxis umzusetzen.

Durch die Anwendung dieses Wissens können Entwickler effizientere und reaktionsschnellere Programme in Python erstellen. Ereignisbehandlung und Callback-Funktionen sind wesentliche Bestandteile für die Entwicklung interaktiver Anwendungen. Üben Sie weiter und integrieren Sie diese Konzepte in Ihre eigenen Projekte.

Python
Inhaltsverzeichnis