Programming I - Object-Oriented Programming Flashcards

Grundlagen der Speicherung und Interpretation von Informationen

• Hardware-Komponenten eines Computers:

  • Prozessor (CPU / Central Processing Unit): Führt Befehle aus und führt arithmetische sowie logische Berechnungen durch.

  • Festplatte (HD / Hard Drive): Dient der dauerhaften (persistenten) Speicherung von Informationen.

  • Arbeitsspeicher (RAM / Random Access Memory): Bietet temporären Speicherplatz mit sehr schnellen Zugriffszeiten.

• Betriebssystem (OS / Operating System):

  • Sammlung von Software-Programmen, die das Zusammenspiel zwischen Hardware und Anwendungssoftware steuern und Schnittstellen bereitstellen.

  • Bekannte Betriebssysteme: Windows, macOS, Linux.

• Binärsystem und Datenrepräsentation:

  • Computer arbeiten im Binärsystem (Zweiersystem) ausschließlich mit den Werten $1$ (Strom fließt) und $0$ (kein Strom).

  • Ein Byte besteht aus $8$ Bits.

• Zahlen- und Zeichenkodierung:

  • Zeichencodierung (Encoding): Eindeutige Zuordnung von Zeichen (Buchstaben, Ziffern, Symbole) zu numerischen Zahlenwerten (Zeichencode).

  • Zeichensatz: Das Gesamtinventar der zu kodierenden Zeichen.

  • ASCII (American Standard Code for Information Interchange):

  • Ursprünglich ein $7\text{-Bit}$-Zeichensatz mit $2^7 = 128$ wählbaren Bitmustern (Positionen $0$ bis $31$ für Steuerzeichen, $127$ für das Löschzeichen DEL).

  • Das ursprüngliche $8\text{-te Bit}$ diente als Paritätsbit zur Fehlerkorrektur.

  • Erweiterung auf $8\text{-Bit}$ (ANSI / ISO-8859-1 bis ISO-8859-16) erlaubt $2^8 = 256$ Zeichen zur Abdeckung verschiedener Sprachräume (z. B. deutsche Umlaute).

  • Umwandlungsbeispiel Dezimal zu Binär: $128_{10} = 1 \times 2^7 + 0 \times 2^6 + 0 \times 2^5 + 0 \times 2^4 + 0 \times 2^3 + 0 \times 2^2 + 0 \times 2^1 + 0 \times 2^0 = 10000000_2$

  • Unicode (ISO-10646):

  • Internationaler Standard zur einheitlichen Kodierung aller bekannten Schriftkulturen und Zeichensysteme (inkl. Emojis).

  • Unterstützt bis zu $1114112$ verschiedene Zeichen.

  • Einmal aufgenommene Zeichen werden niemals wieder entfernt, um Datenlanglebigkeit zu garantieren.

  • UTF-8 (8-Bit Universal Coded Character Set Transformation Format):

  • Variable Kodierung mit $1$ bis $4$ Bytes pro Zeichen.

  • Vollständig abwärtskompatibel zu ASCII in den ersten $128$ Zeichen ($1$ Byte Speicherbedarf).

  • Standard im Internet für über $95\,\%$ aller Webseiten.

Vom Quellcode zum Programm

• Compiler:

  • Übersetzt Quellcode einer Programmiersprache vollständig in maschinenlesbaren Binärcode oder Assemblersprache vor der Ausführung.

  • Phasen der Übersetzung:

  • Lexikalische Analyse: Überprüfung des Codes und Extraktion von Programmsymbolen.

  • Syntaktische Analyse (Parsing): Überprüfung der Grammatik und Struktur des Quelltexts.

  • Semantische Analyse: Überprüfung der formalen Korrektheit und des Sinns des Quellcodes.

  • Vorteile: Höhere Ausführungsgeschwindigkeit zur Laufzeit, frühe Fehlererkennung vor Programmstart.

  • Sprachen mit Compiler: C, C++, Objective-C, Pascal, COBOL, Fortran.

• Interpreter:

  • Verarbeitet und interpretiert den Quellcode direkt zur Laufzeit Zeile für Zeile und Anweisung für Anweisung.

  • Erzeugt keine eigenständige ausführbare Binärdatei.

  • Vorteile: Leichtere Fehleranalyse (genaue Zeilenangabe bei Fehlern), plattformunabhängige Ausführbarkeit.

  • Nachteile: Langsamere Ausführung (Anweisungen in Schleifen werden bei jedem Durchlauf neu übersetzt).

  • Sprachen mit Interpreter: Python, Ruby, PHP, BASIC, Perl.

• Hybridlösungen und Just-in-Time (JIT) Compiler:

  • Kompilierung von Quellcode zur Laufzeit direkt in optimierten Maschinen- oder Binärcode.

  • Bytecode-Interpretation: Quellcode wird erst in einen Zwischencode (Bytecode) kompiliert und dann von einer virtuellen Maschine (z. B. Java Virtual Machine - JVM) interpretiert und ab definierten Ausführungsschwellen kompiliert.

  • Sprachen/Plattformen mit Hybridansatz: Java, C#, .NET Framework, Python.

Programmierparadigmen und Sprachübersicht

• Funktionale Programmierung:

  • Strukturierung von Programmen als Sequenz verschachtelter mathematischer Funktionen.

  • Auswertung von Ausdrücken steht im Vordergrund statt Befehlsausführung.

  • Vorteile: Leicht testbar, gut für parallele Ausführung, präzise und kurz.

  • Nachteile: Unveränderliche Daten, ineffizient bei Datenbankanbindungen oder großen Abfragen.

  • Sprachen: Erlang, LISP, Haskell, F#, Scala (auch Python, Ruby, Perl).

• Objektorientierte Programmierung (OOP):

  • Bündelung von Datenstrukturen (Attributen) und Operationen (Methoden) zu Objekten.

  • Einhalten des DRY-Prinzips („Don’t Repeat Yourself“).

  • Modellierung realer Objekte und deren Interaktionen über definierte Schnittstellen.

  • Vorteile: Hohe Modularität, einfache Wiederverwendbarkeit, geringere Fehleranfälligkeit.

  • Sprachen: Java, Python, C#, C++, JavaScript.

• Reaktive Programmierung:

  • Event-basiertes Paradigma fokussiert auf asynchrone Datenflüsse.

  • Ausbreitung von Datenänderungen über Ausführungs-Graphen:

  • Push: Automatische Übermittlung geänderter Daten.

  • Pull (Polling): Explizites Anfordern geänderter Daten durch den Empfänger.

  • Push-Pull: Benachrichtigung über Änderung gefolgt von gezielter Abfrage der Daten.

  • Frameworks: React, RxJS, Redux.NET.

• Übersicht klassischer Programmiersprachen:

  • C: Prozedural, hohe Performanz, hardwarenah, Basis für Betriebssysteme (UNIX/Linux) und Embedded Systems.

  • C++: Objektorientierte Erweiterung von C, unterstützt Mehrfachvererbung und maschinennahe Abstraktion.

  • C#: Von Microsoft für die .NET-Plattform entwickelt, kompiliert in CIL (Common Intermediate Language) und ausgeführt von der CLR.

  • Java: Objektorientiert, kompiliert in Bytecode für die Java Virtual Machine (JVM), plattformunabhängig („Write once, run anywhere“).

  • JavaScript: Interpretierte Skriptsprache des Web, läuft in einer Sandbox im Browser sowie serverseitig (Node.js).

  • PHP: Serverseitige Skriptsprache für dynamische Webseiten und Datenbankanbindungen.

  • Ruby: Objektorientierte Skriptsprache mit englischnaher Syntax und Frameworks wie Ruby on Rails.

  • Python: Universal einsetzbar, klare Einrückungssyntax, reichhaltige Bibliotheken für Data Science (pandas, numpy, scipy) und Machine Learning (scikit-learn, tensorflow).

Algorithmen und Entwicklungsumgebung

• Definition eines Algorithmus:

  • Eine eindeutige Handlungsvorschrift zur formalen Lösung eines Problems in endlich vielen Schritten, die eine bestimmte Eingabe in eine bestimmte Ausgabe überführt.

• Charakteristische Eigenschaften eines Algorithmus:

  • Eindeutigkeit: Keine mehrdeutigen oder widersprüchlichen Anweisungen.

  • Ausführbarkeit: Jeder Einzelschritt muss praktisch ausführbar sein.

  • Endlichkeit (Finitheit): Beendigung nach endlich vielen Schritten.

  • Determiniertheit: Gleiche Eingabe liefert stets das gleiche Ergebnis.

  • Determinismus: Der Folgeschritt ist zu jedem Zeitpunkt eindeutig festgelegt.

• Einrichtung von Visual Studio Code (VS Code) für Python:

  • Installation von VS Code und der offiziellen Python-Erweiterung (ms-python.python).

  • Unterstützung ab Python Version $3.4$ (Empfohlene Version: Python $3.9.5$).

  • Tastenkombinationen:

  • Befehlspalette öffnen: Strg + Umschalt + P

  • Neue Datei: Strg + N

  • Speichern: Strg + S (Endung .py aktiviert Syntax-Highlighting)

  • Ausführen ohne Debugging: F5 drop-down

Einführung in die Programmierung mit Python

• Aufbau von Python-Code & Pakete:

  • Organisation des Codes in Dateien mit der Endung .py (Module).

  • Zusammenfassung zusammengehöriger Module in Packages (Ordnerstruktur mit einer __init__.py-Datei).

  • Verwaltung externer Pakete über den Package Installer pip:

  • Windows-Befehl (Administrator): sudo python -m pip install numpy

  • macOS-Befehl: sudo pip install numpy

• Ausführung und IDLE:

  • Integrierte Lern- und Entwicklungsumgebung IDLE mit interaktiver Shell (>>>) und Editor.

  • Tastenkombinationen in IDLE: Alt + p (vorherige Anweisung), Alt + n (nächste Anweisung).

• Die Funktion print() & Ausgabesteuerung:

  • Standardfunktion zur Ausgabe von Werten auf der Konsole.

  • Leerer Aufruf print() erzeugt eine Leerzeile.

• Escape-Characters (Steuersequenzen):

  • Anführungszeichen maskieren: \" oder \'

  • Zeilenumbruch:

  • Tabulator: \t

  • Backslash maskieren: \\

• Reservierte Schlüsselwörter:

  • Wörter mit fester syntaktischer Bedeutung, die nicht als Variablennamen verwendet werden dürfen (z. B. and, as, assert, break, class, def, if, global, while, return).

• Programmstruktur & Einrückung (Indentation):

  • Einrückungstiefe ist syntaktisch zwingend vorgegeben (Standard: $4$ Leerzeichen pro Block).

  • Anweisungsblöcke werden durch einen Doppelpunkt (:) am Ende des Kopfes eingeleitet.

• Kommentare & Hilfe:

  • Einzeilige Kommentare mit #.

  • Mehrzeilige Kommentare oder Docstrings mit dreifachen Anführungszeichen ''' oder """.

  • Aufruf der eingebauten Hilfe-Funktion: help().

Datentypen, Strings und Reguläre Ausdrücke

• Numerische Datentypen:

  • int: Ganze Zahlen (z. B. $5$, $-42$).

  • float: Gleitkommazahlen mit Punkt als Dezimaltrenner (z. B. $3.14$, $1\text{e-}3$ für $0.001$).

  • bool: Boolesche Wahrheitswerte (True oder False). Evaluieren zu $1$ (True) bzw. $0$ (False).

• Werte, die zu False evaluieren:

  • Numerische $0$, leere Strings '', leere Listen [], leere Tupel (), leere Dictionaries {} und None.

• String-Verarbeitung & Slicing:

  • Strings sind unveränderliche (immutable) Sequenzen von Zeichen.

  • Länge ermitteln: len(s).

  • Indizierung beginnt bei $0$. Negative Indizes zählen von hinten ($-1$ entspricht dem letzten Zeichen).

  • Syntax für Slicing: s[start:stop:step] (Der Index stop ist exklusiv!).

• Wichtige String-Methoden:

  • s.upper(), s.lower(): Umwandlung in Groß-/Kleinbuchstaben.

  • s.strip(): Entfernt führende und nachstehende Leerzeichen/Whitespaces.

  • s.replace(alt, neu): Ersetzt Teilstrings.

  • s.split(trenner): Zerlegt einen String an Trennzeichen in eine Liste.

  • trenner.join(liste): Fügt eine Liste von Strings mit einem Trennzeichen zusammen.

• String-Formatierung (f-Strings):

  • Eingeführt in Python 3.6: f"Hallo {name}, du bist {alter} Jahre alt.".

  • Auswertung von Ausdrücken direkt zur Laufzeit innerhalb geschweifter Klammern ($2 \times 42 = 84$).

  • Maskierung geschweifter Klammern in f-Strings durch Dopplung: {{ und }}.

• Reguläre Ausdrücke (re-Modul):

  • Suche und Validierung von Mustern in Zeichenketten via import re.

  • Metazeichen: [] (Zeichenmenge), . (Beliebiges Zeichen außer Zeilenumbruch), ^ (Zeilenanfang), $ (Zeilenende), * ($\ge 0$ Vorkommen), + ($\ge 1$ Vorkommen), {n} (Exakt $n$ Vorkommen).

  • Spezielle Sequenzen: \d (Ziffern $0\text{--}9$), \D (Keine Ziffern), \s (Whitespace), \S (Kein Whitespace), \w (Wortzeichen: Buchstaben, Ziffern, Unterstrich), \W (Kein Wortzeichen).

  • Hauptfunktionen: re.search(), re.findall(), re.split(), re.sub().

Variablen, Literale und Operatoren

• Variablen & Namenskonventionen:

  • Eine Variable ist ein benannter Speicherplatz im RAM.

  • Namenskonventionen in Python:

  • snake_case: Für Variablennamen und Funktionen.

  • UpperCamelCase: Für Klassennamen.

  • CAPITALIZED_WITH_UNDERSCORES: Für Konstanten.

  • Führender Unterstrich _variable: Kennzeichnung als privat.

  • Variablennamen dürfen nicht mit einer Ziffer beginnen und keine Bindestriche oder Leerzeichen enthalten.

• Deklaration, Initialisierung und Zuweisung:

  • In Python erfolgt keine explizite Typdeklaration; der Typ ergibt sich dynamisch aus der Zuweisung.

  • Initialisierung: Erste Zuweisung eines Wertes an eine Variable.

• Lokale und Globale Variablen:

  • Variablen innerhalb einer Funktion sind lokal.

  • Verwenden des Schlüsselworts global innerhalb einer Funktion erlaubt die Modifikation globaler Variablen.

  • Das Schlüsselwort nonlocal erlaubt den Zugriff auf Variablen umschließender lokaler Funktions-Scopes.

• Literale:

  • Feste Werte im Quellcode: String-Literale ("Text"), Numerische Literale (Dezimal 50, Binär 0b10100, Oktal 0o320, Hexadezimal 0x12b), Boolean-Literale (True, False), Literal Collections (Listen, Tupel, Sets, Dictionaries), Spezielles Literal (None).

• Operatoren und Rangfolge:

  • Arithmetische Operatoren: Potenzierung **, Multiplikation *, Division /, Ganzzahl-Division //, Modulo (Rest) %, Addition +, Subtraktion -.

  • Bitweise Operatoren: Komplement ~, Shift <<, >>, Bitweises UND &, XOR ^, ODER |.

  • Vergleichsoperatoren: ==, !=, <, <=, >, >=.

Datenstrukturen in Python

• Listen (list):

  • Geordnete, veränderbare (mutable) Sammlung von Elementen in eckigen Klammern [].

  • Erlaubt Duplikate und unterschiedliche Datentypen.

  • Wichtige Methoden: append(), insert(index, elem), extend(), remove(wert), pop(index), clear(), sort(), reverse(), copy().

• Arrays:

  • Müssen über Module (array oder numpy) importiert werden.

  • Speichern Daten kompakter und sind für mathematisch-numerische Vektoroperationen optimiert.

• Tupel (tuple):

  • Geordnete, unveränderliche (immutable) Sammlung in runden Klammern ().

  • Packing: Zuweisung mehrerer Werte an ein Tupel.

  • Unpacking: Entpacken von Tupel-Werten in einzelne Variablen (Verwendung von *var für Restlisten).

  • Methoden: count(), index().

• Mengen (set):

  • Ungeordnete, nicht indizierte Sammlung eindeutiger Elemente in geschweiften Klammern {}.

  • Duplikate werden automatisch entfernt.

  • Methoden & Mengenoperationen: add(), remove(), discard(), union() (Vereinigung), intersection() (Schnittmenge), difference() (Differenz), symmetric_difference() (Symmetrische Differenz).

• Dictionaries (dict):

  • Geordnete Sammlung von Schlüssel-Wert-Paaren (key: value) in geschweiften Klammern.

  • Schlüssel müssen eindeutig und unveränderbar sein.

  • Zugriff auf Werte über Schlüssel d[key] oder d.get(key).

  • Methoden: keys(), values(), items(), update(), pop(), clear().

Kontrollstrukturen, Schleifen und Funktionen

• Anweisungsblöcke & Fallunterscheidungen:

  • Verzweigungen mit if, elif und else.

  • Die pass-Anweisung dient als Platzhalter für leere Blöcke.

• Schleifen:

  • while-Schleife: Wiederholte Ausführung, solange eine Bedingung True ist.

  • for-Schleife: Iteration über Elemente einer Sequenz.

  • range(start, stop, step): Erzeugt eine unveränderliche Zahlenfolge (Stopp-Wert exklusiv).

• Schleifensteuerung: break (sofortiger Abbruch), continue (Sprung zur nächsten Iteration), else-Block nach Schleifen (wird ausgeführt, wenn die Schleife regulär ohne break beendet wurde).

  • Funktionen und Methoden:

• Definition mit def funktion_name(parameter):.

• Beliebige Anzahl von Argumenten (*args als Tupel) und Schlüsselwortargumenten (**kwargs als Dictionary).

• Rückgabe von Werten über return.

• Dokumentation über Docstrings ("""Doku""").

• Unterschied Funktion vs. Methode: Funktionen werden direkt aufgerufen (funktion()), Methoden sind an ein Objekt gebunden (objekt.methode()).

Rekursion und praktische Programmierkonzepte

• Rekursion:

  • Eine Funktion, die sich direkt oder indirekt selbst aufruft.

  • Benötigt zwingend eine Basis- oder Abbruchbedingung zur Verhinderung von Endlosrekursionen.

  • Maximale Rekursionstiefe in Python ist standardmäßig auf $1000$ beschränkt.

  • Mathematische Darstellung der Fakultät $f(n) = n!$:     $f(n) = \begin{cases} 1 & \text{falls } n = 1 \\ n \times f(n - 1) & \text{falls } n > 1 \end{cases}$

Objektorientierte Programmierung

• Modularisierung:

  • Aufteilung von Code in wiederverwendbare Module (.py-Dateien) und Packages.

  • Einbinden via import modul, from modul import funktion, import modul as alias.

• Klassen und Objekte:

  • Klasse: Abstrakte Bauanleitung / Schablone.

  • Objekt / Instanz: Konkrete Ausprägung einer Klasse im Speicher.

• Konstruktor (__init__): Spezialmethode zur Initialisierung von Objektattributen. Der erste Parameter ist stets self (Referenz auf die aktuelle Instanz).

• Klassenattribute vs. Instanzattribute: Klassenattribute gelten global für alle Instanzen der Klasse; Instanzattribute sind individuell pro Objekt.

  • Statische Methoden & Vererbung:

• Statische Methoden werden mit @staticmethod oder staticmethod() deklariert und benötigen kein self.

• Vererbung: Ableitung von Unterklassen aus Basisklassen zur Code-Wiederverwendung.

• Mehrfachvererbung: Eine Klasse erbt von mehreren Elternklassen.

• Aufzählungstyp (Enum):

  • Aus dem Modul enum: Erstellung unveränderlicher Aufzählungstypen mit symbolischen Konstanten zur Erhöhung der Typsicherheit und Lesbarkeit.

Fehler- und Ausnahmebehandlung sowie Dateiverarbeitung

• Fehlerarten:

  • Syntaxfehler: Verstöße gegen die Grammatik der Programmiersprache (werden vor der Ausführung erkannt).

  • Semantische / Laufzeitfehler: Fehler während der Programmausführung (z. B. Division durch Null, KeyError, TypeError).

• Assertions:

  • Aufstellen von Bedingungen mit assert bedingung, "Fehlermeldung". Löst bei False einen AssertionError aus.

• Ausnahmebehandlung (try / except / else / finally):

  • try: Enthält den auszuführenden, potenziell fehleranfälligen Code.

  • except ExceptionType as e: Fängt spezifische Ausnahmen ab.

  • else: Wird nur ausgeführt, wenn im try-Block KEINE Exception aufgetreten ist.

  • finally: Wird in jedem Fall ausgeführt (ideal zum Freigeben von Ressourcen).

• Dateiverarbeitung:

  • Öffnen mit open(dateiname, modus):

  • Modi: 'r' (Lesen), 'w' (Schreiben/Überschreiben), 'a' (Anhängen), 'x' (Erstellen), Textmodus 't', Binärmodus 'b'.

  • Methoden: read(), readline(), write(), close().

  • Sichere Verwendung mit Kontextmanager: with open(...) as datei:.

Netzwerkkommunikation

• Grundlagen & Schichtenmodell:

  • Abstrakte Hierarchie von Netzwerkprotokollen (OSI-Modell / TCP/IP-Stack).

• IP-Adressen & Ports:

  • IP-Adresse: Eindeutige logische Adresse eines Geräts im Netzwerk (z. B. 192.168.0.100).

  • Port: $16\text{-Bit}$-Nummer ($0$ bis $2^{16}-1 = 65535$) zur Adressierung eines spezifischen Prozesses auf dem Zielrechner. Freie Ports ab $50000$.

• Client-Server-Modell vs. Peer-to-Peer:

  • Client stellt aktive Anfragen; Server lauscht passiv auf eingehende Verbindungen.

• Netzwerkprotokolle:

  • UDP (User Datagram Protocol): Verbindungslos, unzuverlässig, schnell, geringer Overhead (geeignet für Audio/Video-Streaming).

  • TCP (Transmission Control Protocol): Verbindungsorientiert, zuverlässig, garantiert Paketreihenfolge und Fehlerkorrektur (geeignet für Web, Dateiübertragung, E-Mail).

Parallele Programmierung

• Prozesse vs. Threads:

  • Prozess: Eigenständiger Ablaufkontext mit eigenem Speicherbereich.

  • Thread: Leichtgewichtiger Ausführungsstrang innerhalb eines Prozesses; teilt sich den Speicherbereich (globale Variablen) mit anderen Threads desselben Prozesses.

• Thread-Steuerung mit threading:

  • Erstellen durch Vererbung von threading.Thread und Überschreiben von run().

  • Methoden: start() (startet Thread), join() (wartet auf Beendigung), isAlive().

• Thread-Synchronisation & Critical Sections:

  • Race Condition: Unkontrollierte parallele Schreibzugriffe auf gemeinsame Variablen führen zu inkonsistenten Daten.

  • Locking: Erzeugen von Sperrobjekten lock = threading.Lock().

  • Methoden: acquire() (Sperre anfordern), release() (Sperre freigeben) oder Verwendung des with lock:-Blocks.

  • Deadlock: Verklemmung, bei der zwei oder mehr Threads wechselseitig auf Ressourcen warten, die vom jeweils anderen gesperrt sind.

• Multiprocessing:

  • Verwenden des Moduls multiprocessing zur Verteilung der Rechenlast auf mehrere physische Prozessorkerne.

Grafische Benutzeroberflächen mit Tkinter

• Grundlagen der GUI-Programmierung:

  • Grafische Benutzeroberflächen bestehen aus Fenstern und Steuerelementen (Widgets).

• Tkinter ist die Standard-GUI-Bibliothek in Python.

• Ausführung der Ereignisschleife über window.mainloop().

  • Wichtige Tkinter-Widgets:

• Label: Anzeige von nicht editierbarem Text oder Bildern.

• Button: Anklickbare Schaltfläche zur Ausführung von Befehlen.

• Checkbutton: Kontrollkästchen für Zwei-Zustand-Auswahlen (aktiviert/deaktiviert).

• Radiobutton: Optionsfeld für Exklusivauswahlen innerhalb einer Gruppe.

• Entry: Einzeiliges Texteingabefeld (get(), insert(), delete()).

• Text: Mehrzeiliges Textfeld (Indizierung im Format 'zeile.zeichen', z. B. '1.0').

• Frame: Behälter-Widget zur Gruppierung und Strukturierung anderer Widgets.

• Geometriemanager:

  • pack(): Anordnung entlang der Seiten (side=TOP/BOTTOM/LEFT/RIGHT, fill=X/Y/BOTH).

  • place(): Absolute Positionierung nach Pixelkoordinaten (x, y).

  • grid(): Rasterbasierte Anordnung (row, column, padx, pady, sticky='nsew').

  • Responsives Raster: window.columnconfigure(index, weight=1, minsize=pixel) und window.rowconfigure(index, weight=1, minsize=pixel).

• Event-Handling:

  • Binden von Ereignissen mit widget.bind('<Ereignis>', handler_funktion).

  • Befehlsbindung bei Buttons via command=funktion.