# hallo.py (Mein erstes Python-Programm)
print("Hallo Welt!")# k04halloWelt.py
''' Das ist mein zweites Programm '''
print("Hallo Welt!") # Es wird Hallo Welt! ausgegeben
print("Heute ist ein schöner Tag") """ In der neuen Zeile wird Heute ist
ein schöner Tag ausgeben """# k05boolean.py
x = True
y = False
print(type(x)) # Ausgabe: <class 'bool'>
print(x) # Ausgabe: True
print(y) # Ausgabe: False# k05boolean2.py
a = 10
b = 5
print(a > b) # Ausgabe: True (10 ist größer als 5)
print(a == b) # Ausgabe: False (10 ist nicht gleich 5)
print(a < b) # Ausgabe: False (10 ist nicht kleiner als 5)# k05boolean3.py
name = "admin"
passwort = "j4T*yf"
print(name == "admin") # Ausgabe: True
print(passwort == "j4T*yf") # Ausgabe: True
print(name == "niko") # Ausgabe: False
print(passwort == "123456") # Ausgabe: False# k05boolean4.py
print(True + True) # Ausgabe: 2 (weil True = 1)
print(False + True) # Ausgabe: 1 (weil False = 0, True = 1)
print(False * 10) # Ausgabe: 0 (weil 0 * 10 = 0)# k05boolean5.py
print(5 == 5) # True, weil 5 gleich 5 ist
print(5 == 6) # False, weil 5 nicht gleich 6 ist
print("" == 0) # False, weil ein leerer String ist nicht 0
print("" == '') # True, weil zwei leere Strings gleich sind
print(0 == 0.0) # True, weil 0 und 0.0 als gleich betrachtet werden
print(4/2 == 2.0) # True, weil 4/2 das Float 2.0 ergibt
print(2*2 == 4) # True, weil 2 mal 2 genau 4 ergibt
print(0.1+0.2 == 0.3) # False! Wegen Rundungsfehler in Gleitkommazahlen
print(True == 1) # True, weil True intern als 1 gespeichert ist
print(False == 0) # True, weil False intern als 0 gespeichert ist
print(True == "True") # False, "True" ist ein String, True ist ein Boolean
print(False == "") # False, leerer String ist nicht derselbe wie False
print(None == False) # False, None ist ein eigener spezieller Wert# k05casting.py# k05casting2.py
eingabe = "30" # Eine Zahl als Text (String)
zahl = int(eingabe) # Umwandlung des Strings in eine ganze Zahl (Integer)
print(zahl + 10) # Ausgabe: 40# k05casting3.py
eingabe = "3.14" # Eine Dezimalzahl als Text (String)
zahl = float(eingabe) # Umwandlung des Strings in eine Dezimalzahl (Float)
print(zahl * 2) # Ausgabe: 6.28# k05casting5.py
zahl = 10 # Eine ganze Zahl (Integer)
text = "20" # Ein Text (String)
# print(zahl + text) # ❌ Fehler: int und str können nicht addiert werden
print(str(zahl) + text) # Ausgabe: "1020" (String-Konkatenation)
print(zahl + int(text)) # Ausgabe: 30 (numerische Addition)# k05escape2.py
# Lösung mit Escape-Zeichen:
print("Ich sagte: \"Hallo!\"") # Ausgabe: Ich sagte: "Hallo!"# k05escape3.py
# Lösung mit unterschiedlichen Anführungszeichen:
print('Ich sagte: "Hallo!"') # Ausgabe: Ich sagte: "Hallo!"# k05escape4.py
text2 = "Zeilenumbruch\nNeue Zeile" # Ein Text mit Zeilenumbruch
print(text2) # Ausgabe: mit Zeilenumbruch# k05fehler.py
alter = 45 # Eine Zahl, die das Alter repräsentiert
plz = "02826" # Eine Postleitzahl als Text (String)
print(alter + plz) # Fehler!
# TypeError: unsupported operand type(s) for +: 'int' and 'str'# k05fehler2.py
text = "Ich sagte: "Hallo!""
# SyntaxError: invalid syntax.# k05fehler3.py
eingabe = "Hallo" # Ein String, Umwandlung in Zahl ist nicht möglich
zahl = int(eingabe) # ❌ Fehler! "Hallo" kann nicht zur Zahl werden# k05float.py
a = 3.14 # Eine positive Dezimalzahl (Float)
b = -0.5 # Eine negative Dezimalzahl (Float)
c = 2.0 # Auch wenn die Nachkommastelle 0 ist, ist das ein Float!
d = 2,0 # Achtung: kein Float, sondern ein Tupel!
print(type(a)) # Ausgabe: <class 'float'>
print(type(b)) # Ausgabe: <class 'float'>
print(type(c)) # Ausgabe: <class 'float'>
print(type(d)) # Ausgabe: <class 'tuple'> Achte auf die Schreibweise!# k05float2.py
a = 5.5
b = 2.0
print(a + b) # Addition: 7.5
print(a - b) # Subtraktion: 3.5
print(a * b) # Multiplikation: 11.0
print(a / b) # Division: 2.75# k05integer.py
x = 10 # Eine positive ganze Zahl
y = -5 # Eine negative ganze Zahl
z = 1000 # Eine große ganze Zahl
print(x) # Ausgabe: 10
print(y) # Ausgabe: -5
print(z) # Ausgabe: 1000# k05integer2.py
counter = 0 # Zähler starten
counter += 1 # Erhöht den Zähler um 1
print(counter) # Ausgabe: 1# k05integer3.py
sehr_große_zahl = 9999999999999999999999999999999999999999999999999999
print(sehr_große_zahl)# k05kommentar.py
wert1 = 10 # Diese Variable speichert eine Zahl
print(wert1) # Ausgabe: 10# k05kommentar2.py
# Das ist ein Kommentar
# Er erklärt, was der Code tut
# Jeder Kommentar beginnt mit einem ## k05kommentar3.py
"""
Das hier ist ein mehrzeiliger Kommentar.
Python ignoriert ihn, weil er keiner Variable zugewiesen wurde.
"""
'''
Das hier ist ein anderer mehrzeiliger Kommentar.
Er funktioniert genauso.
'''# k05kommentar4.py
print("Start")
"""
print("Dieser Teil des Codes wird gerade nicht ausgeführt.")
print("Vielleicht möchtest du ihn später wieder aktivieren.")
"""
# print("Dieser Teil wird ebenfalls nicht ausgeführt.")
print("Ende")# k05mehrzeilig.py
text = """Das ist ein langer Text,
der über mehrere Zeilen
geht.""" # Ein mehrzeiliger Text (String)
print(text) # Ausgabe: Das ist ein langer Text,
# der über mehrere Zeilen
# geht.# k05rundungsfehler.py
print(0.1 + 0.2) # Ausgabe: 0.30000000000000004 statt 0.3# k05string.py
text1 = "Hallo!" # Ein einfacher Text (String)
text2 = 'I <3 Python' # Ein einfacher Text (String)
text3 = "\u2764" # Text mit Unicode-Zeichen für ein Herz (❤)
print(text1) # Ausgabe: Hallo!
print(text2) # Ausgabe: I <3 Python
print(text3) # Ausgabe: ❤# k05string2.py
satz = "Ich mag Python's Flexibilität."
print(satz) # Ausgabe: Ich mag Python's Flexibilität.# k05uebung.py
wert1 = 10 # Integer
wert2 = 20 # Integer
wert3 = "30" # String
print(wert1 + wert2) # Funktioniert direkt
print(wert2 + int(wert3)) # Umwandlung nötig
print(wert1 + wert2 + int(wert3)) # Alle Werte als int# k05uebung2.py
breite = 5 # Integer
hoehe = "10" # String
pi = 3.14 # Float
radius = "7" # String
print(int(breite) * int(hoehe)) # Flächeninhalt Rechteck
print(2 * pi * int(radius)) # Umfang Kreis
print(breite + int(hoehe) + pi + int(radius)) # Summe aller Werte# k05wissenschaftlich.py
entfernung_sonne = 1.496e8 # 149600000 km (Entfernung Erde - Sonne)
atom_radius = 5.3e-11 # 0.000000000053 m (Radius Wasserstoffatom)
print(entfernung_sonne) # Ausgabe: 149600000.0
print(atom_radius) # Ausgabe: 5.3e-11# k06arithmetisch.py
a = 10
b = 3
# Arithmetische Operatoren
print(a + b) # Addition
print(a - b) # Subtraktion
print(a * b) # Multiplikation
print(a / b) # Division
print(a // b) # Ganzzahlige Division
print(a % b) # Modulo
print(a ** b) # Potenzierung# k06logisch.py Logische Operatoren
a = 10
b = 3
print(a > 5 and b < 5) # True: Beide Bedingungen wahr
print(a < 5 or b > 5) # False: Keine Bedingung wahr
print(not(a > 5)) # False: Umkehrung der Bedingung# k06mehrzeilig2.py
text = '''Das ist ein langer Text,
der über mehrere Zeilen
geht.''' # Ein mehrzeiliger Text (String)
print(text) # Ausgabe: Das ist ein langer Text,
# der über mehrere Zeilen
# geht.# k06modulo.py
print(10 % 3) # Ausgabe: 1# k06uebung.py
a = 15
b = 4
c = 2.5 # Float
print(a + b) # Addition
print(a - b) # Subtraktion
print(b * c) # Multiplikation
print(b / c) # Division
print(a // b) # Ganzzahlige Division
print(a % b) # Modulo (Rest)
print(a ** b) # Potenzierung# k06uebung1.py
a = 15
b = 4
print(a + b) # Addition
print(a - b) # Subtraktion
print(a * b) # Multiplikation
print(a / b) # Division
print(a // b) # Ganzzahlige Division
print(a % b) # Modulo (Rest)
print(a ** b) # Potenzierung# k06uebung2.py
zahl = 27
print(zahl % 2 == 0) # Ausgabe: False, da 27 ungerade ist# k06uebung3.py
x = 12
y = 8
print(x == y) # Gleichheit prüfen
print(x != y) # Ungleichheit prüfen
print(x > y) # Größer als
print(x >= y) # Größer oder gleich
print(x < y) # kleiner als
print(x <= y) # kleiner oder gleich# k06uebung4.py
alter = 20
geld = 15
student = True
print(alter > 18 and geld >= 10) # Alter größer 18 und genug Geld
print(alter < 18 or geld > 20) # Jünger als 18 oder mehr als 20€
print(not student) # Ist kein Student
print(alter > 18 and (geld >= 20 or student)) # Alter größer 18 und genug Geld ODER Student# k06uebung5.py
punktestand = 50 # Initialer Punktestand: 50
punktestand += 10
print(punktestand) # Punktestand nach Erhöhung: 60
punktestand -= 5
print(punktestand) # Punktestand nach Abzug: 55
punktestand *= 2
print(punktestand) # Punktestand nach Verdopplung: 110
punktestand /= 10
print(punktestand) # Punktestand nach Division: 11.0
punktestand %= 3
print(punktestand) # Punktestand nach Modulo: 2.0# k06uebung6.py
a = 15
b = 4
c = 2.5
print((a + b) * c) # Summe von a und b, multipliziert mit c
print(a // b) # Ganzzahldivision
print(a % b) # Rest der Division
print(a > b) # Vergleich: a größer als b?
print(b * c >= a) # Vergleich: Produkt von b und c größer oder gleich a?# k06uebung7.py
x = 12
y = 5
z = 3.0
print(x ** 2) # Quadrat von x
print((x + y) / z) # Summe von x und y, geteilt durch z
print((x % y) * z) # Rest der Division von x durch y, multipliziert mit z
print(x % 2 == 0) # True, wenn x gerade ist
print(x * y > 50) # True, wenn x * y größer als 50 ist# k06uebung8.py
a = 15
b = 4
c = 2.5
print((a * b) / c) # Produkt von a und b, geteilt durch c
print(a > b and a > c) # True, wenn a größer als b und c ist
print(a % b == 0) # True, wenn a durch b ohne Rest teilbar ist
print(a > b and c < 5) # True, wenn a > b und c < 5
print(a < 10 or b % 2 == 1) # True, wenn a < 10 oder b ungerade ist# k06vergleich.py
a = 10
b = 3
# Vergleichsoperatoren
print(a == b) # False 10 == 3 stimmt nicht
print(a != b) # True 10 != 3 stimmt
print(a > b) # True 10 > 3 stimmt
print(a < b) # False 10 < 3 stimmt nicht
print(a >= b) # True 10 >= 3 stimmt
print(a <= b) # False 10 <= 3 stimmt nicht# k06zuweisung.py
print("Zuweisungsoperatoren: ")
x = 5 # Zuweisung eines Wertes
print(x) # 5
x += 3 # x = x + 3
print(x) # 5+3= 8
x -= 2 # x = x - 2
print(x) # 8-2= 6
x *= 4 # x = x * 4
print(x) # 6*4= 24
x /= 2 # x = x / 2
print(x) # 24/2= 12
x %= 7 # x = x % 7
print(x) # 12%7= 5# k07fehler.py
zahl = input("Gib eine Zahl ein: ")
print(zahl + 5) # ❌ Fehler: TypeError, weil zahl ein String ist!# k07inputCasting.py
# Eingabe als String speichern
eingabe = input("Gib eine Zahl ein: ")
zahl = int(eingabe) # Umwandlung in eine Ganzzahl (int)
# Berechnung durchführen
print(zahl + 5) # Jetzt funktioniert es!# k07inputCasting2.py
# Eingabe als String speichern
eingabe = input("Gib eine Dezimalzahl ein: ")
zahl = float(eingabe) # Umwandlung in eine Dezimalzahl (float)
print(zahl * 2) # Rechnen mit einer Dezimalzahl# k07inputCasting3.py
zahl = int(input("Gib eine Zahl ein: ")) # Direkte Umwandlung in int
print(zahl + 5)
zahl = float(input("Gib eine Kommazahl ein: ")) # Direkte Umwandlung in float
print(zahl * 2)# k07inputHallo.py
# Name abfragen
name = input("Wie heißt du? ")
# Begrüßung ausgeben
print("Hallo")
print(name)
print("Willkommen in Python.")# k07inputUebung.py
name = input("Wie heißt du? ") # Namen abfragen
alter = input("Wie alt bist du? ") # Alter abfragen
# Begrüßung ausgeben
print("Hallo")
print(name)
print("Du bist")
print(alter)
print("Jahre alt.")# k07inputUebung2.py
alter = input("Wie alt bist du? ") # Alter abfragen
alter = int(alter) # Umwandeln in eine Zahl
differenz = 100 - alter # Jahre bis 100 berechnen
print("Du wirst in", differenz, "Jahren 100 Jahre alt!") # Ausgabe# k08alterNext.py
alter = int(input("Wie alt bist du? "))
# Ausgabe mit f"-String und Berechnung eingegebenes Alter + 1
print(f"Nächstes Jahr wirst du {alter + 1} Jahre alt.")# k08fString.py
variable = "Wert"
print(f"Text {variable}") # Ausgabe: Text Wert# k08fString2.py
name = "Anna"
begrüßung = f"Hallo {name}!" # f"-String in Variable speichern
print(begrüßung) # Ausgabe: Hallo Anna!# k08fString3.py
name = input("Wie heißt du? ") # Nach Namen fragen
alter = input("Wie alt bist du? ") # Nach Alter fragen
# Begrüßung mit f"-String ausgeben
print(f"Hallo {name}! Du bist {alter} Jahre alt.")# k08fStringUebung.py
name= input("Wie heißt du? ") # Nach Namen fragen
alter=input("Wie alt bist du? ") # Nach Alter fragen
stadt=input("Woher kommst du? ") # Nach Stadt fragen
farbe=input("Was ist deine Lieblingsfarbe? ") # Nach Lieblingsfarbe fragen
# Ausgabe mit f"-String
print(f"Hallo {name}! Du bist {alter} Jahre alt, kommst aus {stadt} und deine Lieblingsfarbe ist {farbe}.")# k08fehler.py
# Komma-Verkettung innerhalb von print()
print("Hallo", "Alex,", "du bist", 25, "Jahre alt.")
# ❌ Fehler: Komma-Verkettung außerhalb von print()
# text = "Hallo", "Alex,", "du bist", 25, "Jahre alt."
# ✅ Korrekte Verkettung mit +
text = "Hallo " + "Alex, " + "du bist " + str(25) + " Jahre alt."
print(text) # Ausgabe: Hallo Alex, du bist 25 Jahre alt.# k08komma.py
name = "Alex"
alter = 25
print("Hallo", name, "! Du bist", alter, "Jahre alt.")# k08lueckentext.py
name = input("Wie heißt du? ")
zahl = input("Nenne eine Zahl: ")
verb = input("Nenne ein Verb (z. B. tanzen): ")
tier = input("Nenne ein Tier: ")
farbe= input("Nenne eine Farbe: ")
# Satz erzeugen
print(f"{name} will heute {zahl} Mal mit einem {farbe}farbenen {tier} {verb}.")# k08plus.py
name = input("Wie heißt du? ") # Nach Namen fragen
# Begrüßung ausgeben (mit Verkettung)
print("Hallo " + name + "! Willkommen in Python.")# k08plus2.py
name = input("Wie heißt du? ") # Nach Namen fragen
alter = input("Wie alt bist du? ") # Nach Alter fragen
nextAlter = int(alter) + 1 # Alter in einem Jahr berechnen
# Begrüßung ausgeben (mit Plus-Operator und String-Umwandlung)
print("Hallo " + name + "! Du bist " + alter + " Jahre alt.")
print("In einem Jahr bist du " + str(nextAlter) + " Jahre alt.")# k08uebung.py
name = input("Wie heißt du? ") # Nach Namen fragen
alter = input("Wie alt bist du? ") # Nach Alter fragen
# Begrüßung ausgeben (mit Verkettung)
print("Hallo " + name + "! Du bist " + alter + " Jahre alt.")# k08wann100.py
alter=int(input("Wie alt bist du? "))# Alter abfragen und in int umwandeln
differenz = 100 - alter # Jahre bis 100 berechnen
# Ausgabe
print(f"Du bist {alter} Jahre alt und wirst in {differenz} Jahren 100.")# k09elifBedingung.py
# randint importieren
from random import randint
# Zufällige Zahl zwischen 1 und 10 generieren
zufallszahl = randint(1, 10) # Zufallszahl zwischen 1 und 10 generieren
print("Zufallszahl:", zufallszahl)
# Mit elif die Zahl analysieren
if zufallszahl < 5: # Wenn die Zufallszahl < 5 ist dann:
print("Die Zahl ist kleiner als fünf.")
elif zufallszahl == 5: # Ansonsten wenn die Zufallszahl gleich 5 ist dann:
print("Die Zahl ist gleich fünf.")
elif zufallszahl > 5: # Ansonsten wenn die Zufallszahl > 5 ist dann:
print("Die Zahl ist größer als fünf.")# k09elseBedingung.py
zahl = int(input("Gib eine Zahl ein: ")) # Eingabe Zahl, in int umwandeln
# Zahl analysieren
if zahl > 0: # Wenn die Zahl größer als 0 ist dann:
print("Die Zahl ist positiv.")
elif zahl < 0: # Ansonsten wenn die Zahl kleiner als 0 ist dann:
print("Die Zahl ist negativ.")
else: # Ansonsten:
print("Die Zahl ist 0.")# k09geradeUngerade.py
zahl = int(input("Gib eine Zahl ein: "))
# Gerade oder ungerade prüfen
if zahl % 2 == 0: # Wenn die Zahl durch 2 keinen Rest hat dann:
print("Die Zahl ist gerade.")
else: # Ansonsten:
print("Die Zahl ist ungerade.")# k09if.py
zahl1 = input("Gib eine Zahl ein: ") # Zahl eingeben
intZahl1 = int(zahl1)
# Prüfen, ob die Zahl positiv ist
if intZahl1 > 0: # Wenn die Zahl größer als 0 ist dann:
print("Die Zahl ist positiv.") # Ausgabe: Die Zahl ist positiv# k09if2.py
# Zahl direkt eingeben und in int umwandeln
zahl1 = int(input("Gib eine Zahl ein: "))
if zahl1 > 0: # Wenn die Zahl größer als 0 ist dann:
print("Die Zahl ist positiv.")# k09logischeOperatoren.py
zahl = int(input("Gib eine Zahl ein: ")) # Eingabe Zahl, in int umwandeln
if zahl >= 10 and zahl <= 20: # Wenn die Zahl >= 10 und <= 20 ist dann:
print("Die Zahl liegt zwischen 10 und 20.")
else: # Ansonsten:
print("Die Zahl liegt außerhalb des Bereichs.")# k09notenspiegel.py
punkte = int(input("Wie viele Punkte hast du? ")) # Eingabe Punktzahl
# Note berechnen
if punkte >= 95: # Wenn die Punktzahl >= 95 ist dann:
note = 1
elif punkte >= 80: # Ansonsten wenn die Punktzahl >= 80 ist dann:
note = 2
elif punkte >= 65: # Ansonsten wenn die Punktzahl >= 65 ist dann:
note = 3
elif punkte >= 50: # Ansonsten wenn die Punktzahl >= 50 ist dann:
note = 4
elif punkte >= 20: # Ansonsten wenn die Punktzahl >= 20 ist dann:
note = 5
else: # Ansonsten (also < 20):
note = 6
print("Du hast eine", note, ".") # Ausgabe der Note# k09notenspiegel2.py
# Maximale Punktzahl und die erreichte Punktzahl sollen eingegeben werden.
max_punkte = int(input("Maximale Punktzahl: "))
punkte = int(input("Deine Punktzahl: "))
prozent = (punkte / max_punkte) * 100 # Prozentwert berechnen
if prozent >= 95: # Wenn der Prozentwert >= 95 ist dann:
note = 1
elif prozent >= 80: # Ansonsten wenn der Prozentwert >= 80 ist dann:
note = 2
elif prozent >= 65: # Ansonsten wenn der Prozentwert >= 65 ist dann:
note = 3
elif prozent >= 50: # Ansonsten wenn der Prozentwert >= 50 ist dann:
note = 4
elif prozent >= 20: # Ansonsten wenn der Prozentwert >= 20 ist dann:
note = 5
else: # Ansonsten (also < 20):
note = 6
print("Du hast", prozent, "% erreicht.") # Ausgabe des Prozentwerts
print("Du hast eine", note, ".") # Ausgabe der Note# k09randint.py
from random import randint # Nur randint importieren
zufallszahl = randint(1, 10) # Zufallszahl zwischen 1 und 10 generieren
print("Zufallszahl:", zufallszahl) # Ausgabe der Zufallszahl# k09uebung.py
zahl = int(input("Gib eine Zahl ein: ")) # Eingabe Zahl, in int umwandeln
# Prüfen, ob die Zahl positiv, negativ oder 0 ist
if zahl > 0: # Wenn die Zahl größer als 0 ist dann:
print("Die Zahl ist positiv.") # Ausgabe: Die Zahl ist positiv.
if zahl < 0: # Wenn die Zahl kleiner als 0 ist dann:
print("Die Zahl ist negativ.") # Ausgabe: Die Zahl ist negativ.
if zahl == 0: # Wenn die Zahl gleich 0 ist dann:
print("Die Zahl ist 0.") # Ausgabe: Die Zahl ist 0.# k09uebung10.py
name = input("Name: ") # Eingabe Name
if name == "admin": # Wenn der Name "admin" ist dann:
passwort = input("Passwort: ") # Eingabe Passwort
if passwort == "geheim": # Wenn das Passwort "geheim" ist dann:
print("Willkommen!") # Ausgabe: Willkommen!
else: # Ansonsten:
print("Falsches Passwort!") # Ausgabe: Falsches Passwort!
else:
print("Zugriff verweigert.") # Ausgabe: Zugriff verweigert.# k09uebung11.py
# Temperatur eingeben
temperatur = int(input("Gib die Temperatur ein: "))
# Temperatur analysieren
if temperatur < 21:
print("Es ist kalt!")
elif temperatur <= 25:
print("Es ist angenehm.")
else:
print("Es ist heiß!")# k09uebung12.py
geschwindigkeit = int(input("Gib die Geschwindigkeit ein: "))
# Geschwindigkeit analysieren
if geschwindigkeit < 30: # Wenn die Geschwindigkeit < 30 km/h ist dann:
print("Langsam.")
elif geschwindigkeit <= 80: # Ansonsten wenn <= 80 km/h ist dann:
print("Normale Geschwindigkeit.")
else: # Ansonsten (also > 80 km/h):
print("Schnell!")# k09uebung2.py
from random import randint # randint importieren
zufallszahl = randint(1, 10) # Zufallszahl zwischen 1 und 10 generieren
print("Zufallszahl:", zufallszahl)
# Mit fünf vergleichen und entsprechende Nachrichten ausgeben
if zufallszahl > 5: # Wenn die Zufallszahl größer als 5 ist dann:
print("Die Zahl ist größer als fünf.") # Ausgabe: ...größer als fünf
if zufallszahl < 5: # Wenn die Zufallszahl kleiner als 5 ist dann:
print("Die Zahl ist kleiner als fünf.") # Ausgabe: ...kleiner als fünf
if zufallszahl == 5: # Wenn die Zufallszahl genau 5 ist dann:
print("Die Zahl ist gleich fünf.") # Ausgabe: ...gleich fünf# k09uebung3.py
from random import randint # randint importieren
zahl1 = randint(1, 10) # Erste Zufallszahl
zahl2 = randint(1, 10) # Zweite Zufallszahl
summe = zahl1 + zahl2 # Summe der beiden Zufallszahlen
# Zufallszahlen anzeigen
print("Erste Zufallszahl:", zahl1) # Ausgabe der ersten Zufallszahl
print("Zweite Zufallszahl:", zahl2) # Ausgabe der zweiten Zufallszahl
# Nach der Summe fragen und die Eingabe in int umwandeln
eingabe = int(input("Wie lautet die Summe der beiden Zahlen? "))
# Überprüfen, ob die Eingabe korrekt ist
if eingabe == summe: # Wenn die Eingabe gleich der Summe ist dann:
print("Richtig! Die Summe ist", summe) # Ausgabe: Richtig! ...
if eingabe != summe: # Wenn die Eingabe ungleich der Summe ist dann:
print("Falsch! Die Summe ist", summe) # Ausgabe: Falsch! ...# k09uebung4.py
# Eingabe Zahl, in int umwandeln
zahl = int(input("Gib eine Zahl von 1 bis 3 ein: "))
# Entscheidung ohne else
if zahl == 1: # Wenn die Zahl 1 ist dann:
print("Du hast die Eins gewählt. Eine sehr gute Wahl!")
elif zahl == 2: # Ansonsten wenn die Zahl 2 ist dann:
print("Die Zwei ist eine ausgewogene Entscheidung.")
elif zahl == 3: # Ansonsten wenn die Zahl 3 ist dann:
print("Die Drei steht für Kreativität!")# k09uebung5.py (Nur if)
zahl = int(input("Gib eine Zahl ein: "))
if zahl >= 0: # Wenn die Zahl >= 0 ist dann:
print("Die Zahl ist positiv oder 0.")
if zahl % 2 == 0: # Wenn die Zahl gerade ist dann:
print("Die Zahl ist gerade.")
if zahl % 2 != 0: # Wenn die Zahl ungerade ist dann:
print("Die Zahl ist ungerade.")# k09uebung6.py (if mit elif)
zahl = int(input("Gib eine Zahl ein: "))
if zahl >= 0: # Wenn die Zahl >= 0 ist dann:
print("Die Zahl ist positiv oder 0.")
elif zahl % 2 == 0: # Ansonsten wenn die Zahl gerade ist dann:
print("Die Zahl ist gerade.")
elif zahl % 2 != 0: # Ansonsten wenn die Zahl ungerade ist dann:
print("Die Zahl ist ungerade.")# k09uebung7.py
alter = int(input("Gib dein Alter ein: "))
# Alter analysieren
if alter <= 12: # Wenn das Alter kleiner oder gleich 12 ist dann:
print("Du bist ein Kind.")
elif alter <= 19: # Ansonsten wenn das Alter < oder gleich 19 ist dann:
print("Du bist ein Teenager.")
else: # Ansonsten:
print("Du bist ein Erwachsener.")# k09uebung8.py
zahl = int(input("Gib eine Zahl ein: ")) # Eingabe Zahl, in int umwandeln
# Bereich überprüfen
if zahl >= 5 and zahl <= 15: # Wenn die Zahl >= 5 und <= 15 ist dann:
print("Die Zahl liegt im Bereich zwischen 5 und 15.")
else: # Ansonsten:
print("Die Zahl liegt nicht im Bereich zwischen 5 und 15.")# k09uebung9.py
alter = int(input("Wie alt bist du? ")) # Eingabe Alter, in int umwandeln
if alter > 0: # Wenn das Alter > 0 ist dann:
if alter < 18: # Wenn das Alter < 18 ist dann:
print("Du bist noch nicht volljährig.")
else: # Ansonsten (also größer als 0 und >= 18):
if alter < 65: # Wenn das Alter < 65 ist dann:
print("Du bist volljährig.")
else: # Ansonsten (also größer oder gleich 65):
print("Du hast das Rentenalter erreicht.")# k09verschachtelt.py
alter = int(input("Wie alt bist du? "))
if alter > 0: # Wenn das Alter > 0 ist dann:
if alter < 18: # Wenn das Alter < 18 ist dann:
print("Du bist noch nicht volljährig.")
else: # Ansonsten (also größer als 0 und >= 18):
print("Du bist volljährig.")# k09zahlRaten.py
from random import randint
zufall = randint(1, 10) # Zufallszahl zwischen 1 und 10 generieren
tipp = int(input("Rate eine Zahl zwischen 1 und 10: ")) # Raten lassen
if tipp == zufall: # Wenn die Eingabe gleich der Zufallszahl ist dann:
print("Richtig! Die Zahl war", zufall)
else: # Ansonsten (also die Eingabe ungleich der Zufallszahl):
print("Falsch! Die richtige Zahl war", zufall)# k10addition.py
from random import randint
# Variablen für richtige und falsche Antworten
richtig = 0
falsch = 0
versuche = 0
# Schleife für 10 Aufgaben
while versuche < 10:
# Zwei Zufallszahlen generieren
zahl1 = randint(1, 10)
zahl2 = randint(1, 10)
summe = zahl1 + zahl2
versuche += 1 # Versuche zählen
# Nach der Summe fragen
print("Wieviel ist", zahl1, "+", zahl2, "?")
antwort = int(input())
# Antwort überprüfen
if antwort == summe:
print("Richtig!")
richtig += 1
else:
print("Falsch! Die richtige Antwort ist", summe)
falsch += 1
# Ergebnisse ausgeben
print("Du hast", richtig, "von 10 Aufgaben richtig beantwortet.")
print("Du hast", falsch, "von 10 Aufgaben falsch beantwortet.")# k10break.py
# Zahlen von 1 bis 5 durchgehen
for zahl in range(1, 6):
if zahl == 3: # Wenn die Zahl 3 ist, beende die Schleife
break
print("Zahl ist:", zahl)# k10breakContinuePass.py
for zahl in range(1, 11):
if zahl == 8:
break
if zahl == 5:
continue
print("Zahl ist:", zahl)# k10continue.py
# Zahlen von 1 bis 5 durchgehen
for zahl in range(1, 6):
if zahl == 3: # Wenn die Zahl 3 ist, überspringe diesen Durchlauf
continue
print("Zahl ist:", zahl)# k10division.py
from random import randint
# Variablen für richtige und falsche Antworten
richtig = 0
falsch = 0
versuche = 0
# Schleife für 10 Aufgaben
while versuche < 10:
zahl2 = randint(1, 10) # Zweite Zufallszahl generieren
zahl1 = zahl2 * randint(1, 10) # Erste Zahl, ein Vielfaches von zahl2
ergebnis = zahl1 // zahl2 # Ganzzahlige Division
# Nach dem Ergebnis der Division fragen
print("Wieviel ist", zahl1, "/", zahl2, "?")
antwort = int(input())
if antwort == ergebnis: # Antwort überprüfen
print("Richtig!")
richtig += 1
else:
print("Falsch! Die richtige Antwort ist", ergebnis)
falsch += 1
versuche += 1 # Versuche zählen
print("Du hast", richtig, "von 10 Aufgaben richtig beantwortet.")
print("Du hast", falsch, "von 10 Aufgaben falsch beantwortet.")# k10forSchleife.py
# Zahlen von 1 bis 5 zählen
for zahl in range(1, 6):
print("Die Zahl ist:", zahl)# k10forSchleife2.py
# Liste mit Namen
namen = ["Anna", "Ben", "Clara"]
# Jeden Namen in der Liste ausgeben
for name in namen:
print("Hallo", name)# k10forSchleife3.py
# Wort
wort = "Python"
# Jeden Buchstaben ausgeben
for buchstabe in wort:
print("Buchstabe:", buchstabe)# k10forUebung.py
# Zahl eingeben
max_zahl = int(input("Bis zu welcher Zahl soll gezählt werden? "))
# Iteration über den Bereich von 1 bis zur angegebenen Zahl
for zahl in range(1, max_zahl + 1):
print(zahl)# k10modulo.py
from random import randint
# Variablen für richtige und falsche Antworten
richtig = 0
falsch = 0
versuche = 0
# Schleife für 10 Versuche
while versuche < 10:
# Zufallszahl generieren
zahl = randint(1, 10)
# Frage stellen
antwort = input(f"Ist {zahl} eine gerade Zahl? (ja/nein) ")
# Überprüfen, ob die Zahl gerade ist
if zahl % 2 == 0:
richtige_antwort = "ja"
else:
richtige_antwort = "nein"
# Antwort überprüfen
if antwort == richtige_antwort:
print("Richtig!")
richtig += 1
else:
print(f"Falsch! Die richtige Antwort ist {richtige_antwort}.")
falsch += 1
versuche += 1 # Versuche zählen
# Ergebnisse ausgeben
print("Du hast", richtig, "von 10 Aufgaben richtig beantwortet.")
print("Du hast", falsch, "von 10 Aufgaben falsch beantwortet.")# k10multiplikation.py
from random import randint
# Variablen für richtige und falsche Antworten
richtig = 0
falsch = 0
versuche = 0
# Schleife für 10 Aufgaben
while versuche < 10:
# Zwei Zufallszahlen generieren
zahl1 = randint(1, 10)
zahl2 = randint(1, 10)
produkt = zahl1 * zahl2
versuche += 1 # Versuche zählen
# Nach dem Produkt fragen
print("Wieviel ist", zahl1, "*", zahl2, "?")
antwort = int(input())
# Antwort überprüfen
if antwort == produkt:
print("Richtig!")
richtig += 1
else:
print("Falsch! Die richtige Antwort ist", produkt)
falsch += 1
# Ergebnisse ausgeben
print("Du hast", richtig, "von 10 Aufgaben richtig beantwortet.")
print("Du hast", falsch, "von 10 Aufgaben falsch beantwortet.")# k10pass.py
# Zahlen von 1 bis 5 durchgehen
for zahl in range(1, 6):
if zahl == 3: # Für die Zahl 3 ist noch keine Aktion definiert
pass
else:
print("Zahl ist:", zahl)# k10addition.py
from random import randint
# Variablen für richtige und falsche Antworten
richtig = 0
falsch = 0
versuche = 0
# Schleife für 10 Aufgaben
while versuche < 10:
# Zwei Zufallszahlen generieren
zahl2 = randint(1, 10)
zahl1 = randint(1, 10) + zahl2 # Damit keine negativen Ergebnisse
differenz = zahl1 - zahl2
versuche += 1 # Versuche zählen
# Nach der Differenz fragen
print("Wieviel ist", zahl1, "-", zahl2, "?")
antwort = int(input())
# Antwort überprüfen
if antwort == differenz:
print("Richtig!")
richtig += 1
else:
print("Falsch! Die richtige Antwort ist", differenz)
falsch += 1
# Ergebnisse ausgeben
print("Du hast", richtig, "von 10 Aufgaben richtig beantwortet.")
print("Du hast", falsch, "von 10 Aufgaben falsch beantwortet.")# k10whileSchleife.py
# Zähler starten
zaehler = 1
# Schleife, die läuft, solange der Zähler kleiner als 5 ist
while zaehler < 5:
print("Zähler ist:", zaehler)
zaehler += 1 # Zähler um 1 erhöhen# k10whileUebung.py
# Zahl abfragen
max_zahl = int(input("Bis zu welcher Zahl soll gezählt werden? "))
zaehler = 1 # Zähler auf 1 setzen
# Schleife, die läuft, solange der Zähler kleiner oder gleich der Zahl ist
while zaehler <= max_zahl:
print(zaehler)
zaehler += 1 # Zähler um 1 erhöhen# k10whileUebung10.py
from random import randint
while True: # Äußere Schleife für mehrere Spielrunden
print("Welche Rechenart möchtest du üben?")
modus = int(input("1: Addition, 2: Subtraktion, 3: Multiplikation, 4: Division"))
richtig = 0 # Zähler für richtige Antworten
falsch = 0 # Zähler für falsche Antworten
for _ in range(10): # 10 Aufgaben pro Runde
zahl1 = randint(1, 10)
zahl2 = randint(1, 10)
if modus == 1: # Wenn 1 dann Addition
ergebnis = zahl1 + zahl2
operator = "+"
elif modus == 2: # Ansonsten wenn 2 dann Subtraktion
if zahl1 < zahl2: # Wenn zahl1 < zahl2 dann:
zahl1, zahl2 = zahl2, zahl1 # Zahlen tauschen
ergebnis = zahl1 - zahl2
operator = "-"
elif modus == 3: # Ansonsten wenn 3 dann Multiplikation
ergebnis = zahl1 * zahl2
operator = "*"
elif modus == 4: # Division (Ergebnis soll eine ganze Zahl sein)
zahl2 = randint(1, 10) # Zufälliger Divisor
zahl1 = zahl2 * randint(1, 10) # Vielfaches von zahl2
ergebnis = zahl1 // zahl2
operator = "/"
else:
print("Ungültige Auswahl! Wähle 1, 2, 3 oder 4.")
break
print("Wieviel ist", zahl1, operator, zahl2, "?")
antwort = int(input()) # Ergebnis abfragen
if antwort == ergebnis: # Wenn antwort richtig dann:
print("Richtig!")
richtig += 1
else: # Ansonsten:
print("Falsch! Die richtige Antwort ist", ergebnis)
falsch += 1
print("Du hast", richtig, "von 10 Aufgaben richtig beantwortet.")
weitermachen = input("Möchtest du noch einmal spielen? (ja/nein) ")
if weitermachen.lower() != "ja":
print("Spiel beendet.")
break# k10whileUebung2.py
# Unendliche Schleife
while True:
# Fragen nach Programmende
eingabe = input("Möchtest du das Programm beenden? (ja/nein) ")
if eingabe == "ja": # Schleife beenden, falls Eingabe "ja"
print("Programm beendet.")
break
else:
print("Schleife läuft weiter.")# k10whileUebung9.py
from random import randint
while True: # Äußere Schleife für mehrere Spielrunden
richtig = 0 # Zähler für richtige Antworten
falsch = 0 # Zähler für falsche Antworten
for _ in range(10): # 10 Aufgaben pro Runde
zahl1 = randint(1, 10) # Erste Zufallszahl generieren
zahl2 = randint(1, 10) # Zweite Zufallszahl generieren
summe = zahl1 + zahl2 # Summe berechnen
print("Wieviel ist", zahl1, "+", zahl2, "?")
antwort = int(input()) # Eingabe der Antwort
if antwort == summe: # Wenn Antwort korrekt
print("Richtig!")
richtig += 1 # Zähler für richtige Antworten erhöhen
else: # Wenn Antwort falsch
print("Falsch! Die richtige Antwort ist", summe)
falsch += 1 # Zähler für falsche Antworten erhöhen
# Rundenergebnis ausgeben
print("Du hast", richtig, "von 10 Aufgaben richtig beantwortet.")
weitermachen = input("Möchtest du noch einmal spielen? (ja/nein) ")
if weitermachen.lower() != "ja": # Schleife beenden, wenn nicht
print("Spiel beendet.")
break# k10whileUnendlich.py
# Initialisierung des Zählers
zaehler = 1
# Unendliche Schleife
while True:
print("Zähler ist:", zaehler)
if zaehler == 10: # Schleife beenden, wenn Zähler 10 erreicht
break
zaehler += 1 # Zähler um 1 erhöhen# k10zahlenraten.py
from random import randint
# Zufallszahl generieren
geheime_zahl = randint(1, 100)
# Spiel starten
while True:
# Nach einer Zahl fragen
tipp = int(input("Rate die Zahl zwischen 1 und 100: "))
# Unterschied berechnen
abstand = abs(geheime_zahl - tipp)
# Rückmeldungen geben
if tipp == geheime_zahl:
print(f"Richtig! Die Zahl ist {geheime_zahl}.")
break # Schleife beenden
elif abstand < 5:
print("Du bist sehr nah dran!")
elif abstand < 10:
print("Du bist nah dran!")
else:
print("Leider nicht richtig. Versuche es erneut.")# k11adventure.py
# Spielzustand initialisieren
room = "Raum 1" # Das Spiel startet in Raum 1
has_key = False # Anfangs besitzt man keinen Schlüssel
playing = True # Solange diese Variable True ist, läuft das Spiel
# Haupt-Spielschleife
while playing:
# Aktuelle Raumbeschreibung und Abfrage der nächsten Aktion
print(f"\nDu befindest dich in {room}. Was möchtest du tun?")
# Mögliche Optionen werden dynamisch zusammengestellt
options = "Optionen: umschauen, "
if room == "Raum 1": # Nur in Raum 1 gibt es diese Option
options += "gehe zu Raum 2, Tür öffnen, "
if room == "Raum 2": # Nur in Raum 2 gibt es diese Optionen
options += "gehe zu Raum 1, "
if not has_key: # Nur wenn der Schlüssel noch nicht genommen wurde
options += "Schlüssel nehmen, "
options += "ende" # Option zum Beenden des Spiels
print(options)
# Eingabe bereinigt und in Kleinbuchstaben umgewandelt
aktion = input(">>> ").strip().lower()
if aktion == "umschauen": # Wenn man sich umsieht
if room == "Raum 1":
print("Du bist in einem wunderschönen Zimmer.")
elif room == "Raum 2":
print("Du bist im Schlafzimmer.")
elif aktion == "gehe zu raum 1": # Ansonsten wenn man zum Raum 1 geht
room = "Raum 1"
print("Du gehst in Raum 1.")
elif aktion == "gehe zu raum 2": # Ansonsten wenn man zum Raum 2 geht
room = "Raum 2"
print("Du gehst in Raum 2.")
# Ansonsten wenn man versucht, den Schlüssel zu nehmen
elif aktion == "schlüssel nehmen":
# Nur in Raum 2 und wenn man den Schlüssel noch nicht hat
if room == "Raum 2" and not has_key:
has_key = True # Schlüssel wird eingesammelt
print("Du hast den Schlüssel gefunden und eingesteckt.")
else: # Ansonsten
print("Hier gibt es keinen Schlüssel.")
# Ansonsten wenn man versucht, die Tür zu öffnen
elif aktion == "tür öffnen":
if room == "Raum 1": # Wenn man sich in Raum 1 befindet
if has_key: # Wenn man den Schlüssel hat
print("Du öffnest die Haustür. Spiel gewonnen!")
playing = False # Schleife wird beendet
else: # Ansonsten:
print("Ohne Schlüssel kannst du die Tür nicht öffnen.")
else:
print("Hier gibt es keine Tür zum Öffnen.")
elif aktion == "ende": # Ansonsten wenn man das Spiel beenden möchte
print("Spiel beendet.")
playing = False # Spielschleife wird verlassen
else: # Ansonsten: Falsche Eingabe
print("Ungültige Eingabe. Bitte versuche es erneut.")# k11quiz.py Quiz-Spiel mit 3 Fragen
score = 0 # Der Punktestand ist zu Beginn 0 Punkte.
# Frage 1: Eingabe wird bereinigt (Leerzeichen entfernt)
antwort = input("Wie viele Beine hat ein Hund? ").strip()
if antwort == "4":
print("Richtig!") # Die Antwort ist korrekt
score += 1 # Ein Punkt wird zum Punktestand addiert
else: # Ansonsten: Hinweis auf die richtige Antwort wenn Antwort falsch
print("Falsch. Die richtige Antwort ist 4.")
# Frage 2: Eingabe wird bereinigt und in Kleinbuchstaben umgewandelt
antwort =input("Was ist die Hauptstadt von Deutschland? ").strip().lower()
if antwort == "berlin":
print("Richtig!") # Richtige Antwort
score += 1
else:
print("Falsch. Die richtige Antwort ist Berlin.")
# Frage 3: Eingabe wird bereinigt
antwort = input("Wieviel ist 3 + 5? ").strip()
if antwort == "8":
print("Richtig!") # Richtige Antwort erkannt
score += 1
else:
print("Falsch. Die richtige Antwort ist 8.")
# Ergebnisanzeige
print(f"Du hast {score} von 3 Punkten erreicht.") # gesammelte Punkte# k12aendern.py
person = ["Max", "männlich", 28] # Ursprüngliche Liste
person[0] = "Alex" # Das erste Element (Index 0) wird geändert
print(person) # Gibt ['Alex', 'männlich', 28] aus# k12aendern2.py
farben = ["Rot", "Grün", "Blau"] # Liste erstellen
farben[0] = "Gelb" # Erstes Elemente ändern
farben[2] = "Lila" # Letztes Element ändern
print(farben) # Gibt ['Gelb', 'Grün', 'Lila'] aus# k12artikel.py
tiere = ["Kuh", "Gans", "Katze", "Maus", "Henne"]
for tier in tiere:
print("Die", tier)# k12doppelte.py
zahlen = [1, 2, 2, 3, 4, 4, 4, 5] # Liste mit Duplikaten
einzigartig = set(zahlen) # Entfernt Duplikate durch Umwandlung in ein Set
print("Ohne Duplikate:", einzigartig) # Ausgabe ohne Duplikate# k12doppelte2.py
woerter = ["Apfel", "Banane", "Apfel", "Orange", "Banane"]
einzigartig = set(woerter) # Entfernt Duplikate
neue_liste = list(einzigartig) # Wandelt das Set zurück in eine Liste um
print("Ohne Duplikate:", neue_liste) # Ausgabe der neuen Liste# k12einkauf.py
einkauf = ["Milch", "Brot", "Eier"] # Einkaufsliste
einkauf.append("Käse") # Element hinzufügen
einkauf.insert(1, "Butter") # Element vor "Brot" einfügen
einkauf.remove("Milch") # Element entfernen
einkauf.reverse() # Reihenfolge umkehren
print("Aktuelle Einkaufsliste:", einkauf)# k12indizes.py
farben = ["rot", "grün", "blau", "gelb", "lila"]
print(farben[0]) # Erstes Element: "rot"
print(farben[2]) # Drittes Element: "blau"
print(farben[-1]) # Letztes Element: "lila"
print(farben[-2]) # Vorletztes Element: "gelb"# k12kombinieren.py
obst = ["Apfel", "Banane", "Orange"] # Liste mit Obstsorten
gemuese = ["Karotte", "Tomate", "Gurke"] # Liste mit Gemüsesorten
alles = obst + gemuese # Listen kombinieren mit Obst und Gemüse
print("Gesamtliste:", alles) # Ausgabe
# Prüfung
if "Apfel" in alles: # Wenn Apfel in der Liste ist dann:
print("Apfel ist dabei!")
else: # Ansonsten:
print("Apfel fehlt.")# k12laenge.py
tiere = ["Hund", "Katze", "Maus"] # Liste mit Tieren
print(len(tiere)) # Gibt 3 aus, da 3 Tiere in der Liste sind# k12laenge2.py
staedte = ["Berlin", "Hamburg", "München", "Köln", "Görlitz"]
print("Städte:", staedte) # Gibt die komplette Liste der Städte aus
print("Anzahl der Städte:", len(staedte)) # Gibt die Länge der Liste aus
print(f"Es wurden {len(staedte)} Städte eingetragen.")# k12liste.py
person = ["Max", "männlich", 28] # einfache Liste
print(person) # Komplette Liste ausgeben
print(person[0]) # Ausgabe: Max
print(person[1]) # Ausgabe: männlich
print(person[2]) # Ausgabe: 28# k12listeFor.py
farben = ["rot", "grün", "blau"]
for farbe in farben:
print(farbe)# k12listeIn.py
farben = ["rot", "blau", "grün"] # Liste mit Farben
print("blau" in farben) # Gibt True aus
print("gelb" in farben) # Gibt False aus# k12listeMal.py
zahlen = [0, 1] # Liste mit 0 und 1
wiederholt = zahlen * 3 # Liste dreimal wiederholen
print(wiederholt) # Gibt [0, 1, 0, 1, 0, 1] aus# k12listePlus.py
liste1 = [1, 2, 3] # Erste Liste mit 3 Zahlen
liste2 = [4, 5] # Zweite Liste mit 2 Zahlen
ergebnis = liste1 + liste2 # Listen kombinieren
print(ergebnis) # Gibt [1, 2, 3, 4, 5] aus# k12lotto.py
lottozahlen = [23, 5, 42, 17, 8, 30]
print("Sortierte Lottozahlen:", sorted(lottozahlen)) # Sortierte Ausgabe
print("Kleinste Zahl:", min(lottozahlen)) # Kleinste Zahl
print("Größte Zahl:", max(lottozahlen)) # Größte Zahl# k12lotto_6aus49.py
from random import shuffle
zahlen = list(range(1, 50)) # Zahlen von 1 bis 49
shuffle(zahlen) # Mischen
ziehung = zahlen[:6] # Erste sechs ziehen
ziehung.sort() # Sortieren
print("Gezogene Lottozahlen:", ziehung) # Ausgabe# k12passwort.py
from random import choice, shuffle # choice für zufällige Auswahl, shuffle zum Mischen
gross = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" # Pool für Großbuchstaben
klein = "abcdefghijklmnopqrstuvwxyz" # Pool für Kleinbuchstaben
zahlen = "0123456789" # Pool für Ziffern
sonder = "!@#+-/&*?()" # Pool für Sonderzeichen
# Passwortliste beginnt mit je einem Zeichen aus jeder Kategorie
zeichen = [
choice(gross), # ein zufälliger Großbuchstabe
choice(klein), # ein zufälliger Kleinbuchstabe
choice(zahlen), # eine zufällige Zahl
choice(sonder) # ein zufälliges Sonderzeichen
]
alle = gross + klein + zahlen + sonder # alle Zeichen zusammenfassen
while len(zeichen) < 8: # Solange weniger als 8 Zeichen:
zeichen.append(choice(alle)) # füge ein zufälliges Zeichen hinzu
shuffle(zeichen) # Liste der Zeichen mischen
print("Passwortliste:", zeichen) # Ausgabe der gemischten Liste
print("Passwort:", "".join(zeichen)) # Zeichen als Passwort zusammenfügen# k12set.py
tiere = {"Hund", "Katze", "Maus", "Hund"}
print(tiere) # Gibt z. B. {'Maus', 'Hund', 'Katze'} aus Hund kommt nur einmal vor, Reihenfolge kann sich beim erneuten ausführen ändern# k12setMethoden.py
a = {1, 2, 3}
b = {3, 4, 5}
print(a.union(b)) # {1, 2, 3, 4, 5}
print(a.intersection(b)) # {3}
print(a.difference(b)) # {1, 2}# k12slicing.py
zahlen = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(zahlen[::2]) # Gibt [0, 2, 4, 6, 8] aus (nur jede zweite Zahl)
print(zahlen[1::3]) # Gibt [1, 4, 7] aus (Start 1, dann jede dritte Zahl)# k12sorted.py
zahlen = [5, 2, 9, 1] # Liste mit Zahlen
# Funktion: Erstellt eine sortierte Kopie von zahlen
neue_liste = sorted(zahlen)
print("Original:", zahlen) # Original: [5, 2, 9, 1]
print("Sortiert:", neue_liste) # Kopie: [1, 2, 5, 9]
zahlen.sort() # Methode: sortiert die Originalliste direkt
print("Nach .sort():", zahlen) # [1, 2, 5, 9]# k12string.py
name = "Python"
print(name[0]) # Gibt "P" aus
print(name[2]) # Gibt "t" aus
print(name[-1]) # Gibt "n" aus# k12string2.py
text = "Programmieren"
print(text[0:4]) # Gibt "Prog" aus
print(text[4:]) # Gibt "rammieren" aus
print(text[:6]) # Gibt "Progra" aus
print(text[::-1]) # Gibt "nereimmargorP" aus# k12tier.py
from random import randint
tiere = ["Kuh", "Gans", "Katze", "Maus", "Henne"] # Liste mit Tieren
zufallsindex = randint(0, 4) # Zufällig ein Tier auswählen
print("Heute triffst du ein:", tiere[zufallsindex]) # Ausgabe# k12tupel.py
koordinaten = (10, 20)
print(koordinaten[0]) # Gibt 10 aus
print(koordinaten[1]) # Gibt 20 aus# k12tupelFunktion.py
zahlen = (3, 7, 2, 9)
print(len(zahlen)) # 4 (4 Elemente im Tupel)
print(min(zahlen)) # 2 (2 ist kleinster Wert)
print(max(zahlen)) # 9 (9 ist großter Wert)
print(sum(zahlen)) # 21 (3 + 7 + 2 + 9)
print(7 in zahlen) # True (7 ist im Tupel vorhanden)# k12uebung.py
zahlen = list(range(1, 11)) # Liste erstellen
zahlen.append(11) # Zahl hinzufügen
zahlen.remove(5) # Zahl entfernen
zahlen.reverse() # Reihenfolge umkehren
print(f"Länge der Liste: {len(zahlen)}") # Länge der Liste ausgeben
zahlen_string = ",".join(map(str, zahlen)) # Liste in String umwandeln
print(zahlen_string) # Ausgabe des Strings# k12umlaute.py
text = "Käse, Öl, Übergröße, Füße, Grüße, Straße"
text = text.replace("ä", "ae") # Ersetzt "ä" durch "ae"
text = text.replace("ö", "oe") # Ersetzt "ö" durch "oe"
text = text.replace("ü", "ue") # Ersetzt "ü" durch "ue"
text = text.replace("Ä", "Ae") # Ersetzt "Ä" durch "Ae"
text = text.replace("Ö", "Oe") # Ersetzt "Ö" durch "Oe"
text = text.replace("Ü", "Ue") # Ersetzt "Ü" durch "Ue"
text = text.replace("ß", "ss") # Ersetzt "ß" durch "ss"
print("Umgewandelter Text:", text) # Gibt den neuen Text aus# k12wetter.py
temperaturen = [12.5, 14.8, 17.2, 16.0, 13.5, 11.9, 15.6]
print("Tiefstwert:", min(temperaturen)) # Niedrigste Temperatur
print("Höchstwert:", max(temperaturen)) # Höchste Temperatur
durchschnitt =sum(temperaturen)/len(temperaturen) # Durchschnitt berechnen
print("Durchschnitt:", durchschnitt)# k12wochentage.py
wochentage = ("Mo.", "Di.", "Mi.", "Do.", "Fr.", "Sa.", "So.")
for tag in wochentage:
print(tag)# k12woerter.py
satz = input("Gib einen Satz ein: ").strip()
woerter = satz.split() # Satz in Wörter aufteilen
print(f"Der Satz enthält {len(woerter)} Wörter.") # Ausgabe der Wortanzahl
for wort in woerter:
print(wort) # Jedes Wort einzeln ausgeben# k12zerlegen.py
text = "Elefantenparade"
print("Erste vier:", text[:4]) # Gibt "Elef" aus
print("Rückwärts:", text[::-1]) # Gibt "edarapnetnafE" aus
print("Mitte:", text[len(text) // 2]) # Gibt "t" aus (bei gerader Länge)# k13dictionary.py
# Ein Dictionary mit drei Schlüssel-Wert-Paaren anlegen
mein_dict = {
"Name": "Alice", # Schlüssel "Name" mit Wert "Alice"
"Alter": 25, # Schlüssel "Alter" mit Wert 25
"Stadt": "Berlin" # Schlüssel "Stadt" mit Wert "Berlin"
}
print(mein_dict["Name"]) # Gibt den Wert "Alice" zum Schlüssel "Name"
print(mein_dict["Stadt"]) # Gibt den Wert "Berlin" zum Schlüssel "Stadt"# k13dictionary2.py
person = {
"Name": "Lina", # Name als Schlüssel
"Hobbys": ["Lesen", "Schwimmen", "Musik"] # Liste als Wert
}
print(person["Hobbys"][0]) # Gibt das erste Hobby aus ("Lesen")# k13dictionary3.py
mein_dict = {"Name": "Fee", "Alter": 25} # Dictionary mit zwei Schlüsseln
mein_dict["Stadt"] = "Ulm" # Schlüssel "Stadt" mit Wert "Ulm" hinzugefügt
print(mein_dict) # Gibt das Dictionary mit allen Werten aus# k13dictionary4.py
mein_dict = {"Name": "Alice", "Alter": 25, "Stadt": "Berlin"}
del mein_dict["Stadt"] # Entfernt den Schlüssel "Stadt" und dessen Wert
print(mein_dict) # Gibt das Dictionary ohne "Stadt" aus# k13dictionary5.py
mein_dict = {"Name": "Alice", "Alter": 25}
print("Name" in mein_dict) # Gibt es "Name" als Schlüssel? (True)
print("Stadt" in mein_dict) # Gibt es "Stadt" als Schlüssel? (False)# k13dictionary6.py
mein_dict = {"Name": "Alice", "Alter": 25, "Stadt": "Berlin"}
# Über alle Schlüssel iterieren
for schluessel in mein_dict:
print(schluessel) # Gibt jeden Schlüssel aus
# Über alle Werte iterieren
for wert in mein_dict.values():
print(wert) # Gibt jeden Wert aus
# Über alle Schlüssel-Wert-Paare iterieren
for schluessel, wert in mein_dict.items():
print(f"{schluessel}: {wert}") # Gibt jedes Paar aus# k13essen.py
essen = {
"Anna": "Pizza", # Lieblingsessen von Anna
"Ben": "Spaghetti", # Lieblingsessen von Ben
"Clara": "Sushi" # Lieblingsessen von Clara
}
essen["David"] = "Burger" # Lieblingsessen für David hinzufügen
print("Anna mag", essen["Anna"]) # Gibt das Lieblingsessen von Anna aus
# Über alle Personen und deren Lieblingsessen iterieren
for name, gericht in essen.items():
print(f"{name} mag {gericht}") # Gibt z. B. "Anna mag Pizza" aus# k13uebung.py
mein_dict = {"Name": "Max", "Alter": 30, "Beruf": "Entwickler"}
mein_dict["Beruf"] = "Datenwissenschaftler" # Ändert den Wert von "Beruf"
mein_dict["Stadt"] = "Berlin" # Fügt "Stadt" als neuen Schlüssel hinzu
if "Alter" in mein_dict: # Prüft, ob "Alter" existiert
print(f"Alter: {mein_dict['Alter']}") # Gibt das Alter aus
# Alle Schlüssel-Wert-Paare durchgehen
for schluessel, wert in mein_dict.items():
print(f"{schluessel}: {wert}") # Gibt jedes Paar aus# k14echo.py
def echo(*werte): # Definition der Funktion echo
neuerString = "" # Leerer String zum Aufbau der Ausgabe
for wert in werte:
neuerString += str(wert) + " " # Jedes Element in den String einfügen, getrennt durch ein Leerzeichen
print(neuerString.strip()) # Entfernt das letzte überflüssige Leerzeichen und gibt den String aus
# Aufruf der Funktion
echo("Hallo", "Welt") # Aufruf mit 2 Argumenten gibt "Hallo Welt" aus
echo(1, 2, 3, "Python") # Aufruf mit 4 Argumenten gibt "1 2 3 Python" aus# k14eingebauteFunktionen.py
name = input("Wie heißt du?") # Funktion input() fragt nach dem Namen
print("Hallo", name) # Funktion print() gibt eine Begrüßung aus
print("Hallo", "Welt") # mehrere Argumente mit Komma getrennt
eingabe = input("Wieviel macht 0.1 + 0.2?") # Funktion input()
zahl = float(eingabe) # Funktion float() Umwandlung in Dezimalzahl
richtig = round(0.1 + 0.2, 1) # Funktion round() rundet auf 1 Kommastelle
# weil sonst 0.1 + 0.2 in Python 0.30000000000000004 ergibt
if zahl == richtig:
print("Richtig!")
else:
print("Leider falsch, die richtige Antwort ist:", richtig)# k14einkaufsliste.py
def zeige_einkaufsliste(*artikel):
print("Deine Einkaufsliste:", ", ".join(artikel))
einkauf = [] # Leere Liste für die Einkaufsliste
while True: # Endlosschleife für die Eingabe
eintrag = input("Was möchtest du einkaufen? (Enter zum Beenden): ")
if eintrag == "": # Wenn nur Enter gedrückt wird dann:
break # Schleife beenden
# Wurde die Schleife nicht abgebrochen, wird der Eintrag hinzugefügt
einkauf.append(eintrag) # Artikel zur Einkaufsliste hinzufügen
zeige_einkaufsliste(*einkauf) # Aufruf der Funktion mit der Einkaufsliste# k14funktion.py
def begruessung(): # Definition einer Funktion
print("Hallo") # Ausgabe der Begrüßung
begruessung() # Aufruf der Funktion gibt "Hallo" aus
begruessung() # Aufruf der Funktion gibt noch einmal "Hallo" aus# k14funktion2.py
def sag_hallo(): # Funktion ohne Parameter
print("Hallo!") # Ausgabe der Begrüßung
sag_hallo() # Aufruf der Funktion gibt "Hallo!" aus# k14funktion3.py
def quadrat(zahl): # Funktion nimmt eine Zahl entgegen
return zahl * zahl # oder zahl ** 2 # Berechnet das Quadrat der Zahl
ergebnis = quadrat(4) # Aufruf der Funktion mit der Zahl 4
print(ergebnis) # Gibt 16 aus# k14funktion4.py
# Funktion mit einem Standardwert
def begruessung(name="Gast"): # 1 Argument mit Standardwert "Gast"
print(f"Hallo {name}!") # Ausgabe der Begrüßung
begruessung("Nina") # Ausgabe: Hallo Nina!
begruessung() # Ausgabe: Hallo Gast!# k14funktionOhneArgumente.py
credits() # ohne Argument, erlaubt keine Argumente
print("Bitte gib etwas ein:") # mit einem Argument
text = input() # ohne Argument, erwartet eine Eingabe
print() # ohne Argument, gibt eine leere Zeile aus
print("Text:", text) # mit zwei Argumenten# k14geburtstagskarte.py
def geburtstagskarte(name, alter=18): # Funktion mit Standardwert für Alter
print(f"Alles Gute zum {alter}. Geburtstag, {name}!")
name = input("Wie ist dein Name? ")
alter_eingabe = input("Wie alt bist heute geworden? ")
if alter_eingabe == "": # Wenn kein Alter eingegeben wurde
geburtstagskarte(name) # Aufruf mit Standardwert
else:
alter = int(alter_eingabe) # Umwandlung der Eingabe in eine Ganzzahl
geburtstagskarte(name, alter) # Aufruf mit dem angegebenen Alter# k14gericht.py
# Definition der Funktion
def lieblingsgericht(name, gericht="Pizza"):
print(f"{name}s Lieblingsgericht ist {gericht}.")
lieblingsgericht("Sina", "Lasagne") # Aufruf mit beiden Werten
lieblingsgericht("Ben") # Aufruf ohne Gericht, Standardwert wird verwendet# k14importierteFunktionen.py
import random
# Verwendung der importierten Funktionen
zufallszahl = random.randint(1, 10) # Zufallszahl zwischen 1 und 10
print("Zufallszahl:", zufallszahl)
liste = [1, 2, 3, 4, 5]
zufallselement = random.choice(liste) # Zufälliges Element aus der Liste
print("Zufallselement:", zufallselement)
random.shuffle(liste) # Liste zufällig mischen
print("Gemischte Liste:", liste)# k14potenz.py
def potenz(basis, exponent): # 2 Parameter: Basis und Exponent
return basis ** exponent # Berechnung und Rückgabe der Potenz
ergebnis = potenz(2, 8)
print(ergebnis) # Gibt 256 aus# k14rechteck.py
def rechteck_flaeche(laenge, breite): # 2 Parameter: Länge und Breite
return laenge * breite # Berechnung der Fläche
flaeche = rechteck_flaeche(5, 3) # Aufruf der Funktion
print(f"Die Fläche beträgt {flaeche} Quadratmeter.") # Ausgabe der Fläche# k14summe.py
def summiere(*zahlen): # Funktion mit *argumente
return sum(zahlen) # Summe aller Zahlen im Tupel
print(summiere(1, 2, 3)) # Aufruf mit 3 Argumenten ergibt 6
print(summiere(10, 20, 30, 40)) # Aufruf mit 4 Argumenten ergibt 100# k14ticket.py
def kinoticket(name, film="Standardfilm"):
print(f"{name} hat ein Ticket für {film}.")
kinoticket("Lena", "Inception")
kinoticket("Tom") # Kein Film angegeben, also wird der Standard verwendet# k14zweiAusgaben.py
def sage_hallo(): # Funktion ohne Parameter
print("Hallo, schön dich zu sehen!") # Ausgabe der Begrüßung
def frage_wie_gehts(): # Funktion ohne Parameter
print("Wie geht es dir heute?") # Ausgabe der Frage
sage_hallo() # Aufruf der ersten Funktion
frage_wie_gehts() # Aufruf der zweiten Funktion# k15datetime.py
import datetime # Modul für Datum und Uhrzeit importieren
jetzt = datetime.datetime.now() # Aktuelles Datum und Uhrzeit holen
print(f"Heute ist der {jetzt.strftime('%d.%m.%Y')} um {jetzt.strftime('%H:%M:%S')}") # Ausgabe im gewünschten Format# k15math.py
import math # Modul für mathematische Funktionen importieren
# Quadratwurzel berechnen
zahl = 25
print(f"Die Quadratwurzel von {zahl} ist {math.sqrt(zahl)}")
# Potenz berechnen (2 hoch 3)
basis = 2
exponent = 3
print(f"{basis} hoch {exponent} ist {math.pow(basis, exponent)}")
# Runden
wert = 5.8
print(f"{wert} aufgerundet: {math.ceil(wert)}") # Aufrunden
print(f"{wert} abgerundet: {math.floor(wert)}") # Abrunden
# Kreisberechnung
radius = 7
umfang = 2 * math.pi * radius # Umfang mit Pi berechnen
# Ausgabe mit 2 Nachkommastellen
print(f"Der Umfang eines Kreises mit Radius {radius} ist {umfang:.2f}")# k15math2.py
import math # Modul für mathematische Funktionen importieren
a = 3 # Erste Seite des Dreiecks
b = 4 # Zweite Seite des Dreiecks
# Satz des Pythagoras: c^2 = a^2 + b^2
# Hypotenuse berechnen: c = Wurzel(a^2 + b^2)
hypotenuse = math.sqrt(math.pow(a, 2) + math.pow(b, 2))
print(f"Die Hypotenuse des Dreiecks ist {hypotenuse}") # Ausgabe# k15math3.py
import math # Modul für mathematische Funktionen importieren
preis = 4.75 # Ursprünglicher Preis
gerundeter_preis = math.ceil(preis) # Preis aufrunden
print(f"Aufgerundeter Fahrkartenpreis: {gerundeter_preis} €")# k15matheSpeed.py
from random import randint # Funktion für Zufallszahlen importieren
import time # Modul für Zeitmessung importieren
while True: # Schleife für mehrere Spielrunden
richtig = 0 # Zähler für richtige Antworten
falsch = 0 # Zähler für falsche Antworten
start = time.time() # Startzeit speichern
for _ in range(10): # 10 Aufgaben pro Runde
zahl1 = randint(1, 10) # Erste Zufallszahl
zahl2 = randint(1, 10) # Zweite Zufallszahl
summe = zahl1 + zahl2 # Summe berechnen
print("Wieviel ist", zahl1, "+", zahl2, "?") # Aufgabe ausgeben
antwort = int(input()) # Antwort abfragen
if antwort == summe: # Antwort überprüfen
print("Richtig!")
richtig += 1 # Richtige Antworten zählen
else:
print("Falsch! Die richtige Antwort ist", summe)
falsch += 1 # Falsche Antworten zählen
ende = time.time() # Endzeit speichern
dauer = ende - start # Dauer berechnen
# Ergebnis ausgeben
print("Du hast", richtig, "von 10 Aufgaben richtig beantwortet.")
print(f"Du hast {dauer:.2f} Sekunden gebraucht.") # Zeit ausgeben
# Abfrage, ob weitergespielt werden soll
weitermachen = input("Möchtest du noch einmal spielen? (ja/nein) ")
if weitermachen.lower() != "ja":
print("Spiel beendet.")
break# k15random.py
import random # Das ganze Modul random importieren
wuerfel = random.randint(1, 6) # Zufallszahl zwischen 1 und 6 (Würfeln)
print(f"Du hast eine {wuerfel} gewürfelt!") # Ausgabe der Zufallszahl
tiere = ["Hund", "Katze", "Maus"] # Liste mit Tieren
zufallstier = random.choice(tiere) # Zufälliges Tier auswählen
print(f"Zufälliges Tier: {zufallstier}") # Ausgabe des Tiers
farben = ["rot", "grün", "blau"] # Liste mit Farben
random.shuffle(farben) # Farben zufällig mischen
# Ausgabe der gemischten Liste
print(f"Zufällig gemischte Farben: {farben}")# k15speedMix.py
import random # Modul für Zufallszahlen und Auswahl importieren
import time # Modul für Zeitmessung importieren
rechenarten = ["+", "-", "*", "/"] # Liste der Rechenarten
richtig = 0 # Zähler für richtige Antworten
start = time.time() # Startzeit speichern
for i in range(10): # 10 Aufgaben
art = random.choice(rechenarten) # Zufällige Rechenart auswählen
if art == "+":
a = random.randint(1, 20) # Erste Zahl
b = random.randint(1, 20) # Zweite Zahl
loesung = a + b # Lösung berechnen
frage = f"{a} + {b}" # Frage formulieren
elif art == "-":
a = random.randint(5, 20) # Erste Zahl (mind. 5)
b = random.randint(1, a) # Zweite Zahl (kleiner als a)
loesung = a - b # Lösung berechnen
frage = f"{a} - {b}" # Frage formulieren
elif art == "*":
a = random.randint(1, 10) # Erste Zahl
b = random.randint(1, 10) # Zweite Zahl
loesung = a * b # Lösung berechnen
frage = f"{a} * {b}" # Frage formulieren
elif art == "/":
b = random.randint(1, 10) # Divisor
loesung = random.randint(1, 10) # Ergebnis soll ganzzahlig sein
a = b * loesung # Dividend berechnen
frage = f"{a} / {b}" # Frage formulieren
print(f"{i+1}. Was ist {frage}?") # Aufgabe ausgeben
antwort = int(input()) # Antwort abfragen
if antwort == loesung: # Antwort überprüfen
print("Richtig!")
richtig += 1
else:
print(f"Falsch! Die richtige Antwort ist {loesung}.")
ende = time.time() # Endzeit speichern
dauer = ende - start # Dauer berechnen
print(f"\nDu hast {richtig} von 10 Aufgaben richtig gelöst.") # \n ist ein Zeilenumbruch
print(f"Benötigte Zeit: {dauer:.2f} Sekunden") # Zeit ausgeben# k15uebung.py
from random import randint # Funktion randint importieren
import math # Modul für mathematische Funktionen importieren
# Zwei Würfel werfen und Summe berechnen
w1 = randint(1, 6) # Erster Würfel
w2 = randint(1, 6) # Zweiter Würfel
print(f"Würfel 1: {w1}, Würfel 2: {w2}, Summe: {w1 + w2}") # Ausgabe
# Kreisfläche mit zufälligem Radius berechnen
radius = randint(1, 10) # Zufälliger Radius zwischen 1 und 10
kreisflaeche = math.pi * math.pow(radius, 2) # Fläche berechnen
print(f"Radius: {radius}, Kreisfläche: {kreisflaeche:.2f}") # Ausgabe# k15wuerfel.py
from random import randint # Importiert nur die Funktion randint
zufallszahl = randint(1, 6) # Zufallszahl zwischen 1 und 6 erzeugen
print(f"Es wurde eine {zufallszahl} gewürfelt.") # Ausgabe der Zufallszahl# k15zufallsaktion.py
import random # Modul für Zufallsfunktionen importieren
# Liste mit 7 verschiedenen Aktivitäten
aktivitaeten = [
"Lies 10 Seiten in einem Buch.",
"Gehe 20 Minuten spazieren.",
"Räume deinen Schreibtisch auf.",
"Lerne ein neues Wort auf Englisch.",
"Mach 10 Kniebeugen.",
"Zeichne etwas Kreatives.",
"Schreibe drei Dinge auf, für die du dankbar bist."
]
aufgabe = random.choice(aktivitaeten) # Wählt eine zufällige Aktivität
print(f"Deine heutige Aufgabe: {aufgabe}") # Gibt die Aktivität aus# k16datei.py
# Eine Datei öffnen
datei = open("meine_datei.txt", "w") # Öffne die Datei im Schreibmodus
# Datei schließen
datei.close()# k16datei2.py
# Eine Datei erstellen und Text hineinschreiben
with open("meine_datei.txt", "w") as datei:
datei.write("Hallo Welt!\n") # Text in die Datei schreiben
datei.write("Python macht Spaß!")# k16datei3.py
# Den gesamten Inhalt einer Datei lesen
with open("meine_datei.txt", "r") as datei:
inhalt = datei.read()
print(inhalt)
# Die Datei Zeile für Zeile lesen
with open("meine_datei.txt", "r") as datei:
for zeile in datei:
print(zeile.strip()) # Entfernt Leerzeichen am Ende jeder Zeile# k16datei4.py
# Text ans Ende einer Datei anhängen
with open("meine_datei.txt", "a") as datei:
datei.write("\nDieser Text wurde hinzugefügt.")# k16datei5.py
# Anzahl der Zeilen in der Datei zählen
with open("meine_datei.txt", "r") as datei:
zeilen = datei.readlines()
print(f"Die Datei hat {len(zeilen)} Zeilen.")# k16datei6.py
# Summe und Durchschnitt berechnen
with open("zahlen.txt", "r") as datei:
inhalt = datei.read() # Inhalt der Datei lesen
zahlen = list(map(int, inhalt.split())) # Text in Zahlen umwandeln
print(f"Summe: {sum(zahlen)}")
print(f"Durchschnitt: {sum(zahlen) / len(zahlen)}")# k16gaestebuch.py
# Nach Namen fragen und ins Gästebuch eintragen
name = input("Wie heißt du? ")
with open("gaestebuch.txt", "a") as datei:
datei.write(name + "\n")
# Gästebuch anzeigen
print("Gästebuch:")
with open("gaestebuch.txt", "r") as datei:
print(datei.read())# k16woerterzaehlen.py
# Eine Datei öffnen und ihren Inhalt lesen
with open("text.txt", "r") as datei:
inhalt = datei.read() # Den gesamten Text aus der Datei lesen
# Den Text in Wörter aufteilen
woerter = inhalt.split() # Aufteilen anhand von Leerzeichen
# Die Anzahl der Wörter berechnen und ausgeben
print(f"Die Datei enthält {len(woerter)} Wörter.")# k17dateifehler.py
dateiname = input("Wie heißt die Datei? ") # Frage nach Dateinamen
try: # Versuche, die Datei zu öffnen
with open(dateiname, "r") as datei: # Datei im Lesemodus öffnen
inhalt = datei.read() # Inhalt der Datei auslesen
print(inhalt) # Inhalt ausgeben
except FileNotFoundError: # Fehler, falls die Datei nicht existiert
print("Die Datei wurde nicht gefunden.")
finally: # Abschlussmeldung, wird immer ausgegeben
print("Dateizugriff abgeschlossen.")# k17exception.py
try: # Versuche, den Code auszuführen
zahl = int("abc") # Versuch, einen Text in eine Zahl umzuwandeln
except ValueError: # Falls die Umwandlung nicht möglich ist
print("Das war keine gültige Zahl!") # Fehlermeldung ausgeben# k17exception2.py
try: # Versuche, den Code auszuführen
zahl = int("abc") # Versuch, einen Text in eine Zahl umzuwandeln
except ValueError as fehler: # Fehler abfangen und die genaue Fehlermeldung speichern
print("Fehlermeldung:", fehler) # Fehlermeldung ausgeben# k17exception3.py
try: # Versuche, den Code auszuführen
zahl = int(input("Gib eine Zahl ein: ")) # Benutzereingabe und Umwandlung in Zahl
ergebnis = 10 / zahl # Division durchführen
except ValueError: # Fehler, falls keine Zahl eingegeben wurde
print("Das war keine gültige Zahl!") # Fehlermeldung ausgeben
except ZeroDivisionError: # Fehler, falls durch 0 geteilt wird
print("Division durch 0 ist nicht erlaubt!") # Fehlermeldung ausgeben
except Exception: # Alle anderen Fehler abfangen
print("Ein anderer Fehler ist aufgetreten") # Fehlermeldung ausgeben# k17exception4.py
try: # Versuche, die Datei zu öffnen
datei = open("daten.txt", "r") # Datei im Lesemodus öffnen
except FileNotFoundError: # Fehler, falls die Datei nicht existiert
print("Die Datei wurde nicht gefunden.") # Fehlermeldung ausgeben
else: # Wird ausgeführt, wenn kein Fehler auftritt
inhalt = datei.read() # Inhalt der Datei auslesen
print(inhalt) # Inhalt ausgeben
datei.close() # Datei schließen
finally: # Wird immer ausgeführt
print("Programm beendet.") # Abschlussmeldung# k17exception5.py
class MeineException(Exception): # Eigene Ausnahme definieren
pass # Nur Platzhalter, da keine Eigenschaften benötigt wird
def pruefe_wert(wert): # Funktion zum Prüfen des Werts
if wert < 0: # Wenn der Wert negativ ist
# Mit raise wird der Fehler ausgelöst
raise MeineException("Der Wert darf nicht negativ sein!")
try: # Versuche, die Funktion mit negativem Wert auszuführen
pruefe_wert(-1)
except MeineException as fehler: # Fehler abfangen und speichern
print(f"Fehler: {fehler}") # Fehlermeldung ausgeben# k17fehler.py
zahl = int("abc") # Versuch, einen Text in eine Zahl umzuwandeln
# Fehler: ValueError# k17komplett.py
# Eigene Ausnahme definieren
class Negativ(Exception): # Eigene Fehlerklasse
pass # Nur Platzhalter, da keine Eigenschaften benötigt wird
def pruefe_wert(wert): # Funktion zum Prüfen des Werts
if wert <= 0: # Wenn der Wert negativ oder null ist
raise Negativ("Value must be positive") # Fehler auslösen
try: # Versuche, den Code auszuführen
eingabe = input("Gib eine Zahl ein: ") # Benutzereingabe
zahl = int(eingabe) # Umwandlung in Zahl
pruefe_wert(zahl) # Wert prüfen
ergebnis = 10 / zahl # Division durchführen
except ValueError as fehler: # Fehler, falls keine Zahl eingegeben wurde
print("Ungültige Eingabe:", fehler) # Fehlermeldung ausgeben
except ZeroDivisionError as fehler: # Fehler, falls durch 0 geteilt wird
print("Division durch 0:", fehler) # Fehlermeldung ausgeben
except Negativ as fehler: # Fehler, falls Wert negativ oder null
print("Negative Zahl:", fehler) # Fehlermeldung ausgeben
except Exception as fehler: # Alle anderen Fehler abfangen
print("Anderer Fehler:", fehler) # Fehlermeldung ausgeben
else: # Wird nur ausgeführt, wenn kein Fehler auftritt
print("Alles hat geklappt. Ergebnis:", ergebnis) # Erfolgsmeldung
finally: # Wird immer ausgeführt
print("Programm wurde ausgeführt, egal ob mit oder ohne Fehler.")# k17liste.py
daten = [10, 20, 30] # Liste mit drei Zahlen
try: # Versuche, den Code auszuführen
index = int(input("Gib einen Index ein: ")) # Nach Index fragen
# Wert an der gewünschten Position ausgeben
print(f"Wert an Position {index}: {daten[index]}")
except ValueError: # Fehler, falls keine Zahl eingegeben wurde
print("Bitte gib eine gültige Zahl ein!")
except IndexError: # Fehler, falls der Index außerhalb der Liste liegt
print("Dieser Index ist nicht vorhanden!")
finally: # Abschlussmeldung, wird immer ausgeführt
print("Fertig mit dem Zugriff auf die Liste.")# k18rechner.py
import tkinter as tk # Tkinter-Modul importieren
# Funktion zur Berechnung
def berechne():
try:
ausdruck = eingabefeld.get() # Text aus dem Eingabefeld holen
ergebnis = eval(ausdruck) # Rechnet aus dem eingegebenen Text
# Ergebnis im Label anzeigen
ergebnis_label.config(text=f"Ergebnis: {ergebnis}")
except:
# Fehler anzeigen, falls etwas schiefgeht
ergebnis_label.config(text="Fehler!")
# Fenster erstellen
fenster = tk.Tk() # Fenster-Objekt erzeugen
fenster.title("Taschenrechner") # Fenstertitel setzen
fenster.geometry("300x200") # Fenstergröße setzen
# Widgets hinzufügen
eingabefeld = tk.Entry(fenster, width=20) # Eingabefeld für Rechenausdruck
eingabefeld.pack() # Eingabefeld anzeigen
# Button zum Berechnen erzeugen
berechne_button = tk.Button(fenster, text="Berechnen", command=berechne)
berechne_button.pack() # Button anzeigen
# Platzhalter-Label für das Ergebnis erzeugen
ergebnis_label = tk.Label(fenster, text="Ergebnis:")
ergebnis_label.pack() # Label anzeigen
fenster.mainloop() # Hauptschleife starten# k18tkButton.py
import tkinter as tk # Tkinter-Modul importieren
# Funktion, die beim Klick auf den Button ausgeführt wird
def button_aktion():
print("Button wurde gedrückt!") # Text in der Konsole ausgeben
# Fenster erstellen
fenster = tk.Tk() # Fenster-Objekt erzeugen
# Button mit Text und Funktion erstellen und hinzufügen
button = tk.Button(fenster, text="Klick mich!", command=button_aktion)
button.pack() # Button zum Fenster hinzufügen und anzeigen
fenster.mainloop() # Hauptschleife starten# k18tkEntry.py
import tkinter as tk # Tkinter-Modul importieren
# Funktion, um den Text aus dem Eingabefeld zu lesen
def zeige_text():
eingabe = eingabefeld.get() # Text aus dem Eingabefeld holen
print(f"Eingabe: {eingabe}") # Text in der Konsole ausgeben
# Fenster erstellen
fenster = tk.Tk() # Fenster-Objekt erzeugen
# Eingabefeld und Button hinzufügen
eingabefeld = tk.Entry(fenster) # Eingabefeld erzeugen
eingabefeld.pack() # Eingabefeld anzeigen
button = tk.Button(fenster, text="Eingabe anzeigen", command=zeige_text) # Button mit Funktion
button.pack() # Button anzeigen
fenster.mainloop() # Hauptschleife starten# k18tkLabel.py
import tkinter as tk # Tkinter-Modul importieren
# Fenster erstellen
fenster = tk.Tk() # Fenster-Objekt erzeugen
fenster.geometry("300x200") # Größe setzen
# Ein Label hinzufügen
label = tk.Label(fenster, text="Willkommen bei Tkinter!") # Label mit Text erzeugen
label.pack() # Label zum Fenster hinzufügen und anzeigen
fenster.mainloop() # Hauptschleife starten# k18tkPassgen.py
import tkinter as tk # Tkinter-Modul importieren
import random # Für Zufallsfunktionen
import string # Für Buchstaben, Ziffern, Sonderzeichen
# Funktion zur Generierung eines Passworts
def passwort_generieren():
pw_laenge = 12 # Festlegen der Länge des Passworts
# a-z, A-Z, 0-9 und Sonderzeichen
zeichen = string.ascii_letters + string.digits + string.punctuation
# Zufälliges Passwort erzeugen
passwort = ''.join(random.choice(zeichen) for _ in range(pw_laenge))
# Passwort im Label anzeigen
label_passwort.config(text=f"Passwort: {passwort}")
# Hauptfenster erstellen
fenster = tk.Tk() # Fenster-Objekt erzeugen
fenster.title("Passwortgenerator") # Fenstertitel setzen
fenster.geometry("400x200") # Fenstergröße setzen
# Begrüßungstext
label_text = tk.Label(fenster, text="Drücke den Button, um ein Passwort zu generieren", font=("Arial", 12)) # Label mit Text
label_text.pack(pady=10) # Label anzeigen
# Button zur Passwortgenerierung
button = tk.Button(fenster, text="Passwort generieren", command=passwort_generieren) # Button mit Funktion
button.pack(pady=10) # Button anzeigen
# Label zur Anzeige des generierten Passworts
label_passwort = tk.Label(fenster, text="Passwort: ", font=("Arial", 14), fg="blue") # Label für Passwort
label_passwort.pack(pady=20) # Label anzeigen
# Fenster starten
fenster.mainloop() # Hauptschleife starten# k18tkPassgenV2.py
import tkinter as tk # Tkinter-Modul importieren
import random # Für Zufallsfunktionen
import string # Für Buchstaben, Ziffern, Sonderzeichen
from tkinter import messagebox # Für Fehlermeldungen
# Funktion zur Generierung eines Passworts
def passwort_generieren():
zeichen = "" # Zeichenmenge, die verwendet wird
passwort = [] # Liste für das Passwort
# Prüfen, welche Checkboxen ausgewählt sind
if kleinbuchstaben_var.get(): # Wenn Kleinbuchstaben ausgewählt sind
zeichen += string.ascii_lowercase # Kleinbuchstaben hinzufügen
# einen Kleinbuchstaben zum Passwort hinzufügen
passwort.append(random.choice(string.ascii_lowercase))
if grossbuchstaben_var .get(): # Wenn Großbuchstaben ausgewählt sind
zeichen += string.ascii_uppercase # Großbuchstaben hinzufügen
# einen Großbuchstaben zum Passwort hinzufügen
passwort.append(random.choice(string.ascii_uppercase))
if zahlen_var.get(): # Wenn Zahlen ausgewählt sind
zeichen += string.digits # Zahlen hinzufügen
# eine Zahl zum Passwort hinzufügen
passwort.append(random.choice(string.digits))
if sonderzeichen_var.get(): # Wenn Sonderzeichen ausgewählt sind
zeichen += string.punctuation # Sonderzeichen hinzufügen
# ein Sonderzeichen zum Passwort hinzufügen
passwort.append(random.choice(string.punctuation))
# Prüfen, ob mindestens eine Option ausgewählt ist
if not zeichen:
messagebox.showerror("Fehler", "Mindestens eine Option muss ausgewählt sein!") # Fehlermeldung anzeigen
return
# Länge des Passworts
pw_laenge = passwort_länge_var.get() # Wert vom Slicer holen
# Zufällige Zeichen hinzufügen, um die gewünschte Länge zu erreichen
passwort.extend(random.choice(zeichen) for _ in range(pw_laenge - len(passwort)))
# Passwort mischen, damit die Reihenfolge zufällig ist
random.shuffle(passwort)
# Passwort in einen String umwandeln und im Eingabefeld anzeigen
passwort_eingabe.delete(0, tk.END) # Eingabefeld leeren
passwort_eingabe.insert(0, "".join(passwort)) # Passwort anzeigen
# Hauptfenster erstellen
fenster = tk.Tk() # Fenster-Objekt erzeugen
fenster.title("Passwortgenerator") # Fenstertitel setzen
fenster.geometry("400x400") # Fenstergröße setzen
# Begrüßungstext
label_text = tk.Label(fenster, text="Wähle Optionen und drücke den Button,\n um ein Passwort zu generieren", font=("Arial", 12)) # Label mit Text
label_text.pack(pady=10) # Label anzeigen
# Checkbox-Optionen definieren (mit Standardwerten: alle aktiv)
kleinbuchstaben_var = tk.BooleanVar(value=True) # Ob Kleinbuchstaben verwendet werden sollen
grossbuchstaben_var = tk.BooleanVar(value=True) # Ob Großbuchstaben verwendet werden sollen
zahlen_var = tk.BooleanVar(value=True) # Ob Zahlen verwendet werden sollen
sonderzeichen_var = tk.BooleanVar(value=True) # Ob Sonderzeichen verwendet werden sollen
# Checkboxen im Fenster anzeigen
checkbox_kleinbuchstaben = tk.Checkbutton(fenster, text="Kleinbuchstaben", variable=kleinbuchstaben_var)
checkbox_kleinbuchstaben.pack(anchor="w")
checkbox_großbuchstaben = tk.Checkbutton(fenster, text="Großbuchstaben", variable=grossbuchstaben_var )
checkbox_großbuchstaben.pack(anchor="w")
checkbox_zahlen = tk.Checkbutton(fenster, text="Zahlen", variable=zahlen_var)
checkbox_zahlen.pack(anchor="w")
checkbox_sonderzeichen = tk.Checkbutton(fenster, text="Sonderzeichen", variable=sonderzeichen_var)
checkbox_sonderzeichen.pack(anchor="w")
# Slicer für Passwortlänge
passwort_länge_var = tk.IntVar(value=12) # Variable für die Länge
label_slicer = tk.Label(fenster, text="Passwortlänge:") # Label für Slicer
label_slicer.pack() # Label anzeigen
slicer = tk.Scale(fenster, from_=6, to=32, orient="horizontal", variable=passwort_länge_var) # Slicer für Länge
slicer.pack() # Slicer anzeigen
# Button zur Passwortgenerierung
button = tk.Button(fenster, text="Passwort generieren", command=passwort_generieren) # Button mit Funktion
button.pack(pady=10) # Button anzeigen
# Eingabefeld für die Passwortausgabe
passwort_eingabe = tk.Entry(fenster, font=("Arial", 14), justify="center", fg="blue", state="normal") # Eingabefeld
passwort_eingabe.pack(pady=20, fill="x", padx=20) # Eingabefeld anzeigen
# Fenster starten
fenster.mainloop() # Hauptschleife starten# k18tkSchereSteinPapier.py
import tkinter as tk # Tkinter-Modul importieren
from tkinter import messagebox # Für Ergebnisfenster
import random # Für Zufallsfunktionen
# Funktion zum Verarbeiten der Wahl
def play(choice):
options = ["Stein", "Schere", "Papier"] # Mögliche Optionen
pc_choice = random.choice(options) # Computer wählt zufällig
# Logik zur Bestimmung des Gewinners
if choice == pc_choice:
result = "Unentschieden!" # Beide haben das gleiche gewählt
elif (choice == "Stein" and pc_choice == "Schere") or (choice == "Schere" and pc_choice == "Papier") or (choice == "Papier" and pc_choice == "Stein"):
result = "Du gewinnst!" # Mensch gewinnt
else:
result = "Der Computer gewinnt!" # Computer gewinnt
# Zeige das Ergebnis im Fenster
messagebox.showinfo("Ergebnis", f"Deine Wahl: {choice}\nComputer: {pc_choice}\n\n{result}")
# Hauptfenster erstellen
root = tk.Tk() # Fenster-Objekt erzeugen
root.title("Stein Schere Papier") # Fenstertitel setzen
root.geometry("300x200") # Fenstergröße setzen
# Label mit Text erstellen
label = tk.Label(root, text="Wähle deine Option:", font=("Arial", 14))
label.pack(pady=10) # Label anzeigen
# Buttons für die Optionen
btn_stein = tk.Button(root, text="Stein", font=("Arial", 12), command=lambda: play("Stein")) # Button für Stein
btn_stein.pack(pady=5) # Button anzeigen
btn_schere = tk.Button(root, text="Schere", font=("Arial", 12), command=lambda: play("Schere")) # Button für Schere
btn_schere.pack(pady=5) # Button anzeigen
btn_papier = tk.Button(root, text="Papier", font=("Arial", 12), command=lambda: play("Papier")) # Button für Papier
btn_papier.pack(pady=5) # Button anzeigen
# Hauptschleife starten
root.mainloop() # GUI starten# k18tkSchereSteinPapierEchseSpock.py
import tkinter as tk # Tkinter-Modul importieren
from tkinter import messagebox # Für Ergebnisfenster
import random # Für Zufallsfunktionen
# Funktion zum Verarbeiten der Wahl
def play(choice):
# Optionen und Regeln
options = ["Stein", "Schere", "Papier", "Echse", "Spock"]
rules = {
"Schere": ["Papier", "Echse"],# schneidet Papier, köpft Echse
"Papier": ["Stein", "Spock"], # bedeckt Stein, widerlegt Spock
"Stein": ["Echse", "Schere"], # zerquetscht Echse, schleift Schere
"Echse": ["Spock", "Papier"], # vergiftet Spock, frisst Papier
"Spock": ["Schere", "Stein"],# zertrümmert Schere, verdampft Stein
}
pc_choice = random.choice(options) # Zufällige Auswahl Computer
# Bestimme das Ergebnis
if choice == pc_choice: # Wenn beide gleich sind
result = "Unentschieden!"
elif pc_choice in rules[choice]: # Wenn die Wahl des Menschen die des Computers schlägt
result = f"Du gewinnst! {choice} schlägt {pc_choice}."
else: # Ansonsten
result = f"Der Computer gewinnt! {pc_choice} schlägt {choice}."
# Zeige das Ergebnis im Fenster
messagebox.showinfo(
"Ergebnis",
f"Deine Wahl: {choice}\nComputer: {pc_choice}\n\n{result}"
)
# Hauptfenster erstellen
root = tk.Tk() # Fenster-Objekt erzeugen
root.title("Schere, Stein, Papier, Echse, Spock") # Fenstertitel setzen
root.geometry("300x400") # Fenstergröße setzen
# Label mit Text erstellen
label = tk.Label(root, text="Wähle deine Option:", font=("Arial", 14))
label.pack(pady=10) # Label anzeigen
# Buttons für die Optionen
for option in ["Stein", "Schere", "Papier", "Echse", "Spock"]:
tk.Button(root, text=option, font=("Arial", 12), command=lambda opt=option: play(opt)).pack(pady=5) # Button für jede Option
root.mainloop() # GUI starten# k18tkinter.py
# Ein einfaches Tkinter-Fenster
import tkinter as tk # Tkinter-Modul importieren
# Hauptfenster erstellen
fenster = tk.Tk() # Fenster-Objekt erzeugen
# Fenstergröße setzen
fenster.geometry("400x300") # Größe auf 400x300 Pixel setzen
# Fenster anzeigen
fenster.mainloop() # Hauptschleife starten, damit das Fenster sichtbar ist# k18zaehler.py
import tkinter as tk # Tkinter-Modul importieren
# Funktion für den Button
def zaehler_erhoehen(): # Funktion, für das Klick auf den Button
global zaehler # Zugriff auf die globale Variable "zaehler"
zaehler += 1 # Zähler um 1 erhöhen
label.config(text=f"Zähler: {zaehler}") # Zähler-Label aktualisieren
# Fenster erstellen
fenster = tk.Tk() # Fenster-Objekt erzeugen
fenster.title("Zähler") # Fenstertitel setzen
fenster.geometry("200x150") # Fenstergröße setzen
zaehler = 0 # Startwert für den Zähler
# Platzhalter-Label für den Zählerstand erzeugen
label = tk.Label(fenster, text=f"Zähler: {zaehler}")
label.pack() # Label anzeigen
# Button zum Erhöhen erstellen
button = tk.Button(fenster, text="Erhöhe", command=zaehler_erhoehen)
button.pack() # Button anzeigen
fenster.mainloop() # Hauptschleife starten# k19haustier.py
class Haustier:
# Konstruktor: Erstellt ein neues Haustier mit Anfangswerten
def __init__(self, name):
self.name = name
self.satt = 50 # 0 = sehr hungrig, 100 = komplett satt
self.energie = 50 # 0 = erschöpft, 100 = topfit
self.laune = 50 # 0 = schlecht gelaunt, 100 = super gelaunt
# Füttert das Haustier: Sättigung und Laune steigt, Energie sinkt
def fuettern(self):
self.satt = min(self.satt + 20, 100)
self.laune = min(self.laune + 10, 100)
self.energie = max(self.energie - 10, 0)
print(f"{self.name} wurde gefüttert. 🥣 Satt: {self.satt}, 😊 Laune: {self.laune}, ⚡ Energie: {self.energie}")
# Spielt mit dem Haustier: Laune steigt, Energie und Sättigung sinkt
def spielen(self):
self.laune = min(self.laune + 20, 100)
self.energie = max(self.energie - 20, 0)
self.satt = max(self.satt - 15, 0)
print(f"{self.name} hat gespielt! 😊 Laune: {self.laune}, ⚡ Energie: {self.energie}, 🥣 Satt: {self.satt}")
# Lässt das Haustier schlafen: Energie steigt, Laune und Sättigung sinkt
def schlafen(self):
self.energie = min(self.energie + 30, 100)
self.laune = max(self.laune - 10, 0)
self.satt = max(self.satt - 10, 0)
print(f"{self.name} hat geschlafen. ⚡ Energie: {self.energie}, 🥣 Satt: {self.satt}, 😊 Laune: {self.laune}")
# Gibt den aktuellen Zustand des Haustiers aus
def status(self):
print(f"\nStatus von {self.name}:")
print(f"🥣 Sättigung: {self.satt}/100")
print(f"⚡ Energie: {self.energie}/100")
print(f"😊 Laune: {self.laune}/100")
print("-" * 30)# k19haustier2.py
import random
class Haustier:
def __init__(self, name):
self.name = name
self.satt = 5 # 0 = sehr hungrig, 10 = satt
self.energie = 5 # 0 = erschöpft, 10 = topfit
self.laune = 5 # 0 = schlecht, 10 = super
self.gesundheit = 10 # 0 = tot, 10 = topfit
def fuettern(self):
self.satt = min(self.satt + random.randint(2, 4), 10)
self.laune = min(self.laune + 1, 10)
self.energie = max(self.energie - 1, 0)
return self.name + " wurde gefüttert."
def spielen(self):
self.laune = min(self.laune + random.randint(2, 5), 10)
self.energie = max(self.energie - 2, 0)
self.satt = max(self.satt - 1, 0)
return self.name + " hat gespielt."
def schlafen(self):
self.energie = min(self.energie + random.randint(3, 5), 10)
self.satt = max(self.satt - 1, 0)
self.laune = max(self.laune - 1, 0)
return self.name + " hat geschlafen."
def heilen(self):
self.gesundheit = min(self.gesundheit + random.randint(1, 2), 10)
self.energie = max(self.energie - 1, 0)
self.satt = max(self.satt - 1, 0)
self.laune = max(self.laune - 1, 0)
return self.name + " hat geschlafen."
def gesundheitscheck(self):
if self.satt < 3 or self.energie < 3 or self.laune < 3:
self.gesundheit -= 1
else:
self.gesundheit = min(self.gesundheit + 1, 10)
return self.gesundheit > 0
def status(self):
# Gibt den aktuellen Zustand als Emoji-String zurück.
return (
f"\nStatus von {self.name}:\n"
f"🍖 Satt: {self.satt}/10\n"
f"⚡ Energie: {self.energie}/10\n"
f"😊 Laune: {self.laune}/10\n"
f"❤️ Gesundheit: {self.gesundheit}/10\n"
+ "-" * 20
)# k19random.py
import random
zufallszahl = random.randint(1, 10) # zufällige Zahl zwischen 1 und 10
print(f"Zufallszahl: {zufallszahl}") # Ausgabe der Zufallszahl# k19random2.py
import random
zufallsgenerator = random.Random() # Ein eigenes Objekt der Klasse Random
zufallszahl = zufallsgenerator.randint(1, 10) # Methode des Objekts nutzen
print(f"Zufallszahl: {zufallszahl}")# k19spiel.py
from k19haustier import Haustier # Haustier-Klasse aus Modul k19haustier
# 🐕 Interaktives Haustier-Spiel
name = input("Wie heißt dein Haustier? 🐾 ")
haustier = Haustier(name)
while True:
haustier.status()
print("\nWas möchtest du tun?")
print("1. Füttern 🍖")
print("2. Spielen 🎾")
print("3. Schlafen 💤")
print("4. Beenden ❌")
wahl = input("Wähle eine Aktion (1-4): ")
if wahl == "1":
haustier.fuettern()
elif wahl == "2":
haustier.spielen()
elif wahl == "3":
haustier.schlafen()
elif wahl == "4":
print("Spiel beendet. Bis zum nächsten Mal! 🐾")
break
else:
print("Ungültige Eingabe! Bitte 1-4 wählen.")# k19spiel2.py
from k19haustier2 import Haustier
# 🐕 Spielstart
name = input("Wie heißt dein Haustier? 🐾 ")
haustier = Haustier(name)
while True:
print(haustier.status())
print("\nWas möchtest du tun?")
print("1. Füttern 🍖")
print("2. Spielen 🎾")
print("3. Schlafen 💤")
print("4. Heilen 🩺")
print("5. Beenden ❌")
wahl = input("Wähle eine Aktion (1-5): ")
if wahl == "1":
print(haustier.fuettern())
elif wahl == "2":
print(haustier.spielen())
elif wahl == "3":
print(haustier.schlafen())
elif wahl == "4":
print(haustier.heilen())
elif wahl == "5":
print("Spiel beendet. Bis zum nächsten Mal! 🐾")
break
else:
print("Ungültige Eingabe! Bitte 1-5 wählen.")
continue
if not haustier.gesundheitscheck():
print(f"\n💔 {haustier.name} ist ausgezogen, weil es sich nicht gut behandelt fühlte ...")
break# k19tasse.py
class Tasse:
# Konstruktor: Erstellt eine neue Tasse mit seinen Eigenschaften
def __init__(self, farbe, material, fuellmenge, max_fuellmenge):
self.farbe = farbe # Farbe der Tasse, z. B. "Weiß"
self.material = material # Material, z. B. "Keramik"
self.fuellmenge = fuellmenge # Aktuelle Füllmenge in ml
self.max_fuellmenge = max_fuellmenge # Max. Kapazität der Tasse
def trinken(self, menge): # Methode zum Trinken aus der Tasse
if self.fuellmenge >= menge: # Wenn genug voll dann:
self.fuellmenge -= menge # Füllmenge reduzieren
print(f"Du trinkst {menge} ml. Es sind noch {self.fuellmenge} ml übrig.")
else: # Ansonsten:
print("So voll ist die Tasse leider nicht mehr!")
def auffuellen(self): # Erhöht die Füllmenge auf das Maximum
self.fuellmenge = self.max_fuellmenge
print(f"Die Tasse ist jetzt voll ({self.max_fuellmenge} ml).")
def leeren(self): # Setzt die Füllmenge auf 0 (die Tasse ist leer)
self.fuellmenge = 0
print("Die Tasse wurde geleert.")
def ist_voll(self): # Gibt zurück, ob die Tasse voll ist (True/False)
return self.fuellmenge == self.max_fuellmenge
# Gibt zurück, ob die Tasse leer ist (True oder False)
def ist_leer(self):
return self.fuellmenge == 0
# Gibt den Status aus
def status(self):
print(f"Farbe: {self.farbe}, Material: {self.material}, Füllmenge: {self.fuellmenge} ml")
tasse1 = Tasse("Weiß", "Keramik", 150, 250) # Erzeugt das Objekt
tasse1.status() # Zeigt den aktuellen Status der Tasse an
tasse1.trinken(50) # Trinken von 50 ml
tasse1.status() # Zeigt den neuen Status an
tasse1.auffuellen() # Füllt auf Maximalwert auf
tasse1.status() # Zeigt den Status nach dem Auffüllen an
tasse1.leeren() # Leert die Tasse
tasse1.status() # Zeigt den Status nach dem Leeren an# k19tasse2.py
class Tasse:
# Konstruktor: Erstellt eine neue Tasse mit seinen Eigenschaften
def __init__(self, farbe, material, fuellmenge, max_fuellmenge):
self.farbe = farbe
self.material = material
self.fuellmenge = fuellmenge
self.max_fuellmenge = max_fuellmenge
def trinken(self, menge): # Trinkt eine bestimmte Menge aus der Tasse
if self.fuellmenge >= menge:
self.fuellmenge -= menge
print(f"Du trinkst {menge} ml aus der {self.farbe}-Tasse.")
else:
print("Nicht genug Flüssigkeit in der Tasse!")
def auffuellen(self): # Füllt die Tasse bis zur max. Füllmenge auf
self.fuellmenge = self.max_fuellmenge
print(f"Die {self.farbe}-Tasse ist jetzt voll.")
# Leert die Tasse komplett
def leeren(self):
self.fuellmenge = 0
print(f"Die {self.farbe}-Tasse wurde geleert.")
# Gibt den aktuellen Füllstand der Tasse aus
def status(self):
print(f"{self.farbe}-Tasse: {self.fuellmenge} / {self.max_fuellmenge} ml")
# Drei verschiedene Tassen erstellen
tassen = [
Tasse("Rot", "Porzellan", 200, 300),
Tasse("Blau", "Glas", 100, 250),
Tasse("Grün", "Metall", 0, 500)
]
# Interaktive Steuerung
while True:
print("\nWelche Tasse möchtest du verwenden?")
for i, tasse in enumerate(tassen):
print(f"{i + 1}. {tasse.farbe} ({tasse.fuellmenge}/{tasse.max_fuellmenge} ml)")
auswahl = input("Wähle eine Tasse (1-3) oder 'q' zum Beenden: ")
if auswahl.lower() == "q":
print("Programm beendet.")
break
if auswahl not in ["1", "2", "3"]:
print("Ungültige Eingabe! Bitte 1, 2 oder 3 wählen.")
continue
tasse = tassen[int(auswahl) - 1]
print("\nWas möchtest du tun?")
print("1. Trinken")
print("2. Auffüllen")
print("3. Leeren")
print("4. Status anzeigen")
aktion = input("Wähle eine Aktion (1-4): ")
if aktion == "1":
menge = int(input("Wie viel ml möchtest du trinken? "))
tasse.trinken(menge)
elif aktion == "2":
tasse.auffuellen()
elif aktion == "3":
tasse.leeren()
elif aktion == "4":
tasse.status()
else:
print("Ungültige Eingabe!")# k19tkinter.py
import tkinter as tk # Modul tkinter als "tk" importieren
fenster = tk.Tk() # Ein Fenster-Objekt der Klasse Tk erstellen
fenster.mainloop() # Hauptschleife des Fensters starten# k19zugriff.py
class Tasse:
def __init__(self, farbe, fuellmenge):
self.farbe = farbe
self.fuellmenge = fuellmenge
meine_tasse = Tasse("Rot", 150)# Ein Tassenobjekt erstellen
meine_tasse.fuellmenge = 200 # Direktes Ändern der Füllmenge
print(meine_tasse.fuellmenge) # Direkter Zugriff auf den Wert# k20tasseUntertasse.py
# Klasse für Untertassen
class Untertasse:
def __init__(self, farbe):
self.farbe = farbe
# Klasse für Tassen
class Tasse:
def __init__(self, farbe, material, untertasse=None):
self.farbe = farbe
self.material = material
self.untertasse = untertasse # Komposition: Enthält ein Untertassen-Objekt
def stelle_auf_untertasse(self, untertasse):
self.untertasse = untertasse
def status(self):
if self.untertasse:
print(f"Die Tasse steht auf einer {self.untertasse.farbe}en Untertasse.")
else:
print("Die Tasse steht auf keiner Untertasse.")# k21haustier.py
class Haustier:
def __init__(self, name):
""" Erstellt ein Haustier mit Namen, Hunger und Energie """
self.name = name
self.hunger = 5
self.energie = 5
def fuettern(self):
""" Füttert das Haustier und reduziert den Hunger """
self.hunger -= 2
if self.hunger < 0:
self.hunger = 0
print(f"{self.name} wurde gefüttert. Hunger: {self.hunger}")
def schlafen(self):
""" Lässt das Haustier schlafen und erhöht die Energie """
self.energie += 4
if self.energie > 10:
self.energie = 10
print(f"{self.name} hat geschlafen. Energie: {self.energie}")
# Kindklassen erben von Haustier
class Hund(Haustier):
def bellen(self):
""" Ein Hund kann bellen """
print(f"{self.name} bellt: Wuff! 🐶")
class Katze(Haustier):
def miauen(self):
""" Eine Katze kann miauen """
print(f"{self.name} miaut: Miau! 🐱")# k21spiel.py
from k21haustier import Hund, Katze
# Die Benutzerin / der Benutzer kann wählen, ob sie / er einen Hund oder eine Katze haben will
tierart = input("Möchtest du einen Hund oder eine Katze? ").lower()
name = input("Wie soll dein Haustier heißen? ")
if tierart == "hund":
haustier = Hund(name)
elif tierart == "katze":
haustier = Katze(name)
else:
print("Ungültige Eingabe! Standardmäßig wird ein Hund erstellt.")
haustier = Hund(name)
while True:
print(f"\nWas möchtest du mit {haustier.name} tun?")
print("1. Füttern 🍖")
print("2. Schlafen 💤")
if isinstance(haustier, Hund):
print("3. Bellen 🐶")
elif isinstance(haustier, Katze):
print("3. Miauen 🐱")
print("4. Beenden ❌")
wahl = input("Wähle eine Aktion (1-4): ")
if wahl == "1":
haustier.fuettern()
elif wahl == "2":
haustier.schlafen()
elif wahl == "3":
if isinstance(haustier, Hund):
haustier.bellen()
elif isinstance(haustier, Katze):
haustier.miauen()
elif wahl == "4":
print(f"{haustier.name} verabschiedet sich. Bis zum nächsten Mal! 🐾")
break
else:
print("Ungültige Eingabe! Bitte 1-4 wählen.")# k22haustier_app.py
from k19haustier2 import Haustier
import tkinter as tk
from tkinter import messagebox
TICK_INTERVAL = 10 # Zeitintervall in Sekunden
class HaustierApp:
def __init__(self, root):
self.root = root
self.haustier = Haustier("Fluffy") # Du kannst den Namen später auch abfragen
self.root.title("🐾 Haustier-Spiel")
self.status_label = tk.Label(root, font=("Arial", 14))
self.status_label.pack(pady=10)
self.gesundheit_label = tk.Label(root, font=("Arial", 12), fg="red")
self.gesundheit_label.pack()
button_frame = tk.Frame(root)
button_frame.pack()
tk.Button(button_frame, text="🍖 Füttern", command=self.fuettern).pack(side=tk.LEFT, padx=5)
tk.Button(button_frame, text="🎾 Spielen", command=self.spielen).pack(side=tk.LEFT, padx=5)
tk.Button(button_frame, text="💤 Schlafen", command=self.schlafen).pack(side=tk.LEFT, padx=5)
tk.Button(button_frame, text="🩺 Heilen", command=self.heilen).pack(side=tk.LEFT, padx=5)
self.update_status()
# Starte den Tick-Mechanismus (Zeitfaktor)
self.root.after(TICK_INTERVAL*1000, self.tick)
def update_status(self):
h = self.haustier
self.status_label.config(
text=f"Satt: {h.satt}/10 Energie: {h.energie}/10 Laune: {h.laune}/10"
)
self.gesundheit_label.config(
text=f"❤️ Gesundheit: {h.gesundheit}/10"
)
def aktion(self, methode):
getattr(self.haustier, methode)()
if not self.haustier.gesundheitscheck():
messagebox.showinfo("Game Over", f"{self.haustier.name} ist ausgezogen ...")
self.root.destroy()
else:
self.update_status()
def fuettern(self):
self.aktion("fuettern")
def spielen(self):
self.aktion("spielen")
def schlafen(self):
self.aktion("schlafen")
def heilen(self):
self.aktion("heilen")
def tick(self):
"""Wird alle TICK_INTERVAL Sekunden aufgerufen und lässt das Haustier altern."""
h = self.haustier
h.satt = max(h.satt - 1, 0)
h.energie = max(h.energie - 1, 0)
h.laune = max(h.laune - 1, 0)
if not h.gesundheitscheck():
messagebox.showinfo("Game Over", f"{h.name} ist ausgezogen ...")
self.root.destroy()
else:
self.update_status()
self.root.after(TICK_INTERVAL*1000, self.tick)
if __name__ == "__main__":
root = tk.Tk()
app = HaustierApp(root)
root.mainloop()# k23apiTest.py
import requests
antwort = requests.get("https://api.chucknorris.io/jokes/random")
daten = antwort.json()
print(daten) # Ganze JSON-Antwort anzeigen# k23apiTest2.py
import requests
antwort = requests.get("https://api.chucknorris.io/jokes/random")
daten = antwort.json()
print(daten["value"]) # Gibt den Witz aus# k23pdf.py
from fpdf import FPDF
pdf = FPDF()
pdf.add_page()
pdf.set_font("Arial", size=12)
pdf.cell(0, 10, "Hallo! Das ist meine erste PDF mit Python.", ln=True)
pdf.output("beispiel.pdf")# k23waehrungsrechnerApi.py
import tkinter as tk
import requests
API_URL = "https://api.frankfurter.dev/v1/latest?from=EUR&to=PLN"
def hole_wechselkurs():
try:
r = requests.get(API_URL) # Abrufen der Wechselkurse
daten = r.json() # JSON-Daten in Dictionary umwandeln
return daten["rates"]["PLN"] # Wechselkurs EUR-PLN zurückgeben
except Exception:
return None # Bei Fehlern (z.B. Offline) None zurückgeben
def umrechnen():
kurs = hole_wechselkurs()
if kurs is None: # Wenn der Wechselkurs nicht abgerufen werden konnte
ergebnis_label.config(text="Fehler beim Abrufen des Kurses")
return # Bricht die Funktion hier direkt ab
try:
euro = float(eingabe.get())
zloty = euro * kurs
ergebnis_label.config(text=f"{euro:.2f} € sind {zloty:.2f} Złoty")
except ValueError:
ergebnis_label.config(text="Bitte gültige Zahl eingeben")
root = tk.Tk()
root.title("Währungsrechner EUR → PLN")
root.geometry("300x200")
tk.Label(root, text="Betrag in Euro").pack(pady=5)
eingabe = tk.Entry(root); eingabe.pack(pady=5)
tk.Button(root, text="Umrechnen", command=umrechnen).pack(pady=5)
ergebnis_label = tk.Label(root, text=""); ergebnis_label.pack(pady=10)
root.mainloop()# k23wetterApi.py
import tkinter as tk
import requests
def hole_wetter(ort):
try:
# Open-Meteo.com nutzt Geokodierung (kein API-Key nötig)
geo_url = "https://geocoding-api.open-meteo.com/v1/search?name=" + ort + "&count=1"
geo = requests.get(geo_url).json()
if "results" not in geo or not geo["results"]:
ergebnis_label.config(text="Ort nicht gefunden")
return
lat = geo["results"][0]["latitude"] # Breitengrad
lon = geo["results"][0]["longitude"] # Längengrad
name = geo["results"][0]["name"] # Ortsname (API-Version)
region = geo["results"][0].get("admin1", "unbekannt") # Bundesland
land = geo["results"][0]["country"] # Land
# Wetterdaten abrufen
wetter_url = (
f"https://api.open-meteo.com/v1/forecast?"
f"latitude={lat}&longitude={lon}¤t_weather=true"
)
daten = requests.get(wetter_url).json() # Wetterdaten abrufen
# Temperatur extrahieren
temperatur = daten["current_weather"]["temperature"]
ergebnis_label.config(
text=f"{name} ({region}, {land}): {temperatur}°C"
)
except Exception:
ergebnis_label.config(text="Ort unbekannt oder Netzwerkfehler")
# GUI
root = tk.Tk()
root.title("Wetterabfrage")
root.geometry("320x200")
tk.Label(root, text="Ort eingeben").pack(pady=5)
eingabe = tk.Entry(root); eingabe.pack(pady=5)
tk.Button(root, text="Wetter anzeigen", command=lambda: hole_wetter(eingabe.get())).pack(pady=5)
ergebnis_label = tk.Label(root, text=""); ergebnis_label.pack(pady=10)
root.mainloop()# k24fenster.py
import pygame # Importiere die Pygame-Bibliothek für Spiele
# Initialisiere alle Pygame-Module
pygame.init()
# Erstelle ein Fenster mit 800x600 Pixeln
fenster = pygame.display.set_mode((800, 600))
pygame.display.set_caption("Beispiel") # Setze den Titel des Fensters
# Definiere Farben als RGB-Werte (Rot, Grün, Blau)
weiss = (255, 255, 255) # Weiß = alle Farben auf Maximum
blau = (0, 0, 255) # Blau = nur Blauanteil auf Maximum
# Hauptschleife des Spiels
running = True
while running:
# Verarbeite alle Ereignisse (Events)
for event in pygame.event.get():
# Prüfe ob das Fenster geschlossen wurde
if event.type == pygame.QUIT:
running = False
fenster.fill(weiss) # Fülle den Hintergrund mit Weiß
# Zeichne blaues Quadrat (x=350, y=250, breite=50, höhe=50)
pygame.draw.rect(fenster, blau, (350, 250, 50, 50))
pygame.display.flip() # Aktualisiere die Anzeige
pygame.quit() # Beendet Pygame sauber# k24quadratSteuern.py
import pygame # Importiere die Pygame-Bibliothek für Spiele
# Initialisiere alle Pygame-Module
pygame.init()
# Fenstergröße definieren
breite, hoehe = 800, 600
fenster = pygame.display.set_mode((breite, hoehe))
pygame.display.set_caption("Quadrat bewegen") # Setze Titel des Fensters
# Definiere Farben als RGB-Werte
weiss = (255, 255, 255) # Hintergrundfarbe
blau = (0, 0, 255) # Farbe des Quadrats
# Startposition des Quadrats in der Mitte des Bildschirms
x, y = 350, 250
geschwindigkeit = 0.1 # Bewegungsgeschwindigkeit des Quadrats
# Hauptschleife des Spiels
running = True
while running:
# Verarbeite alle Ereignisse
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
# Hole den Status aller Tasten
tasten = pygame.key.get_pressed()
# Bewege das Quadrat basierend auf den Pfeiltasten
if tasten[pygame.K_LEFT]:
x -= geschwindigkeit # Nach links bewegen
if tasten[pygame.K_RIGHT]:
x += geschwindigkeit # Nach rechts bewegen
if tasten[pygame.K_UP]:
y -= geschwindigkeit # Nach oben bewegen
if tasten[pygame.K_DOWN]:
y += geschwindigkeit # Nach unten bewegen
fenster.fill(weiss) # Lösche den vorherigen Frame
# Zeichne das Quadrat an neuer Position
pygame.draw.rect(fenster, blau, (x, y, 50, 50))
pygame.display.flip() # Aktualisiere die Anzeige
pygame.quit() # Beendet Pygame sauber# k24spiel.py
import pygame # Die Pygame-Bibliothek wird geladen
# Alle Module von Pygame werden initialisiert
pygame.init()
# Breite und Höhe des Fensters festlegen
WIDTH, HEIGHT = 800, 600
# Fenster mit fester Größe öffnen
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Spieler vs. Gegner") # Titel setzen
# Farben definieren (RGB-Werte)
BACKGROUND_COLOR = (30, 30, 30) # Hintergrund: dunkles Grau
PLAYER_COLOR = (135, 206, 250) # Spieler: hellblau
ENEMY_COLOR = (255, 99, 71) # Gegner: tomatenrot
TEXT_COLOR = (255, 255, 255) # Weiß für Texte
BUTTON_COLOR = (50, 50, 50) # Dunkelgrau für den Button
BUTTON_HOVER_COLOR = (70, 70, 70) # Hellgrau beim Hover mit der Maus
# Schriftarten laden (Standard, ohne extra Datei)
font = pygame.font.Font(None, 50) # Große Schrift
small_font = pygame.font.Font(None, 36) # Kleinere Schrift
# Funktion zum Anzeigen von Texten auf dem Bildschirm
def draw_text(text, x, y, font, color):
text_surface = font.render(text, True, color) # Text als Bild rendern
screen.blit(text_surface, (x, y)) # Textbild auf Fenster zeichnen
# Spiel-Funktion mit eigener Spiellogik
def game():
# Startposition des Spielers (Mitte)
player_x, player_y = 400, 300
player_speed = 5 # Geschwindigkeit des Spielers
player_size = 50 # Größe des Spielers (Quadrat)
# Startposition des Gegners (oben links)
enemy_x, enemy_y = 100, 100
enemy_speed = 2 # Geschwindigkeit des Gegners
enemy_size = 50 # Größe des Gegners (Quadrat)
running = True # Hauptschleife läuft
game_over = False # Spielstatus: nicht verloren
while running:
pygame.time.delay(30) # Warte 30ms (steuert Spielgeschwindigkeit)
# Alle Ereignisse (z. B. Tastendrücke oder Mausklicks) abfragen
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit() # Pygame schließen
exit() # Programm beenden
if not game_over:
keys = pygame.key.get_pressed() # Tastenzustände abrufen
# Bewegung des Spielers mit den Pfeiltasten
if keys[pygame.K_LEFT]:
player_x -= player_speed # Nach links bewegen
if keys[pygame.K_RIGHT]:
player_x += player_speed # Nach rechts bewegen
if keys[pygame.K_UP]:
player_y -= player_speed # Nach oben bewegen
if keys[pygame.K_DOWN]:
player_y += player_speed # Nach unten bewegen
# Spieler soll im Fenster bleiben
player_x = max(0, min(WIDTH - player_size, player_x))
player_y = max(0, min(HEIGHT - player_size, player_y))
# Gegner bewegt sich auf den Spieler zu
if enemy_x < player_x: # Wenn Gegner links vom Spieler ist
enemy_x += enemy_speed # Nach rechts bewegen
if enemy_x > player_x: # Wenn Gegner rechts vom Spieler ist
enemy_x -= enemy_speed # Nach links bewegen
if enemy_y < player_y: # Wenn Gegner über dem Spieler ist
enemy_y += enemy_speed # Nach unten bewegen
if enemy_y > player_y: # Wenn Gegner unter dem Spieler ist
enemy_y -= enemy_speed # Nach oben bewegen
# Wenn Gegner den Spieler berührt
dx, dy = abs(player_x - enemy_x), abs(player_y - enemy_y)
if dx < player_size and dy < player_size:
game_over = True # Spiel ist verloren
screen.fill(BACKGROUND_COLOR) # Hintergrund zeichnen
if not game_over: # Wenn das Spiel nicht verloren ist dann:
# Spieler und Gegner als Rechtecke anzeigen
pygame.draw.rect(screen, PLAYER_COLOR, (player_x, player_y, player_size, player_size))
pygame.draw.rect(screen, ENEMY_COLOR, (enemy_x, enemy_y, enemy_size, enemy_size))
else: # Ansonsten: Game Over anzeigen
draw_text("Game Over", WIDTH // 2 - 100, HEIGHT // 2 - 50, font, TEXT_COLOR)
# Position und Größe des Neustart-Buttons
button_x, button_y = WIDTH // 2 - 75, HEIGHT // 2 + 50
button_w, button_h = 150, 50
# Mausposition ermitteln
mouse_x, mouse_y = pygame.mouse.get_pos()
# Farbe des Buttons abhängig von Mausposition
if button_x < mouse_x < button_x + button_w and button_y < mouse_y < button_y + button_h:
button_color = BUTTON_HOVER_COLOR
else:
button_color = BUTTON_COLOR
# Button zeichnen und Text einfügen
pygame.draw.rect(screen, button_color, (button_x, button_y, button_w, button_h))
draw_text("Neustart", button_x + 20, button_y + 10, small_font, TEXT_COLOR)
pygame.display.flip() # Anzeige aktualisieren
# Neustart-Schleife: Hier wird gewartet, bis der Spieler auf den Button klickt
while game_over:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit() # Spiel sauber beenden
exit()
if event.type == pygame.MOUSEBUTTONDOWN:
mouse_x, mouse_y = pygame.mouse.get_pos()
# Prüfe, ob der Neustart-Button angeklickt wurde
if button_x < mouse_x < button_x + button_w and button_y < mouse_y < button_y + button_h:
return # Zurück zur game()-Funktion (Spiel neu starten)
# Mausposition erneut abrufen für Hover-Effekt auf dem Button
mouse_x, mouse_y = pygame.mouse.get_pos()
if button_x < mouse_x < button_x + button_w and button_y < mouse_y < button_y + button_h:
button_color = BUTTON_HOVER_COLOR # Button wird heller, wenn Maus darüber ist
else:
button_color = BUTTON_COLOR # Standardfarbe
# Button neu zeichnen und Text einfügen
pygame.draw.rect(screen, button_color, (button_x, button_y, button_w, button_h))
draw_text("Neustart", button_x + 20, button_y + 10, small_font, TEXT_COLOR)
pygame.display.flip() # Anzeige aktualisieren
# Fenster ein letztes Mal aktualisieren, bevor das Spiel neu startet
pygame.display.flip() # Fenster aktualisieren
# Hauptschleife: das Spiel wird immer wieder neu gestartet
while True:
game()# k25webserverLED.py
import network # Für WLAN-Verbindung
import socket # Für Webserver
import time # Für Wartezeiten
from machine import Pin # Für die LED-Pin
led = Pin(2, Pin.OUT) # LED definieren (ESP8266: meist Pin 2)
ssid = "DEIN_NETZWERK"
password = "DEIN_PASSWORT"
wlan = network.WLAN(network.STA_IF) # Setzt WLAN in den Station-Modus
wlan.active(True) # Aktiviere WLAN
wlan.connect(ssid, password) # Verbinde mit dem WLAN
while not wlan.isconnected(): # Solange nicht verbunden
time.sleep(1) # Warte eine Sekunde
print("Verbunden mit:", ssid)
print("IP-Adresse:", wlan.ifconfig()[0])
# HTML mit Buttons
def webseite(status):
return f"""<!DOCTYPE html>
<html>
<head>
<title>LED-Steuerung</title>
<meta charset="utf-8">
</head>
<body>
<h1>LED über Web schalten</h1>
<p>LED ist aktuell: <strong>{status}</strong></p>
<a href="/?led=on"><button>LED einschalten</button></a>
<a href="/?led=off"><button>LED ausschalten</button></a>
</body>
</html>"""
# Webserver starten
addr = socket.getaddrinfo("0.0.0.0", 80)[0][-1]
s = socket.socket()
s.bind(addr)
s.listen(1)
print("Webserver läuft...")
while True:
conn, addr = s.accept()
request = conn.recv(1024).decode()
print("Anfrage:", request)
led_status = "AUS"
if "/?led=on" in request:
led.on() # ON = LEDEIN
led_status = "EIN"
elif "/?led=off" in request:
led.off() # OFF = LED AUS
led_status = "AUS"
antwort = webseite(led_status)
conn.send("HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n")
conn.send(antwort)
conn.close()# k26klickMich.py
from kivy.app import App
from kivy.uix.button import Button
class MeineApp(App):
def build(self):
self.zahl = 0
self.button = Button(text="Klick mich!")
self.button.bind(on_press=self.button_geklickt) # Bindet die Methode button_geklickt an das Ereignis des Knopfes
return self.button # Erstellt und gibt den Button zurück
def button_geklickt(self, instance):
self.zahl += 1
self.button.text = f"Klicks: {self.zahl}"
MeineApp().run() # Starte die App# k27erkennen.py
# Programm zur Erkennung von gezeichneten Buchstaben mit dem trainierten Modell
import tkinter as tk # Für die grafische Oberfläche
import numpy as np # Für die Arbeit mit Zahlen und Arrays
from PIL import Image, ImageDraw # Für die Bildverarbeitung
from joblib import load # Zum Laden des gespeicherten Modells
# Bildgröße und Modell-Datei festlegen
bildgroesse = 28
modell_datei = "modell.pkl"
# Das trainierte Modell laden
modell = load(modell_datei)
# Hauptfenster für die Zeichnung erstellen
root = tk.Tk()
root.title("Buchstabenerkennung")
canvas = tk.Canvas(root, width=280, height=280, bg="white")
canvas.grid(row=0, column=0, columnspan=2)
bild = Image.new("L", (280, 280), 255) # Weißes Bild
draw = ImageDraw.Draw(bild)
# Funktion zum Zeichnen mit der Maus
def zeichne(event):
x, y = event.x, event.y
r = 8 # Radius des "Pinsels"
canvas.create_oval(x - r, y - r, x + r, y + r, fill="black", outline="black")
draw.ellipse((x - r, y - r, x + r, y + r), fill=0) # Schwarz malen
# Zeichnen aktivieren, solange die Maustaste gedrückt ist
canvas.bind("<B1-Motion>", zeichne)
# Funktion zum Leeren der Zeichenfläche und der Anzeige
def loesche():
canvas.delete("all")
draw.rectangle((0, 0, 280, 280), fill=255) # Alles weiß
ausgabe.config(text="")
# Funktion zur Erkennung des gezeichneten Buchstabens
def erkenne():
# Bild auf 28x28 Pixel verkleinern und als Graustufen konvertieren
skaliert = bild.resize((bildgroesse, bildgroesse)).convert("L")
daten = np.asarray(skaliert)
daten = 255 - daten # Farben invertieren
daten = daten.flatten().reshape(1, -1) # In eine Zahlenreihe umwandeln
vorhersage = modell.predict(daten)[0] # Vorhersage mit dem Modell
ausgabe.config(text=f"Erkannt: {vorhersage}")
# Button zum Erkennen des Buchstabens
btn_erkennen = tk.Button(root, text="Erkennen", height=2, command=erkenne)
btn_erkennen.grid(row=1, column=0, sticky="ew")
# Button zum Leeren der Fläche
btn_clear = tk.Button(root, text="Leeren", height=2, command=loesche)
btn_clear.grid(row=1, column=1, sticky="ew")
# Anzeige für die Vorhersage
ausgabe = tk.Label(root, text="", font=("Arial", 20))
ausgabe.grid(row=2, column=0, columnspan=2)
# Hauptschleife starten (Fenster anzeigen)
root.mainloop()# k27trainieren.py
# Programm zum Trainieren eines Machine-Learning-Modells mit den gesammelten Buchstaben
import pandas as pd # Für das Einlesen und Verarbeiten der CSV-Daten
from sklearn.neighbors import KNeighborsClassifier # Für den Klassifikationsalgorithmus
from joblib import dump # Zum Speichern des Modells
# Dateinamen für Trainingsdaten und Modell
dateiname = "buchstaben_daten.csv"
modell_datei = "modell.pkl"
# Trainingsdaten aus der CSV-Datei laden
daten = pd.read_csv(dateiname)
X = daten.drop("label", axis=1).values # Alle Pixelwerte
y = daten["label"].values # Die zugehörigen Buchstaben
# K-Nearest-Neighbors-Modell erstellen und trainieren
modell = KNeighborsClassifier(n_neighbors=3)
modell.fit(X, y)
# Modell als Datei speichern
dump(modell, modell_datei)
print(f"Modell wurde erfolgreich in '{modell_datei}' gespeichert.")# k27zeichnen.py
# Programm zum Zeichnen und Speichern von Buchstaben als Trainingsdaten
import tkinter as tk # Für die grafische Oberfläche
import numpy as np # Für die Arbeit mit Zahlen und Arrays
from PIL import Image, ImageDraw # Für die Bildverarbeitung
import csv # Für das Schreiben der CSV-Datei
import os # Für Dateiprüfung
# Bildgröße und Dateiname festlegen
bildgroesse = 28
dateiname = "buchstaben_daten.csv"
# Prüfe, ob die CSV-Datei existiert, falls nicht: Kopfzeile anlegen
if not os.path.exists(dateiname):
with open(dateiname, "w", newline="") as f:
writer = csv.writer(f)
# Erste Spalte: Label, danach die Pixelwerte
writer.writerow(["label"] + [f"pix{i}" for i in range(bildgroesse * bildgroesse)])
# Hauptfenster für die Zeichnung erstellen
root = tk.Tk()
root.title("Zeichne ein p oder m")
canvas = tk.Canvas(root, width=280, height=280, bg="white")
canvas.grid(row=0, column=0, columnspan=2)
# Bildobjekt für die interne Speicherung der Zeichnung
bild = Image.new("L", (280, 280), 255) # Weißes Bild
draw = ImageDraw.Draw(bild)
# Funktion zum Zeichnen mit der Maus
def zeichne(event):
x, y = event.x, event.y
r = 8 # Radius des "Pinsels"
canvas.create_oval(x - r, y - r, x + r, y + r, fill="black", outline="black")
draw.ellipse((x - r, y - r, x + r, y + r), fill=0) # Schwarz malen
# Zeichnen aktivieren, solange die Maustaste gedrückt ist
canvas.bind("<B1-Motion>", zeichne)
# Funktion zum Speichern der Zeichnung als Trainingsbeispiel
def speichere_bild(label):
# Bild auf 28x28 Pixel verkleinern und als Graustufen konvertieren
skaliert = bild.resize((bildgroesse, bildgroesse)).convert("L")
daten = np.asarray(skaliert)
daten = 255 - daten # Farben invertieren (Schwarz = 255)
daten = daten.flatten() # In eine lange Zahlenreihe umwandeln
zeile = [label] + daten.tolist() # Label und Pixelwerte zusammenfügen
# In die CSV-Datei schreiben
with open(dateiname, "a", newline="") as f:
writer = csv.writer(f)
writer.writerow(zeile)
print(f"Bild gespeichert als {label}")
loesche() # Zeichenfläche automatisch leeren
# Buttons zum Speichern der Zeichnung als "p" oder "m"
btn_p = tk.Button(root, text="Speichere als p", height=2, command=lambda: speichere_bild("p"))
btn_p.grid(row=1, column=0, sticky="ew")
btn_m = tk.Button(root, text="Speichere als m", height=2, command=lambda: speichere_bild("m"))
btn_m.grid(row=1, column=1, sticky="ew")
# Funktion zum Leeren der Zeichenfläche
def loesche():
canvas.delete("all")
draw.rectangle((0, 0, 280, 280), fill=255) # Alles weiß
# Button zum Leeren der Fläche
btn_clear = tk.Button(root, text="Leeren", height=2, command=loesche)
btn_clear.grid(row=2, column=0, columnspan=2, sticky="ew")
# Hauptschleife starten (Fenster anzeigen)
root.mainloop()# k28flask.py
from flask import Flask # Flask-Modul importieren
app = Flask(__name__) # Webanwendung erzeugen
@app.route("/") # Route für die Startseite festlegen
def startseite():
return "Hallo Welt!" # Text im Browser ausgeben
# Flask-App starten, wenn die Datei direkt ausgeführt wird
if __name__ == "__main__":
app.run(debug=True) # Anwendung im Debug-Modus starten# k28gaestebuch.py
from flask import Flask, request # Flask und request importieren
app = Flask(__name__) # Webanwendung erzeugen
eintraege = [] # Liste für Gästebucheinträge
@app.route("/", methods=["GET", "POST"])# Startseite, erlaubt GET und POST
def startseite():
if request.method == "POST": # Wenn das Formular abgeschickt wurde
name = request.form.get("name") # Name aus dem Formular holen
eintraege.append(name) # Name zur Liste hinzufügen
antwort = "<h1>Gästebuch</h1>" # Überschrift für das Gästebuch
antwort += "<form method='post'>Name: <input name='name'><input type='submit'></form>" # Eingabefeld für Namen
antwort += "<ul>"
for eintrag in eintraege: # Alle Einträge anzeigen
antwort += f"<li>{eintrag}</li>"
antwort += "</ul>"
return antwort # HTML an den Browser zurückgeben
if __name__ == "__main__":
app.run() # Anwendung starten# k28uebung.py
from flask import Flask, request # Flask und request importieren
app = Flask(__name__) # Webanwendung erzeugen
eintraege = [] # Liste für Gästebucheinträge (Name, Nachricht)
@app.route("/", methods=["GET", "POST"]) # Startseite, erlaubt GET & POST
def startseite():
if request.method == "POST": # Wenn das Formular abgeschickt wurde
name = request.form.get("name") # Name aus dem Formular holen
nachricht = request.form.get("nachricht") # Nachricht holen
eintraege.append((name, nachricht)) # Beides als Tupel speichern
antwort = "<h1>Gästebuch</h1>" # Überschrift für das Gästebuch
antwort += "<form method='post'>" # Formular für Name und Nachricht
antwort += "Name: <input name='name'><br>"
antwort += "Nachricht: <input name='nachricht'><br>"
antwort += "<input type='submit'></form>"
antwort += "<ul>"
for name, nachricht in eintraege: # Alle Einträge anzeigen
antwort+= f"<li><strong>{name}</strong> schrieb: {nachricht}</li>"
antwort += "</ul>"
return antwort # HTML an den Browser zurückgeben
if __name__ == "__main__":
app.run() # Anwendung starten# k30analyse.py
import pandas as pd
# CSV-Datei einlesen
df = pd.read_csv("temperaturen.csv")
# Tabelle anzeigen
print(df)# k30analyse2.py
import pandas as pd
df = pd.read_csv("temperaturen.csv") # CSV-Datei einlesen
durchschnitt = df["Temperatur"].mean() # Durchschnittstemperatur
print("Durchschnitt:", durchschnitt)
min_temp = df["Temperatur"].min() # Minimalwert
print("Niedrigste Temperatur:", min_temp)
max_temp = df["Temperatur"].max() # Maximalwert
print("Höchste Temperatur:", max_temp)
print(df[df["Temperatur"] > 22]) # Nur Tage mit mehr als 22 Grad# k30analyse3.py
import pandas as pd
import matplotlib.pyplot as plt
df = pd.read_csv("temperaturen.csv")
plt.bar(df["Tag"], df["Temperatur"]) # Balkendiagramm zeichnen
# Achsentitel hinzufügen
plt.title("Temperaturen über eine Woche")
plt.xlabel("Wochentag")
plt.ylabel("Temperatur (°C)")
plt.show() # Diagramm anzeigen