Willkommen in der Lösungssektion!

Aufgabe 1: Die Begrüßung

# Eingabe des Benutzernamens
benutzername = input("Wie heißt du? ")

# Begrüßungsnachricht mit f-string
begrüßung = f"Hallo, {benutzername}! Herzlich willkommen auf PythonWorld.online."

# Ausgabe der Begrüßungsnachricht
print(begrüßung)

Erklärung:

'input("Wie heißt du? ")': Diese Zeile fragt den Benutzer nach seinem Namen und speichert die Eingabe in der Variable 'benutzername'.

'begrüßung = f"Hallo, {benutzername}! Herzlich willkommen auf PythonWorld.online."': Hier verwenden wir einen sogenannten f-string, um eine Begrüßungsnachricht zu erzeugen. Dabei wird der eingegebene Benutzername direkt in den String eingefügt.

'print(begrüßung)': Schließlich geben wir die Begrüßungsnachricht aus, die den eingegebenen Benutzernamen enthält.

Aufgabe 2: Zahlensumme

# Eingabe der ersten Zahl vom Benutzer
erste_zahl = float(input("Bitte gib die erste Zahl ein: "))

# Eingabe der zweiten Zahl vom Benutzer
zweite_zahl = float(input("Bitte gib die zweite Zahl ein: "))

# Berechnung der Summe
summe = erste_zahl + zweite_zahl

# Ausgabe der Summe mit f-string
print(f"Die Summe von {erste_zahl} und {zweite_zahl} ist {summe}.")

Erklärung:

'float(input("Bitte gib die erste Zahl ein: "))': Diese Zeile fragt den Benutzer nach der ersten Zahl. Da input() einen String zurückgibt, verwende ich 'float()' um den String in eine Gleitkommazahl umzuwandeln.

'float(input("Bitte gib die zweite Zahl ein: "))': Auch hier wird der Benutzer nach der zweiten Zahl gefragt, und die Eingabe wird in eine Gleitkommazahl umgewandelt.

'summe = erste_zahl + zweite_zahl': In dieser Zeile berechnen wir die Summe der beiden Zahlen und speichern das Ergebnis in der Variable 'summe'.

'print(f"Die Summe von {erste_zahl} und {zweite_zahl} ist {summe}.")': Abschließend geben wir die Summe der beiden Zahlen mit einem f-string aus.

Aufgabe 3: Quadratzahlen

# Verwende eine for-Schleife, um durch die Zahlen von 1 bis 10 zu iterieren
for zahl in range(1, 11):
    # Berechne das Quadrat der Zahl
    quadrat = zahl ** 2
    # Ausgabe des Quadrats mit einem f-string
    print(f"Das Quadrat von {zahl} ist {quadrat}.")

Erklärung:

'for zahl in range(1, 11)': Die for-Schleife wird hier mit 'range(1, 11)' initialisiert, was bedeutet, dass sie von 1 bis 10 läuft (die obere Grenze 11 ist exklusiv).

'quadrat = zahl ** 2': Innerhalb der Schleife berechnen wir das Quadrat der aktuellen Zahl mit dem Operator **, der in Python für die Potenzierung verwendet wird.

'print(f"Das Quadrat von {zahl} ist {quadrat}.")': Schließlich geben wir mit einem f-string aus, welches Quadrat wir gerade berechnet haben.

Mit dieser Schleife decken wir alle Zahlen von 1 bis 10 ab und berechnen deren Quadrate.

Aufgabe 4: Wochentage zählen

# Liste der Wochentage
wochentage = ["Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag", "Sonntag"]

# Durchlaufen der Liste der Wochentage
for tag in wochentage:
    # Zählen der Buchstaben 'e' in jedem Wochentag
    anzahl_e = tag.lower().count('e')
    # Ausgabe der Anzahl der 'e'-Buchstaben mit einem f-string
    print(f"Der Wochentag {tag} enthält {anzahl_e} 'e'-Buchstaben.")

Erklärung:

'wochentage = ["Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag", "Sonntag"]': Wir definieren eine Liste, die die Wochentage enthält.

'for tag in wochentage': Mit dieser for-Schleife durchlaufen wir jeden Wochentag in der Liste 'wochentage'

'anzahl_e = tag.lower().count('e')': Innerhalb der Schleife verwenden wir die count()-Methode, um die Anzahl der "e"-Buchstaben in jedem Wochentag zu zählen. Ich habe auch 'lower()' verwendet, um sicherzustellen, dass die Zählung unabhängig von der Groß- oder Kleinschreibung ist (obwohl das hier nicht notwendig ist).

'print(f"Der Wochentag {tag} enthält {anzahl_e} 'e'-Buchstaben.")': Zuletzt geben wir die Anzahl der "e"-Buchstaben für jeden Wochentag mit einem f-string aus.

Aufgabe 5: Gerade oder Ungerade

# Benutzer nach einer ganzen Zahl fragen
eingabe = input("Bitte gib eine ganze Zahl ein: ")

# Umwandlung der Eingabe in eine ganze Zahl
zahl = int(eingabe)

# Überprüfung, ob die Zahl gerade oder ungerade ist
if zahl % 2 == 0:
    ergebnis = "gerade"
else:
    ergebnis = "ungerade"

# Ausgabe des Ergebnisses mit f-string
print(f"Die Zahl {zahl} ist {ergebnis}.")

Erklärung:

'input("Bitte gib eine ganze Zahl ein: ")': Zuerst fragen wir den Benutzer nach einer Zahl. Die Eingabe wird als String gespeichert.

'int(eingabe)': Wir konvertieren die Eingabe in eine Ganzzahl ('int'), damit wir mathematische Operationen darauf anwenden können.

'if zahl % 2 == 0:': Dann verwenden wir den Modulo-Operator % um zu prüfen, ob die Zahl durch 2 teilbar ist (also gerade ist). Wenn 'zahl % 2' gleich 0 ist, dann ist die Zahl gerade.

'else:': Wenn die Zahl nicht gerade ist (also ungerade), führt der Code im else-Block aus.

'print(f"Die Zahl {zahl} ist {ergebnis}.")': Zum Schluss geben wir das Ergebnis aus, ob die Zahl gerade oder ungerade ist, und nutzen dafür einen f-string.

Aufgabe 6: Addition von Zahlen

# Eingabe der ersten Zahl vom Benutzer
erste_zahl = float(input("Bitte gib die erste Zahl ein: "))

# Eingabe der zweiten Zahl vom Benutzer
zweite_zahl = float(input("Bitte gib die zweite Zahl ein: "))

# Berechnung der Summe
summe = erste_zahl + zweite_zahl

# Ausgabe der Summe mit f-string
print(f"Die Summe von {erste_zahl} und {zweite_zahl} ist {summe}.")

Erklärung:

'float(input("Bitte gib die erste Zahl ein: "))': Hier fragen wir den Benutzer nach der ersten Zahl. Wir verwenden 'float()', um die Eingabe in eine Gleitkommazahl umzuwandeln.

'float(input("Bitte gib die zweite Zahl ein: "))': Gleiches gilt für die zweite Zahl.

'summe = erste_zahl + zweite_zahl': Die Summe der beiden Zahlen wird in der Variable summe gespeichert.

'print(f"Die Summe von {erste_zahl} und {zweite_zahl} ist {summe}.")': Und schließlich geben wir die Summe mit einem f-string aus.

Aufgabe 7: Größere Zahl finden

# Eingabe der ersten, zweiten und dritten Zahl vom Benutzer
erste_zahl = float(input("Bitte gib die erste Zahl ein: "))
zweite_zahl = float(input("Bitte gib die zweite Zahl ein: "))
dritte_zahl = float(input("Bitte gib die dritte Zahl ein: "))

# Finde die größte Zahl
if erste_zahl > zweite_zahl and erste_zahl > dritte_zahl:
    groesste_zahl = erste_zahl
elif zweite_zahl > erste_zahl and zweite_zahl > dritte_zahl:
    groesste_zahl = zweite_zahl
else:
    groesste_zahl = dritte_zahl

# Ausgabe der größten Zahl mit einem f-string
print(f"Die größte Zahl ist {groesste_zahl}.")

Erklärung:

Wir fragen den Benutzer nach drei Zahlen und speichern diese als Gleitkommazahlen.

Dann verwenden wir 'if', 'elif' und 'else' Anweisungen, um die größte der drei Zahlen zu finden: 'if erste_zahl > zweite_zahl and erste_zahl > dritte_zahl': Wenn die erste Zahl sowohl größer als die zweite als auch die dritte ist, ist sie die größte. 'elif zweite_zahl > erste_zahl and zweite_zahl > dritte_zahl': Wenn die zweite Zahl größer als die erste und die dritte ist, ist sie die größte. 'else': Wenn keines der beiden zutrifft, muss die dritte Zahl die größte sein.

Schließlich geben wir die größte Zahl mit einem f-string aus.

Aufgabe 8: Zahlen umkehren

# Benutzer nach einer ganzen Zahl fragen
eingabe = input("Bitte gib eine ganze Zahl ein: ")

# Überprüfen, ob die Eingabe eine ganze Zahl ist
try:
    int(eingabe)
except ValueError:
    print("Das ist keine ganze Zahl!")
    exit()

# Umkehren der Zahl durch Umwandlung in einen String und dann zurück in eine Zahl
umgekehrte_zahl = int(eingabe[::-1])

# Ausgabe der umgekehrten Zahl mit einem f-string
print(f"Die umgekehrte Zahl ist {umgekehrte_zahl}.")

Erklärung:

'input("Bitte gib eine ganze Zahl ein: ")': Wir fragen den Benutzer nach einer Zahl und speichern diese als String.

Dann überprüfen wir, ob die Eingabe tatsächlich eine ganze Zahl ist. Wenn nicht, geben wir eine Fehlermeldung aus und beenden das Programm.

'int(eingabe[::-1])': Hier nutzen wir Python's Slicing, um den String umzudrehen ('eingabe[::-1]'). Dann wandeln wir den umgekehrten String zurück in eine ganze Zahl.

print(f"Die umgekehrte Zahl ist {umgekehrte_zahl}."): Schließlich geben wir die umgekehrte Zahl aus.

Aufgabe 9: Wochentag ermitteln

# Benutzer nach einer Zahl zwischen 1 und 7 fragen
eingabe = input("Bitte gib eine Zahl zwischen 1 und 7 ein: ")

# Überprüfen, ob die Eingabe eine Zahl zwischen 1 und 7 ist
try:
    zahl = int(eingabe)
    if zahl < 1 or zahl > 7:
        print("Die Zahl sollte zwischen 1 und 7 liegen.")
        exit()
except ValueError:
    print("Das ist keine gültige Zahl!")
    exit()

# Ermittlung des Wochentags
if zahl == 1:
    tag = "Montag"
elif zahl == 2:
    tag = "Dienstag"
elif zahl == 3:
    tag = "Mittwoch"
elif zahl == 4:
    tag = "Donnerstag"
elif zahl == 5:
    tag = "Freitag"
elif zahl == 6:
    tag = "Samstag"
else:
    tag = "Sonntag"

# Ausgabe des Wochentags mit einem f-string
print(f"Die Zahl {zahl} entspricht dem Wochentag {tag}.")

Erklärung:

Zuerst fragen wir den Benutzer nach einer Zahl und prüfen, ob sie zwischen 1 und 7 liegt.

Dann verwenden wir 'if', 'elif' und 'else' Anweisungen, um den Wochentag zu ermitteln, der der eingegebenen Zahl entspricht.

Schließlich geben wir den entsprechenden Wochentag mit einem f-string aus.

Aufgabe 10: Einfacher Taschenrechner

# Benutzer nach der ersten und zweiten Zahl fragen
erste_zahl = float(input("Bitte gib die erste Zahl ein: "))
zweite_zahl = float(input("Bitte gib die zweite Zahl ein: "))

# Benutzer nach der Operation fragen
operation = input("Bitte wähle eine der folgenden Operationen: +, -, *, /: ")

# Durchführung der Operation und Speicherung des Ergebnisses
if operation == "+":
    ergebnis = erste_zahl + zweite_zahl
elif operation == "-":
    ergebnis = erste_zahl - zweite_zahl
elif operation == "*":
    ergebnis = erste_zahl * zweite_zahl
elif operation == "/":
    if zweite_zahl == 0:
        print("Division durch Null ist nicht erlaubt!")
        exit()
    ergebnis = erste_zahl / zweite_zahl
else:
    print("Das ist keine gültige Operation!")
    exit()

# Ausgabe des Ergebnisses mit einem f-string
print(f"Das Ergebnis von {erste_zahl} {operation} {zweite_zahl} ist {ergebnis}.")

Erklärung:

Wir fragen den Benutzer nach zwei Zahlen ('float' für die Unterstützung von Dezimalzahlen) und einer mathematischen Operation.

Dann verwenden wir 'if', 'elif' und 'else' Anweisungen, um die entsprechende Operation durchzuführen: Beachte die zusätzliche Prüfung für die Division durch Null.

Schließlich geben wir das Ergebnis mit einem f-string aus.

Aufgabe 11: Das Alter berechnen

from datetime import datetime

# Benutzereingabe für das Geburtsjahr
geb_jahr = input("Bitte geben Sie Ihr Geburtsjahr ein: ")

# Eingabe in Integer umwandeln
geb_jahr = int(geb_jahr)

# Aktuelles Jahr ermitteln
aktuelles_jahr = datetime.now().year

# Alter berechnen
alter = aktuelles_jahr - geb_jahr

# Ergebnis ausgeben
print(f"Ihr Alter ist: {alter} Jahre")

Erklärung:

'input("Bitte geben Sie Ihr Geburtsjahr ein: ")': Zuerst fragen wir den Benutzer nach seinem Geburtsjahr und speichern die Eingabe als String.

'int(geb_jahr)': Danach wandeln wir die Eingabe in einen Integer um, damit wir damit rechnen können.

'datetime.now().year': Hier verwenden wir das datetime-Modul, um das aktuelle Jahr zu ermitteln.

'alter = aktuelles_jahr - geb_jahr': Wir berechnen das Alter des Benutzers, indem wir das aktuelle Jahr vom Geburtsjahr subtrahieren.

'print(f"Ihr Alter ist: {alter} Jahre")': Schließlich geben wir das berechnete Alter aus.

Aufgabe 12: Umrechnung von Kilometer in Meilen

# Benutzereingabe für die Entfernung in Kilometern
km = input("Bitte geben Sie die Entfernung in Kilometern ein: ")

# Eingabe in Float umwandeln
km = float(km)

# Umrechnungsfaktor von Kilometer zu Meilen
faktor = 0.621371

# Entfernung in Meilen umrechnen
meilen = km * faktor

# Ergebnis ausgeben
print(f"Die Entfernung in Meilen beträgt: {meilen}")

Erklärung:

'input("Bitte geben Sie die Entfernung in Kilometern ein: ")': Zuerst fragen wir den Benutzer nach der Entfernung in Kilometern und speichern diese als String.

'float(km)': Die Eingabe wird in eine Gleitkommazahl (Float) umgewandelt, damit wir damit rechnen können.

'faktor = 0.621371': Wir legen den Umrechnungsfaktor von Kilometern zu Meilen fest. 1 Kilometer entspricht etwa 0,621371 Meilen.

'meilen = km * faktor': Die Entfernung wird in Meilen umgerechnet, indem wir die Kilometer mit dem Umrechnungsfaktor multiplizieren.

'print(f"Die Entfernung in Meilen beträgt: {meilen}")': Schließlich geben wir die umgerechnete Entfernung in Meilen aus.

Aufgabe 13: Berechnung des BMI (Body Mass Index)

# Benutzereingabe für Gewicht und Größe
gewicht = float(input("Bitte geben Sie Ihr Gewicht in Kilogramm ein: "))
groesse = float(input("Bitte geben Sie Ihre Größe in Metern ein: "))

# BMI berechnen
bmi = gewicht / (groesse ** 2)

# Ergebnis ausgeben
print(f"Ihr BMI beträgt: {bmi:.2f}")

Erklärung:

'float(input("Bitte geben Sie Ihr Gewicht in Kilogramm ein: "))': Wir fragen den Benutzer nach seinem Gewicht in Kilogramm und speichern diese als Gleitkommazahl.

'float(input("Bitte geben Sie Ihre Größe in Metern ein: "))': Ebenso fragen wir nach der Größe in Metern und speichern auch diese als Gleitkommazahl.

'bmi = gewicht / (groesse ** 2)': Der BMI wird nach der Formel \( \text{BMI} = \frac{\text{Gewicht (kg)}}{\text{Größe (m)}^2} \) berechnet.

'print(f"Ihr BMI beträgt: {bmi:.2f}")': Schließlich geben wir den BMI aus. Wir nutzen die Formatierung ':.2f' im f-string, um das Ergebnis auf zwei Dezimalstellen zu begrenzen.

Aufgabe 14: Zahlen sortieren

# Benutzereingabe für die drei Zahlen
zahl1 = float(input("Bitte geben Sie die erste Zahl ein: "))
zahl2 = float(input("Bitte geben Sie die zweite Zahl ein: "))
zahl3 = float(input("Bitte geben Sie die dritte Zahl ein: "))

# Die Zahlen in einer Liste speichern
zahlen_liste = [zahl1, zahl2, zahl3]

# Die Liste sortieren
zahlen_liste.sort()

# Ergebnis ausgeben
print(f"Die Zahlen in aufsteigender Reihenfolge sind: {zahlen_liste}")

Erklärung:

'float(input("Bitte geben Sie die erste Zahl ein: "))', 'float(input("Bitte geben Sie die zweite Zahl ein: "))', 'float(input("Bitte geben Sie die dritte Zahl ein: "))': Wir fragen den Benutzer nach drei Zahlen und speichern sie als Gleitkommazahlen.

'zahlen_liste = [zahl1, zahl2, zahl3]': Die eingegebenen Zahlen werden in einer Liste gespeichert.

'zahlen_liste.sort()': Mit der 'sort()' Methode sortieren wir die Liste in aufsteigender Reihenfolge.

'print(f"Die Zahlen in aufsteigender Reihenfolge sind: {zahlen_liste}")': Schließlich geben wir die sortierte Liste aus.

Aufgabe 15: Durchschnitt berechnen

# Benutzereingabe für die fünf Noten
note1 = float(input("Bitte geben Sie die erste Note ein: "))
note2 = float(input("Bitte geben Sie die zweite Note ein: "))
note3 = float(input("Bitte geben Sie die dritte Note ein: "))
note4 = float(input("Bitte geben Sie die vierte Note ein: "))
note5 = float(input("Bitte geben Sie die fünfte Note ein: "))

# Durchschnitt berechnen
durchschnitt = (note1 + note2 + note3 + note4 + note5) / 5

# Ergebnis ausgeben
print(f"Der Durchschnitt der Noten beträgt: {durchschnitt:.2f}")

Erklärung:

'float(input("Bitte geben Sie die erste Note ein: "))', ... , 'float(input("Bitte geben Sie die fünfte Note ein: "))': Wir fragen den Benutzer nach fünf Noten und speichern diese als Gleitkommazahlen.

'durchschnitt = (note1 + note2 + note3 + note4 + note5) / 5': Der Durchschnitt wird durch das Addieren aller Noten und die anschließende Division durch 5 berechnet.

'print(f"Der Durchschnitt der Noten beträgt: {durchschnitt:.2f}")': Schließlich geben wir den Durchschnitt aus, dabei runden wir das Ergebnis auf zwei Dezimalstellen.

Aufgabe 16: Schräge Linien zeichnen

# Benutzer nach einer positiven ganzen Zahl fragen
anzahl_zeilen = int(input("Bitte geben Sie eine positive ganze Zahl ein: "))

# Überprüfen, ob die Zahl positiv ist
if anzahl_zeilen <= 0:
    print("Bitte eine positive ganze Zahl eingeben!")
else:
    # Schräge Linien zeichnen
    for i in range(1, anzahl_zeilen + 1):
        print(" " * (i - 1) + "*")

Erklärung:

'int(input("Bitte geben Sie eine positive ganze Zahl ein: "))': Wir fragen den Benutzer nach einer positiven ganzen Zahl.

'if anzahl_zeilen <= 0:': Wir überprüfen, ob die eingegebene Zahl tatsächlich positiv ist. Falls nicht, wird eine Fehlermeldung ausgegeben.

'for i in range(1, anzahl_zeilen + 1):': Wir verwenden eine for-Schleife, um durch die Anzahl der Zeilen zu iterieren.

'print(" " * (i - 1) + "*")': In jeder Iteration wird die Anzahl der Leerzeichen erhöht und ein Stern am Ende der Zeile hinzugefügt, um die schrägen Linien zu zeichnen.

Aufgabe 17: Primzahlen finden

# Benutzer nach einer positiven ganzen Zahl fragen
obergrenze = int(input("Bitte geben Sie eine positive ganze Zahl ein: "))

# Überprüfen, ob die Zahl positiv ist
if obergrenze <= 1:
    print("Bitte eine Zahl größer als 1 eingeben!")
else:
    print("Die Primzahlen von 2 bis", obergrenze, "sind:")

    for zahl in range(2, obergrenze + 1):
        for teiler in range(2, int(zahl ** 0.5) + 1):
            if zahl % teiler == 0:
                break
        else:
            print(zahl)

Erklärung:

'int(input("Bitte geben Sie eine positive ganze Zahl ein: "))': Wir fragen den Benutzer nach einer positiven ganzen Zahl als Obergrenze für die Primzahlen.

'if obergrenze <= 1:': Wir überprüfen, ob die eingegebene Zahl größer als 1 ist. Falls nicht, wird eine Fehlermeldung ausgegeben.

'for zahl in range(2, obergrenze + 1):': Wir verwenden eine äußere for-Schleife, um alle Zahlen von 2 bis zur Obergrenze zu durchlaufen.

'for teiler in range(2, int(zahl ** 0.5) + 1):': Eine innere for-Schleife prüft, ob die aktuelle Zahl durch irgendeine andere Zahl ohne Rest teilbar ist. Wir verwenden hier die Quadratwurzel der Zahl als Obergrenze für die Optimierung.

'if zahl % teiler == 0:': Wenn die Zahl ohne Rest teilbar ist, brechen wir die innere Schleife ab und prüfen die nächste Zahl.

'else: print(zahl)': Wenn die Zahl nur durch 1 und sich selbst teilbar ist, drucken wir sie aus.

Aufgabe 18: Faktorielle berechnen

# Benutzer nach einer nicht-negativen ganzen Zahl fragen
zahl = int(input("Bitte gib eine nicht-negative ganze Zahl ein: "))

# Überprüfen, ob die Zahl nicht-negativ ist
if zahl < 0:
    print("Bitte eine nicht-negative Zahl eingeben!")
else:
    faktorielle = 1
    for i in range(1, zahl + 1):
        faktorielle *= i
    print(f"Die Faktorielle von {zahl} ist {faktorielle}.")

Erklärung:

'int(input("Bitte gib eine nicht-negative ganze Zahl ein: "))': Wir fragen den Benutzer nach einer nicht-negativen ganzen Zahl.

'if zahl < 0:': Wir überprüfen, ob die eingegebene Zahl nicht-negativ ist. Falls nicht, wird eine Fehlermeldung ausgegeben.

'faktorielle = 1': Wir initialisieren eine Variable mit dem Wert 1, die das Ergebnis speichern wird.

'for i in range(1, zahl + 1):': Wir verwenden eine for-Schleife, um die Faktorielle zu berechnen. Das Produkt aller Zahlen von 1 bis zur eingegebenen Zahl wird in der Variable gespeichert.

'faktorielle *= i': In jedem Durchlauf der Schleife wird die Variable 'faktorielle' mit der aktuellen Zahl multipliziert.

'print(f"Die Faktorielle von {zahl} ist {faktorielle}.")': Wir geben das Ergebnis aus.

Aufgabe 19: Primfaktoren finden

# Benutzer nach einer positiven ganzen Zahl fragen
zahl = int(input("Bitte gib eine positive ganze Zahl ein: "))

# Überprüfen, ob die Zahl positiv ist
if zahl <= 1:
    print("Bitte eine positive ganze Zahl größer als 1 eingeben!")
else:
    i = 2
    primfaktoren = []
    while zahl > 1:
        if zahl % i == 0:
            primfaktoren.append(i)
            zahl = zahl // i
        else:
            i += 1
    print(f"Die Primfaktoren sind: {primfaktoren}")

Erklärung:

'int(input("Bitte gib eine positive ganze Zahl ein: "))': Wir fragen den Benutzer nach einer positiven ganzen Zahl.

'if zahl <= 1:': Wir überprüfen, ob die Zahl positiv und größer als 1 ist.

'i = 2': Wir starten mit der kleinsten Primzahl 2 als möglichen Faktor.

'while zahl > 1:': Wir setzen die Schleife fort, bis die Zahl zu 1 reduziert ist.

'if zahl % i == 0:': Wenn die Zahl durch 'i' ohne Rest teilbar ist, fügen wir 'i' zu den Primfaktoren hinzu und teilen die Zahl durch 'i'.

'else: i += 1': Wenn die Zahl nicht durch 'i' teilbar ist, erhöhen wir 'i' um 1.

'print(f"Die Primfaktoren sind: {primfaktoren}")': Wir geben die gefundenen Primfaktoren aus.

Aufgabe 20: Palindrom überprüfen

# Benutzer nach einer Zeichenkette fragen
zeichenkette = input("Bitte gib ein Wort oder eine Zeichenkette ein: ")

# Zeichenkette in Kleinbuchstaben umwandeln
zeichenkette = zeichenkette.lower()

# Überprüfen, ob die Zeichenkette ein Palindrom ist
if zeichenkette == zeichenkette[::-1]:
    print(f"{zeichenkette} ist ein Palindrom.")
else:
    print(f"{zeichenkette} ist kein Palindrom.")

Erklärung:

'input("Bitte gib ein Wort oder eine Zeichenkette ein: ")': Wir fragen den Benutzer nach einer Zeichenkette.

'zeichenkette = zeichenkette.lower()': Wir wandeln die Zeichenkette in Kleinbuchstaben um, um die Überprüfung unabhängig von der Groß- und Kleinschreibung zu machen.

'if zeichenkette == zeichenkette[::-1]:': Mit Slicing kehren wir die Zeichenkette um und vergleichen sie mit der Originalzeichenkette.

'print(f"{zeichenkette} ist ein Palindrom.")' und 'print(f"{zeichenkette} ist kein Palindrom.")': Abhängig vom Ergebnis des Vergleichs geben wir aus, ob die Zeichenkette ein Palindrom ist oder nicht.

Aufgabe 21: Textanalyse - Häufigkeit von Wörtern

from collections import Counter
import string

# Benutzer nach einem Text fragen
text = input("Bitte gib einen Text ein: ")

# Text in Kleinbuchstaben umwandeln
text = text.lower()

# Satzzeichen aus dem Text entfernen
text = text.translate(str.maketrans("", "", string.punctuation))

# Text in Wörter zerlegen
woerter = text.split()

# Häufigkeit der Wörter zählen
haeufigkeit = Counter(woerter)

# Wörter und ihre Häufigkeit in absteigender Reihenfolge ausgeben
for wort, anzahl in haeufigkeit.most_common():
    print(f"{wort}: {anzahl}")

Erklärung:

'from collections import Counter': Wir importieren die Counter-Klasse aus dem collections-Modul, um die Häufigkeit der Wörter zu zählen.

'import string': Wir importieren das string-Modul, um Satzzeichen zu entfernen.

'text = input("Bitte gib einen Text ein: ")': Wir fragen den Benutzer nach einem Text.

'text = text.lower()': Wir wandeln den Text in Kleinbuchstaben um.

'text = text.translate(str.maketrans("", "", string.punctuation))': Wir entfernen alle Satzzeichen aus dem Text.

'woerter = text.split()': Wir zerlegen den Text in eine Liste von Wörtern.

'haeufigkeit = Counter(woerter)': Wir zählen die Häufigkeit der Wörter mit der Counter-Klasse.

'for wort, anzahl in haeufigkeit.most_common():': Wir geben die Wörter und ihre Häufigkeit in absteigender Reihenfolge aus.

Aufgabe 22: Worträtsel erstellen

import random

# Vordefinierte Liste von Wörtern
woerter_liste = ['Apfel', 'Birne', 'Banane', 'Kirsche']

# Zufälliges Wort auswählen
zufaelliges_wort = random.choice(woerter_liste)

# Buchstaben des Worts mischen
gemischte_buchstaben = list(zufaelliges_wort)
random.shuffle(gemischte_buchstaben)
gemischtes_wort = ''.join(gemischte_buchstaben)

# Rätsel dem Benutzer präsentieren
print(f"Errate das Wort: {gemischtes_wort}")

# Antwort des Benutzers einholen
antwort = input("Deine Antwort: ")

# Überprüfung der Antwort
if antwort == zufaelliges_wort:
    print("Richtig!")
else:
    print(f"Falsch, das richtige Wort war {zufaelliges_wort}.")

Erklärung:

'import random': Wir importieren das random-Modul, um ein zufälliges Wort aus der Liste zu wählen.

'woerter_liste = ['Apfel', 'Birne', 'Banane', 'Kirsche']': Wir definieren eine Liste von Wörtern, aus der ein Wort für das Rätsel ausgewählt wird.

'zufaelliges_wort = random.choice(woerter_liste)': Wir wählen ein zufälliges Wort aus der Liste aus.

'gemischte_buchstaben = list(zufaelliges_wort)': Wir zerlegen das ausgewählte Wort in eine Liste von Buchstaben.

'random.shuffle(gemischte_buchstaben)': Wir mischen die Buchstaben der Liste.

'gemischtes_wort = ''.join(gemischte_buchstaben)': Wir fügen die gemischten Buchstaben wieder zu einem Wort zusammen.

'print(f"Errate das Wort: {gemischtes_wort}")': Wir zeigen das gemischte Wort dem Benutzer.

'antwort = input("Deine Antwort: ")': Wir nehmen die Antwort des Benutzers entgegen.

'if antwort == zufaelliges_wort:': Wir überprüfen, ob die Antwort des Benutzers korrekt ist.

Aufgabe 23: Temperaturumrechnung

# Benutzer nach der Art der Umrechnung fragen
wahl = input("Welche Umrechnung möchtest du durchführen? 'c': Von Fahrenheit nach Celsius, 'f': Von Celsius nach Fahrenheit: ")

# Temperatur vom Benutzer abfragen
temperatur = float(input("Bitte gib die Temperatur ein, die umgerechnet werden soll: "))

# Umrechnung durchführen
if wahl.lower() == 'c':
    umgerechnet = (temperatur - 32) * 5/9
    print(f"{temperatur} Fahrenheit sind {umgerechnet:.2f} Celsius.")
elif wahl.lower() == 'f':
    umgerechnet = (temperatur * 9/5) + 32
    print(f"{temperatur} Celsius sind {umgerechnet:.2f} Fahrenheit.")
else:
    print("Ungültige Auswahl.")

Erklärung:

'wahl = input("...")': Wir fragen den Benutzer, welche Art von Umrechnung er vornehmen möchte.

'temperatur = float(input("..."))': Wir fragen den Benutzer nach der Temperatur, die umgerechnet werden soll. Wir verwenden float, um sicherzustellen, dass die Eingabe als Fließkommazahl behandelt wird.

'if wahl.lower() == 'c':': Wir überprüfen, ob der Benutzer die Umrechnung von Fahrenheit nach Celsius ausgewählt hat. Wir verwenden .lower(), um sicherzustellen, dass die Eingabe unabhängig von der Groß- und Kleinschreibung ist.

'umgerechnet = (temperatur - 32) * 5/9': Wir führen die Umrechnung von Fahrenheit nach Celsius durch.

'elif wahl.lower() == 'f':': Wir überprüfen, ob der Benutzer die Umrechnung von Celsius nach Fahrenheit ausgewählt hat.

'umgerechnet = (temperatur * 9/5) + 32': Wir führen die Umrechnung von Celsius nach Fahrenheit durch.

'else:': Falls eine ungültige Auswahl getroffen wurde, geben wir eine entsprechende Nachricht aus.

Aufgabe 24: Fibonacci-Folge

# Benutzer nach einer nicht-negativen ganzen Zahl fragen
n = int(input("Bitte gib eine nicht-negative ganze Zahl ein: "))

# Die ersten beiden Zahlen der Fibonacci-Folge
a, b = 0, 1

# Die Fibonacci-Folge bis zu 'n' berechnen und ausgeben
print("Die Fibonacci-Folge bis zu diesem Wert ist:")
print(a, end=" ")

while b <= n:
    print(b, end=" ")
    a, b = b, a + b

Erklärung:

'n = int(input("..."))': Wir fragen den Benutzer nach einer nicht-negativen ganzen Zahl.

'a, b = 0, 1': Wir initialisieren die ersten beiden Zahlen der Fibonacci-Folge mit 0 und 1.

'print("Die Fibonacci-Folge bis zu diesem Wert ist:")': Wir geben eine Einführungsnachricht aus.

'print(a, end=" ")': Wir geben die erste Zahl der Folge aus und setzen das Ende auf ein Leerzeichen, damit die Zahlen in einer Zeile erscheinen.

'while b <= n:': Wir führen die Schleife aus, solange 'b' kleiner oder gleich 'n' ist.

'a, b = b, a + b': Wir aktualisieren die Werte von 'a' und 'b', so dass 'a' den aktuellen Wert von 'b' bekommt und 'b' die Summe von 'a' und 'b' bekommt.

Aufgabe 25: Wortspiegelung

# Benutzer nach einem Wort fragen
wort = input("Bitte gib ein Wort ein: ")

# Das Wort spiegeln
gespiegeltes_wort = wort[::-1]

# Das gespiegelte Wort ausgeben
print(f"Das gespiegelte Wort ist: {gespiegeltes_wort}")

Erklärung:

'wort = input("Bitte gib ein Wort ein: ")': Wir fragen den Benutzer nach einem Wort.

'gespiegeltes_wort = wort[::-1]': Wir spiegeln das Wort, indem wir es in umgekehrter Reihenfolge ausgeben. In Python erreichen wir das durch Slicing mit einem Schritt von -1.

'print(f"Das gespiegelte Wort ist: {gespiegeltes_wort}")': Wir geben das gespiegelte Wort aus.

Aufgabe 26: Schräge Linien zeichnen (Pyramide)

# Benutzer nach einer positiven ganzen Zahl fragen
zeilen = int(input("Bitte gib eine positive ganze Zahl ein: "))

# Pyramide aus Sternen zeichnen
for i in range(1, zeilen + 1):
    leerzeichen = ' ' * (zeilen - i)
    sterne = '*' * (2 * i - 1)
    print(f"{leerzeichen}{sterne}")

Erklärung:

'zeilen = int(input("Bitte gib eine positive ganze Zahl ein: "))': Wir fragen den Benutzer nach der Anzahl der Zeilen der Pyramide.

'for i in range(1, zeilen + 1):': Wir erstellen eine Schleife, die von 1 bis zur angegebenen Anzahl der Zeilen geht.

'leerzeichen = ' ' * (zeilen - i)': Wir berechnen die Anzahl der Leerzeichen für jede Zeile.

'sterne = '*' * (2 * i - 1)': Wir berechnen die Anzahl der Sterne für jede Zeile.

'print(f"{leerzeichen}{sterne}")': Wir geben die Kombination aus Leerzeichen und Sternen aus, um die Pyramide zu zeichnen.

Aufgabe 27: Zahlenraten Spiel

import random

# Zufällige Zahl zwischen 1 und 100 wählen
zielzahl = random.randint(1, 100)

# Anzahl der Versuche festlegen
versuche = 10

# Spiel starten
for i in range(versuche):
    zahl = int(input("Rate die Zahl zwischen 1 und 100: "))
    
    if zahl < zielzahl:
        print("Zu niedrig!")
    elif zahl > zielzahl:
        print("Zu hoch!")
    else:
        print(f"Gratulation, du hast die Zahl {zielzahl} erraten!")
        break
else:
    print(f"Schade, du hast alle {versuche} Versuche aufgebraucht. Die richtige Zahl war {zielzahl}.")

Erklärung:

'import random': Wir importieren das 'random' Modul, um eine zufällige Zahl zu generieren.

'zielzahl = random.randint(1, 100)': Das Programm wählt eine zufällige Zahl zwischen 1 und 100.

'versuche = 10': Der Benutzer hat 10 Versuche, um die Zahl zu erraten.

'for i in range(versuche):': Wir starten eine Schleife für die Anzahl der Versuche.

'if zahl < zielzahl:': Das Programm gibt Hinweise, ob die geratene Zahl zu niedrig ist.

'elif zahl > zielzahl:': Das Programm gibt Hinweise, ob die geratene Zahl zu hoch ist.

'else:': Das Spiel endet, wenn die Zahl erraten wurde oder alle Versuche aufgebraucht sind.

Aufgabe 28: FizzBuzz

# Zahlen von 1 bis 100 durchgehen
for i in range(1, 101):
    if i % 3 == 0 and i % 5 == 0:
        print("FizzBuzz")
    elif i % 3 == 0:
        print("Fizz")
    elif i % 5 == 0:
        print("Buzz")
    else:
        print(i)

Erklärung:

'for i in range(1, 101):': Wir gehen durch die Zahlen von 1 bis 100.

'if i % 3 == 0 and i % 5 == 0:': Wenn die Zahl durch 3 und 5 ohne Rest teilbar ist, geben wir "FizzBuzz" aus.

'elif i % 3 == 0:': Wenn die Zahl nur durch 3 teilbar ist, geben wir "Fizz" aus.

'elif i % 5 == 0:': Wenn die Zahl nur durch 5 teilbar ist, geben wir "Buzz" aus.

'else:': Wenn keine der Bedingungen zutrifft, geben wir die Zahl selbst aus.

Aufgabe 29: Tierarzt - Berechnung der Medikamentendosis

# Tierarzt nach dem Gewicht des Tieres fragen
gewicht = float(input("Bitte geben Sie das Gewicht des Tieres in Kilogramm ein: "))

# Tierarzt nach der Konzentration des Medikaments fragen
konzentration = float(input("Bitte geben Sie die Konzentration des Medikaments in mg/ml ein: "))

# Empfohlene Dosis in mg/kg
empfohlene_dosis = 10.0

# Dosis in ml berechnen
dosis_ml = (gewicht * empfohlene_dosis) / konzentration

# Dosis in ml ausgeben
print(f"Die richtige Dosis des Medikaments beträgt {dosis_ml} ml.")

Erklärung:

'gewicht = float(input("..."))': Wir fragen den Tierarzt nach dem Gewicht des Tieres in Kilogramm und speichern es als Gleitkommazahl.

'konzentration = float(input("..."))': Wir fragen nach der Konzentration des Medikaments in mg/ml.

'empfohlene_dosis = 10.0': Wir setzen die empfohlene Dosis auf 10 mg/kg.

'dosis_ml = (gewicht * empfohlene_dosis) / konzentration': Wir berechnen die Dosis in ml mit der gegebenen Formel.

'print(f"Die richtige Dosis des Medikaments beträgt {dosis_ml} ml.")': Wir geben die berechnete Dosis aus.

Aufgabe 30: Zeitumrechnung - Sekunden in Stunden, Minuten und Sekunden

# Benutzer nach der Anzahl der Sekunden fragen
sekunden = int(input("Bitte geben Sie die Anzahl der Sekunden ein: "))

# Anzahl der Stunden berechnen
stunden = sekunden // 3600

# Restliche Sekunden ermitteln
rest_sekunden = sekunden % 3600

# Anzahl der Minuten berechnen
minuten = rest_sekunden // 60

# Restliche Sekunden ermitteln
rest_sekunden %= 60

# Ergebnis ausgeben
print(f"{stunden} Stunde(n), {minuten} Minute(n) und {rest_sekunden} Sekunde(n)")

Erklärung:

'sekunden = int(input("..."))': Wir fragen den Benutzer nach der Anzahl der Sekunden und speichern sie als Ganzzahl.

'stunden = sekunden // 3600': Wir berechnen die Anzahl der Stunden durch Ganzzahldivision.

'rest_sekunden = sekunden % 3600': Wir berechnen die restlichen Sekunden nach der Ermittlung der Stunden.

'minuten = rest_sekunden // 60': Wir berechnen die Anzahl der Minuten mit den restlichen Sekunden.

'rest_sekunden %= 60': Wir ermitteln die endgültig übrigen Sekunden.

'print(f"{stunden} Stunde(n), {minuten} Minute(n) und {rest_sekunden} Sekunde(n)")': Wir geben das Ergebnis in Stunden, Minuten und Sekunden aus.

Aufgabe 31: Finden des kürzesten Wegs in einem Labyrinth

import heapq

def manhattan_distance(a, b):
    return abs(a[0] - b[0]) + abs(a[1] - b[1])

def a_star_search(labyrinth, start, goal):
    frontier = [(0, start)]
    came_from = {start: None}
    cost_so_far = {start: 0}

    while frontier:
        current_priority, current = heapq.heappop(frontier)

        if current == goal:
            path = []
            while current:
                path.append(current)
                current = came_from[current]
            path.reverse()
            return path

        for dx, dy in [(1, 0), (-1, 0), (0, 1), (0, -1)]:
            next_x, next_y = current[0] + dx, current[1] + dy
            next_node = (next_x, next_y)

            if 0 <= next_x < len(labyrinth) and 0 <= next_y < len(labyrinth[0]) and labyrinth[next_x][next_y] == '0':
                new_cost = cost_so_far[current] + 1

                if next_node not in cost_so_far or new_cost < cost_so_far[next_node]:
                    cost_so_far[next_node] = new_cost
                    priority = new_cost + manhattan_distance(goal, next_node)
                    heapq.heappush(frontier, (priority, next_node))
                    came_from[next_node] = current

    return None
	
labyrinth = [
    ['0', '0', '0', '1', '0'],
    ['1', '1', '0', '1', '0'],
    ['0', '0', '0', '0', '0'],
    ['0', '1', '1', '1', '0'],
    ['0', '0', '0', '0', '0']
]

start = (0, 0)
goal = (4, 4)

path = a_star_search(labyrinth, start, goal)

if path:
    print("Pfad gefunden:", path)
else:
    print("Kein Pfad gefunden.")

Erklärung:

'import heapq': Wir importieren das Modul heapq für die Verwaltung der Prioritätswarteschlange.

'def manhattan_distance(a, b)': Diese Funktion berechnet die Manhattan-Distanz zwischen zwei Punkten a und b.

'def a_star_search(labyrinth, start, goal)': Diese Funktion implementiert den A*-Suchalgorithmus.

'frontier = [(0, start)]': Wir initialisieren die Prioritätswarteschlange mit dem Startpunkt.

'came_from = {start: None}': Ein Wörterbuch, das für jeden Punkt speichert, von welchem Punkt er erreicht wurde.

'cost_so_far = {start: 0}': Ein Wörterbuch, das die Kosten speichert, um einen bestimmten Punkt zu erreichen.

'while frontier:': Die Hauptschleife des Algorithmus, die läuft, solange es noch Punkte zu überprüfen gibt.

'current_priority, current = heapq.heappop(frontier)': Wir holen den Punkt mit der höchsten Priorität aus der Warteschlange.

'if current == goal:': Wenn wir das Ziel erreicht haben, beenden wir die Suche.

'for dx, dy in [(1, 0), (-1, 0), (0, 1), (0, -1)]:': Wir überprüfen alle vier möglichen Bewegungsrichtungen.

'heapq.heappush(frontier, (priority, next_node))': Wir fügen einen neuen Punkt zur Prioritätswarteschlange hinzu.

Aufgabe 32: Implementierung von RSA-Verschlüsselung von Grund auf

import random

# Einfache Funktion zur Berechnung des größten gemeinsamen Teilers (ggT)
def gcd(a, b):
    while b:
        a, b = b, a % b
    return a

# Erzeugen eines Schlüsselpaares
def generate_keypair(p, q):
    n = p * q
    phi = (p-1) * (q-1)

    # Wähle eine Zahl e, die teilerfremd zu phi ist
    e = random.randrange(1, phi)
    while gcd(e, phi) != 1:
        e = random.randrange(1, phi)

    # Berechne d
    d = 0
    for i in range(1, phi):
        if (e * i) % phi == 1:
            d = i
            break

    return ((e, n), (d, n))

# Verschlüsselungsfunktion
def encrypt(pk, plaintext):
    e, n = pk
    return [pow(ord(c), e, n) for c in plaintext]

# Entschlüsselungsfunktion
def decrypt(pk, ciphertext):
    d, n = pk
    return ''.join([chr(pow(c, d, n)) for c in ciphertext])

# Testen des RSA-Algorithmus
def test_rsa():
    p = 61
    q = 53
    public_key, private_key = generate_keypair(p, q)
    print("Öffentlicher Schlüssel:", public_key)
    print("Privater Schlüssel:", private_key)
    
    plaintext = "HELLO"
    print("Klartext:", plaintext)
    
    ciphertext = encrypt(public_key, plaintext)
    print("Verschlüsselter Text:", ciphertext)
    
    decrypted_text = decrypt(private_key, ciphertext)
    print("Entschlüsselter Text:", decrypted_text)
    
    assert decrypted_text == plaintext

test_rsa()

Erklärung:

'import random': Wir importieren das Modul random für die Zufallszahlenerzeugung.

'def gcd(a, b):': Diese Funktion berechnet den größten gemeinsamen Teiler von zwei Zahlen.

'def generate_keypair(p, q):': Diese Funktion erzeugt ein Schlüsselpaar bestehend aus einem öffentlichen und einem privaten Schlüssel.

'def encrypt(pk, plaintext):': Diese Funktion verschlüsselt einen Klartext unter Verwendung des öffentlichen Schlüssels.

'def decrypt(pk, ciphertext):': Diese Funktion entschlüsselt einen Geheimtext unter Verwendung des privaten Schlüssels.

'def test_rsa():': Diese Funktion testet den RSA-Algorithmus durch Verschlüsselung und Entschlüsselung eines Test-Strings.

Aufgabe 33: Erstellung eines Neuronalen Netzes zur Textklassifikation von Grund auf

import numpy as np

# Sigmoid-Aktivierungsfunktion
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

# Derivative of the Sigmoid
def sigmoid_derivative(x):
    return x * (1 - x)

# Eingabedaten und Labels (Hier nur als Beispiel)
X = np.array([[0,0], [0,1], [1,0], [1,1]])  # Input
y = np.array([[0], [1], [1], [0]])  # Labels

# Initialisierung der Gewichte und Bias
inputLayerNeurons, hiddenLayerNeurons, outputLayerNeurons = 2, 2, 1
hidden_weights = np.random.uniform(size=(inputLayerNeurons, hiddenLayerNeurons))
hidden_bias = np.random.uniform(size=(1, hiddenLayerNeurons))
output_weights = np.random.uniform(size=(hiddenLayerNeurons, outputLayerNeurons))
output_bias = np.random.uniform(size=(1, outputLayerNeurons))

# Training des Modells
epochs = 10000
lr = 0.1
for _ in range(epochs):
    # Feedforward
    hidden_layer_activation = np.dot(X, hidden_weights) + hidden_bias
    hidden_layer_output = sigmoid(hidden_layer_activation)
    output_layer_activation = np.dot(hidden_layer_output, output_weights) + output_bias
    predicted_output = sigmoid(output_layer_activation)

    # Backpropagation
    error = y - predicted_output
    d_predicted_output = error * sigmoid_derivative(predicted_output)
    error_hidden_layer = d_predicted_output.dot(output_weights.T)
    d_hidden_layer = error_hidden_layer * sigmoid_derivative(hidden_layer_output)

    # Update Weights and Biases
    output_weights += hidden_layer_output.T.dot(d_predicted_output) * lr
    output_bias += np.sum(d_predicted_output, axis=0, keepdims=True) * lr
    hidden_weights += X.T.dot(d_hidden_layer) * lr
    hidden_bias += np.sum(d_hidden_layer, axis=0, keepdims=True) * lr
	
	# Ausgabe der Ergebnisse nach dem Training
print("Vorhersagen nach dem Training:")
print(predicted_output)

# Ausgabe des Fehlers nach dem Training
print("Fehler nach dem Training:")
print(error)

Erklärung:

'import numpy as np': Wir importieren die NumPy-Bibliothek für numerische Operationen.

'def sigmoid(x):': Definition der Sigmoid-Aktivierungsfunktion.

'def sigmoid_derivative(x):': Ableitung der Sigmoid-Funktion, nützlich für Backpropagation.

'X = np.array([...])': Eingabedaten für das Training.

'y = np.array([...])': Die zugehörigen Labels.

'hidden_weights = np.random.uniform(...)': Initialisierung der Gewichte für die versteckte Schicht.

'for _ in range(epochs):': Trainingsschleife des Modells.

'hidden_layer_activation = np.dot(X, hidden_weights) + hidden_bias': Feedforward-Schritt für die versteckte Schicht.

'error = y - predicted_output': Fehlerberechnung.

'output_weights += ...': Aktualisierung der Gewichte und Bias mit dem Backpropagation-Algorithmus.

Das ist eine sehr einfache Implementierung eines Feedforward-Neuronalen Netzes mit Backpropagation. Die Aufgabe ist natürlich ausbaufähig, insbesondere durch die Implementierung verschiedener Aktivierungsfunktionen oder durch das Hinzufügen einer Speicher-/Ladefunktionalität.

Aufgabe 34: Implementierung eines eigenen Web-Servers in Python

import socket
import threading

def handle_client(client_socket):
    request = client_socket.recv(1024).decode('utf-8')
    print(f"Received: {request}")

    headers = "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n"
    body = "Hello, World!"

    client_socket.send((headers + body).encode('utf-8'))
    client_socket.close()

def main():
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server.bind(('0.0.0.0', 8080))
    server.listen(5)

    print("Server started on port 8080...")

    while True:
        client_socket, addr = server.accept()
        print(f"Accepted connection from: {addr}")

        client_thread = threading.Thread(target=handle_client, args=(client_socket,))
        client_thread.start()

if __name__ == "__main__":
    main()

Erklärung:

'import socket, threading': Importiert die benötigten Module für Netzwerk- und Threading-Funktionen.

'def handle_client(client_socket):': Funktion zur Bearbeitung von Client-Anfragen.

'request = client_socket.recv(1024).decode("utf-8")': Empfängt die Client-Anfrage.

'headers = "HTTP/1.1 200 OK..."': HTTP-Antwort-Header.

'client_socket.send((headers + body).encode("utf-8"))': Sendet die HTTP-Antwort zurück zum Client.

'server = socket.socket(...)': Erstellt einen neuen Socket für den Server.

'server.bind(("0.0.0.0", 8080))': Bindet den Server an eine bestimmte IP und Port.

'server.listen(5)': Setzt den Server in den Zuhörmodus mit einer Warteschlange von maximal 5 Verbindungen.

'client_thread = threading.Thread(...)': Erstellt einen neuen Thread für jeden Client, um mehrere Clients gleichzeitig zu bedienen.

Dies ist ein einfacher Web-Server, der mit dem socket-Modul in Python erstellt wurde. Es handelt sich um einen sehr grundlegenden Server, der einfach nur eine HTTP-Antwort mit "Hello, World!" zurückgibt. Es gibt viele Möglichkeiten, diesen Code zu erweitern, z. B. durch die Implementierung eines Routers oder die Möglichkeit, statische Dateien zu servieren.

Aufgabe 35: Ein Chatbot mit Zustandsverwaltung in Python entwickeln

# Zustand des Chatbots
chatbot_state = {}

def handle_greeting(user_input):
    if 'Hallo' in user_input:
        return 'Hallo! Wie kann ich dir helfen?', 'greeting'
    return None, None

def handle_farewell(user_input):
    if 'Tschüss' in user_input:
        return 'Tschüss! Bis bald!', 'farewell'
    return None, None

def chatbot_response(user_input):
    handlers = [handle_greeting, handle_farewell]
    for handler in handlers:
        response, state = handler(user_input)
        if response:
            chatbot_state['last_state'] = state
            return response
    return 'Ich habe das nicht verstanden.', 'unknown'

while True:
    user_input = input('Du: ')
    response = chatbot_response(user_input)
    print(f'Chatbot: {response}')

Erklärung:

'chatbot_state = {}': Ein Dictionary zur Speicherung des Zustands des Chatbots.

'handle_greeting(user_input)': Funktion zur Handhabung von Begrüßungen.

'handle_farewell(user_input)': Funktion zur Handhabung von Verabschiedungen.

'chatbot_response(user_input)': Hauptfunktion zur Generierung der Antwort des Chatbots.

'handlers = [handle_greeting, handle_farewell]': Liste von Handler-Funktionen, die durchlaufen werden, um eine Antwort zu generieren.

'chatbot_state["last_state"] = state': Speichert den letzten Zustand des Chatbots.

'while True:': Endlosschleife für die Konversation mit dem Chatbot.

Dieser Chatbot ist ziemlich einfach und benutzt ein Dictionary namens 'chatbot_state' zur Zustandsverwaltung. Du kannst es natürlich viel komplexer gestalten, indem du NLP oder sogar Machine Learning hinzufügst.

Aufgabe 36: Ein simples Blockchain-System in Python

import hashlib
import json
from time import time

class Block:
    def __init__(self, index, timestamp, transactions, previous_hash):
        self.index = index
        self.timestamp = timestamp
        self.transactions = transactions
        self.previous_hash = previous_hash
        self.hash = self.calculate_hash()

    def calculate_hash(self):
        block_string = json.dumps(self.__dict__, sort_keys=True)
        return hashlib.sha256(block_string.encode()).hexdigest()

class Blockchain:
    def __init__(self):
        self.chain = [self.create_genesis_block()]
        self.pending_transactions = []

    def create_genesis_block(self):
        return Block(0, time(), [], "0")

    def get_latest_block(self):
        return self.chain[-1]

    def add_transaction(self, transaction):
        self.pending_transactions.append(transaction)

    def mine_block(self):
        new_block = Block(len(self.chain), time(), self.pending_transactions, self.get_latest_block().hash)
        self.chain.append(new_block)
        self.pending_transactions = []
		
if __name__ == "__main__":
    my_blockchain = Blockchain()
    print(f"Genesis block: {my_blockchain.get_latest_block().hash}")

    my_blockchain.add_transaction("Sascha sends 1 BTC to Alice")
    my_blockchain.add_transaction("Alice sends 0.5 BTC to Bob")

    my_blockchain.mine_block()
    print(f"New block has been added: {my_blockchain.get_latest_block().hash}")

    my_blockchain.add_transaction("Bob sends 0.2 BTC to Charlie")
    my_blockchain.mine_block()
    print(f"Another new block has been added: {my_blockchain.get_latest_block().hash}")

Erklärung:

'import hashlib, json, time': Importieren der notwendigen Bibliotheken.

'class Block': Klasse für einen Block in der Blockchain.

'calculate_hash()': Methode zur Berechnung des Hash eines Blocks.

'class Blockchain': Klasse für die Blockchain selbst.

'create_genesis_block()': Erstellung des Genesis-Blocks, der ersten Block in der Blockchain.

'get_latest_block()': Rückgabe des neuesten Blocks in der Kette.

'add_transaction(transaction)': Hinzufügen einer Transaktion zur Liste der ausstehenden Transaktionen.

'mine_block()': Erstellen und Hinzufügen eines neuen Blocks zur Blockchain.

Dies ist eine einfache Implementierung einer Blockchain in Python. Für den Hash verwenden wir den SHA-256-Algorithmus, und die Blockchain selbst wird in einer Liste gespeichert. Du kannst natürlich noch viel mehr hinzufügen, z.B. eine Überprüfung der Integrität oder eine Benutzeroberfläche.

Aufgabe 37: Web Scraping einer Nachrichtenseite mit Python

from bs4 import BeautifulSoup
import requests
import json

def scrape_news(url):
    page = requests.get(url)
    soup = BeautifulSoup(page.content, 'html.parser')
    
    # Extrahiere die Informationen
    title = soup.find('h1').get_text()
    author = soup.find('span', {'class': 'author'}).get_text()
    date = soup.find('span', {'class': 'date'}).get_text()
    text = soup.find('div', {'class': 'article-body'}).get_text()
    
    # Speichere die Daten als JSON
    data = {
        'Title': title,
        'Author': author,
        'Date': date,
        'Text': text
    }
    
    with open('news.json', 'w') as f:
        json.dump(data, f, indent=4)

# Beispielaufruf
scrape_news('https://example-news-site.com/article/1')

Erklärung:

'from bs4 import BeautifulSoup, import requests, import json': Importieren der erforderlichen Bibliotheken.

'scrape_news(url)': Funktion zum Durchführen des Web Scrapings.

'page = requests.get(url)': Abrufen der Webseite.

'soup = BeautifulSoup(page.content, 'html.parser')': Erstellen eines BeautifulSoup-Objekts zur Analyse der HTML-Struktur.

'title, author, date, text': Extrahieren der verschiedenen Informationen aus dem HTML.

'with open(...)': Speichern der extrahierten Daten im JSON-Format.

Bitte beachte, dass du die Nutzungsbedingungen der Website und die 'robots.txt' respektieren solltest. Diese Aufgabe sollte dir eine gute Einführung in das Web Scraping mit Python bieten.

Aufgabe 38: Implementierung eines Recommender-Systems

from surprise import Dataset, Reader
from surprise import KNNBasic
from surprise.model_selection import train_test_split

# Synthetische Daten
ratings = {
    'User': [1, 1, 2, 2, 3, 3],
    'Item': ['A', 'B', 'A', 'C', 'B', 'C'],
    'Rating': [5, 4, 4, 5, 3, 2]
}

reader = Reader(rating_scale=(1, 5))

# Laden der Daten
data = Dataset.load_from_df(pd.DataFrame(ratings), reader)
trainset, testset = train_test_split(data, test_size=0.2)

# Verwenden von KNN (k-Nearest Neighbors)
model = KNNBasic()
model.fit(trainset)
predictions = model.test(testset)

# Bewertung des Modells und Generierung von Empfehlungen
# ... (hier würde dein Code zur Bewertung und Generierung von Empfehlungen stehen)

Erklärung:

'from surprise import Dataset, Reader, KNNBasic': Importieren der erforderlichen Bibliotheken.

'ratings': Synthetische Daten mit Benutzern, Items und Bewertungen.

'reader = Reader(rating_scale=(1, 5))': Reader-Objekt mit einer Bewertungsskala von 1 bis 5.

'data = Dataset.load_from_df(...)': Laden der Daten in das Dataset.

'trainset, testset = train_test_split(data, test_size=0.2)': Aufteilen der Daten in Trainings- und Testdaten.

'model = KNNBasic()': Verwendung des k-Nearest Neighbors-Algorithmus für Collaborative Filtering.

'model.fit(trainset)': Trainieren des Modells.

'predictions = model.test(testset)': Generieren von Vorhersagen basierend auf dem Testset.

Für die Bonusaufgabe könntest du eine Funktion implementieren, die neue Benutzer und Items hinzufügt und die Bewertungen in einer Datenbank speichert. Vergiss nicht, dein Modell regelmäßig zu aktualisieren, um die Genauigkeit der Empfehlungen zu verbessern.

Aufgabe 39: Implementierung einer Chat-Anwendung mit WebSockets

import asyncio
import websockets

async def chat_handler(websocket, path):
    while True:
        msg = await websocket.recv()
        print(f"Received: {msg}")
        await websocket.send(f"Echo: {msg}")

start_server = websockets.serve(chat_handler, "localhost", 12345)
asyncio.get_event_loop().run_until_complete(start_server)
asyncio.get_event_loop().run_forever()
    

<script>
const ws = new WebSocket('ws://localhost:12345/');

ws.onmessage = function(event) {
    console.log(`Received: ${event.data}`);
};

function sendMessage() {
    const msg = document.getElementById('message').value;
    ws.send(msg);
}
</script>

<input type="text" id="message">
<button onclick="sendMessage()">Send</button>
    

Erklärung:

Python Code (Server): Ein einfacher WebSocket-Server, der Nachrichten empfängt und ein Echo zurücksendet.

HTML/JavaScript Code (Client): Ein einfacher WebSocket-Client, der Nachrichten sendet und empfängt.

Für die Bonusaufgabe könntest du eine Benutzerauthentifizierung hinzufügen und Chat-Räume implementieren, in denen Benutzer über bestimmte Themen sprechen können.

Aufgabe 40: Erstellung eines Mini-Compilers in Python

# Lexer
def tokenize(expression):
    tokens = []
    # Tokenizing logic here
    return tokens

# Parser
def parse(tokens):
    ast = {}
    # Parsing logic here
    return ast

# Evaluator
def evaluate(ast):
    result = 0
    # Evaluation logic here
    return result

expression = "1 + 2 * (3 - 4)"
tokens = tokenize(expression)
ast = parse(tokens)
result = evaluate(ast)
print("Result:", result)
    

Erklärung:

Lexer: Zerlegt den Eingabestring in Tokens.

Parser: Erzeugt einen AST basierend auf den Tokens.

Evaluator: Wertet den AST aus und gibt das Ergebnis zurück.

Für die Bonusaufgaben könntest du auch Unterstützung für Schleifen und bedingte Anweisungen implementieren. Fehlerbehandlungen für Syntaxfehler wären ebenfalls ein nettes Extra.