ZUM-Unterrichten - Benutzerbeiträge [de]

Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Einführung in objektorientierte Programmierung (OOP)

2026-02-24T14:54:59Z

Kwschneider: Quiz ergänzt

= 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:
Mit dieser Klasse könnt ihr jetzt verschiedene Autos erzeugen:
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:
def hupen(self):
print("Hup! Hup!")

Jetzt könnt ihr jedes Auto im Programm „hupen“ lassen:
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.

== Quiz ==

<div class="multiplechoice-quiz">

Was ist der hauptsächliche Vorteil von Objektorientierung bei der Entwicklung von Programmen?
(!Komplexität wird erhöht)
(Wiederverwendbarkeit des Codes)
(!Programme laufen schneller)
(!Es gibt keine Vorteile)

Was ist der Unterschied zwischen einer Klasse und einem Objekt?
(!Eine Klasse ist eine Instanz, ein Objekt ist eine Vorlage)
(Eine Klasse ist eine Vorlage, ein Objekt ist eine Instanz)
(!Es gibt keinen Unterschied)
(!Ein Objekt kann Methoden definieren, eine Klasse nicht)

Welche der folgenden Aussagen trifft auf Vererbung zu?
(!Nur Methoden, aber keine Attribute können vererbt werden)
(Ein Kind-Objekt hat Zugriff auf die Attribute und Methoden der Elternklasse)
(!Vererbung ist nur in Java möglich)
(!Vererbung bedeutet, dass ein Objekt mehrere Klassen gleichzeitig sein kann)

Was ist ein typischer Ansatz zur praxisorientierten Vermittlung von Programmierkenntnissen?
(!Nur Theorie vermitteln)
(Viele praktische Übungen und kleine Projekte)
(!Abschlussprüfung ohne Vorbereitung)
(!Nur Frontalunterricht)

[[Kategorie:Softwareentwicklung]]
[[Kategorie:Informatik]]
__INDEXIEREN__
[[Kategorie:Berufsschule]]

Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Einführung in objektorientierte Programmierung (OOP)

2026-02-24T14:50:18Z

Kwschneider:

Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Einführung in objektorientierte Programmierung (OOP)

2026-02-24T14:48:42Z

Kwschneider: neues Kapitel

= 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:
Mit dieser Klasse könnt ihr jetzt verschiedene Autos erzeugen:
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:
def hupen(self):
print("Hup! Hup!")

Jetzt könnt ihr jedes Auto im Programm „hupen“ lassen:
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.

Benutzer:Kwschneider

2026-02-24T14:44:00Z

Kwschneider: neues Kapitel

Ich habe nach einer handwerklichen Ausbildung Ingenieurinformatik studiert. Neben meiner Arbeit als Ingenieur bin ich ehrenamtlich Prüfer für IT-Ausbildungsberufe bei der Industrie- und Handelskammer. Ich bin Dozent an einer technischen Hochschule und unterrichte seit Herbst 2025 als Lehrer an einer Berufsschule. Schwerpunkt sind hier Grundlagen der Softwareentwicklung.

=Grundlagen der Softwareentwicklung=
Unterlagen zum Selbststudium nebst Lernkontrolle anhand von MultipleChoice-Fragen:

* [[Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Einführung]]
* [[Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Denkweisen und Konzepte der Programmierung]]
* [[Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Programmiergrundlagen]]
* [[Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Datenstrukturen und einfache Algorithmen]]
* [[Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Softwareentwicklung in der Praxis]]
* [[Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Softwareentwicklungsprozesse und -modelle]]
* [[Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Einführung in objektorientierte Programmierung (OOP)]]

=Übungsbeispiele Python=
* [[Benutzer:Kwschneider/Softwareentwicklung/Python/Übungen/Passwortverwaltung]]

Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Softwareentwicklungsprozesse und -modelle

2026-02-24T14:41:55Z

Kwschneider:

= 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 Auftraggeber*innen haben. Dabei hilft die Unterscheidung zwischen zwei wichtigen Dokumenten: dem Lastenheft und dem Pflichtenheft.

Im Lastenheft beschreiben die Auftraggeber''innen, 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 Nutzer''innen 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 Entwickler*innen 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.

== Quiz ==

<div class="multiplechoice-quiz">

Was beschreibt das Lastenheft im Softwareentwicklungsprozess?
(!Wie die Anforderungen technisch umgesetzt werden)
(Welche Wünsche und Anforderungen die Auftraggeber*innen an die Software haben)
(!Welche Programmiersprache verwendet wird)
(!Die geplante Teamgröße)

Wer erstellt in der Regel das Pflichtenheft?
(!Die Auftraggeber*innen)
(!Die Nutzer*innen)
(Die Entwickler*innen)
(!Die Produktmanager*innen)

Warum ist es sinnvoll, die Aufgaben bei einem kleinen Softwareprojekt in einzelne Arbeitsschritte zu unterteilen?
(!Weil es den Code kürzer macht)
(Damit jede Person im Team weiss, wofür sie zuständig ist)
(!Weil es schneller ist)
(!Damit die Software teurer wird)

Was sind in der objektorientierten Programmierung Attribute?
(!Die Fähigkeiten eines Objekts)
(Die Eigenschaften eines Objekts)
(!Die Programmiersprache)
(!Die Teamrollen)

Welcher Vorteil ergibt sich, wenn man Klassen und Objekte in einem Programm verwendet?
(!Der Code wird unübersichtlicher)
(Es können viele Objekte auf Basis einer Vorlage erstellt werden)
(!Die Software wird langsamer)
(!Es gibt keine Wiederverwendbarkeit)

[[Kategorie:Softwareentwicklung]]
[[Kategorie:Informatik]]
__INDEXIEREN__
[[Kategorie:Berufsschule]]

Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Softwareentwicklungsprozesse und -modelle

2026-02-24T14:40:46Z

Kwschneider: Quiz ergänzt

= 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 Auftraggeber*innen haben. Dabei hilft die Unterscheidung zwischen zwei wichtigen Dokumenten: dem Lastenheft und dem Pflichtenheft.

Im Lastenheft beschreiben die Auftraggeber''innen, 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 Nutzer''innen 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 Entwickler*innen 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.

== Quiz ==

<div class="multiplechoice-quiz">

Was beschreibt das Lastenheft im Softwareentwicklungsprozess?
(!Wie die Anforderungen technisch umgesetzt werden)
(Welche Wünsche und Anforderungen die Auftraggeber*innen an die Software haben)
(!Welche Programmiersprache verwendet wird)
(!Die geplante Teamgröße)

Wer erstellt in der Regel das Pflichtenheft?
(!Die Auftraggeber*innen)
(!Die Nutzer*innen)
(Die Entwickler*innen)
(!Die Produktmanager*innen)

Warum ist es sinnvoll, die Aufgaben bei einem kleinen Softwareprojekt in einzelne Arbeitsschritte zu unterteilen?
(!Weil es den Code kürzer macht)
(Damit jede Person im Team weiss, wofür sie zuständig ist)
(!Weil es schneller ist)
(!Damit die Software teurer wird)

Was sind in der objektorientierten Programmierung (OOP) Attribute?
(!Die Fähigkeiten eines Objekts)
(Die Eigenschaften eines Objekts)
(!Die Programmiersprache)
(!Die Teamrollen)

Welcher Vorteil ergibt sich, wenn man Klassen und Objekte in einem Programm verwendet?
(!Der Code wird unübersichtlicher)
(Es können viele Objekte auf Basis einer Vorlage erstellt werden)
(!Die Software wird langsamer)
(!Es gibt keine Wiederverwendbarkeit)

[[Kategorie:Softwareentwicklung]]
[[Kategorie:Informatik]]
__INDEXIEREN__
[[Kategorie:Berufsschule]]

Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Softwareentwicklungsprozesse und -modelle

2026-02-24T14:34:50Z

Kwschneider:

Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Softwareentwicklungsprozesse und -modelle

2026-02-24T14:33:48Z

Kwschneider: neues Kapitel

<nowiki>= 6. Softwareentwicklungsprozesse und -modelle =</nowiki>

<nowiki>== Wasserfallmodell vs. agile Methoden ==</nowiki>

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.

<nowiki>== Anforderungen und Lasten-/Pflichtenheft ==</nowiki>

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 Auftraggeber*innen haben. Dabei hilft die Unterscheidung zwischen zwei wichtigen Dokumenten: dem Lastenheft und dem Pflichtenheft.

Im Lastenheft beschreiben die Auftraggeber''innen, 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 Nutzer''innen 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 Entwickler*innen 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.

<nowiki>== Planung und Umsetzung kleiner Projekte im Team ==</nowiki>

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.

Benutzer:Kwschneider

2026-02-24T14:32:36Z

Kwschneider: neues Kapitel

Ich habe nach einer handwerklichen Ausbildung Ingenieurinformatik studiert. Neben meiner Arbeit als Ingenieur bin ich ehrenamtlich Prüfer für IT-Ausbildungsberufe bei der Industrie- und Handelskammer. Ich bin Dozent an einer technischen Hochschule und unterrichte seit Herbst 2025 als Lehrer an einer Berufsschule. Schwerpunkt sind hier Grundlagen der Softwareentwicklung.

=Grundlagen der Softwareentwicklung=
Unterlagen zum Selbststudium nebst Lernkontrolle anhand von MultipleChoice-Fragen:

* [[Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Einführung]]
* [[Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Denkweisen und Konzepte der Programmierung]]
* [[Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Programmiergrundlagen]]
* [[Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Datenstrukturen und einfache Algorithmen]]

* [[Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Softwareentwicklung in der Praxis]]
* [[Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Softwareentwicklungsprozesse und -modelle]]

=Übungsbeispiele Python=
* [[Benutzer:Kwschneider/Softwareentwicklung/Python/Übungen/Passwortverwaltung]]

Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Softwareentwicklung in der Praxis

2026-02-23T19:50:11Z

Kwschneider: Quiz ergänzt

= 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 Annotations ==

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 <nowiki>'''</nowiki>, 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:

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:

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.

== Quiz ==

<div class="multiplechoice-quiz">

Was ist der Hauptvorteil von Typannotationen in Python?
(!Sie beschleunigen die Laufzeit des Programms.)
(Sie helfen, Fehler früh zu erkennen und machen den Code verständlicher.)
(!Sie sind verpflichtend und werden vom Interpreter geprüft.)
(!Sie ersetzen die Notwendigkeit zu testen.)

Was beschreibt eine typische Unit-Test-Aufgabe am besten?
(!Überprüfung der gesamten Software.)
(Testen einzelner Funktionen oder Methoden auf korrektes Verhalten.)
(!Kontrolle des Designs der Benutzeroberfläche.)
(!Erstellung eines Lastenhefts.)

Welches Python-Modul ist speziell für das Schreiben und Ausführen von Unit�Tests vorgesehen?
(!math)
(!random)
(unittest)
(!os)

Was ist ein zentrales Merkmal des Wasserfallmodells?
(!Iterative Entwicklung mit vielen Rückkopplungen.)
(Feste Reihenfolge von Phasen, jeweils Abschluss einer Phase vor Beginn der nächsten.)
(!Kontinuierliche Auslieferung.)
(!Ständige Einbindung der Endnutzer*innen.)

Welche Aussage trifft auf das Pflichtenheft zu?
(!Es wird ausschließlich von den Nutzer*innen geschrieben.)
(Es beschreibt, wie die Anforderungen technisch umgesetzt werden.)
(!Es enthält ausschließlich Kundenwünsche.)
(!Es wird nach Abschluss der Entwicklung erstellt.)

[[Kategorie:Softwareentwicklung]]
[[Kategorie:Informatik]]
__INDEXIEREN__
[[Kategorie:Berufsschule]]

Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Softwareentwicklung in der Praxis

2026-02-23T19:41:38Z

Kwschneider:

Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Softwareentwicklung in der Praxis

2026-02-23T19:40:36Z

Kwschneider:

= 5. Softwareentwicklung in der Praxis =</nowiki> =
== 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 Annotations ==

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 <nowiki>'''</nowiki>, 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:

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:

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.

Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Softwareentwicklung in der Praxis

2026-02-23T19:38:25Z

Kwschneider:

==== <nowiki>= 5. Softwareentwicklung in der Praxis =</nowiki> ====
<nowiki>== Entwicklungsumgebungen (IDE, Editor, Compiler/Interpreter) ==</nowiki>

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.

<nowiki>== Versionsverwaltung mit Git (Grundlagen, einfache Workflows) ==</nowiki>

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.

<nowiki>== Dokumentation und Kommentierung von Code ==</nowiki>

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!

<nowiki>== Docstrings und Annotations ==</nowiki>

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 <nowiki>'''</nowiki>, 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:

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:

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.

<nowiki>== Testen und Qualitätssicherung (Unit-Tests, Testfälle) ==</nowiki>

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.

Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Softwareentwicklung in der Praxis

2026-02-23T19:34:07Z

Kwschneider: neues Kapitel

== Softwareentwicklung in der Praxis ==

<nowiki>=== Entwicklungsumgebungen (IDE, Editor, Compiler/Interpreter) ===</nowiki>

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.

<nowiki>=== Versionsverwaltung mit Git (Grundlagen, einfache Workflows) ===</nowiki>

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.

<nowiki>=== Dokumentation und Kommentierung von Code ===</nowiki>

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!

<nowiki>=== Docstrings und Annotations ===</nowiki>

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 <nowiki>'''</nowiki>, 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:

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:

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.

<nowiki>=== Testen und Qualitätssicherung (Unit-Tests, Testfälle) ===</nowiki>

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.

Benutzer:Kwschneider

2026-02-23T19:32:12Z

Kwschneider: Kapitel ergänzt: Softwareentwicklung in der Praxis

Ich habe nach einer handwerklichen Ausbildung Ingenieurinformatik studiert. Neben meiner Arbeit als Ingenieur bin ich ehrenamtlich Prüfer für IT-Ausbildungsberufe bei der Industrie- und Handelskammer. Ich bin Dozent an einer technischen Hochschule und unterrichte seit Herbst 2025 als Lehrer an einer Berufsschule. Schwerpunkt sind hier Grundlagen der Softwareentwicklung.

=Grundlagen der Softwareentwicklung=
Unterlagen zum Selbststudium nebst Lernkontrolle anhand von MultipleChoice-Fragen:

* [[Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Einführung]]
* [[Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Denkweisen und Konzepte der Programmierung]]
* [[Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Programmiergrundlagen]]
* [[Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Datenstrukturen und einfache Algorithmen]]

* [[Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Softwareentwicklung in der Praxis]]
* Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/

=Übungsbeispiele Python=
* [[Benutzer:Kwschneider/Softwareentwicklung/Python/Übungen/Passwortverwaltung]]

Thema:Z6fho9uzwoia2z0y

2026-01-13T20:01:09Z

Kwschneider (Diskussion | Beiträge) kommentierte auf „Lieber Kwschneider“ (Hallo Herr Dautel, auch von meiner Seite a guads Nei‘s, wie man in Bayern sagt! Und vielen Dank, für das Angebot, meine Beiträge über den Z…).

Benutzer:Kwschneider/Softwareentwicklung/Python/Übungen/Passwortverwaltung

2026-01-12T17:57:34Z

Kwschneider:

=Python-Übungsaufgabe:=
=Verwaltung von Benutzernamen und Passwörtern=

==Teil 1: Manuelle Eingabe und Dateispeicherung==
;Lernziel
:Schüler lernen, wie man Benutzernamen und Passwörter per Konsole abfragt, in einer Datei speichert und grundlegende Dateizugriffe in Python nutzt.

Wichtige Hinweise zu Dateizugriffen
* Beim Lesen/Schreiben von Dateien sollte stets ein Context Manager (with open(...) as f:) verwendet werden.
* Verwende den Modus "a" (append) zum Hinzufügen neuer Einträge, ohne vorhandene zu überschreiben.
* Achte auf Zeichencodierung (z. B. encoding="utf-8"), um Umlaute oder Sonderzeichen korrekt abzulegen.
* Sensible Daten niemals in öffentlich einsehbaren Dateien ablegen.

Beispielcode

<syntaxhighlight lang="python" line>
def teil1_neuer_eintrag(dateipfad):
benutzer = input("Benutzername: ")
passwort = input("Passwort: ")
eintrag = f"{benutzer}:{passwort}\n"
with open(dateipfad, "a", encoding="utf-8") as file:
file.write(eintrag)
print("Eintrag gespeichert.")
</syntaxhighlight>

==Teil 2: Passwortregeln prüfen==
;Lernziel
:Schüler implementieren eine Funktion, die Passwörter gegen aktuelle Sicherheitsstandards validiert.

Vorgeschlagene Regeln
* Mindestens 12 Zeichen Länge
* Mindestens ein Großbuchstabe
* Mindestens ein Kleinbuchstabe
* Mindestens eine Ziffer
* Mindestens ein Sonderzeichen (!@#$%^&*()_+-=[]{};:,.<>/?)
* Keine Leerzeichen
* Keine Wiederholungen (z. B. “aaa”, “111”)

Beispielcode

<syntaxhighlight lang="python" line>
import re

def pruefe_passwort(pw):
if len(pw) < 12:
return False, "Passwort zu kurz (mind. 12 Zeichen)."
if not re.search(r"[A-Z]", pw):
return False, "Mindestens ein Großbuchstabe fehlt."
if not re.search(r"[a-z]", pw):
return False, "Mindestens ein Kleinbuchstabe fehlt."
if not re.search(r"[0-9]", pw):
return False, "Mindestens eine Ziffer fehlt."
if not re.search(r"[!@#$%^&*()_+\-=\[\]{};:,.<>/?]", pw):
return False, "Mindestens ein Sonderzeichen fehlt."
if " " in pw:
return False, "Passwort darf keine Leerzeichen enthalten."
if re.search(r"(.)\1\1", pw):
return False, "Drei gleiche Zeichen hintereinander sind nicht erlaubt."
return True, "Passwort erfüllt alle Regeln."

# Integrierte Nutzung im Hauptprogramm
pw = input("Passwort wählen: ")
ok, meldung = pruefe_passwort(pw)
print(meldung)
</syntaxhighlight>

==Teil 3: Hash-Verfahren und MD5==
;Lernziel
:Schüler verstehen, was Hash-Funktionen sind und wie man MD5 in Python anwendet.

Allgemeines zu Hash-Verfahren
* Hash-Funktionen wandeln Eingaben beliebiger Länge in eine fixe Bitfolge um.
* Sie sind Einbahn: aus dem Hash kann man normalerweise nicht das Originalpasswort rekonstruieren.
* Kollisionen (zwei Eingaben mit demselben Hash) sind unerwünscht, treten aber teilweise auf.
* Für echte Anwendungen werden heute stärkere Verfahren (z. B. SHA-256, bcrypt) empfohlen.

MD5 in Python:
<syntaxhighlight lang="python" line>
import hashlib
def md5_hash(pw):
hasher = hashlib.md5()
hasher.update(pw.encode("utf-8"))
return hasher.hexdigest()

# Beispiel:
klartext_passwort = "MeinSicheresPW!123"
hash_wert = md5_hash(klartext_passwort)
print("MD5-Hash:", hash_wert)
</syntaxhighlight>

Anwendung während des Speicherns:

<syntaxhighlight lang="python" line>
def teil3_neuer_eintrag(dateipfad):
benutzer = input("Benutzername: ")
pw = input("Passwort wählen: ")
hashed = md5_hash(pw)
eintrag = f"{benutzer}:{hashed}\n"
with open(dateipfad, "a", encoding="utf-8") as f:
f.write(eintrag)
print("Benutzer und Hash gespeichert.")
</syntaxhighlight>

==Teil 4: Passwortprüfung bei bestehendem Benutzer==
;Lernziel
:Schüler erweitern ihr Programm um eine Login-Funktion: Eingabe von Benutzername und Passwort wird gegen die gespeicherten MD5-Hashes geprüft.

Beispielcode:

<syntaxhighlight lang="python" line>
def lade_passwortdatei(dateipfad):
daten = {}
with open(dateipfad, "r", encoding="utf-8") as f:
for zeile in f:
name, hashwert = zeile.strip().split(":", 1)
daten[name] = hashwert
return daten

def login_pruefung(dateipfad):
daten = lade_passwortdatei(dateipfad)
benutzer = input("Benutzername: ")
if benutzer not in daten:
print("Benutzer nicht gefunden.")
return

pw = input("Passwort: ")
if md5_hash(pw) == daten[benutzer]:
print("Login erfolgreich.")
else:
print("Falsches Passwort.")

# Beispielaufruf
login_pruefung("passwoerter.txt")
</syntaxhighlight>

Weiterführende Anregungen
* Salted Hashes einführen: Für jeden Benutzer einen zufälligen Salt vor dem Hashen nutzen.
* Bessere Algorithmen einsetzen: z. B. hashlib.sha256, bcrypt oder scrypt.
* Verwaltung in einer SQLite-Datenbank statt in einer Textdatei.
* Zwei-Faktor-Authentifizierung (2FA) simulieren.
* Passwort-Blacklist implementieren, um häufige Passwörter zu verbieten.
[[Kategorie:Python]]
[[Kategorie:Informatik]]
[[Kategorie:Softwareentwicklung]]
__INDEXIEREN__
[[Kategorie:Berufsschule]]
[[Kategorie:Programmieren]]

Benutzer:Kwschneider/Softwareentwicklung/Python/Übungen/Passwortverwaltung

2026-01-11T21:25:22Z

Kwschneider:

Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Datenstrukturen und einfache Algorithmen

2026-01-11T21:24:46Z

Kwschneider:

= 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:
<syntaxhighlight lang="python">
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.")
</syntaxhighlight>

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:
<syntaxhighlight lang="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]
</syntaxhighlight>

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:

<syntaxhighlight lang="python">
def fakultaet(n):
if n == 0:
return 1
else:
return n * fakultaet(n - 1)

print(fakultaet(5)) # Ausgabe: 120
</syntaxhighlight>

Hier ruft sich die Funktion <code>fakultaet</code> immer wieder selbst auf, bis die Bedingung <code>n == 0</code> 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:

<syntaxhighlight lang="python">
for zahl in liste:
print(zahl)
</syntaxhighlight>

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: <code>liste[0]</code>).
* 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.

== Quiz ==

<div class="multiplechoice-quiz">

Was beschreibt die Big-O-Notation hauptsächlich?
(!Die Lesbarkeit des Codes)
(!Die Anzahl der Variablen im Programm)
(!Das Speicherformat einer Datei)
(Die Laufzeit oder den Ressourcenverbrauch eines Algorithmus in Abhängigkeit von der Eingabemenge)

Welche Laufzeit hat ein Algorithmus mit O[n²]?
(!Die Laufzeit bleibt immer gleich, egal wie viele Elemente)
(!Die Laufzeit wächst exponentiell bei mehr Elementen)
(Für jedes Element wird die komplette Liste erneut durchlaufen)
(!Die Laufzeit halbiert sich bei doppelter Eingabegröße)

Was ist der Hauptvorteil von Versionsverwaltungssystemen wie Git?
(!Sie machen den Code schneller)
(Änderungen am Code können nachverfolgt und ältere Versionen wiederhergestellt werden)
(!Sie übersetzen den Code in Maschinensprache)
(!Sie formatieren automatisch den Quelltext)

Wie dokumentierst du in Python längere Erklärungen zu Funktionen am besten?
(!Mit einfachen Anführungszeichen)
(Mit Docstrings, die durch dreifache Anführungszeichen gekennzeichnet sind)
(!Mit eckigen Klammern)
(!Mit dem Zeichen %)

Was beschreibt ein typischer Workflow bei der Arbeit mit Git in einem Team?
(!Jeder arbeitet im selben Branch und überschreibt Änderungen anderer)
(!Änderungen werden per E-Mail verschickt)
(Änderungen werden in einem eigenen Branch vorgenommen und später mit dem Hauptzweig zusammengeführt)
(!Alle machen ihre Änderungen direkt im Hauptzweig, ohne Absprachen)
[[Kategorie:Softwareentwicklung]]
[[Kategorie:Informatik]]
__INDEXIEREN__
[[Kategorie:Berufsschule]]

Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Programmiergrundlagen

2026-01-11T21:24:25Z

Kwschneider:

= 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:

<syntaxhighlight lang="python" line>
x = 5

name = "Anna"

ist_alt_genug = True
</syntaxhighlight>

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:
<syntaxhighlight lang="python" line>
name = input("Wie heißt du? ")

print("Hallo,", name)
</syntaxhighlight>

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

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:
<syntaxhighlight lang="python" line>
ergebnis = 7 * 4
</syntaxhighlight>
=== Vergleichsoperatoren ===

Damit prüfst du, ob zwei Werte gleich oder unterschiedlich sind.

== bedeutet „ist gleich“, != „ist ungleich“.

Beispiel:
<syntaxhighlight lang="python" line>
if alter == 18:
</syntaxhighlight>
=== Größer und 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:
<syntaxhighlight lang="python" line>
if ist_alt_genug and name == "Anna":
</syntaxhighlight>
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 und Benutzer nach Informationen fragen.

Zum Beispiel:
<syntaxhighlight lang="python" line>
name = input("Wie heißt du? ")
</syntaxhighlight>
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:
<syntaxhighlight lang="python" line>
print("Hallo, " + name)
</syntaxhighlight>
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 Zusatzaufwand benötigen.

Selbst komplexere Aufgaben wie das Formatieren von Ausgaben kannst du mit wenigen Handgriffen erledigen, zum Beispiel mit:
<syntaxhighlight lang="python" line>
print(f"Du bist {alter} Jahre alt.")
</syntaxhighlight>
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:
<syntaxhighlight lang="python" line>
def begruessung(name):

print(f"Hallo, {name}!")
</syntaxhighlight>
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 zum Beispiel 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 es mit einem Debugger, der in vielen Entwicklungsumgebungen 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.

== Quiz ==

<div class="multiplechoice-quiz">

Welche der folgenden Fehlerarten tritt auf, wenn ein Programm zwar startet, aber während der Ausführung auf ein Problem stößt?
(!Syntaxfehler)
(Laufzeitfehler)
(!Logischer Fehler)
(!Tippfehler)

Was ist ein Vorteil von Modulen in Python?
(!Sie machen Programme langsamer)
(Sie erlauben es, Funktionen und Code übersichtlich zu strukturieren und wiederzuverwenden)
(!Sie verhindern Fehler vollständig)
(!Sie ersetzen die Notwendigkeit von Datenstrukturen)

Welcher Befehl wird empfohlen, um beim Debugging den Programmverlauf zu überprüfen?
(!input)
(print)
(!exit)
(!import)

Was unterscheidet ein Tupel von einer Liste in Python?
(!Tupel können nach dem Erstellen verändert werden, Listen nicht)
(!Listen sind unveränderlich, Tupel nicht)
(Tupel sind unveränderlich, Listen nicht)
(!Es gibt keinen Unterschied)

Wie funktioniert die lineare Suche?
(!Die Liste wird nach Größe sortiert)
(Alle Elemente werden von vorne bis hinten durchgegangen und mit dem gesuchten Wert verglichen)
(!Die Suche wird mithilfe eines Wörterbuchs durchgeführt)
(!Die Elemente werden zufällig überprüft)

</div>
[[Kategorie:Softwareentwicklung]]
[[Kategorie:Informatik]]
__INDEXIEREN__
[[Kategorie:Berufsschule]]

Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Denkweisen und Konzepte der Programmierung

2026-01-11T21:24:05Z

Kwschneider:

= 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 großes 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
* Rauten für Entscheidungen (zum Beispiel: „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),
* 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.

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.

= Quiz =

<div class="multiplechoice-quiz">

Was ist der Hauptvorteil eines Flussdiagramms beim Programmieren?
(!Es generiert automatisch den Programmcode.)
(!Es hilft dabei, den genauen Speicherbedarf zu berechnen.)
(Es stellt den Ablauf eines Programms grafisch dar und erleichtert das
Erkennen von Fehlern.)
(!Es ersetzt die Programmbeschreibung vollständig.)

Welcher der folgenden Begriffe ist KEINE Kontrollstruktur?
(Variable)
(!Sequenz)
(!Verzweigung)
(!Schleife)

Wie sieht ein Beispiel für Pseudocode aus?
(!x = 5 + 3)
(„Frage das Alter ab, vergleiche es mit 18, gib das Ergebnis aus.“)
(!return x)
(!for i in liste: i += 1)

Wie weist man in Python einer Variablen einen Wert zu?
(!variable == wert)
(!wert = variable)
(variable = wert)
(!set variable wert)

Was macht der Befehl input() in Python?
(!Gibt einen Wert auf dem Bildschirm aus.)
(Fragt eine Eingabe von der*dem Benutzer*in ab.)
(!Vergleicht zwei Werte.)
(!Definiert eine neue Variable.)

</div>
[[Kategorie:Softwareentwicklung]]
[[Kategorie:Informatik]]
__INDEXIEREN__
[[Kategorie:Berufsschule]]

Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Einführung

2026-01-11T21:23:44Z

Kwschneider:

= 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.

<u>Merke</u><br>
Softwareentwicklung umfasst mehr als Programmieren: Analyse, Planung und Zusammenarbeit sind ebenso wichtig.

== Überblick über Softwarearten ==
Es gibt verschiedene Arten von Software, die in unserem Alltag und in der Arbeitswelt eine wichtige Rolle spielen.

Grundsätzlich unterscheidet man zwischen Systemsoftware, Anwendungssoftware sowie Web- und Mobile-Apps.

=== Systemsoftware ===
Systemsoftware ist die Software, die dafür sorgt, dass ein 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önnten keine anderen Programme genutzt werden.

=== Anwendungssoftware ===
Anwendungssoftware bezeichnet alle Programme, mit denen Nutzerinnen und Nutzer direkt arbeiten.

Dazu gehören zum Beispiel:
* Textverarbeitungen wie Word
* Tabellenkalkulationen wie Excel
* Grafikprogramme wie Photoshop
* Spiele, Musikplayer oder Chat-Programme

Anwendungssoftware hilft dabei, bestimmte Aufgaben zu erledigen oder dient der Unterhaltung.

=== Web- und Mobile-Apps ===
Viele Programme gibt es heute nicht mehr nur für den Computer, sondern auch als Anwendungen im Internet oder als Apps auf mobilen Geräten.

Ein Beispiel ist WhatsApp als App auf dem Smartphone oder Google Docs, das direkt im Browser genutzt wird.

Web- und Mobile-Apps sind besonders praktisch, weil sie ortsunabhängig und oft auf verschiedenen Geräten genutzt werden können.

<u>Zusammenfassung</u><br>
Software sorgt in unterschiedlichen Formen dafür, dass digitale Geräte für Arbeit, Lernen und Freizeit genutzt werden können.

== Softwareentwicklungsprozess – Überblick ==
Damit aus einer Idee am Ende eine funktionierende Software wird, gibt es verschiedene Schritte, die im sogenannten Softwareentwicklungsprozess aufeinander folgen.

=== Planung und Konzeption ===
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 folgt die Konzeption. Dabei wird geplant, wie die Software aufgebaut sein soll, zum Beispiel welche Funktionen es geben wird und wie das Programm aussehen könnte.

=== Programmierung und Testen ===
Ist der Plan fertig, startet die eigentliche Programmierung.

Die Entwicklerinnen und Entwickler schreiben den Code, testen Zwischenergebnisse und passen ihn immer wieder an.

Parallel dazu prüfen Testerinnen und Tester die Software gezielt auf Fehler, damit am Ende alles zuverlässig funktioniert.

Häufig wird die Software in mehreren Versionen entwickelt, sodass schon früh ausprobiert und verbessert werden kann.

=== Auslieferung und Wartung ===
Wenn alles funktioniert, wird die fertige Software ausgeliefert und installiert – entweder direkt auf den Geräten oder über das Internet.

Aber damit ist der Prozess nicht abgeschlossen. Auch nach der Veröffentlichung kümmern sich die Beteiligten um Updates und Verbesserungen, damit die Software weiterhin sicher und nützlich bleibt.

<u>Merke</u><br>
Ein strukturierter Entwicklungsprozess hilft dabei, aus einer Idee schrittweise eine zuverlässige Software zu entwickeln.

== Rollen im Softwareentwicklungsprozess ==
Im Softwareentwicklungsprozess arbeiten viele verschiedene Personen zusammen, die jeweils unterschiedliche Aufgaben und Verantwortlichkeiten haben.

Diese unterschiedlichen Aufgaben werden als Rollen bezeichnet.

=== Entwicklerinnen und Entwickler ===
Entwicklerinnen und Entwickler 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 und Tester ===
Testerinnen und Tester 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 und Projektmanager ===
Projektmanagerinnen und Projektmanager behalten den Überblick.

Sie planen, wer was wann erledigt, achten auf den Zeitplan und sorgen dafür, dass das Team gut zusammenarbeitet.

Außerdem vermitteln sie zwischen Kundinnen und Kunden und dem Entwicklungsteam.

=== Weitere Rollen ===
Neben diesen Hauptrollen gibt es häufig weitere Beteiligte, zum Beispiel:
* Designerinnen und Designer für das Aussehen und die Bedienbarkeit
* Support-Mitarbeitende für Fragen der Nutzerinnen und Nutzer

<u>Merke</u><br>
Alle Rollen tragen gemeinsam dazu bei, dass eine Software den Erwartungen entspricht und gut genutzt werden kann.

== Quiz ==
<div class="multiplechoice-quiz">

Was ist die erste Phase im Softwareentwicklungsprozess?
(!Programmierung)
(Planung)
(!Testen)
(!Installation)

Welche Aufgabe haben Tester*innen im Softwareentwicklungsprozess?
(!Das Design der Benutzeroberfläche entwickeln)
(Die Software auf Fehler prüfen)
(!Die Codebasis verwalten)
(!Updates veröffentlichen)

Welche Rolle sorgt dafür, dass das Team gut zusammenarbeitet und der
Zeitplan eingehalten wird?
(!Entwickler*innen)
(!Tester*innen)
(Projektmanager*innen)
(!Support-Mitarbeitende)

Was bedeutet algorithmisches Denken?
(Ein Problem Schritt für Schritt lösen)
(!Einen Computer bauen)
(!Fehler im Code suchen)
(!Programme in Alltagssprache erklären)

Warum werden vor dem Programmieren oft Flussdiagramme oder
Pseudocode verwendet?
(!Um das fertige Programm schneller ausführen zu können)
(Um die Lösung grafisch oder in Alltagssprache zu planen)
(!Weil der Computer es verlangt)
(!Um den Code zu verkürzen)

</div>
[[Kategorie:Softwareentwicklung]]
[[Kategorie:Informatik]]
__INDEXIEREN__
[[Kategorie:Berufsschule]]

Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Datenstrukturen und einfache Algorithmen

2026-01-11T21:22:39Z

Kwschneider:

Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Programmiergrundlagen

2026-01-11T21:22:14Z

Kwschneider:

Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Denkweisen und Konzepte der Programmierung

2026-01-11T21:21:46Z

Kwschneider:

Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Einführung

2026-01-11T21:20:59Z

Kwschneider:

Benutzer:Kwschneider/Softwareentwicklung/Python/Übungen/Passwortverwaltung

2026-01-11T21:19:59Z

Kwschneider:

Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Datenstrukturen und einfache Algorithmen

2026-01-09T19:29:41Z

Kwschneider:

Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Datenstrukturen und einfache Algorithmen

2026-01-09T19:26:38Z

Kwschneider: Quiz ergänzt

= 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:
<syntaxhighlight lang="python">
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.")
</syntaxhighlight>

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:
<syntaxhighlight lang="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]
</syntaxhighlight>

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:

<syntaxhighlight lang="python">
def fakultaet(n):
if n == 0:
return 1
else:
return n * fakultaet(n - 1)

print(fakultaet(5)) # Ausgabe: 120
</syntaxhighlight>

Hier ruft sich die Funktion <code>fakultaet</code> immer wieder selbst auf, bis die Bedingung <code>n == 0</code> 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:

<syntaxhighlight lang="python">
for zahl in liste:
print(zahl)
</syntaxhighlight>

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: <code>liste[0]</code>).
* 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.

== Quiz ==

<div class="multiplechoice-quiz">

Was beschreibt die Big-O-Notation hauptsächlich?
(!Die Lesbarkeit des Codes)
(!Die Anzahl der Variablen im Programm)
(!Das Speicherformat einer Datei)
(Die Laufzeit oder den Ressourcenverbrauch eines Algorithmus in Abhängigkeit von der Eingabemenge)

Welche Laufzeit hat ein Algorithmus mit O(n²)?
(!Die Laufzeit bleibt immer gleich, egal wie viele Elemente)
(!Die Laufzeit wächst exponentiell bei mehr Elementen)
(Für jedes Element wird die komplette Liste erneut durchlaufen)
(!Die Laufzeit halbiert sich bei doppelter Eingabegröße)

Was ist der Hauptvorteil von Versionsverwaltungssystemen wie Git?
(!Sie machen den Code schneller)
(Änderungen am Code können nachverfolgt und ältere Versionen wiederhergestellt werden)
(!Sie übersetzen den Code in Maschinensprache)
(!Sie formatieren automatisch den Quelltext)

Wie dokumentierst du in Python längere Erklärungen zu Funktionen am besten?
(!Mit einfachen Anführungszeichen)
(Mit Docstrings, die durch dreifache Anführungszeichen gekennzeichnet sind)
(!Mit eckigen Klammern)
(!Mit dem Zeichen %)

Was beschreibt ein typischer Workflow bei der Arbeit mit Git in einem Team?
(!Jeder arbeitet im selben Branch und überschreibt Änderungen anderer)
(!Änderungen werden per E-Mail verschickt)
(Änderungen werden in einem eigenen Branch vorgenommen und später mit dem Hauptzweig zusammengeführt)
(!Alle machen ihre Änderungen direkt im Hauptzweig, ohne Absprachen)

Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Datenstrukturen und einfache Algorithmen

2026-01-09T19:20:49Z

Kwschneider: Formatierungen

= 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:
<syntaxhighlight lang="python">
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.")
</syntaxhighlight>

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:
<syntaxhighlight lang="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]
</syntaxhighlight>

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:

<syntaxhighlight lang="python">
def fakultaet(n):
if n == 0:
return 1
else:
return n * fakultaet(n - 1)

print(fakultaet(5)) # Ausgabe: 120
</syntaxhighlight>

Hier ruft sich die Funktion <code>fakultaet</code> immer wieder selbst auf, bis die Bedingung <code>n == 0</code> 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:

<syntaxhighlight lang="python">
for zahl in liste:
print(zahl)
</syntaxhighlight>

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: <code>liste[0]</code>).
* 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?'''
** a) Die Lesbarkeit des Codes
** b) Die Anzahl der Variablen im Programm
** c) Das Speicherformat einer Datei
** d) Die Laufzeit oder den Ressourcenverbrauch eines Algorithmus in Abhängigkeit von der Eingabemenge
'''Welche Laufzeit hat ein Algorithmus mit O(n²)?'''
** a) Die Laufzeit bleibt immer gleich, egal wie viele Elemente
** b) Die Laufzeit wächst exponentiell bei mehr Elementen
** c) Für jedes Element wird die komplette Liste erneut durchlaufen
** d) Die Laufzeit halbiert sich bei doppelter Eingabegröße
'''Was ist der Hauptvorteil von Versionsverwaltungssystemen wie Git?'''
** a) Sie machen den Code schneller
** b) Änderungen am Code können nachverfolgt und ältere Versionen wiederhergestellt werden
** c) Sie übersetzen den Code in Maschinensprache
** d) Sie formatieren automatisch den Quelltext
'''Wie dokumentierst du in Python längere Erklärungen zu Funktionen am besten?'''
** a) Mit einfachen Anführungszeichen
** b) Mit Docstrings, die durch dreifache Anführungszeichen gekennzeichnet sind
** c) Mit eckigen Klammern
** d) Mit dem Zeichen %
'''Was beschreibt ein typischer Workflow bei der Arbeit mit Git in einem Team?'''
** a) Jeder arbeitet im selben Branch und überschreibt Änderungen anderer
** b) Änderungen werden per E-Mail verschickt
** c) Änderungen werden in einem eigenen Branch vorgenommen und später mit dem Hauptzweig zusammengeführt
** d) Alle machen ihre Änderungen direkt im Hauptzweig, ohne Absprachen

Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Programmiergrundlagen

2026-01-09T18:58:43Z

Kwschneider:

Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Programmiergrundlagen

2026-01-09T18:56:43Z

Kwschneider:

= 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:

<syntaxhighlight lang="python" line>
x = 5

name = "Anna"

ist_alt_genug = True
</syntaxhighlight>

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:
<syntaxhighlight lang="python" line>
name = input("Wie heißt du? ")

print("Hallo,", name)
</syntaxhighlight>

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

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:
<syntaxhighlight lang="python" line>
ergebnis = 7 * 4
</syntaxhighlight>
=== Vergleichsoperatoren ===

Damit prüfst du, ob zwei Werte gleich oder unterschiedlich sind.

== bedeutet „ist gleich“, != „ist ungleich“.

Beispiel:
<syntaxhighlight lang="python" line>
if alter == 18:
</syntaxhighlight>
=== Größer und 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:
<syntaxhighlight lang="python" line>
if ist_alt_genug and name == "Anna":
</syntaxhighlight>
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 und Benutzer nach Informationen fragen.

Zum Beispiel:
<syntaxhighlight lang="python" line>
name = input("Wie heißt du? ")
</syntaxhighlight>
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:
<syntaxhighlight lang="python" line>
print("Hallo, " + name)
</syntaxhighlight>
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 Zusatzaufwand benötigen.

Selbst komplexere Aufgaben wie das Formatieren von Ausgaben kannst du mit wenigen Handgriffen erledigen, zum Beispiel mit:
<syntaxhighlight lang="python" line>
print(f"Du bist {alter} Jahre alt.")
</syntaxhighlight>
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:
<syntaxhighlight lang="python" line>
def begruessung(name):

print(f"Hallo, {name}!")
</syntaxhighlight>
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 zum Beispiel 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 es mit einem Debugger, der in vielen Entwicklungsumgebungen 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.

== Quiz ==

<div class="multiplechoice-quiz">
Welche der folgenden Fehlerarten tritt auf, wenn ein Programm zwar startet, aber während der Ausführung auf ein Problem stößt?

(!Syntaxfehler)
(Laufzeitfehler)
(!Logischer Fehler)
(!Tippfehler)

Was ist ein Vorteil von Modulen in Python?

(!Sie machen Programme langsamer)
(Sie erlauben es, Funktionen und Code übersichtlich zu strukturieren und wiederzuverwenden)
(!Sie verhindern Fehler vollständig)
(!Sie ersetzen die Notwendigkeit von Datenstrukturen)

Welcher Befehl wird empfohlen, um beim Debugging den Programmverlauf zu überprüfen?

(!input)
(print)
(!exit)
(!import)

Was unterscheidet ein Tupel von einer Liste in Python?

(!Tupel können nach dem Erstellen verändert werden, Listen nicht)
(!Listen sind unveränderlich, Tupel nicht)
(Tupel sind unveränderlich, Listen nicht)
(!Es gibt keinen Unterschied)

Wie funktioniert die lineare Suche?

(!Die Liste wird nach Größe sortiert)
(Alle Elemente werden von vorne bis hinten durchgegangen und mit dem gesuchten Wert verglichen)
(!Die Suche wird mithilfe eines Wörterbuchs durchgeführt)
(!Die Elemente werden zufällig überprüft)

</div>

Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Programmiergrundlagen

2026-01-09T18:49:38Z

Kwschneider: Quiz ergänzt

= 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:

<syntaxhighlight lang="python" line>
x = 5

name = "Anna"

ist_alt_genug = True
</syntaxhighlight>

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:
<syntaxhighlight lang="python" line>
name = input("Wie heißt du? ")

print("Hallo,", name)
</syntaxhighlight>

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

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:
<syntaxhighlight lang="python" line>
ergebnis = 7 * 4
</syntaxhighlight>
=== Vergleichsoperatoren ===

Damit prüfst du, ob zwei Werte gleich oder unterschiedlich sind.

== bedeutet „ist gleich“, != „ist ungleich“.

Beispiel:
<syntaxhighlight lang="python" line>
if alter == 18:
</syntaxhighlight>
=== Größer und 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:
<syntaxhighlight lang="python" line>
if ist_alt_genug and name == "Anna":
</syntaxhighlight>
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 und Benutzer nach Informationen fragen.

Zum Beispiel:
<syntaxhighlight lang="python" line>
name = input("Wie heißt du? ")
</syntaxhighlight>
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:
<syntaxhighlight lang="python" line>
print("Hallo, " + name)
</syntaxhighlight>
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 Zusatzaufwand benötigen.

Selbst komplexere Aufgaben wie das Formatieren von Ausgaben kannst du mit wenigen Handgriffen erledigen, zum Beispiel mit:
<syntaxhighlight lang="python" line>
print(f"Du bist {alter} Jahre alt.")
</syntaxhighlight>
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:
<syntaxhighlight lang="python" line>
def begruessung(name):

print(f"Hallo, {name}!")
</syntaxhighlight>
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 zum Beispiel 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 es mit einem Debugger, der in vielen Entwicklungsumgebungen 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.

== Quiz ==
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üf

Benutzer:Kwschneider

2026-01-09T18:40:36Z

Kwschneider:

Ich habe nach einer handwerklichen Ausbildung Ingenieurinformatik studiert. Neben meiner Arbeit als Ingenieur bin ich ehrenamtlich Prüfer für IT-Ausbildungsberufe bei der Industrie- und Handelskammer. Ich bin Dozent an einer technischen Hochschule und unterrichte seit Herbst 2025 als Lehrer an einer Berufsschule. Schwerpunkt sind hier Grundlagen der Softwareentwicklung.

=Grundlagen der Softwareentwicklung=
Unterlagen zum Selbststudium nebst Lernkontrolle anhand von MultipleChoice-Fragen:

* [[Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Einführung]]
* [[Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Denkweisen und Konzepte der Programmierung]]
* [[Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Programmiergrundlagen]]
* [[Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Datenstrukturen und einfache Algorithmen]]

* Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/
* Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/

=Übungsbeispiele Python=
* [[Benutzer:Kwschneider/Softwareentwicklung/Python/Übungen/Passwortverwaltung]]

Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Datenstrukturen und einfache Algorithmen

2026-01-08T11:32:22Z

Kwschneider: Rohfassung

=Datenstrukturen und einfache Algorithmen=
==Arrays/Listen, Tupel, Dictionaries==
Listen (in Python auch Arrays genannt), Tupel und Dictionaries sind wichtige Datenstrukturen, mit denen du mehrere Werte gleichzeitig speichern und verarbeiten kannst.

Listen sind besonders flexibel. Du kannst Werte hinzufügen, entfernen oder ändern. Sie eignen sich gut, wenn sich die Anzahl der gespeicherten Elemente verändern kann.

Tupel ähneln Listen, sind aber unveränderlich. Das bedeutet, dass ihre Inhalte nach dem Erstellen nicht mehr geändert werden können. Sie werden oft genutzt, wenn Daten zusammengehören und unverändert bleiben sollen.

Dictionaries bestehen aus sogenannten Schlüssel-Wert-Paaren. Jedem Schlüssel ist genau ein Wert zugeordnet. Das ist besonders praktisch, wenn du Informationen schnell über einen Namen oder eine Bezeichnung abrufen möchtest.

So kannst du blitzschnell nachschauen, was zu welchem Schlüssel gehört.

Wenn du mit diesen Daten arbeitest, brauchst du manchmal einfache Algorithmen, um sie zu durchsuchen oder zu sortieren – 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 enthalten ist. Dabei gehst du die Liste Element für Element durch, bis du den gesuchten Wert findest oder am Ende angekommen bist.

In Python sieht das zum Beispiel so aus:<syntaxhighlight python="">
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!")
</syntaxhighlight>Auch Sortierverfahren spielen eine wichtige Rolle. Ein bekanntes, aber eher einfaches Sortierverfahren ist der sogenannte Bubble Sort.

Dabei werden benachbarte Elemente miteinander verglichen und vertauscht, wenn sie in der falschen Reihenfolge stehen. Dieser Vorgang wird so lange wiederholt, bis die Liste vollständig sortiert ist.

Auch wenn Bubble Sort nicht besonders effizient ist, eignet er sich gut, um das Grundprinzip des Sortierens zu verstehen.

In der Praxis hilft dir dieses Wissen, bessere und schnellere Programme zu schreiben, denn viele Probleme lassen sich mit den richtigen Algorithmen und cleveren Datenstrukturen schon viel einfacher lösen.
==Wiederholungs- und Übungsfragen==
b) Mit Docstrings, die durch dreifache Anführungszeichen gekennzeichnet sind c) Mit eckigen Klammern d) Mit dem Zeichen %

Was beschreibt ein typischer Workflow bei der Arbeit mit Git in einem Team?

a) Jeder arbeitet im selben Branch und überschreibt Änderungen anderer b) Änderungen werden per E-Mail verschickt c) Änderungen werden in einem eigenen Branch vorgenommen und später mit dem Hauptzweig zusammengeführt d) Alle machen ihre Änderungen direkt im Hauptzweig, ohne Absprachen

Benutzer:Kwschneider

2026-01-08T11:31:12Z

Kwschneider: weiteres Kapitel ergänzt

Ich habe nach einer handwerklichen Ausbildung Ingenieurinformatik studiert. Neben meiner Arbeit als Ingenieur bin ich ehrenamtlich Prüfer für IT-Ausbildungsberufe bei der Industrie- und Handelskammer. Ich bin Dozent an einer technischen Hochschule und unterrichte seit Herbst 2025 als Lehrer an einer Berufsschule. Schwerpunkt sind hier Grundlagen der Softwareentwicklung.

=Grundlagen der Softwareentwicklung=
Unterlagen zum Selbststudium nebst Lernkontrolle anhand von MultipleChoice-Fragen:
[[Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Einführung]]
[[Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Denkweisen und Konzepte der Programmierung]]
[[Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Programmiergrundlagen]]
[[Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Datenstrukturen und einfache Algorithmen]]
Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/
Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/

=Übungsbeispiele Python=
[[Benutzer:Kwschneider/Softwareentwicklung/Python/Übungen/Passwortverwaltung]]

Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Programmiergrundlagen

2026-01-08T11:15:28Z

Kwschneider: initiale Fassung

Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Programmiergrundlagen

2026-01-08T11:10:08Z

Kwschneider: Rohfassung

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

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

=== Vergleichsoperatoren ===

Damit prüfst du, ob zwei Werte gleich oder unterschiedlich sind.

== bedeutet „ist gleich“, != „ist ungleich“.

Beispiel:

if alter == 18:

=== Größer und 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":

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 und Benutzer 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)

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 Zusatzaufwand 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 zum Beispiel 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 es mit einem Debugger, der in vielen Entwicklungsumgebungen 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.

Benutzer:Kwschneider

2026-01-08T10:53:18Z

Kwschneider:

Benutzer:Kwschneider

2026-01-08T10:52:46Z

Kwschneider:

Benutzer:Kwschneider/Softwareentwicklung/Python/Übungen/Passwortverwaltung

2026-01-07T20:36:03Z

Kwschneider:

Benutzer:Kwschneider/Softwareentwicklung/Python/Übungen/Passwortverwaltung

2026-01-07T20:24:32Z

Kwschneider:

=Python-Übungsaufgabe:=
=Verwaltung von Benutzernamen und Passwörtern=

==Teil 1: Manuelle Eingabe und Dateispeicherung==
Lernziel
Schüler lernen, wie man Benutzernamen und Passwörter per Konsole abfragt, in einer Datei speichert und grundlegende Dateizugriffe in Python nutzt.

Wichtige Hinweise zu Dateizugriffen
* Beim Lesen/Schreiben von Dateien sollte stets ein Context Manager (with open(...) as f:) verwendet werden.
* Verwende den Modus "a" (append) zum Hinzufügen neuer Einträge, ohne vorhandene zu überschreiben.
* Achte auf Zeichencodierung (z. B. encoding="utf-8"), um Umlaute oder Sonderzeichen korrekt abzulegen.
* Sensible Daten niemals in öffentlich einsehbaren Dateien ablegen.

Beispielcode

<syntaxhighlight lang="python" line>
def teil1_neuer_(dateipfad):
benutzer = input("Benutzername: ")
passwort = input("Passwort: ")
eintrag = f"{benutzer}:{passwort}\n"
with open(dateipfad, "a", encoding="utf-8") as file:
file.write(eintrag)
print("Eintrag gespeichert.")
</syntaxhighlight>

==Teil 2: Passwortregeln prüfen==
Lernziel
Schüler implementieren eine Funktion, die Passwörter gegen aktuelle Sicherheitsstandards validiert.

Vorgeschlagene Regeln
* Mindestens 12 Zeichen Länge
* Mindestens ein Großbuchstabe
* Mindestens ein Kleinbuchstabe
* Mindestens eine Ziffer
* Mindestens ein Sonderzeichen (!@#$%^&*()_+-=[]{};:,.<>/?)
* Keine Leerzeichen
* Keine Wiederholungen (z. B. “aaa”, “111”)

Beispielcode

<syntaxhighlight lang="python" line>
import re

def pruefe_passwort(pw):
if len(pw) < 12:
return False, "Passwort zu kurz (mind. 12 Zeichen)."
if not re.search(r"[A-Z]", pw):
return False, "Mindestens ein Großbuchstabe fehlt."
if not re.search(r"[a-z]", pw):
return False, "Mindestens ein Kleinbuchstabe fehlt."
if not re.search(r"[0-9]", pw):
return False, "Mindestens eine Ziffer fehlt."
if not re.search(r"[!@#$%^&*()_+\-=\[\]{};:,.<>/?]", pw):
return False, "Mindestens ein Sonderzeichen fehlt."
if " " in pw:
return False, "Passwort darf keine Leerzeichen enthalten."
if re.search(r"(.)\1\1", pw):
return False, "Drei gleiche Zeichen hintereinander sind nicht erlaubt."
return True, "Passwort erfüllt alle Regeln."

# Integrierte Nutzung im Hauptprogramm
pw = input("Passwort wählen: ")
ok, meldung = pruefe_passwort(pw)
print(meldung)
</syntaxhighlight>

==Teil 3: Hash-Verfahren und MD5==
Lernziel
Schüler verstehen, was Hash-Funktionen sind und wie man MD5 in Python anwendet.

Allgemeines zu Hash-Verfahren
* Hash-Funktionen wandeln Eingaben beliebiger Länge in eine fixe Bitfolge um.
* Sie sind Einbahn: aus dem Hash kann man normalerweise nicht das Originalpasswort rekonstruieren.
* Kollisionen (zwei Eingaben mit demselben Hash) sind unerwünscht, treten aber teilweise auf.
* Für echte Anwendungen werden heute stärkere Verfahren (z. B. SHA-256, bcrypt) empfohlen.

MD5 in Python
<syntaxhighlight lang="python" line>
import hashlib
def md5_hash(pw):
hasher = hashlib.md5()
hasher.update(pw.encode("utf-8"))
return hasher.hexdigest()

# Beispiel:
klare_passwort = "MeinSicheres!123"
hash_wert = md5_hash(klare_passwort)
print("MD5-Hash:", hash_wert)
</syntaxhighlight>

Anwendung im Speichern

<syntaxhighlight lang="python" line>
def teil3_neuer_eintrag(dateipfad):
benutzer = input("Benutzername: ")
pw = input("Passwort wählen: ")
hashed = md5_hash(pw)
eintrag = f"{benutzer}:{hashed}\n"
with open(dateipfad, "a", encoding="utf-8") as f:
f.write(eintrag)
print("Benutzer und Hash gespeichert.")
</syntaxhighlight>

==Teil 4: Passwortprüfung bei bestehendem Benutzer==
Lernziel
Schüler erweitern ihr Programm um eine Login-Funktion: Eingabe von Benutzername und Passwort wird gegen die gespeicherten MD5-Hashes geprüft.

Beispielcode

<syntaxhighlight lang="python" line>
def lade_passwortdatei(dateipfad):
daten = {}
with open(dateipfad, "r", encoding="utf-8") as f:
for zeile in f:
name, hashwert = zeile.strip().split(":", 1)
daten[name] = hashwert
return daten

def login_pruefung(dateipfad):
daten = lade_passwortdatei(dateipfad)
benutzer = input("Benutzername: ")
if benutzer not in daten:
print("Benutzer nicht gefunden.")
return

pw = input("Passwort: ")
if md5_hash(pw) == daten[benutzer]:
print("Login erfolgreich.")
else:
print("Falsches Passwort.")

# Beispielaufruf
login_pruefung("passwoerter.txt")
</syntaxhighlight>

Weiterführende Anregungen
* Salted Hashes einführen: Für jeden Benutzer einen zufälligen Salt vor dem Hashen nutzen.
* Bessere Algorithmen einsetzen: z. B. hashlib.sha256, bcrypt oder scrypt.
* Verwaltung in einer SQLite-Datenbank statt in einer Textdatei.
* Zwei-Faktor-Authentifizierung (2FA) simulieren.
* Passwort-Blacklist implementieren, um häufige Passwörter zu verbieten.

Benutzer:Kwschneider/Softwareentwicklung/Python/Übungen/Passwortverwaltung

2026-01-07T20:21:11Z

Kwschneider:

=Python-Übungsaufgabe:=
=Verwaltung von Benutzernamen und Passwörtern=

==Teil 1: Manuelle Eingabe und Dateispeicherung==
Lernziel
Schüler lernen, wie man Benutzernamen und Passwörter per Konsole abfragt, in einer Datei speichert und grundlegende Dateizugriffe in Python nutzt.

Wichtige Hinweise zu Dateizugriffen
* Beim Lesen/Schreiben von Dateien sollte stets ein Context Manager (with open(...) as f:) verwendet werden.
* Verwende den Modus "a" (append) zum Hinzufügen neuer Einträge, ohne vorhandene zu überschreiben.
* Achte auf Zeichencodierung (z. B. encoding="utf-8"), um Umlaute oder Sonderzeichen korrekt abzulegen.
* Sensible Daten niemals in öffentlich einsehbaren Dateien ablegen.

Beispielcode

<syntaxhighlight lang="python" line>
def teil1_neuer_(dateipfad):
benutzer = input("Benutzername: ")
passwort = input("Passwort: ")
eintrag = f"{benutzer}:{passwort}\n"
with open(dateipfad, "a", encoding="utf-8") as file:
file.write(eintrag)
print("Eintrag gespeichert.")
</syntaxhighlight>

==Teil 2: Passwortregeln prüfen==
Lernziel
Schüler implementieren eine Funktion, die Passwörter gegen aktuelle Sicherheitsstandards validiert.

Vorgeschlagene Regeln
* Mindestens 12 Zeichen Länge
* Mindestens ein Großbuchstabe
* Mindestens ein Kleinbuchstabe
* Mindestens eine Ziffer
* Mindestens ein Sonderzeichen (!@#$%^&*()_+-=[]{};:,.<>/?)
* Keine Leerzeichen
* Keine Wiederholungen (z. B. “aaa”, “111”)

Beispielcode

{{code|lang=python|import re

def pruefe_passwort(pw):
if len(pw) < 12:
return False, "Passwort zu kurz (mind. 12 Zeichen)."
if not re.search(r"[A-Z]", pw):
return False, "Mindestens ein Großbuchstabe fehlt."
if not re.search(r"[a-z]", pw):
return False, "Mindestens ein Kleinbuchstabe fehlt."
if not re.search(r"[0-9]", pw):
return False, "Mindestens eine Ziffer fehlt."
if not re.search(r"[!@#$%^&*()_+\-=\[\]{};:,.<>/?]", pw):
return False, "Mindestens ein Sonderzeichen fehlt."
if " " in pw:
return False, "Passwort darf keine Leerzeichen enthalten."
if re.search(r"(.)\1\1", pw):
return False, "Drei gleiche Zeichen hintereinander sind nicht erlaubt."
return True, "Passwort erfüllt alle Regeln."

# Integrierte Nutzung im Hauptprogramm
pw = input("Passwort wählen: ")
ok, meldung = pruefe_passwort(pw)
print(meldung)
}}

==Teil 3: Hash-Verfahren und MD5==
Lernziel
Schüler verstehen, was Hash-Funktionen sind und wie man MD5 in Python anwendet.

Allgemeines zu Hash-Verfahren
* Hash-Funktionen wandeln Eingaben beliebiger Länge in eine fixe Bitfolge um.
* Sie sind Einbahn: aus dem Hash kann man normalerweise nicht das Originalpasswort rekonstruieren.
* Kollisionen (zwei Eingaben mit demselben Hash) sind unerwünscht, treten aber teilweise auf.
* Für echte Anwendungen werden heute stärkere Verfahren (z. B. SHA-256, bcrypt) empfohlen.
MD5 in Python
{{code|lang=python|import hashlib
def md5_hash(pw):
hasher = hashlib.md5()
hasher.update(pw.encode("utf-8"))
return hasher.hexdigest()

# Beispiel:
klare_passwort = "MeinSicheres!123"
hash_wert = md5_hash(klare_passwort)
print("MD5-Hash:", hash_wert)
Anwendung im Speichern

def teil3_neuer_eintrag(dateipfad):
benutzer = input("Benutzername: ")
pw = input("Passwort wählen: ")
hashed = md5_hash(pw)
eintrag = f"{benutzer}:{hashed}\n"
with open(dateipfad, "a", encoding="utf-8") as f:
f.write(eintrag)
print("Benutzer und Hash gespeichert.")
}}

==Teil 4: Passwortprüfung bei bestehendem Benutzer==
Lernziel
Schüler erweitern ihr Programm um eine Login-Funktion: Eingabe von Benutzername und Passwort wird gegen die gespeicherten MD5-Hashes geprüft.

Beispielcode
{{code|lang=python|def lade_passwortdatei(dateipfad):
daten = {}
with open(dateipfad, "r", encoding="utf-8") as f:
for zeile in f:
name, hashwert = zeile.strip().split(":", 1)
daten[name] = hashwert
return daten

def login_pruefung(dateipfad):
daten = lade_passwortdatei(dateipfad)
benutzer = input("Benutzername: ")
if benutzer not in daten:
print("Benutzer nicht gefunden.")
return

pw = input("Passwort: ")
if md5_hash(pw) == daten[benutzer]:
print("Login erfolgreich.")
else:
print("Falsches Passwort.")

# Beispielaufruf
login_pruefung("passwoerter.txt")
}}

Weiterführende Anregungen
* Salted Hashes einführen: Für jeden Benutzer einen zufälligen Salt vor dem Hashen nutzen.
* Bessere Algorithmen einsetzen: z. B. hashlib.sha256, bcrypt oder scrypt.
* Verwaltung in einer SQLite-Datenbank statt in einer Textdatei.
* Zwei-Faktor-Authentifizierung (2FA) simulieren.
* Passwort-Blacklist implementieren, um häufige Passwörter zu verbieten.

Benutzer:Kwschneider/Softwareentwicklung/Python/Übungen/Passwortverwaltung

2026-01-07T20:17:39Z

Kwschneider:

=Python-Übungsaufgabe:=
=Verwaltung von Benutzernamen und Passwörtern=

==Teil 1: Manuelle Eingabe und Dateispeicherung==
Lernziel
Schüler lernen, wie man Benutzernamen und Passwörter per Konsole abfragt, in einer Datei speichert und grundlegende Dateizugriffe in Python nutzt.

Wichtige Hinweise zu Dateizugriffen
* Beim Lesen/Schreiben von Dateien sollte stets ein Context Manager (with open(...) as f:) verwendet werden.
* Verwende den Modus "a" (append) zum Hinzufügen neuer Einträge, ohne vorhandene zu überschreiben.
* Achte auf Zeichencodierung (z. B. encoding="utf-8"), um Umlaute oder Sonderzeichen korrekt abzulegen.
* Sensible Daten niemals in öffentlich einsehbaren Dateien ablegen.

Beispielcode

<code>
def teil1_neuer_(dateipfad):
benutzer = input("Benutzername: ")
passwort = input("Passwort: ")
eintrag = f"{benutzer}:{passwort}\n"
with open(dateipfad, "a", encoding="utf-8") as file:
file.write(eintrag)
print("Eintrag gespeichert.")
</code>

==Teil 2: Passwortregeln prüfen==
Lernziel
Schüler implementieren eine Funktion, die Passwörter gegen aktuelle Sicherheitsstandards validiert.

Vorgeschlagene Regeln
* Mindestens 12 Zeichen Länge
* Mindestens ein Großbuchstabe
* Mindestens ein Kleinbuchstabe
* Mindestens eine Ziffer
* Mindestens ein Sonderzeichen (!@#$%^&*()_+-=[]{};:,.<>/?)
* Keine Leerzeichen
* Keine Wiederholungen (z. B. “aaa”, “111”)

Beispielcode

{{code|lang=python|import re

def pruefe_passwort(pw):
if len(pw) < 12:
return False, "Passwort zu kurz (mind. 12 Zeichen)."
if not re.search(r"[A-Z]", pw):
return False, "Mindestens ein Großbuchstabe fehlt."
if not re.search(r"[a-z]", pw):
return False, "Mindestens ein Kleinbuchstabe fehlt."
if not re.search(r"[0-9]", pw):
return False, "Mindestens eine Ziffer fehlt."
if not re.search(r"[!@#$%^&*()_+\-=\[\]{};:,.<>/?]", pw):
return False, "Mindestens ein Sonderzeichen fehlt."
if " " in pw:
return False, "Passwort darf keine Leerzeichen enthalten."
if re.search(r"(.)\1\1", pw):
return False, "Drei gleiche Zeichen hintereinander sind nicht erlaubt."
return True, "Passwort erfüllt alle Regeln."

# Integrierte Nutzung im Hauptprogramm
pw = input("Passwort wählen: ")
ok, meldung = pruefe_passwort(pw)
print(meldung)
}}

==Teil 3: Hash-Verfahren und MD5==
Lernziel
Schüler verstehen, was Hash-Funktionen sind und wie man MD5 in Python anwendet.

Allgemeines zu Hash-Verfahren
* Hash-Funktionen wandeln Eingaben beliebiger Länge in eine fixe Bitfolge um.
* Sie sind Einbahn: aus dem Hash kann man normalerweise nicht das Originalpasswort rekonstruieren.
* Kollisionen (zwei Eingaben mit demselben Hash) sind unerwünscht, treten aber teilweise auf.
* Für echte Anwendungen werden heute stärkere Verfahren (z. B. SHA-256, bcrypt) empfohlen.
MD5 in Python
{{code|lang=python|import hashlib
def md5_hash(pw):
hasher = hashlib.md5()
hasher.update(pw.encode("utf-8"))
return hasher.hexdigest()

# Beispiel:
klare_passwort = "MeinSicheres!123"
hash_wert = md5_hash(klare_passwort)
print("MD5-Hash:", hash_wert)
Anwendung im Speichern

def teil3_neuer_eintrag(dateipfad):
benutzer = input("Benutzername: ")
pw = input("Passwort wählen: ")
hashed = md5_hash(pw)
eintrag = f"{benutzer}:{hashed}\n"
with open(dateipfad, "a", encoding="utf-8") as f:
f.write(eintrag)
print("Benutzer und Hash gespeichert.")
}}

==Teil 4: Passwortprüfung bei bestehendem Benutzer==
Lernziel
Schüler erweitern ihr Programm um eine Login-Funktion: Eingabe von Benutzername und Passwort wird gegen die gespeicherten MD5-Hashes geprüft.

Beispielcode
{{code|lang=python|def lade_passwortdatei(dateipfad):
daten = {}
with open(dateipfad, "r", encoding="utf-8") as f:
for zeile in f:
name, hashwert = zeile.strip().split(":", 1)
daten[name] = hashwert
return daten

def login_pruefung(dateipfad):
daten = lade_passwortdatei(dateipfad)
benutzer = input("Benutzername: ")
if benutzer not in daten:
print("Benutzer nicht gefunden.")
return

pw = input("Passwort: ")
if md5_hash(pw) == daten[benutzer]:
print("Login erfolgreich.")
else:
print("Falsches Passwort.")

# Beispielaufruf
login_pruefung("passwoerter.txt")
}}

Weiterführende Anregungen
* Salted Hashes einführen: Für jeden Benutzer einen zufälligen Salt vor dem Hashen nutzen.
* Bessere Algorithmen einsetzen: z. B. hashlib.sha256, bcrypt oder scrypt.
* Verwaltung in einer SQLite-Datenbank statt in einer Textdatei.
* Zwei-Faktor-Authentifizierung (2FA) simulieren.
* Passwort-Blacklist implementieren, um häufige Passwörter zu verbieten.

Benutzer:Kwschneider/Softwareentwicklung/Python/Übungen/Passwortverwaltung

2026-01-07T20:12:15Z

Kwschneider:

=Python-Übungsaufgabe:=
=Verwaltung von Benutzernamen und Passwörtern=

==Teil 1: Manuelle Eingabe und Dateispeicherung==
Lernziel
Schüler lernen, wie man Benutzernamen und Passwörter per Konsole abfragt, in einer Datei speichert und grundlegende Dateizugriffe in Python nutzt.

Wichtige Hinweise zu Dateizugriffen
* Beim Lesen/Schreiben von Dateien sollte stets ein Context Manager (with open(...) as f:) verwendet werden.
* Verwende den Modus "a" (append) zum Hinzufügen neuer Einträge, ohne vorhandene zu überschreiben.
* Achte auf Zeichencodierung (z. B. encoding="utf-8"), um Umlaute oder Sonderzeichen korrekt abzulegen.
* Sensible Daten niemals in öffentlich einsehbaren Dateien ablegen.

Beispielcode

{{code|lang=python|def teil1_neuer_eintrag(dateipfad):
benutzer = input("Benutzername: ")
passwort = input("Passwort: ")
eintrag = f"{benutzer}:{passwort}\n"
with open(dateipfad, "a", encoding="utf-8") as file:
file.write(eintrag)
print("Eintrag gespeichert.")
}}

==Teil 2: Passwortregeln prüfen==
Lernziel
Schüler implementieren eine Funktion, die Passwörter gegen aktuelle Sicherheitsstandards validiert.

Vorgeschlagene Regeln
* Mindestens 12 Zeichen Länge
* Mindestens ein Großbuchstabe
* Mindestens ein Kleinbuchstabe
* Mindestens eine Ziffer
* Mindestens ein Sonderzeichen (!@#$%^&*()_+-=[]{};:,.<>/?)
* Keine Leerzeichen
* Keine Wiederholungen (z. B. “aaa”, “111”)

Beispielcode

{{code|lang=python|import re

def pruefe_passwort(pw):
if len(pw) < 12:
return False, "Passwort zu kurz (mind. 12 Zeichen)."
if not re.search(r"[A-Z]", pw):
return False, "Mindestens ein Großbuchstabe fehlt."
if not re.search(r"[a-z]", pw):
return False, "Mindestens ein Kleinbuchstabe fehlt."
if not re.search(r"[0-9]", pw):
return False, "Mindestens eine Ziffer fehlt."
if not re.search(r"[!@#$%^&*()_+\-=\[\]{};:,.<>/?]", pw):
return False, "Mindestens ein Sonderzeichen fehlt."
if " " in pw:
return False, "Passwort darf keine Leerzeichen enthalten."
if re.search(r"(.)\1\1", pw):
return False, "Drei gleiche Zeichen hintereinander sind nicht erlaubt."
return True, "Passwort erfüllt alle Regeln."

# Integrierte Nutzung im Hauptprogramm
pw = input("Passwort wählen: ")
ok, meldung = pruefe_passwort(pw)
print(meldung)
}}

==Teil 3: Hash-Verfahren und MD5==
Lernziel
Schüler verstehen, was Hash-Funktionen sind und wie man MD5 in Python anwendet.

Allgemeines zu Hash-Verfahren
* Hash-Funktionen wandeln Eingaben beliebiger Länge in eine fixe Bitfolge um.
* Sie sind Einbahn: aus dem Hash kann man normalerweise nicht das Originalpasswort rekonstruieren.
* Kollisionen (zwei Eingaben mit demselben Hash) sind unerwünscht, treten aber teilweise auf.
* Für echte Anwendungen werden heute stärkere Verfahren (z. B. SHA-256, bcrypt) empfohlen.
MD5 in Python
{{code|lang=python|import hashlib
def md5_hash(pw):
hasher = hashlib.md5()
hasher.update(pw.encode("utf-8"))
return hasher.hexdigest()

# Beispiel:
klare_passwort = "MeinSicheres!123"
hash_wert = md5_hash(klare_passwort)
print("MD5-Hash:", hash_wert)
Anwendung im Speichern

def teil3_neuer_eintrag(dateipfad):
benutzer = input("Benutzername: ")
pw = input("Passwort wählen: ")
hashed = md5_hash(pw)
eintrag = f"{benutzer}:{hashed}\n"
with open(dateipfad, "a", encoding="utf-8") as f:
f.write(eintrag)
print("Benutzer und Hash gespeichert.")
}}

==Teil 4: Passwortprüfung bei bestehendem Benutzer==
Lernziel
Schüler erweitern ihr Programm um eine Login-Funktion: Eingabe von Benutzername und Passwort wird gegen die gespeicherten MD5-Hashes geprüft.

Beispielcode
{{code|lang=python|def lade_passwortdatei(dateipfad):
daten = {}
with open(dateipfad, "r", encoding="utf-8") as f:
for zeile in f:
name, hashwert = zeile.strip().split(":", 1)
daten[name] = hashwert
return daten

def login_pruefung(dateipfad):
daten = lade_passwortdatei(dateipfad)
benutzer = input("Benutzername: ")
if benutzer not in daten:
print("Benutzer nicht gefunden.")
return

pw = input("Passwort: ")
if md5_hash(pw) == daten[benutzer]:
print("Login erfolgreich.")
else:
print("Falsches Passwort.")

# Beispielaufruf
login_pruefung("passwoerter.txt")
}}

Weiterführende Anregungen
* Salted Hashes einführen: Für jeden Benutzer einen zufälligen Salt vor dem Hashen nutzen.
* Bessere Algorithmen einsetzen: z. B. hashlib.sha256, bcrypt oder scrypt.
* Verwaltung in einer SQLite-Datenbank statt in einer Textdatei.
* Zwei-Faktor-Authentifizierung (2FA) simulieren.
* Passwort-Blacklist implementieren, um häufige Passwörter zu verbieten.

Benutzer:Kwschneider/Softwareentwicklung/Python/Übungen/Passwortverwaltung

2026-01-07T20:07:53Z

Kwschneider:

=Python-Übungsaufgabe:=
=Verwaltung von Benutzernamen und Passwörtern=

==Teil 1: Manuelle Eingabe und Dateispeicherung==
Lernziel
Schüler lernen, wie man Benutzernamen und Passwörter per Konsole abfragt, in einer Datei speichert und grundlegende Dateizugriffe in Python nutzt.

Wichtige Hinweise zu Dateizugriffen
* Beim Lesen/Schreiben von Dateien sollte stets ein Context Manager (with open(...) as f:) verwendet werden.
* Verwende den Modus "a" (append) zum Hinzufügen neuer Einträge, ohne vorhandene zu überschreiben.
* Achte auf Zeichencodierung (z. B. encoding="utf-8"), um Umlaute oder Sonderzeichen korrekt abzulegen.
* Sensible Daten niemals in öffentlich einsehbaren Dateien ablegen.

Beispielcode

{{{def teil1_neuer_eintrag(dateipfad):
benutzer = input("Benutzername: ")
passwort = input("Passwort: ")
eintrag = f"{benutzer}:{passwort}\n"
with open(dateipfad, "a", encoding="utf-8") as file:
file.write(eintrag)
print("Eintrag gespeichert.")
}}}

==Teil 2: Passwortregeln prüfen==
Lernziel
Schüler implementieren eine Funktion, die Passwörter gegen aktuelle Sicherheitsstandards validiert.

Vorgeschlagene Regeln
* Mindestens 12 Zeichen Länge
* Mindestens ein Großbuchstabe
* Mindestens ein Kleinbuchstabe
* Mindestens eine Ziffer
* Mindestens ein Sonderzeichen (!@#$%^&*()_+-=[]{};:,.<>/?)
* Keine Leerzeichen
* Keine Wiederholungen (z. B. “aaa”, “111”)

Beispielcode

{{{import re

def pruefe_passwort(pw):
if len(pw) < 12:
return False, "Passwort zu kurz (mind. 12 Zeichen)."
if not re.search(r"[A-Z]", pw):
return False, "Mindestens ein Großbuchstabe fehlt."
if not re.search(r"[a-z]", pw):
return False, "Mindestens ein Kleinbuchstabe fehlt."
if not re.search(r"[0-9]", pw):
return False, "Mindestens eine Ziffer fehlt."
if not re.search(r"[!@#$%^&*()_+\-=\[\]{};:,.<>/?]", pw):
return False, "Mindestens ein Sonderzeichen fehlt."
if " " in pw:
return False, "Passwort darf keine Leerzeichen enthalten."
if re.search(r"(.)\1\1", pw):
return False, "Drei gleiche Zeichen hintereinander sind nicht erlaubt."
return True, "Passwort erfüllt alle Regeln."

# Integrierte Nutzung im Hauptprogramm
pw = input("Passwort wählen: ")
ok, meldung = pruefe_passwort(pw)
print(meldung)
}}}

==Teil 3: Hash-Verfahren und MD5==
Lernziel
Schüler verstehen, was Hash-Funktionen sind und wie man MD5 in Python anwendet.

Allgemeines zu Hash-Verfahren
* Hash-Funktionen wandeln Eingaben beliebiger Länge in eine fixe Bitfolge um.
* Sie sind Einbahn: aus dem Hash kann man normalerweise nicht das Originalpasswort rekonstruieren.
* Kollisionen (zwei Eingaben mit demselben Hash) sind unerwünscht, treten aber teilweise auf.
* Für echte Anwendungen werden heute stärkere Verfahren (z. B. SHA-256, bcrypt) empfohlen.
MD5 in Python
{{{import hashlib
def md5_hash(pw):
hasher = hashlib.md5()
hasher.update(pw.encode("utf-8"))
return hasher.hexdigest()

# Beispiel:
klare_passwort = "MeinSicheres!123"
hash_wert = md5_hash(klare_passwort)
print("MD5-Hash:", hash_wert)
Anwendung im Speichern

def teil3_neuer_eintrag(dateipfad):
benutzer = input("Benutzername: ")
pw = input("Passwort wählen: ")
hashed = md5_hash(pw)
eintrag = f"{benutzer}:{hashed}\n"
with open(dateipfad, "a", encoding="utf-8") as f:
f.write(eintrag)
print("Benutzer und Hash gespeichert.")
}}}

==Teil 4: Passwortprüfung bei bestehendem Benutzer==
Lernziel
Schüler erweitern ihr Programm um eine Login-Funktion: Eingabe von Benutzername und Passwort wird gegen die gespeicherten MD5-Hashes geprüft.

Beispielcode
{{{def lade_passwortdatei(dateipfad):
daten = {}
with open(dateipfad, "r", encoding="utf-8") as f:
for zeile in f:
name, hashwert = zeile.strip().split(":", 1)
daten[name] = hashwert
return daten

def login_pruefung(dateipfad):
daten = lade_passwortdatei(dateipfad)
benutzer = input("Benutzername: ")
if benutzer not in daten:
print("Benutzer nicht gefunden.")
return

pw = input("Passwort: ")
if md5_hash(pw) == daten[benutzer]:
print("Login erfolgreich.")
else:
print("Falsches Passwort.")

# Beispielaufruf
login_pruefung("passwoerter.txt")
}}}

Weiterführende Anregungen
* Salted Hashes einführen: Für jeden Benutzer einen zufälligen Salt vor dem Hashen nutzen.
* Bessere Algorithmen einsetzen: z. B. hashlib.sha256, bcrypt oder scrypt.
* Verwaltung in einer SQLite-Datenbank statt in einer Textdatei.
* Zwei-Faktor-Authentifizierung (2FA) simulieren.
* Passwort-Blacklist implementieren, um häufige Passwörter zu verbieten.

Benutzer:Kwschneider/Softwareentwicklung/Python/Übungen/Passwortverwaltung

2026-01-07T20:06:20Z

Kwschneider: initiale Fassung

=Python-Übungsaufgabe:
Verwaltung von Benutzernamen und Passwörtern=

==Teil 1: Manuelle Eingabe und Dateispeicherung==
Lernziel
Schüler lernen, wie man Benutzernamen und Passwörter per Konsole abfragt, in einer Datei speichert und grundlegende Dateizugriffe in Python nutzt.

Wichtige Hinweise zu Dateizugriffen
* Beim Lesen/Schreiben von Dateien sollte stets ein Context Manager (with open(...) as f:) verwendet werden.
* Verwende den Modus "a" (append) zum Hinzufügen neuer Einträge, ohne vorhandene zu überschreiben.
* Achte auf Zeichencodierung (z. B. encoding="utf-8"), um Umlaute oder Sonderzeichen korrekt abzulegen.
* Sensible Daten niemals in öffentlich einsehbaren Dateien ablegen.
Beispielcode
{{{def teil1_neuer_eintrag(dateipfad):
benutzer = input("Benutzername: ")
passwort = input("Passwort: ")
eintrag = f"{benutzer}:{passwort}\n"
with open(dateipfad, "a", encoding="utf-8") as file:
file.write(eintrag)
print("Eintrag gespeichert.")
}}}

==Teil 2: Passwortregeln prüfen==
Lernziel
Schüler implementieren eine Funktion, die Passwörter gegen aktuelle Sicherheitsstandards validiert.

Vorgeschlagene Regeln
* Mindestens 12 Zeichen Länge
* Mindestens ein Großbuchstabe
* Mindestens ein Kleinbuchstabe
* Mindestens eine Ziffer
* Mindestens ein Sonderzeichen (!@#$%^&*()_+-=[]{};:,.<>/?)
* Keine Leerzeichen
* Keine Wiederholungen (z. B. “aaa”, “111”)
Beispielcode
{{{import re

def pruefe_passwort(pw):
if len(pw) < 12:
return False, "Passwort zu kurz (mind. 12 Zeichen)."
if not re.search(r"[A-Z]", pw):
return False, "Mindestens ein Großbuchstabe fehlt."
if not re.search(r"[a-z]", pw):
return False, "Mindestens ein Kleinbuchstabe fehlt."
if not re.search(r"[0-9]", pw):
return False, "Mindestens eine Ziffer fehlt."
if not re.search(r"[!@#$%^&*()_+\-=\[\]{};:,.<>/?]", pw):
return False, "Mindestens ein Sonderzeichen fehlt."
if " " in pw:
return False, "Passwort darf keine Leerzeichen enthalten."
if re.search(r"(.)\1\1", pw):
return False, "Drei gleiche Zeichen hintereinander sind nicht erlaubt."
return True, "Passwort erfüllt alle Regeln."

# Integrierte Nutzung im Hauptprogramm
pw = input("Passwort wählen: ")
ok, meldung = pruefe_passwort(pw)
print(meldung)
}}}

==Teil 3: Hash-Verfahren und MD5==
Lernziel
Schüler verstehen, was Hash-Funktionen sind und wie man MD5 in Python anwendet.

Allgemeines zu Hash-Verfahren
* Hash-Funktionen wandeln Eingaben beliebiger Länge in eine fixe Bitfolge um.
* Sie sind Einbahn: aus dem Hash kann man normalerweise nicht das Originalpasswort rekonstruieren.
* Kollisionen (zwei Eingaben mit demselben Hash) sind unerwünscht, treten aber teilweise auf.
* Für echte Anwendungen werden heute stärkere Verfahren (z. B. SHA-256, bcrypt) empfohlen.
MD5 in Python
{{{import hashlib
def md5_hash(pw):
hasher = hashlib.md5()
hasher.update(pw.encode("utf-8"))
return hasher.hexdigest()

# Beispiel:
klare_passwort = "MeinSicheres!123"
hash_wert = md5_hash(klare_passwort)
print("MD5-Hash:", hash_wert)
Anwendung im Speichern

def teil3_neuer_eintrag(dateipfad):
benutzer = input("Benutzername: ")
pw = input("Passwort wählen: ")
hashed = md5_hash(pw)
eintrag = f"{benutzer}:{hashed}\n"
with open(dateipfad, "a", encoding="utf-8") as f:
f.write(eintrag)
print("Benutzer und Hash gespeichert.")
}}}

==Teil 4: Passwortprüfung bei bestehendem Benutzer==
Lernziel
Schüler erweitern ihr Programm um eine Login-Funktion: Eingabe von Benutzername und Passwort wird gegen die gespeicherten MD5-Hashes geprüft.

Beispielcode
{{{def lade_passwortdatei(dateipfad):
daten = {}
with open(dateipfad, "r", encoding="utf-8") as f:
for zeile in f:
name, hashwert = zeile.strip().split(":", 1)
daten[name] = hashwert
return daten

def login_pruefung(dateipfad):
daten = lade_passwortdatei(dateipfad)
benutzer = input("Benutzername: ")
if benutzer not in daten:
print("Benutzer nicht gefunden.")
return

pw = input("Passwort: ")
if md5_hash(pw) == daten[benutzer]:
print("Login erfolgreich.")
else:
print("Falsches Passwort.")

# Beispielaufruf
login_pruefung("passwoerter.txt")
}}}

Weiterführende Anregungen
* Salted Hashes einführen: Für jeden Benutzer einen zufälligen Salt vor dem Hashen nutzen.
* Bessere Algorithmen einsetzen: z. B. hashlib.sha256, bcrypt oder scrypt.
* Verwaltung in einer SQLite-Datenbank statt in einer Textdatei.
* Zwei-Faktor-Authentifizierung (2FA) simulieren.
* Passwort-Blacklist implementieren, um häufige Passwörter zu verbieten.

Benutzer:Kwschneider

2026-01-07T19:57:50Z

Kwschneider: Sektion Übungen mit Python ergänzt

Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Denkweisen und Konzepte der Programmierung

2026-01-07T19:53:40Z

Kwschneider:

Benutzer:Kwschneider/Softwareentwicklung/Grundlagen/Denkweisen und Konzepte der Programmierung

2026-01-07T19:49:50Z

Kwschneider:

= 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 großes 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
* Rauten für Entscheidungen (zum Beispiel: „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),
* 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.

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.

= Quiz =

<div class="multiplechoice-quiz">

Was ist der Hauptvorteil eines Flussdiagramms beim Programmieren?
(!Es generiert automatisch den Programmcode.)
(!Es hilft dabei, den genauen Speicherbedarf zu berechnen.)
(Es stellt den Ablauf eines Programms grafisch dar und erleichtert das
Erkennen von Fehlern.)
(!Es ersetzt die Programmbeschreibung vollständig.)

Welcher der folgenden Begriffe ist KEINE Kontrollstruktur?
(Variable)
(!Sequenz)
(!Verzweigung)
(!Schleife)

Wie sieht ein Beispiel für Pseudocode aus?
(!x = 5 + 3)
(„Frage das Alter ab, vergleiche es mit 18, gib das Ergebnis aus.“)
(!print("Hallo Welt"))
(!for i in range(5): print(i))

Wie weist man in Python einer Variablen einen Wert zu?
(!variable == wert)
(!wert = variable)
(variable = wert)
(!set variable wert)

Was macht der Befehl input() in Python?
(!Gibt einen Wert auf dem Bildschirm aus.)
(Fragt eine Eingabe von der*dem Benutzer*in ab.)
(!Vergleicht zwei Werte.)
(!Definiert eine neue Variable.)

</div>