BERUFSSCHULE BS1IN

Grundlagen SW-Entwicklung - IT-TEC-ENT

39 min read

BS1IN IT-TEC-ENT Schneider BW1

Grundlagen der Softwareentwicklung

  1. Einführung in die Softwareentwicklung Bedeutung und Ziele der Softwareentwicklung Softwareentwicklung bedeutet, Programme und Anwendungen so zu entwerfen und zu bauen, dass sie bestimmte Aufgaben für Menschen oder andere Programme übernehmen. Das Ziel ist, nützliche, zuverlässige und einfach bedienbare Software zu erstellen – egal ob für den Computer, das Smartphone oder Maschinen in der Industrie. Dabei geht es nicht nur darum, Code zu schreiben, sondern auch darum, Probleme zu analysieren, Lösungen zu planen und mit anderen zusammenzuarbeiten. Softwareentwicklung verbindet also technisches Wissen mit Teamarbeit und Kreativität, damit am Ende ein funktionierendes Produkt entsteht, das das Leben oder Arbeiten erleichtert. Überblick über Softwarearten (Systemsoftware, Anwendungssoftware, Web-/Mobile-Apps) Es gibt verschiedene Arten von Software, die in unserem Alltag und in der Arbeitswelt eine wichtige Rolle spielen. Grundsätzlich unterscheidet man zwischen: • Systemsoftware: Das ist die Software, die dafür sorgt, dass dein Computer oder Smartphone überhaupt funktioniert. Ein bekanntes Beispiel ist das Betriebssystem wie Windows, macOS, Linux oder Android. Die Systemsoftware verwaltet die Hardware, startet Programme und stellt sicher, dass alles richtig zusammenarbeitet. Ohne Systemsoftware könntest du keine anderen Programme nutzen. • Anwendungssoftware: Damit sind alle Programme gemeint, mit denen du direkt arbeitest. Das können Textverarbeitungen wie Word, Tabellenkalkulationen wie Excel oder Grafikprogramme wie Photoshop sein. Auch Spiele, Musikplayer oder Apps zum Chatten gehören dazu. Anwendungssoftware hilft dir dabei, bestimmte Aufgaben zu erledigen oder dich zu unterhalten. • Web- und Mobile-Apps: Viele Programme gibt es heute nicht mehr nur für den Computer, sondern auch als Apps für das Smartphone oder als Anwendungen, die direkt im Internetbrowser laufen. Ein Beispiel ist WhatsApp als App auf dem Handy oder Google Docs, das du über den Browser nutzen kannst. Web- und Mobile-Apps sind besonders praktisch, weil du sie überall und meistens auf verschiedenen Geräten nutzen kannst. So sorgt Software in ganz unterschiedlichen Formen dafür, dass digitale Geräte für verschiedene Zwecke genutzt werden können – ob zum Arbeiten, Lernen oder für die Freizeit. Der Softwareentwicklungsprozess im Überblick Damit aus einer Idee am Ende eine funktionierende Software wird, gibt es verschiedene Schritte, die im sogenannten Softwareentwicklungsprozess aufeinander folgen. Alles beginnt mit der Planung: Zuerst überlegen sich alle Beteiligten, welches Problem gelöst werden soll und was die neue Software genau können muss. In dieser Phase werden Anforderungen gesammelt und aufgeschrieben. Danach geht es an die Konzeption, das heißt, es wird ein Plan gemacht, wie die Software aufgebaut sein soll – zum Beispiel, welche Funktionen es geben wird und wie das Programm aussehen könnte. Ist der Plan fertig, startet die eigentliche Programmierung: Die Entwicklerinnen schreiben den Code, testen Zwischenergebnisse und passen ihn immer wieder an. Parallel dazu prüfen auch Testerinnen die Software auf Fehler, damit am Ende alles zuverlässig läuft. Häufig wird die Software in mehreren Versionen entwickelt, sodass schon früh ausprobiert und verbessert werden kann. Wenn alles funktioniert, wird die fertige Software ausgeliefert und installiert – entweder direkt auf den Geräten oder übers Internet. Aber damit ist der Prozess noch nicht zu Ende: Auch nach der Veröffentlichung kümmern sich die Beteiligten um Updates und Verbesserungen, damit das Programm weiterhin sicher und nützlich bleibt. So sorgt ein strukturierter Ablauf dafür, dass aus einer Idee Schritt für Schritt eine Software entsteht, die den Alltag oder die Arbeit erleichtert und auf die sich die Nutzerinnen verlassen können. Rollen im Softwareentwicklungsprozess (z. B. Entwickler, Tester, Projektmanager) Im Softwareentwicklungsprozess arbeiten viele verschiedene Personen zusammen, die jeweils unterschiedliche Aufgaben und Verantwortlichkeiten haben. Diese verschiedenen Aufgaben werden als Rollen bezeichnet. Typische Rollen sind zum Beispiel Entwicklerinnen, Testerinnen und Projektmanagerinnen. Entwicklerinnen sind dafür zuständig, den Code der Software zu schreiben und technische Lösungen für die gestellten Aufgaben zu finden. Sie setzen die Ideen und Anforderungen praktisch um, programmieren die Funktionen und sorgen dafür, dass alles technisch funktioniert. Testerinnen prüfen die Software auf Herz und Nieren. Sie suchen gezielt nach Fehlern, testen verschiedene Funktionen und melden Probleme, damit die Software am Ende stabil und zuverlässig läuft. Projektmanagerinnen behalten den Überblick. Sie planen, wer was wann erledigt, achten auf den Zeitplan und sorgen dafür, dass das Team gut zusammenarbeitet. Sie vermitteln auch zwischen Kundinnen und dem Entwicklungsteam und sorgen dafür, dass die Anforderungen verstanden und umgesetzt werden. Neben diesen drei Hauptrollen kann es noch weitere geben, zum Beispiel Designerinnen, die sich um das Aussehen und die Bedienbarkeit kümmern, oder Support-Mitarbeitende, die Nutzerinnen bei Fragen helfen. Alle Rollen sind wichtig, damit am Ende eine Software entsteht, die den Erwartungen entspricht und gut genutzt werden kann. Multiple-Choice-Test • Frage 1: Was ist die erste Phase im Softwareentwicklungsprozess? o a) Programmierung o b) Planung o c) Testen o d) Installation • Frage 2: Welche Aufgabe haben Testerinnen im Softwareentwicklungsprozess? o a) Das Design der Benutzeroberfläche entwickeln o b) Die Software auf Fehler prüfen o c) Die Codebasis verwalten o d) Updates veröffentlichen • Frage 3: Welche Rolle sorgt dafür, dass das Team gut zusammenarbeitet und der Zeitplan eingehalten wird? o a) Entwicklerinnen o b) Testerinnen o c) Projektmanagerinnen o d) Support-Mitarbeitende • Frage 4: Was bedeutet algorithmisches Denken? o a) Ein Problem Schritt für Schritt lösen o b) Einen Computer bauen o c) Fehler im Code suchen o d) Programme in Alltagssprache erklären • Frage 5: Warum werden vor dem Programmieren oft Flussdiagramme oder Pseudocode verwendet? o a) Um das fertige Programm schneller ausführen zu können o b) Um die Lösung grafisch oder in Alltagssprache zu planen o c) Weil der Computer es verlangt o d) Um den Code zu verkürzen
  2. Denkweisen und Konzepte der Programmierung Algorithmisches Denken und Problemlösungsstrategien Algorithmisches Denken bedeutet, ein Problem Schritt für Schritt zu lösen – ähnlich wie bei einer Bauanleitung oder einem Kochrezept. In der Programmierung überlegst du dir, wie du ein Ziel erreichen kannst, indem du einzelne, logisch aufeinanderfolgende Anweisungen formulierst. Ziel ist es, eine Lösung so klar zu beschreiben, dass ein Computer oder eine andere Person sie ganz genau nachvollziehen kann. Ein Beispiel: Stell dir vor, du möchtest ein Programm schreiben, das prüft, ob jemand volljährig ist. Du musst den Ablauf logisch planen. Zuerst fragst du nach dem Alter, dann vergleichst du es mit 18, und entscheidest, was ausgegeben werden soll – das ist schon algorithmisches Denken! Problemlösungsstrategien helfen dir dabei, auch komplexere Aufgaben zu meistern. Dazu gehört es, ein grosses Problem in kleine Teilprobleme zu zerlegen, verschiedene Lösungswege abzuwägen und mögliche Fehlerquellen zu erkennen. Häufig werden solche Schritte erst auf Papier geplant, bevor sie als Programm umgesetzt werden. So lernst du nach und nach, nicht nur Aufgaben zu lösen, sondern auch möglichst effiziente und fehlerfreie Lösungen zu entwickeln. Dieses Denken ist die Grundlage dafür, später eigene Programme zu schreiben und immer wieder neue Herausforderungen erfolgreich zu meistern. Von der Idee zum Code: Problemanalyse und Lösungsentwurf Bevor du mit dem eigentlichen Programmieren startest, ist es wichtig, eine klare Vorstellung davon zu haben, was dein Programm eigentlich tun soll. Das beginnt mit der Problemanalyse: Du schaust dir genau an, welche Aufgabe gelöst werden soll. Dafür kann es helfen, das Problem in kleinere, überschaubare Teile zu zerlegen. Du überlegst beispielsweise: Welche Informationen brauche ich? Welche Schritte müssen der Reihe nach abgearbeitet werden? Gibt es verschiedene Möglichkeiten, das Ziel zu erreichen? Sobald du das Problem verstanden hast, folgt der Lösungsentwurf. Dabei planst du, wie dein Programm grundsätzlich aufgebaut sein soll. Häufig nutzt man dafür einfache Hilfsmittel wie Flussdiagramme, die den Ablauf grafisch darstellen, oder Pseudocode, eine Art „Programmiersprache in Alltagssprache“. So kannst du ausprobieren und testen, ob deine Lösung logisch und vollständig ist, bevor du eine einzige Zeile Code schreibst. Dieser Planungsprozess hilft dir, Fehler frühzeitig zu erkennen und sorgt dafür, dass du später beim Programmieren gezielter und strukturierter arbeiten kannst. Einführung in Flussdiagramme und Pseudocode Flussdiagramme und Pseudocode sind zwei praktische Werkzeuge, die dir beim Planen und Verstehen von Programmen helfen. Ein Flussdiagramm ist eine Art Zeichnung, mit der du den Ablauf eines Programms Schritt für Schritt darstellst. Du verwendest verschiedene Symbole: Ovale für den Start und das Ende, Rechtecke für Anweisungen, und Rauten für Entscheidungen (wie „Ist die Zahl größer als 18?“). Die einzelnen Schritte sind mit Pfeilen verbunden, so dass du leicht siehst, welcher Schritt als nächstes kommt. Das hilft dir, den Überblick zu behalten und logische Fehler früh zu erkennen. Pseudocode dagegen ist wie eine Beschreibung des Programms in ganz normalen Worten, aber so aufgebaut, dass du daraus leicht richtigen Code machen kannst. Dabei schreibst du keine exakten Befehle einer Programmiersprache, sondern beschreibst die Abläufe so klar wie möglich – etwa so: „Frage das Alter ab, vergleiche es mit 18, gib das Ergebnis aus.“ Pseudocode hilft dir, den roten Faden zu behalten, ohne dich gleich mit der genauen Syntax von Python oder Java beschäftigen zu müssen. Beides, Flussdiagramm und Pseudocode, sind besonders am Anfang nützlich, weil du damit deine Ideen durchdenken und strukturieren kannst, noch bevor du mit dem eigentlichen Programmieren loslegst. Damit bist du bestens vorbereitet auf die nächsten Themen, wie die verschiedenen Kontrollstrukturen in Programmen. Kontrollstrukturen: Sequenz, Verzweigung, Schleifen Kontrollstrukturen bilden das Grundgerüst jeder Programmiersprache. Sie bestimmen, in welcher Reihenfolge Anweisungen im Programm ausgeführt werden. Grundsätzlich gibt es drei Arten von Kontrollstrukturen: die Sequenz (also das „der Reihe nach Durcharbeiten“), die Verzweigung (Entscheidungen wie if/else) und die Schleifen (Wiederholungen wie for oder while). Bei der Sequenz werden die Befehle einfach Schritt für Schritt abgearbeitet – ganz ohne Umwege. Sobald das Programm aber an eine Stelle kommt, an der eine Entscheidung getroffen werden muss (zum Beispiel: „Ist das Alter größer als 18?“), kommt die Verzweigung ins Spiel: Das Programm wählt dann abhängig von der Bedingung einen bestimmten Weg. Mit Schleifen kannst du erreichen, dass bestimmte Anweisungen mehrfach wiederholt werden, zum Beispiel solange eine Bedingung erfüllt ist oder eine bestimmte Anzahl an Wiederholungen erreicht wurde. Das ist besonders praktisch, wenn Aufgaben immer wieder durchgeführt werden sollen, etwa beim Durchlaufen einer Liste von Werten. Durch das geschickte Zusammenspiel dieser Kontrollstrukturen kannst du auch schon mit einfachen Mitteln sehr flexible und vielseitige Programme schreiben – und hast das Handwerkszeug, um komplexere Themen wie Datenstrukturen und Algorithmen zu verstehen. Multiple-Choice-Fragen • Was ist der Hauptvorteil eines Flussdiagramms beim Programmieren? o A) Es generiert automatisch den Programmcode. o B) Es hilft dabei, den genauen Speicherbedarf zu berechnen. o C) Es stellt den Ablauf eines Programms grafisch dar und erleichtert das Erkennen von Fehlern. o D) Es ersetzt die Programmbeschreibung vollständig. • Welcher der folgenden Begriffe ist KEINE Kontrollstruktur? o A) Variable o B) Sequenz o C) Verzweigung o D) Schleife • Wie sieht ein Beispiel für Pseudocode aus? o A) x = 5 + 3 o B) „Frage das Alter ab, vergleiche es mit 18, gib das Ergebnis aus.“ o C) print(“Hallo Welt”) o D) for i in range(5): print(i) • Wie weist man in Python einer Variablen einen Wert zu? o A) variable == wert o B) wert = variable o C) variable = wert o D) set variable wert • Was macht der Befehl input() in Python? o A) Gibt einen Wert auf dem Bildschirm aus. o B) Fragt eine Eingabe von derdem Benutzerin ab. o C) Vergleicht zwei Werte. o D) Definiert eine neue Variable.
  3. Programmiergrundlagen Datentypen und Variablen Wenn du mit dem Programmieren startest, begegnen dir viele neue Begriffe. Aber keine Sorge: Mit ein paar Grundlagen und der Programmiersprache Python schaffst du den Einstieg ganz leicht! In Python ist alles darauf ausgelegt, möglichst einfach und verständlich zu sein. Das beginnt schon bei den sogenannten Datentypen. Ein Datentyp beschreibt, welche Art von Wert eine Variable annehmen kann – zum Beispiel Zahlen (wie 7 oder 3.14), Text (also Zeichenketten wie “Hallo Welt”) oder Wahrheitswerte (True oder False). Variablen wiederum sind wie kleine Behälter, in denen du solche Werte abspeichern kannst. In Python musst du übrigens nicht vorher angeben, welchen Typ eine Variable hat. Du schreibst einfach: x = 5 name = “Anna” ist_alt_genug = True Du siehst: Das geht ganz unkompliziert! Beim Programmieren arbeitest du häufig mit sogenannten Operatoren, um Werte zu berechnen oder miteinander zu vergleichen. Zum Beispiel kannst du mit +, -, * und / rechnen, oder mit == prüfen, ob zwei Werte gleich sind. Auch das funktioniert in Python sehr intuitiv – probiere es einfach in einem sogenannten Python-Interpreter aus, um direkt zu sehen, was passiert. Ein- und Ausgaben erlauben es dir, mit dem Programm zu kommunizieren. Mit input() kannst du Eingaben vom Benutzer abfragen, und mit print() gibst du etwas auf dem Bildschirm aus. Zum Beispiel: name = input(“Wie heißt du? ”) print(“Hallo,”, name) So einfach kannst du ein kleines, interaktives Programm schreiben! Jetzt hast du die wichtigsten Grundlagen kennengelernt. Im nächsten Abschnitt lernst du, wie man mit Operatoren arbeitet, Eingaben und Ausgaben programmiert und wie Kontrollstrukturen in Python konkret aussehen. So kannst du schon bald eigene Programme schreiben und nach und nach deine Kenntnisse erweitern! Operatoren und Ausdrücke Operatoren und Ausdrücke Wenn du in Python programmierst, begegnen dir ständig sogenannte Operatoren und Ausdrücke. Doch was bedeutet das eigentlich? Ein Ausdruck ist im Grunde alles, was einen Wert erzeugt, zum Beispiel eine einfache Rechnung wie 3 + 5 oder das Vergleichen von zwei Zahlen, etwa 10 > 7. Du kombinierst also Werte (wie Zahlen oder Variablen) mit Operatoren, damit das Programm etwas berechnen oder überprüfen kann. Die wichtigsten Operatoren sind: • Rechenoperatoren: Mit + addierst du, mit - subtrahierst du, * steht für multiplizieren und / zum teilen. Beispiel: ergebnis = 7 * 4 ergibt 28. • Vergleichsoperatoren: Damit prüfst du, ob zwei Werte gleich oder unterschiedlich sind. == bedeutet „ist gleich“, != „ist ungleich“. Beispiel: if alter == 18: prüft, ob die Variable alter genau 18 ist. • Größer/kleiner: Mit >= und ⇐ vergleichst du, ob Werte größer oder kleiner (oder gleich groß) sind. • Logische Operatoren: and, or und not helfen dir, mehrere Bedingungen zu verknüpfen. Beispiel: if ist_alt_genug and name == “Anna”: prüft, ob beide Bedingungen erfüllt sind. Mit diesen Operatoren kannst du schon viele Aufgaben lösen: vom Berechnen von Preisen über das Prüfen von Passwörtern bis zum Auswerten von Quizfragen. Wichtig ist vor allem, dass du verstehst, wie du Werte miteinander vergleichen oder berechnen kannst – das ist die Grundlage für viele Programme. Im nächsten Kapitel schaust du dir an, wie man Daten einliest und ausgibt und welche Kontrollstrukturen Python für dich bereithält. Ein- und Ausgabe Um mit einem Programm zu „kommunizieren“, also Eingaben (Input) zu verarbeiten und Ausgaben (Output) anzuzeigen, stellt dir Python einfache, aber sehr mächtige Werkzeuge zur Verfügung. Am häufigsten nutzt du dafür die Funktionen input() und print(). Mit input() kannst du Benutzerinnen nach Informationen fragen. Zum Beispiel: name = input(“Wie heißt du? ”). Das Programm wartet dann, bis jemand etwas eingibt, und speichert diese Eingabe in der Variable name. Mit print() gibst du Werte, Texte, Rechenergebnisse oder ganze Nachrichten auf dem Bildschirm aus. Zum Beispiel: print(“Hallo, ” + name) zeigt den Namen an, den die Benutzerin vorher eingegeben hat. Du kannst input() und print() beliebig kombinieren, um Programme interaktiv zu gestalten – etwa für kleine Frage-Antwort-Spiele, die Abfrage von Zahlen für Berechnungen oder das Anzeigen von Ergebnissen. Typisch für Python ist, dass diese Befehle sehr leicht zu verstehen sind und wenig „Zusatzkram“ benötigen. Selbst komplexere Aufgaben wie das Formatieren von Ausgaben kannst du mit wenigen Handgriffen erledigen, zum Beispiel mit print(f”Du bist {alter} Jahre alt.”), wobei alter eine Variable ist. Mit Input- und Output-Funktionen legst du den Grundstein dafür, dass deine Programme nicht nur rechnen, sondern auch mit den Menschen am Computer direkt zusammenarbeiten können. Kontrollstrukturen (if, while, for) Kontrollstrukturen sind das Herzstück jeder Programmiersprache – auch bei Python. Sie helfen dir dabei, den Ablauf deines Programms zu steuern, also beispielsweise Entscheidungen zu treffen oder bestimmte Anweisungen mehrfach auszuführen. Mit einer if-Anweisung kannst du Bedingungen prüfen: Das Programm entscheidet dann, was passieren soll – je nachdem, ob eine bestimmte Aussage wahr oder falsch ist. So kannst du zum Beispiel festlegen, dass eine Nachricht nur dann ausgegeben wird, wenn eine Zahl größer als 10 ist. Die while-Schleife hilft dir, Anweisungen so lange zu wiederholen, bis eine bestimmte Bedingung nicht mehr erfüllt ist. Ein Beispiel wäre, dass ein Programm so lange nach dem Passwort fragt, bis das richtige eingegeben wurde. Mit der for-Schleife kannst du eine Aufgabe für jedes Element in einer Liste oder für eine bestimmte Anzahl an Wiederholungen automatisch abarbeiten lassen. Das brauchst du zum Beispiel, um alle Namen aus einer Liste zu begrüßen oder Zahlen von 1 bis 10 nacheinander auszugeben. Auch wenn das im ersten Moment kompliziert klingt: In Python sind diese Strukturen besonders leicht verständlich und übersichtlich geschrieben. Dadurch kannst du schon mit wenig Code sehr mächtige Abläufe gestalten – und deine Programme erledigen genau das, was du willst! Funktionen und Modularisierung Funktionen sind Abschnitte deines Programms, denen du einen eigenen Namen gibst. Sie helfen dir, deinen Code übersichtlich zu halten und wiederzuverwenden. Stell dir eine Funktion wie eine kleine Maschine vor: Du gibst ihr etwas (Argumente), sie erledigt eine bestimmte Aufgabe und gibt dir das Ergebnis zurück. Zum Beispiel: def begruessung(name): print(f”Hallo, {name}!“) Wenn du begruessung(“Alex”) aufrufst, erscheint „Hallo, Alex!“ auf dem Bildschirm. So kannst du oft gebrauchte Abläufe – wie Rechnungen, Begrüßungen oder Prüfungen – einmal als Funktion schreiben und dann beliebig oft im Programm nutzen. Gerade bei längeren Programmen wird Modularisierung wichtig. Das bedeutet, dass du deinen Code in einzelne Bausteine aufteilst, zum Beispiel durch mehrere Funktionen oder sogar eigene Dateien (Module). Dadurch wird dein Programm nicht nur lesbarer, sondern auch leichter zu testen und zu erweitern. Du kannst zum Beispiel eine Datei für Mathefunktionen und eine andere für Benutzereingaben anlegen. In Python ist das besonders einfach. Du kannst eigene Module schreiben und mit import in anderen Programmen verwenden. Auch viele nützliche Module wie math oder random sind schon in Python eingebaut: Mit import math kannst du z.B. mathematische Funktionen direkt nutzen. Mit Funktionen und Modularisierung bist du bestens gerüstet, um auch größere Projekte übersichtlich und clever zu strukturieren – ganz nach dem Motto: Teile und herrsche! Fehlerarten und Debugging Beim Programmieren in Python wirst du früher oder später auf Fehler stoßen – das ist ganz normal und gehört zum Lernprozess! Wichtig ist, die verschiedenen Arten von Fehlern zu kennen, damit du sie schnell beheben kannst. Es gibt drei Hauptarten von Fehlern: • Syntaxfehler: Hier hast du dich vielleicht vertippt oder etwas vergessen, zum Beispiel eine Klammer oder einen Doppelpunkt. Python versteht dann nicht, was du gemeint hast, und zeigt eine Fehlermeldung direkt beim Ausführen an. • Laufzeitfehler: Diese entstehen, wenn dein Programm zwar fehlerfrei startet, aber während der Ausführung auf ein Problem stößt – zum Beispiel, wenn du versuchst, durch Null zu teilen oder auf ein Element in einer Liste zuzugreifen, das es gar nicht gibt. • Logische Fehler: Dein Programm läuft zwar ohne eine Fehlermeldung, aber das Ergebnis ist nicht das, was du erwartet hast. Hier hast du dich vielleicht in einer Rechnung vertan oder die falsche Bedingung verwendet. Diese Fehlerart nennt man auch „semantische Fehler“. Um Fehler zu finden und zu beheben, spricht man von „Debugging“. In Python kannst du dafür Ausgaben mit print() einbauen, um zu sehen, was im Programm passiert. Noch einfacher wird’s mit einem Debugger, der in vielen Entwicklungsumgebungen (IDEs) eingebaut ist: Damit kannst du das Programm Schritt für Schritt durchgehen, Variablen beobachten und gezielt nach Fehlern suchen. Ein Tipp: Lass dich von Fehlern nicht entmutigen! Fehler sind beim Programmieren ganz normal und helfen dir dabei, ein besseres Verständnis für die Funktionsweise von Python zu bekommen. Mit etwas Übung werden dir die Fehlermeldungen immer vertrauter, und du bist schneller im Finden und Beheben von Problemen. Multiple-Choice-Fragen • Welche der folgenden Fehlerarten tritt auf, wenn ein Programm zwar startet, aber während der Ausführung auf ein Problem stößt? o A) Syntaxfehler o B) Laufzeitfehler o C) Logischer Fehler o D) Tippfehler • Was ist ein Vorteil von Modulen in Python? o Sie machen Programme langsamer o Sie erlauben es, Funktionen und Code übersichtlich zu strukturieren und wiederzuverwenden o Sie verhindern Fehler vollständig o Sie ersetzen die Notwendigkeit von Datenstrukturen • Welcher Befehl wird empfohlen, um beim Debugging den Programmverlauf zu überprüfen? o input() o print() o exit() o import() • Was unterscheidet ein Tupel von einer Liste in Python? o Tupel können nach dem Erstellen verändert werden, Listen nicht o Listen sind unveränderlich, Tupel nicht o Tupel sind unveränderlich, Listen nicht o Es gibt keinen Unterschied • Wie funktioniert die lineare Suche? o Die Liste wird nach Größe sortiert o Alle Elemente werden von vorne bis hinten durchgegangen und mit dem gesuchten Wert verglichen o Die Suche wird mithilfe eines Wörterbuchs durchgeführt o Die Elemente werden zufällig überprüft
  4. Datenstrukturen und einfache Algorithmen Arrays/Listen, Tupel, Dictionaries Listen (in Python auch Arrays genannt), Tupel und Dictionaries sind grundlegende Datenstrukturen, die du immer wieder brauchst. Eine Liste ist wie ein Behälter, in dem du verschiedene Werte speichern kannst – zum Beispiel Zahlen oder Wörter – und du kannst sie später einfach verändern, Elemente hinzufügen oder entfernen. Ein Tupel funktioniert ähnlich, aber die Werte darin kannst du nach dem Erstellen nicht mehr verändern: Es ist quasi eine „feste“ Liste. Dictionaries (Wörterbücher) sind besonders praktisch, wenn du Daten als Paare speichern willst, zum Beispiel Namen und dazugehörige Telefonnummern. Jedes Element besteht aus einem Schlüssel und einem Wert – so kannst du blitzschnell nachschauen, was zu welchem Schlüssel gehört. Wenn du mit diesen Daten arbeitest, brauchst du manchmal einfache Algorithmen, also Schritt-für-Schritt-Anleitungen, um Probleme zu lösen. Ein Beispiel ist die lineare Suche: Du gehst eine Liste von vorne bis hinten durch, um herauszufinden, ob ein bestimmter Wert darin vorkommt. Zum Sortieren von Listen gibt es viele Möglichkeiten – eine davon ist der sogenannte Bubble Sort. Dabei werden die Elemente immer wieder paarweise verglichen und getauscht, wenn sie in der falschen Reihenfolge stehen, bis die ganze Liste sortiert ist. Diese Techniken sind die Basis für viele Aufgaben – und in Python kannst du sie mit ein paar Zeilen Code ausprobieren! Suchen und Sortieren (lineare Suche, Bubble Sort) Suchen und Sortieren sind grundlegende Techniken, die dir im Programmieren immer wieder begegnen – gerade auch in Python. Die lineare Suche nutzt du, wenn du herausfinden willst, ob ein bestimmter Wert in einer Liste steckt. Das funktioniert ganz einfach: Du gehst die Liste von vorne bis hinten durch und vergleichst jedes Element mit dem Wert, den du suchst. Passt es? Super, dann bist du fertig! Wenn nicht, schaust du einfach weiter, bis du am Ende angekommen bist. In Python sieht das zum Beispiel so aus: gesucht = 42 liste = [17, 23, 42, 5, 8] gefunden = False for zahl in liste: if zahl == gesucht: gefunden = True break if gefunden: print(“Die Zahl wurde gefunden!”) else: print(“Die Zahl ist nicht in der Liste.“) Beim Sortieren gibt es verschiedene Algorithmen. Ein ganz einfacher ist der Bubble Sort. Dabei vergleichst du immer benachbarte Werte in der Liste und vertauschst sie, wenn sie in der falschen Reihenfolge stehen. Das machst du so lange, bis keine Werte mehr vertauscht werden müssen – dann ist die Liste sortiert. Hier ein Beispiel in Python: liste = [4, 2, 7, 1, 9] n = len(liste) for i in range(n): for j in range(0, n-i-1): if liste[j] > liste[j+1]: liste[j], liste[j+1] = liste[j+1], liste[j] print(liste) # Ausgabe: [1, 2, 4, 7, 9] Solche Algorithmen helfen dir, Daten zu durchsuchen oder zu ordnen – egal, ob es um Zahlen, Wörter oder andere Werte geht. Gerade in Python kannst du viele dieser Dinge mit wenigen Zeilen Code ausprobieren und bekommst so schnell ein Gefühl dafür, wie Programme im Hintergrund arbeiten. Grundlagen der Rekursion Rekursion bedeutet, dass sich eine Funktion in ihrem eigenen Körper selbst aufruft. Das klingt vielleicht erst mal kompliziert, ist aber eigentlich ein elegantes Werkzeug, um Probleme zu lösen, die sich in kleinere Teilprobleme zerlegen lassen. Ein klassisches Beispiel ist die Berechnung der Fakultät einer Zahl. Schauen wir uns das mal in Python an: def fakultaet(n): if n 0: return 1 else: return n * fakultaet(n-1) print(fakultaet(5)) # Ausgabe: 120 Hier ruft sich die Funktion fakultaet immer wieder selbst auf, bis die Bedingung n 0 erfüllt ist. Das nennt man auch die Abbruchbedingung – sie verhindert, dass die Funktion endlos weiterläuft. Rekursive Funktionen können viele Aufgaben lösen, zum Beispiel das Durchlaufen von Verzeichnissen, das Berechnen von Zahlenfolgen oder das Lösen von Rätseln wie dem berühmten Türme-von-Hanoi-Problem. Wichtig ist bei der Rekursion immer, dass es eine klare Abbruchbedingung gibt, damit das Programm nicht in einer Endlosschleife festhängt. In Python sind rekursive Lösungen oft sehr kompakt und anschaulich, aber bei sehr tiefen Rekursionen kann der Speicher knapp werden. Deshalb sollte man Rekursion immer mit Bedacht wählen und überlegen, ob auch eine Schleife zum Ziel führt. Komplexität (Big-O-Notation – optional, je nach Niveau) Wenn du Programme schreibst, möchtest du oft wissen, wie schnell oder wie viel Speicher sie brauchen – besonders, wenn sie mit grossen Datenmengen arbeiten. Dafür gibt es die sogenannte „Big-O-Notation“. Sie hilft, grob einzuschätzen, wie sich die Laufzeit oder der Speicherverbrauch eines Programms verhält, wenn die Eingabe immer grösser wird. Stell dir vor, du hast eine Liste von 100 Zahlen und möchtest jede Zahl einmal anschauen. In Python machst du das mit einer Schleife: for zahl in liste: print(zahl) Hier läuft das Programm 100-mal – bei 1.000 Zahlen läuft es 1.000-mal. Wir sagen dann: Das hat eine Komplexität von O(n). Das „n“ steht für die Anzahl der Elemente. Je mehr Elemente, desto länger dauert’s. Bei rekursiven Funktionen wie der Fakultät von oben ist die Komplexität O(n), weil für jede Zahl bis 0 ein eigener Funktionsaufruf gemacht wird. Es gibt aber auch schnellere und langsamere Algorithmen, zum Beispiel: • O(1): Dauert immer gleich lang, egal wie gross die Eingabe ist (z.B. Zugriff auf ein einzelnes Element in einer Liste: liste[0]). • O(n): Die Laufzeit wächst linear mit der Eingabemenge (z.B. durch eine Liste laufen). • O(n²): Für jede Zahl wird noch einmal die ganze Liste durchlaufen, wie bei einer verschachtelten Schleife (Doppelschleife). • O(log n): Eine Suche, die immer die Hälfte ausschliesst (z.B. binäre Suche), ist viel schneller als das Durchgehen aller Elemente. In der Praxis hilft dir das, bessere und schnellere Programme zu schreiben. Du musst die Big-O-Notation nicht auswendig können, aber wenn du ein grundlegendes Verständnis davon hast, erkennst du, warum manche Lösungen bei kleinen Datenmengen gut und bei grossen langsam werden. In Python kannst du oft mit eingebauten Funktionen und cleveren Datenstrukturen schon viel erreichen. Multiple-Choice-Fragen • Was beschreibt die Big-O-Notation hauptsächlich? o a) Die Lesbarkeit des Codes o b) Die Anzahl der Variablen im Programm o c) Das Speicherformat einer Datei o d) Die Laufzeit oder den Ressourcenverbrauch eines Algorithmus in Abhängigkeit von der Eingabemenge • Welche Laufzeit hat ein Algorithmus mit O(n²)? o a) Die Laufzeit bleibt immer gleich, egal wie viele Elemente o b) Die Laufzeit wächst exponentiell bei mehr Elementen o c) Für jedes Element wird die komplette Liste erneut durchlaufen o d) Die Laufzeit halbiert sich bei doppelter Eingabegröße • Was ist der Hauptvorteil von Versionsverwaltungssystemen wie Git? o a) Sie machen den Code schneller o b) Änderungen am Code können nachverfolgt und ältere Versionen wiederhergestellt werden o c) Sie übersetzen den Code in Maschinensprache o d) Sie formatieren automatisch den Quelltext • Wie dokumentierst du in Python längere Erklärungen zu Funktionen am besten? o a) Mit einfachen Anführungszeichen o b) Mit Docstrings, die durch dreifache Anführungszeichen gekennzeichnet sind o c) Mit eckigen Klammern o d) Mit dem Zeichen % • Was beschreibt ein typischer Workflow bei der Arbeit mit Git in einem Team? o a) Jeder arbeitet im selben Branch und überschreibt Änderungen anderer o b) Änderungen werden per E-Mail verschickt o c) Änderungen werden in einem eigenen Branch vorgenommen und später mit dem Hauptzweig zusammengeführt o d) Alle machen ihre Änderungen direkt im Hauptzweig, ohne Absprachen
  5. Softwareentwicklung in der Praxis Entwicklungsumgebungen (IDE, Editor, Compiler/Interpreter) In der Praxis der Softwareentwicklung brauchst du nicht nur das Wissen, wie man Programme schreibt, sondern auch Werkzeuge, die dir die Arbeit erleichtern. Dazu gehören zum Beispiel Entwicklungsumgebungen, also Programme wie Editoren oder IDEs (Integrated Development Environments). Sie bieten dir viele praktische Funktionen – du kannst damit Code schreiben, testen und sogar direkt ausführen. Ein Compiler oder Interpreter sorgt dafür, dass dein Code vom Computer verstanden und ausgeführt wird. So wird aus deinem Python-Programm zum Beispiel eine lauffähige Anwendung. Moderne Entwicklungsteams nutzen ausserdem Tools, um gemeinsam am Code zu arbeiten und Änderungen nachzuverfolgen. Ein sehr bekanntes Werkzeug dafür ist Git. Versionsverwaltung mit Git (Grundlagen, einfache Workflows) Eine wichtige Grundlage moderner Softwareentwicklung ist die Versionsverwaltung. Damit ist gemeint, dass Änderungen am Code nachverfolgt und gespeichert werden. Besonders in Teams ist das hilfreich, weil so nachvollziehbar bleibt, wer wann was geändert hat und ältere Versionen jederzeit wiederhergestellt werden können. Eines der bekanntesten Systeme dafür ist derzeit Git. Mit Git kannst du einfach verschiedene Entwicklungsstände sichern, neue Features ausprobieren, ohne den Hauptcode zu stören, und gemeinsam mit anderen am selben Projekt arbeiten. Ein typischer Workflow ist zum Beispiel: Du lädst dir den aktuellen Code (Klonen), erstellst einen neuen Zweig (Branch) für deine Änderungen, testest alles und verbindest am Ende deine Arbeit wieder mit dem Hauptzweig (Merge). So bleibt die Übersicht erhalten, Fehler lassen sich leichter beheben und die Zusammenarbeit wird viel effizienter. Dokumentation und Kommentierung von Code Beim Programmieren ist es wichtig, dass nicht nur der Computer, sondern auch andere Menschen – und du selbst nach ein paar Wochen – verstehen, was dein Code macht. Genau dafür gibt es Kommentare und Dokumentation. Kommentare schreibst du direkt in den Quelltext, damit zum Beispiel erklärt wird, warum du etwas auf eine bestimmte Weise gelöst hast oder was eine komplizierte Funktion macht. In Python benutzt du dafür das Zeichen # für einzelne Zeilen oder dreifache Anführungszeichen ("""…""") für längere Erklärungen, sogenannte Docstrings. Gute Dokumentation hilft dir und dem Team, den Überblick zu behalten und Fehler zu vermeiden. Sie ist besonders wichtig, wenn mehrere Personen am selben Projekt arbeiten oder Programme später weiterentwickelt werden sollen. In Python ist es üblich, Funktionen und Klassen mit Docstrings zu versehen, damit später automatisch Nachschlagewerke (sogenannte API-Dokumentationen) daraus generiert werden können. Auch kleine Beispiele oder Hinweise zu den Eingaben und Ausgaben einer Funktion sind hilfreich. Kurz gesagt: Schreibe deinen Code so, dass andere ihn verstehen können, auch wenn sie nicht dabei waren, als du ihn geschrieben hast. Das spart Zeit, Nerven – und macht dich zu einer Person, mit der alle gern im Team arbeiten! Docstrings und Anotations Docstrings sind spezielle mehrzeilige Kommentare, die direkt am Anfang einer Funktion, Klasse oder eines Moduls stehen. Sie werden in Python mit dreifachen Anführungszeichen geschrieben, also entweder """ oder ''', und dienen dazu, die Aufgabe und Verwendung eines Programmteils ausführlich zu beschreiben. Der große Vorteil: Docstrings können von Tools und anderen Programmen automatisch ausgelesen werden, etwa für Nachschlagewerke oder Hilfeseiten (wie die integrierte Hilfe mit help()). Ein typischer Docstring erklärt, was die Funktion macht, welche Parameter sie erwartet und was sie zurückgibt. Damit hilft er nicht nur anderen im Team, sondern auch dir selbst beim späteren Nachschlagen. Beispiel einer Funktion mit Docstring: def addiere(a, b): """ Addiert zwei Zahlen und gibt das Ergebnis zurück. Parameter: a (int oder float): Die erste Zahl. b (int oder float): Die zweite Zahl. Rückgabe: int oder float: Die Summe der beiden Zahlen. """ return a + b Annotations – genauer Typannotationen – sind ein weiteres nützliches Werkzeug in Python. Sie erlauben es, die erwarteten Datentypen von Parametern und Rückgabewerten anzugeben. Typannotationen sind zwar optional und werden beim Ausführen nicht erzwungen, sie helfen aber dabei, Fehler früh zu erkennen und den Code verständlicher zu machen – gerade in großen Projekten. Viele moderne Editoren und Tools können diese Typinformationen nutzen, um Hinweise oder Warnungen anzuzeigen. Typische Annotation sieht so aus: def addiere(a: int, b: int) → int: """Addiert zwei ganze Zahlen.""" return a + b Hier ist klar ersichtlich, dass sowohl a als auch b ganze Zahlen sein sollen und die Funktion ebenfalls eine ganze Zahl zurückgibt. Diese Zusatzinformationen fördern die Lesbarkeit und Wartbarkeit deines Codes – und sorgen dafür, dass auch später noch nachvollziehbar bleibt, was du dir beim Programmieren gedacht hast. Testen und Qualitätssicherung (Unit-Tests, Testfälle) Tests spielen eine zentrale Rolle, wenn du sicherstellen willst, dass dein Programm wirklich das tut, was es soll. Besonders beliebt sind sogenannte Unit-Tests: Das sind kleine, automatisierte Prüfungen, die einzelne Teile deines Codes – zum Beispiel eine Funktion oder Methode – testen. Stell dir vor, du hast eine Funktion geschrieben, die zwei Zahlen addieren soll. Mit einem Unit-Test kannst du automatisch prüfen, ob das Ergebnis zum Beispiel bei 2 + 3 wirklich 5 ist. Solche Tests helfen dir, Fehler möglichst früh zu entdecken, und sie erleichtern die Wartung von Programmen, weil du schnell erkennst, ob spätere Änderungen etwas kaputtmachen. In Python gibt es dafür eigene Module wie „unittest“ oder „pytest“, mit denen du Testfälle einfach definieren und immer wieder automatisch ausführen kannst. Je mehr Tests du schreibst, desto sicherer kannst du sein, dass dein Programm auch nach Änderungen zuverlässig funktioniert. Gute Qualitätssicherung bedeutet also nicht, dass du alles doppelt machen musst, sondern dass du mit klugen Tests viel Zeit und Stress sparst – und die Software am Ende einfach besser ist. Multiple-Choice-Fragen • Was ist der Hauptvorteil von Typannotationen in Python? o A) Sie beschleunigen die Laufzeit des Programms. o B) Sie helfen, Fehler früh zu erkennen und machen den Code verständlicher. o C) Sie sind verpflichtend und werden vom Interpreter geprüft. o D) Sie ersetzen die Notwendigkeit zu testen. • Was beschreibt eine typische Unit-Test-Aufgabe am besten? o A) Überprüfung der gesamten Software. o B) Testen einzelner Funktionen oder Methoden auf korrektes Verhalten. o C) Kontrolle des Designs der Benutzeroberfläche. o D) Erstellung eines Lastenhefts. • Welches Python-Modul ist speziell für das Schreiben und Ausführen von Unit- Tests vorgesehen? o A) math o B) random o C) unittest o D) os • Was ist ein zentrales Merkmal des Wasserfallmodells? o A) Iterative Entwicklung mit vielen Rückkopplungen. o B) Feste Reihenfolge von Phasen, jeweils Abschluss einer Phase vor Beginn der nächsten. o C) Kontinuierliche Auslieferung. o D) Ständige Einbindung der Endnutzerinnen. • Welche Aussage trifft auf das Pflichtenheft zu? o A) Es wird ausschließlich von den Nutzerinnen geschrieben. o B) Es beschreibt, wie die Anforderungen technisch umgesetzt werden. o C) Es enthält ausschließlich Kundenwünsche. o D) Es wird nach Abschluss der Entwicklung erstellt.
  6. Softwareentwicklungsprozesse und -modelle Wasserfallmodell vs. agile Methoden Softwareentwicklungsprozesse und -modelle beschreiben, wie ein Softwareprojekt von der Idee bis zur fertigen Anwendung abläuft. Sie helfen Teams, die Arbeit zu strukturieren, Aufgaben zu verteilen, Zeit zu planen und am Ende ein funktionierendes Produkt zu liefern. Grundsätzlich gibt es verschiedene Ansätze, wie so ein Ablauf organisiert werden kann. Ein klassisches Modell ist das sogenannte Wasserfallmodell. Hier werden die einzelnen Phasen – wie zum Beispiel Planung, Entwicklung, Testen und Auslieferung – nacheinander durchgeführt. Das bedeutet, erst wenn eine Phase abgeschlossen ist, geht es mit der nächsten weiter. Dieses Modell ist übersichtlich, aber wenig flexibel, wenn sich zum Beispiel zwischendurch Anforderungen ändern. In modernen Softwareprojekten werden deshalb oft agile Methoden verwendet, zum Beispiel Scrum. Bei agilen Methoden arbeitet das Team in kurzen Abschnitten, sogenannten Sprints, und überprüft regelmäßig die bisherigen Ergebnisse. Neue Wünsche oder Änderungen können schneller eingeplant werden, und die Zusammenarbeit im Team steht im Mittelpunkt. So können Softwareprodukte Schritt für Schritt entwickelt und laufend verbessert werden. Welches Modell am besten passt, hängt von der Art des Projekts und den Anforderungen ab. In jedem Fall helfen klar strukturierte Prozesse dabei, Aufgaben sinnvoll zu verteilen, Fehler zu vermeiden und das Ziel besser zu erreichen. Anforderungen und Lasten-/Pflichtenheft Bevor mit der eigentlichen Entwicklung einer Software begonnen wird, müssen genau festgelegt werden, was die Software eigentlich können soll und welche Wünsche oder Erwartungen die Auftraggeberinnen haben. Dabei hilft die Unterscheidung zwischen zwei wichtigen Dokumenten: dem Lastenheft und dem Pflichtenheft. Im Lastenheft beschreiben die Auftraggeberinnen, was sie von der Software erwarten, also welche Aufgaben und Probleme die Software lösen soll. Hier stehen die Wünsche und Anforderungen aus Sicht der Nutzerinnen im Mittelpunkt, zum Beispiel: „Die App soll Kundendaten speichern können“ oder „Die Software muss auch auf Smartphones funktionieren“. Das Pflichtenheft wird meist von den Entwicklerinnen erstellt. Hier wird genau erklärt, wie die Anforderungen aus dem Lastenheft technisch umgesetzt werden können. Es geht also darum, konkrete Lösungen zu finden und zu beschreiben, wie die Software gebaut wird, welche Programmiersprache genutzt wird oder wie die Daten gespeichert werden. Durch diese klare Aufteilung wissen alle Beteiligten genau, worauf es ankommt. So können Missverständnisse vermieden werden und das Projekt läuft reibungsloser ab. Planung und Umsetzung kleiner Projekte im Team Wenn ihr als Team ein kleines Softwareprojekt plant, ist es wichtig, von Anfang an gemeinsam zu überlegen, was genau erreicht werden soll. Zuerst setzt ihr euch zusammen und besprecht die Anforderungen: Was muss die Software können? Welche Funktionen sind wirklich notwendig, und was wäre vielleicht ein Extra? Es lohnt sich, die wichtigsten Aufgaben in einzelne Arbeitsschritte zu unterteilen. So könnt ihr die Aufgaben gerecht im Team verteilen und jede Person weiss, wofür sie zuständig ist. Während der Umsetzung tauscht ihr euch regelmässig aus – zum Beispiel bei wöchentlichen Treffen oder kurzen Abstimmungen. Ihr besprecht, welche Aufgaben schon erledigt sind, wo es vielleicht Schwierigkeiten gibt und wie ihr als Gruppe weiter vorgeht. Durch diese enge Zusammenarbeit lassen sich Probleme oft schnell lösen, und am Ende entsteht eine Software, die allen Anforderungen entspricht. Zum Abschluss stellt ihr euer Projekt vor, präsentiert die wichtigsten Funktionen und gebt vielleicht sogar einen Ausblick, wie man die Software weiterentwickeln könnte. So lernt ihr nicht nur das Programmieren, sondern auch Teamarbeit, Planung und Präsentation – Fähigkeiten, die in der Arbeitswelt sehr gefragt sind. Multiple-Choice-Fragen • Was beschreibt das Lastenheft im Softwareentwicklungsprozess? o A) Wie die Anforderungen technisch umgesetzt werden o B) Welche Wünsche und Anforderungen die Auftraggeberinnen an die Software haben o C) Welche Programmiersprache verwendet wird o D) Die geplante Teamgröße • Wer erstellt in der Regel das Pflichtenheft? o A) Die Auftraggeberinnen o B) Die Nutzerinnen o C) Die Entwicklerinnen o D) Die Produktmanager*innen • Warum ist es sinnvoll, die Aufgaben bei einem kleinen Softwareprojekt in einzelne Arbeitsschritte zu unterteilen? o A) Weil es den Code kürzer macht o B) Damit jede Person im Team weiss, wofür sie zuständig ist o C) Weil es schneller ist o D) Damit die Software teurer wird • Was sind in der objektorientierten Programmierung (OOP) Attribute? o A) Die Fähigkeiten eines Objekts o B) Die Eigenschaften eines Objekts o C) Die Programmiersprache o D) Die Teamrollen • Welcher Vorteil ergibt sich, wenn man Klassen und Objekte in einem Programm verwendet? o A) Der Code wird unübersichtlicher o B) Es können viele Objekte auf Basis einer Vorlage erstellt werden o C) Die Software wird langsamer o D) Es gibt keine Wiederverwendbarkeit
  7. Einführung in objektorientierte Programmierung (OOP) Klassen und Objekte Klassen und Objekte sind ein zentraler Bestandteil der objektorientierten Programmierung, die ihr zum Beispiel mit Python kennenlernen werdet. In Python kann man mit Klassen Vorlagen für sogenannte “Objekte” erstellen – das sind Dinge oder Begriffe aus der echten Welt, die in einem Programm abgebildet werden. Eine Klasse ist wie eine Bauanleitung: Sie beschreibt, welche Eigenschaften (Attribute) und Fähigkeiten (Methoden) ein Objekt haben soll. Wenn ihr zum Beispiel eine Klasse “Auto” erstellt, könnt ihr darin festlegen, dass jedes Auto eine bestimmte Farbe und eine maximale Geschwindigkeit hat. Aus dieser Klasse könnt ihr dann beliebig viele einzelne Autos – also Objekte – erzeugen, zum Beispiel ein rotes Auto oder ein blaues Auto. Der grosse Vorteil: Ihr könnt mit Klassen und Objekten übersichtliche und strukturierte Programme schreiben. Anstatt für jedes Auto alles einzeln zu programmieren, legt ihr einmal eine Klasse fest und erstellt daraus so viele Autos (Objekte), wie ihr braucht. Das macht euren Code einfacher, wiederverwendbar und leichter zu pflegen. Attribute und Methoden Stellt euch vor, ihr wollt in Python eine Klasse für „Auto“ schreiben. Damit ein Auto im Programm sinnvoll funktioniert, braucht es Eigenschaften und Fähigkeiten – in der objektorientierten Programmierung nennt man diese Eigenschaften „Attribute“ und die Fähigkeiten „Methoden“. Ein Attribut ist zum Beispiel die Farbe oder die maximale Geschwindigkeit eines Autos. Ihr könnt also in eurer Klasse festlegen, dass jedes Auto eine Farbe (zum Beispiel „rot“ oder „blau“) und eine Höchstgeschwindigkeit besitzt. In Python sieht das dann so aus: class Auto: def init(self, farbe, max_geschwindigkeit): self.farbe = farbe self.max_geschwindigkeit = max_geschwindigkeit Mit dieser Klasse könnt ihr jetzt verschiedene Autos erzeugen: auto1 = Auto(“rot”, 180) auto2 = Auto(“blau”, 200) Methoden sind Funktionen, die zu einer Klasse gehören. Sie geben an, was ein Objekt tun kann. Zum Beispiel könnt ihr für die Klasse Auto eine Methode erstellen, mit der das Auto hupt: class Auto: def init(self, farbe, max_geschwindigkeit): self.farbe = farbe self.max_geschwindigkeit = max_geschwindigkeit def hupen(self): print(“Hup! Hup!“) Jetzt könnt ihr jedes Auto im Programm „hupen“ lassen: auto1.hupen() auto2.hupen() Zusammengefasst: Attribute speichern Informationen über das Objekt, Methoden sorgen dafür, dass das Objekt etwas tun kann. Mit Klassen, Attributen und Methoden könnt ihr in Python übersichtlichen und wiederverwendbaren Code schreiben – und genau das braucht ihr später auch für grössere Projekte. Vererbung und Polymorphie (Grundlagen) Vererbung bedeutet, dass eine neue Klasse (die sogenannte „Kindklasse“) die Eigenschaften und Methoden einer bestehenden Klasse (der „Elternklasse“) übernehmen kann. Das spart viel Schreibarbeit und macht deinen Code übersichtlicher. Zum Beispiel: Wenn du eine Klasse „Fahrzeug“ hast, kannst du eine neue Klasse „Auto“ erstellen, die alles von „Fahrzeug“ erbt und zusätzlich eigene Eigenschaften oder Methoden bekommt. So musst du nicht alles doppelt schreiben. Polymorphie heisst, dass ein Objekt – zum Beispiel ein „Auto“ oder ein „Motorrad“ – zwar unterschiedlich aussehen kann, aber gleich angesprochen werden kann. Du kannst also verschiedene Objekte mit der gleichen Methode wie zum Beispiel .hupen() verwenden, und jedes Objekt reagiert auf seine eigene Weise. Das macht Programme flexibel und leicht erweiterbar. Praxisbeispiel: Mini-Projekt mit OOP Aufgabenstellung: OOP-Miniprojekt „Fahrzeugverwaltung“ Stellt euch vor, ihr arbeitet bei einem kleinen Autoverleih. Eure Aufgabe ist es, ein einfaches Verwaltungssystem für verschiedene Fahrzeuge zu programmieren. Ihr sollt eine Übersichts-Liste aller Fahrzeuge führen können, neue Fahrzeuge hinzufügen und bestimmte Aktionen mit ihnen durchführen. Nutzt dafür die Prinzipien der objektorientierten Programmierung (OOP): Klassen, Attribute, Methoden, Vererbung und Polymorphie. • Erstellt eine Elternklasse Fahrzeug mit Attributen wie marke, modell und baujahr sowie einer Methode beschreibung_ausgeben(). • Leitet davon zwei Kindklassen ab: Auto (mit zusätzlichem Attribut anzahl_tueren) und Motorrad (mit zusätzlichem Attribut hat_beiwagen). • Implementiert für beide Kindklassen eigene hupen()-Methoden, die je nach Fahrzeugtyp unterschiedlich klingen. • Erstellt eine Liste mit mehreren Fahrzeugen und lasst alle Fahrzeuge ihre Beschreibung ausgeben und hupen. Multiple-Choice-Test (5 Fragen) • Was ist der hauptsächliche Vorteil von Objektorientierung bei der Entwicklung von Programmen? o a) Komplexität wird erhöht o b) Wiederverwendbarkeit des Codes o c) Programme laufen schneller o d) Es gibt keine Vorteile • Was ist der Unterschied zwischen einer Klasse und einem Objekt? o a) Eine Klasse ist eine Instanz, ein Objekt ist eine Vorlage o b) Eine Klasse ist eine Vorlage, ein Objekt ist eine Instanz o c) Es gibt keinen Unterschied o d) Ein Objekt kann Methoden definieren, eine Klasse nicht • Welche Methode wird typischerweise verwendet, um eine Beschreibung eines Fahrzeugs auszugeben? o a) hupen() o b) beschreibung_ausgeben() o c) fahren() o d) speichern() • Welche der folgenden Aussagen trifft auf Vererbung zu? o a) Nur Methoden, aber keine Attribute können vererbt werden o b) Ein Kind-Objekt hat Zugriff auf die Attribute und Methoden der Elternklasse o c) Vererbung ist nur in Java möglich o d) Vererbung bedeutet, dass ein Objekt mehrere Klassen gleichzeitig sein kann • Was ist ein typischer Ansatz zur praxisorientierten Vermittlung von Programmierkenntnissen? o a) Nur Theorie vermitteln o b) Viele praktische Übungen und kleine Projekte o c) Abschlussprüfung ohne Vorbereitung o d) Nur Frontalunterricht Anhang Einführung in Git Schritt-für-Schritt-Anleitung am Beispiel eines kleinen Softwareprojekts Git ist ein Werkzeug, das hilft, den Überblick über Änderungen im Code zu behalten und mit anderen im Team zusammenzuarbeiten. Es ist wie eine „Zeitmaschine“ für deine Projekte: Du kannst zu alten Versionen zurückspringen, Änderungen vergleichen und gemeinsam an Dateien arbeiten, ohne dass etwas verloren geht. Eine ausführliche Online-Anleitung findest du hier: [https://git-scm.com/book/de/v2] Warum sollte man Git nutzen? • Sicherheit: Du kannst jederzeit zu einer funktionierenden Version zurückkehren, falls etwas schiefgeht. • Teamarbeit: Mehrere Personen können gleichzeitig am gleichen Projekt arbeiten, ohne sich gegenseitig zu stören. • Nachvollziehbarkeit: Alle Änderungen werden dokumentiert. So sieht man immer, wer was wann geändert hat. Beispiel: Git in einem kleinen Softwareprojekt Stell dir vor, ihr entwickelt im Team eine kleine To-Do-Listen-App. Hier erfährst du, wie ihr Git dafür einsetzen könnt.
  8. Git installieren Warum? Damit du Git-Befehle auf deinem Computer nutzen kannst. • Lade Git von [https://git-scm.com/downloads] herunter und installiere es entsprechend deinem Betriebssystem.
  9. Ein neues Git-Repository anlegen Warum? Das Repository ist der „Topf“, in dem deine Projektdateien und deren Versionen gespeichert werden. • Erstelle einen neuen Ordner für dein Projekt, z. B. todolist-app. • Öffne ein Terminal (oder die Git Bash). • Gehe in deinen neuen Ordner: cd todolist-app • Starte Git im Ordner: git init
  10. Dateien zum Repository hinzufügen Warum? Damit Git weiß, welche Dateien es überwachen soll. • Lege eine Datei an, z. B. main.py. • Füge den ersten Code ein, zum Beispiel: • print(“Willkommen bei der To-Do-Liste!“) • Speichere die Datei. • Im Terminal: git add main.py
  11. Änderungen speichern („committen“) Warum? Du hältst damit eine Version deines Projekts fest, auf die du später zurückgreifen kannst. • Im Terminal: git commit -m “Erstes Programm erstellt” • Mit -m schreibst du eine kurze Beschreibung der Änderung dazu.
  12. Weitere Änderungen machen Schreibe weiter am Code, zum Beispiel eine Funktion, um Aufgaben zur Liste hinzuzufügen. Danach wieder: • git add main.py (um die geänderte Datei zu verfolgen) • git commit -m “Funktion zum Hinzufügen von Aufgaben”
  13. Zusammenarbeit mit anderen (optional: GitHub) Warum? So kann das Team gemeinsam an einem Code arbeiten, egal wo die Mitglieder sind. • Erstellt ein Repository auf GitHub. • Verbindet euer lokales Repository mit dem entfernten auf GitHub: • git remote add origin [URL] • Lade die aktuelle Version hoch: git push -u origin main • Um Änderungen von anderen zu holen: git pull Fazit Mit Git behältst du jederzeit den Überblick über dein Projekt. Du kannst Änderungen rückgängig machen, im Team arbeiten und Fehler leichter finden. Am besten lernst du Git, indem du es einfach ausprobierst – schon nach kurzer Zeit wirst du merken, wie hilfreich es ist!

Graph View