Projekt: Quiz-Game in Python
Entwickle ein interaktives Quiz-Spiel mit Punktesystem, Timer, Kategorien und Highscore-Liste - ein spannendes Python-Projekt
Aktualisiert:
Projekt: Quiz-Game in Python
In diesem Projekt entwickelst du ein interaktives Quiz-Spiel, bei dem Spieler Fragen beantworten, Punkte sammeln und sich mit Highscores messen können. Dieses Projekt verbindet Datenstrukturen, Dateioperationen und objektorientierte Programmierung.
Projektübersicht und Ziele
Unser Quiz-Game wird folgende Features haben:
- Fragen-Datenbank: Fragen mit mehreren Antwortmöglichkeiten
- Punktesystem: Punkte für richtige Antworten
- Timer: Zeitlimit für jede Frage
- Kategorien: Verschiedene Themengebiete zur Auswahl
- Highscore-Liste: Bestenliste, die in einer Datei gespeichert wird
- OOP-Version: Saubere Code-Struktur mit Klassen
Lass uns Schritt für Schritt das Spiel aufbauen!
Schritt 1: Fragen als Datenstruktur
Zuerst brauchen wir eine gute Datenstruktur für unsere Fragen. Wir nutzen eine Liste von Dictionaries:
fragen = [
{
"frage": "Welche Programmiersprache wurde von Guido van Rossum entwickelt?",
"optionen": ["A) Java", "B) Python", "C) C++", "D) Ruby"],
"antwort": "B",
"kategorie": "Programmierung",
"schwierigkeit": 1
},
{
"frage": "Was gibt 'print(type(42))' in Python aus?",
"optionen": ["A) <class 'float'>", "B) <class 'str'>",
"C) <class 'int'>", "D) <class 'number'>"],
"antwort": "C",
"kategorie": "Programmierung",
"schwierigkeit": 2
},
{
"frage": "Welches Schlüsselwort definiert eine Funktion in Python?",
"optionen": ["A) function", "B) func", "C) define", "D) def"],
"antwort": "D",
"kategorie": "Programmierung",
"schwierigkeit": 1
},
{
"frage": "Wie viele Planeten hat unser Sonnensystem?",
"optionen": ["A) 7", "B) 8", "C) 9", "D) 10"],
"antwort": "B",
"kategorie": "Wissenschaft",
"schwierigkeit": 1
},
{
"frage": "Was ist die chemische Formel von Wasser?",
"optionen": ["A) CO2", "B) NaCl", "C) H2O", "D) O2"],
"antwort": "C",
"kategorie": "Wissenschaft",
"schwierigkeit": 1
},
{
"frage": "In welchem Jahr fiel die Berliner Mauer?",
"optionen": ["A) 1987", "B) 1989", "C) 1991", "D) 1990"],
"antwort": "B",
"kategorie": "Geschichte",
"schwierigkeit": 1
},
{
"frage": "Wer schrieb 'Faust'?",
"optionen": ["A) Schiller", "B) Lessing", "C) Goethe", "D) Heine"],
"antwort": "C",
"kategorie": "Geschichte",
"schwierigkeit": 2
},
]Jede Frage enthält den Fragetext, die Antwortoptionen, die korrekte Antwort, die Kategorie und einen Schwierigkeitsgrad. Diese Struktur macht es einfach, neue Fragen hinzuzufügen.
Schritt 2: Quiz-Logik — Fragen stellen und Antworten prüfen
Jetzt schreiben wir die Grundlogik, die dem Spieler Fragen stellt und die Antwort prüft:
def frage_stellen(frage_dict):
"""Stellt eine einzelne Frage und gibt zurück, ob richtig beantwortet."""
print(f"\n{'=' * 50}")
print(f" {frage_dict['frage']}")
print(f"{'=' * 50}")
for option in frage_dict["optionen"]:
print(f" {option}")
print()
while True:
antwort = input("Deine Antwort (A/B/C/D): ").strip().upper()
if antwort in ("A", "B", "C", "D"):
break
print(" Bitte wähle A, B, C oder D!")
if antwort == frage_dict["antwort"]:
print(" Richtig! Sehr gut!")
return True
else:
print(f" Leider falsch. Die richtige Antwort war: {frage_dict['antwort']}")
return False
def quiz_starten(fragen_liste):
"""Führt ein komplettes Quiz durch."""
punkte = 0
for i, frage in enumerate(fragen_liste, 1):
print(f"\n--- Frage {i} von {len(fragen_liste)} ---")
if frage_stellen(frage):
punkte += 1
print(f"\n{'*' * 50}")
print(f" Quiz beendet! Du hast {punkte} von {len(fragen_liste)} Punkte erreicht.")
print(f"{'*' * 50}")
return punkteDie Funktion frage_stellen zeigt eine Frage an, wartet auf eine gültige Antwort und gibt True oder False zurück. quiz_starten durchläuft alle Fragen und zählt die Punkte.
Schritt 3: Punktesystem
Ein einfaches Punktesystem ist gut, aber wir können es spannender machen. Schwierigere Fragen sollen mehr Punkte bringen:
def punkte_berechnen(schwierigkeit, zeit_benoetigt, max_zeit):
"""Berechnet Punkte basierend auf Schwierigkeit und Antwortzeit."""
basis_punkte = schwierigkeit * 100 # 100, 200, 300 Punkte
# Zeitbonus: Schnellere Antworten = mehr Punkte
if zeit_benoetigt < max_zeit:
zeit_faktor = 1 - (zeit_benoetigt / max_zeit)
zeitbonus = int(basis_punkte * zeit_faktor * 0.5)
else:
zeitbonus = 0
gesamt = basis_punkte + zeitbonus
return gesamt
def ergebnis_anzeigen(punkte, gesamt_fragen, richtige):
"""Zeigt eine detaillierte Auswertung an."""
prozent = (richtige / gesamt_fragen) * 100 if gesamt_fragen > 0 else 0
print(f"\n{'*' * 50}")
print(f" QUIZ-ERGEBNIS")
print(f"{'*' * 50}")
print(f" Richtige Antworten: {richtige} / {gesamt_fragen}")
print(f" Erfolgsquote: {prozent:.1f}%")
print(f" Gesamtpunkte: {punkte}")
print(f"{'*' * 50}")
# Bewertung
if prozent == 100:
print(" Perfekt! Du bist ein Genie!")
elif prozent >= 75:
print(" Sehr gut! Beeindruckend!")
elif prozent >= 50:
print(" Gut gemacht! Weiter üben!")
else:
print(" Übung macht den Meister! Versuch es nochmal.")Das Punktesystem berücksichtigt jetzt die Schwierigkeit der Frage und wie schnell der Spieler geantwortet hat.
Schritt 4: Timer für jede Frage
Mit dem time-Modul können wir die Antwortzeit messen:
import time
def frage_mit_timer(frage_dict, max_zeit=15):
"""Stellt eine Frage mit Zeitlimit."""
print(f"\n{'=' * 50}")
print(f" Kategorie: {frage_dict['kategorie']} | "
f"Schwierigkeit: {'*' * frage_dict['schwierigkeit']}")
print(f" Zeitlimit: {max_zeit} Sekunden")
print(f"{'=' * 50}")
print(f"\n {frage_dict['frage']}\n")
for option in frage_dict["optionen"]:
print(f" {option}")
print()
startzeit = time.time()
while True:
antwort = input("Deine Antwort (A/B/C/D): ").strip().upper()
vergangene_zeit = time.time() - startzeit
if vergangene_zeit > max_zeit:
print(f"\n Zeit abgelaufen! ({vergangene_zeit:.1f}s)")
print(f" Die richtige Antwort war: {frage_dict['antwort']}")
return False, vergangene_zeit
if antwort in ("A", "B", "C", "D"):
break
print(" Bitte wähle A, B, C oder D!")
vergangene_zeit = time.time() - startzeit
print(f" (Beantwortet in {vergangene_zeit:.1f} Sekunden)")
ist_richtig = antwort == frage_dict["antwort"]
if ist_richtig:
print(" Richtig!")
else:
print(f" Falsch! Die richtige Antwort war: {frage_dict['antwort']}")
return ist_richtig, vergangene_zeitDer Timer startet, sobald die Frage angezeigt wird. Wenn die Zeit abläuft, wird die Frage als falsch gewertet.
Hinweis: In dieser Konsolen-Version prüfen wir die Zeit nach der Eingabe. Für eine echte Echtzeit-Prüfung bräuchte man Threading oder eine GUI.
Schritt 5: Kategorien
Jetzt ermöglichen wir dem Spieler, eine Kategorie auszuwählen:
def kategorien_abrufen(fragen_liste):
"""Gibt alle verfügbaren Kategorien zurück."""
kategorien = set()
for frage in fragen_liste:
kategorien.add(frage["kategorie"])
return sorted(kategorien)
def fragen_nach_kategorie(fragen_liste, kategorie):
"""Filtert Fragen nach Kategorie."""
if kategorie == "Alle":
return fragen_liste
return [f for f in fragen_liste if f["kategorie"] == kategorie]
def kategorie_waehlen(fragen_liste):
"""Lässt den Spieler eine Kategorie wählen."""
kategorien = kategorien_abrufen(fragen_liste)
print("\n--- Kategorien ---")
print(" 0. Alle Kategorien")
for i, kat in enumerate(kategorien, 1):
anzahl = len(fragen_nach_kategorie(fragen_liste, kat))
print(f" {i}. {kat} ({anzahl} Fragen)")
while True:
try:
auswahl = int(input("\nKategorie wählen: "))
if auswahl == 0:
return "Alle"
if 1 <= auswahl <= len(kategorien):
return kategorien[auswahl - 1]
print(" Ungültige Auswahl!")
except ValueError:
print(" Bitte gib eine Zahl ein!")Durch set() sammeln wir alle einzigartigen Kategorien. Der Spieler kann dann eine bestimmte Kategorie oder alle Fragen wählen.
Schritt 6: Highscore-Liste
Die Highscores speichern wir in einer JSON-Datei, damit sie auch nach dem Programmneustart erhalten bleiben:
import json
import os
HIGHSCORE_DATEI = "highscores.json"
def highscores_laden():
"""Lädt die Highscore-Liste aus einer Datei."""
if not os.path.exists(HIGHSCORE_DATEI):
return []
try:
with open(HIGHSCORE_DATEI, "r", encoding="utf-8") as datei:
return json.load(datei)
except (json.JSONDecodeError, IOError):
return []
def highscores_speichern(highscores):
"""Speichert die Highscore-Liste in eine Datei."""
with open(HIGHSCORE_DATEI, "w", encoding="utf-8") as datei:
json.dump(highscores, datei, indent=2, ensure_ascii=False)
def highscore_hinzufuegen(name, punkte, richtige, gesamt):
"""Fügt einen neuen Highscore hinzu."""
highscores = highscores_laden()
eintrag = {
"name": name,
"punkte": punkte,
"richtige": richtige,
"gesamt": gesamt,
"datum": time.strftime("%d.%m.%Y %H:%M")
}
highscores.append(eintrag)
# Nach Punkten sortieren (höchste zuerst)
highscores.sort(key=lambda x: x["punkte"], reverse=True)
# Nur die Top 10 behalten
highscores = highscores[:10]
highscores_speichern(highscores)
return highscores
def highscores_anzeigen():
"""Zeigt die Highscore-Liste an."""
highscores = highscores_laden()
print(f"\n{'=' * 55}")
print(f" {'HIGHSCORE-LISTE':^50}")
print(f"{'=' * 55}")
if not highscores:
print(" Noch keine Highscores vorhanden.")
else:
print(f" {'#':<4} {'Name':<15} {'Punkte':<10} {'Richtig':<12} {'Datum'}")
print(f" {'-' * 50}")
for i, hs in enumerate(highscores, 1):
print(f" {i:<4} {hs['name']:<15} {hs['punkte']:<10} "
f"{hs['richtige']}/{hs['gesamt']:<8} {hs['datum']}")
print(f"{'=' * 55}")Die Highscores werden als JSON gespeichert. Nach jedem Spiel wird der Spieler gefragt, ob er seinen Score speichern möchte.
Schritt 7: OOP-Version
Jetzt refaktorieren wir das gesamte Spiel mit Klassen für eine saubere Struktur:
import time
import json
import os
import random
class Frage:
"""Repräsentiert eine einzelne Quiz-Frage."""
def __init__(self, frage, optionen, antwort, kategorie="Allgemein",
schwierigkeit=1):
self.frage = frage
self.optionen = optionen
self.antwort = antwort.upper()
self.kategorie = kategorie
self.schwierigkeit = schwierigkeit
def anzeigen(self):
"""Zeigt die Frage und Optionen an."""
print(f"\n {self.frage}\n")
for option in self.optionen:
print(f" {option}")
def pruefen(self, antwort):
"""Prüft, ob die gegebene Antwort korrekt ist."""
return antwort.upper() == self.antwort
def __str__(self):
return f"[{self.kategorie}] {self.frage}"
class Quiz:
"""Verwaltet ein komplettes Quiz-Spiel."""
def __init__(self, fragen_daten, max_zeit=15):
self.fragen = self._fragen_erstellen(fragen_daten)
self.max_zeit = max_zeit
self.punkte = 0
self.richtige = 0
self.gesamte_fragen = 0
self.highscore_datei = "highscores.json"
def _fragen_erstellen(self, fragen_daten):
"""Erstellt Frage-Objekte aus Rohdaten."""
return [
Frage(
frage=fd["frage"],
optionen=fd["optionen"],
antwort=fd["antwort"],
kategorie=fd.get("kategorie", "Allgemein"),
schwierigkeit=fd.get("schwierigkeit", 1)
)
for fd in fragen_daten
]
def kategorien(self):
"""Gibt alle verfügbaren Kategorien zurück."""
return sorted(set(f.kategorie for f in self.fragen))
def fragen_filtern(self, kategorie=None, schwierigkeit=None):
"""Filtert Fragen nach Kriterien."""
ergebnis = self.fragen
if kategorie:
ergebnis = [f for f in ergebnis if f.kategorie == kategorie]
if schwierigkeit:
ergebnis = [f for f in ergebnis if f.schwierigkeit == schwierigkeit]
return ergebnis
def frage_stellen(self, frage):
"""Stellt eine Frage mit Timer und gibt Punkte zurück."""
print(f"\n{'=' * 50}")
print(f" Kategorie: {frage.kategorie} | "
f"Schwierigkeit: {'*' * frage.schwierigkeit}")
print(f" Zeitlimit: {self.max_zeit}s")
print(f"{'=' * 50}")
frage.anzeigen()
print()
startzeit = time.time()
while True:
antwort = input(" Deine Antwort (A/B/C/D): ").strip().upper()
if antwort in ("A", "B", "C", "D"):
break
print(" Bitte wähle A, B, C oder D!")
dauer = time.time() - startzeit
# Zeitüberschreitung prüfen
if dauer > self.max_zeit:
print(f"\n Zeit abgelaufen! ({dauer:.1f}s)")
print(f" Richtige Antwort: {frage.antwort}")
return 0
# Antwort prüfen
print(f" (Beantwortet in {dauer:.1f}s)")
if frage.pruefen(antwort):
punkte = self._punkte_berechnen(frage.schwierigkeit, dauer)
print(f" Richtig! +{punkte} Punkte")
return punkte
else:
print(f" Falsch! Richtige Antwort: {frage.antwort}")
return 0
def _punkte_berechnen(self, schwierigkeit, dauer):
"""Berechnet Punkte mit Zeit- und Schwierigkeitsbonus."""
basis = schwierigkeit * 100
if dauer < self.max_zeit:
zeitbonus = int(basis * (1 - dauer / self.max_zeit) * 0.5)
else:
zeitbonus = 0
return basis + zeitbonus
def starten(self, kategorie=None, mischen=True):
"""Startet ein Quiz-Spiel."""
aktive_fragen = self.fragen_filtern(kategorie=kategorie)
if not aktive_fragen:
print("\n Keine Fragen für diese Auswahl verfügbar.")
return
if mischen:
random.shuffle(aktive_fragen)
self.punkte = 0
self.richtige = 0
self.gesamte_fragen = len(aktive_fragen)
print(f"\n{'*' * 50}")
print(f" Quiz startet! {self.gesamte_fragen} Fragen")
if kategorie:
print(f" Kategorie: {kategorie}")
print(f"{'*' * 50}")
for i, frage in enumerate(aktive_fragen, 1):
print(f"\n--- Frage {i} von {self.gesamte_fragen} ---")
gewonnene_punkte = self.frage_stellen(frage)
if gewonnene_punkte > 0:
self.richtige += 1
self.punkte += gewonnene_punkte
print(f" Aktueller Stand: {self.punkte} Punkte")
self._ergebnis_anzeigen()
def _ergebnis_anzeigen(self):
"""Zeigt das Endergebnis an."""
prozent = (self.richtige / self.gesamte_fragen * 100
if self.gesamte_fragen > 0 else 0)
print(f"\n{'*' * 50}")
print(f" ENDERGEBNIS")
print(f"{'*' * 50}")
print(f" Richtig: {self.richtige} / {self.gesamte_fragen}")
print(f" Quote: {prozent:.1f}%")
print(f" Punkte: {self.punkte}")
print(f"{'*' * 50}")
if prozent == 100:
print(" Perfekt! Absoluter Experte!")
elif prozent >= 75:
print(" Sehr gut! Beeindruckende Leistung!")
elif prozent >= 50:
print(" Solide! Weiter üben lohnt sich!")
else:
print(" Nicht aufgeben! Übung macht den Meister!")
# Highscore-Methoden
def highscores_laden(self):
"""Lädt Highscores aus Datei."""
if not os.path.exists(self.highscore_datei):
return []
try:
with open(self.highscore_datei, "r", encoding="utf-8") as f:
return json.load(f)
except (json.JSONDecodeError, IOError):
return []
def highscore_speichern(self, name):
"""Speichert den aktuellen Score."""
highscores = self.highscores_laden()
highscores.append({
"name": name,
"punkte": self.punkte,
"richtige": self.richtige,
"gesamt": self.gesamte_fragen,
"datum": time.strftime("%d.%m.%Y %H:%M")
})
highscores.sort(key=lambda x: x["punkte"], reverse=True)
highscores = highscores[:10]
with open(self.highscore_datei, "w", encoding="utf-8") as f:
json.dump(highscores, f, indent=2, ensure_ascii=False)
def highscores_anzeigen(self):
"""Zeigt die Highscore-Tabelle an."""
scores = self.highscores_laden()
print(f"\n{'=' * 55}")
print(f" {'HIGHSCORE-LISTE':^50}")
print(f"{'=' * 55}")
if not scores:
print(" Noch keine Einträge.")
else:
print(f" {'#':<4} {'Name':<15} {'Punkte':<10} {'Richtig':<10} {'Datum'}")
print(f" {'-' * 50}")
for i, s in enumerate(scores, 1):
print(f" {i:<4} {s['name']:<15} {s['punkte']:<10} "
f"{s['richtige']}/{s['gesamt']:<7} {s['datum']}")
print(f"{'=' * 55}")Vollständiger Code — Hauptprogramm
Hier ist das Hauptprogramm, das alles zusammenfügt:
def hauptmenue(quiz):
"""Zeigt das Hauptmenü und steuert den Spielablauf."""
while True:
print(f"\n{'=' * 40}")
print(f" QUIZ-GAME")
print(f"{'=' * 40}")
print(" 1. Quiz starten (alle Fragen)")
print(" 2. Quiz nach Kategorie")
print(" 3. Highscores anzeigen")
print(" 4. Beenden")
print(f"{'=' * 40}")
auswahl = input("Deine Wahl: ").strip()
if auswahl == "1":
quiz.starten()
_nach_spiel(quiz)
elif auswahl == "2":
kategorien = quiz.kategorien()
print("\n--- Verfügbare Kategorien ---")
for i, kat in enumerate(kategorien, 1):
print(f" {i}. {kat}")
try:
kat_auswahl = int(input("\nKategorie wählen: ")) - 1
if 0 <= kat_auswahl < len(kategorien):
quiz.starten(kategorie=kategorien[kat_auswahl])
_nach_spiel(quiz)
else:
print(" Ungültige Auswahl!")
except ValueError:
print(" Bitte gib eine Zahl ein!")
elif auswahl == "3":
quiz.highscores_anzeigen()
elif auswahl == "4":
print("\nDanke fürs Spielen! Bis zum nächsten Mal!")
break
else:
print(" Ungültige Auswahl!")
def _nach_spiel(quiz):
"""Fragt nach Highscore-Speicherung nach einem Spiel."""
speichern = input("\n Highscore speichern? (j/n): ").strip().lower()
if speichern == "j":
name = input(" Dein Name: ").strip()
if name:
quiz.highscore_speichern(name)
print(f" Score gespeichert für {name}!")
# ============================================
# PROGRAMMSTART
# ============================================
if __name__ == "__main__":
# Fragen-Datenbank
fragen_daten = [
{
"frage": "Welche Programmiersprache wurde von Guido van Rossum entwickelt?",
"optionen": ["A) Java", "B) Python", "C) C++", "D) Ruby"],
"antwort": "B",
"kategorie": "Programmierung",
"schwierigkeit": 1
},
{
"frage": "Was gibt 'print(type(42))' aus?",
"optionen": ["A) <class 'float'>", "B) <class 'str'>",
"C) <class 'int'>", "D) <class 'number'>"],
"antwort": "C",
"kategorie": "Programmierung",
"schwierigkeit": 2
},
{
"frage": "Welches Schlüsselwort definiert eine Funktion?",
"optionen": ["A) function", "B) func", "C) define", "D) def"],
"antwort": "D",
"kategorie": "Programmierung",
"schwierigkeit": 1
},
{
"frage": "Wie viele Planeten hat unser Sonnensystem?",
"optionen": ["A) 7", "B) 8", "C) 9", "D) 10"],
"antwort": "B",
"kategorie": "Wissenschaft",
"schwierigkeit": 1
},
{
"frage": "Was ist die chemische Formel von Wasser?",
"optionen": ["A) CO2", "B) NaCl", "C) H2O", "D) O2"],
"antwort": "C",
"kategorie": "Wissenschaft",
"schwierigkeit": 1
},
{
"frage": "In welchem Jahr fiel die Berliner Mauer?",
"optionen": ["A) 1987", "B) 1989", "C) 1991", "D) 1990"],
"antwort": "B",
"kategorie": "Geschichte",
"schwierigkeit": 1
},
{
"frage": "Wer schrieb 'Faust'?",
"optionen": ["A) Schiller", "B) Lessing", "C) Goethe", "D) Heine"],
"antwort": "C",
"kategorie": "Geschichte",
"schwierigkeit": 2
},
{
"frage": "Was ist eine Liste in Python?",
"optionen": ["A) Ein Datentyp für Zeichenketten",
"B) Eine geordnete, veränderbare Sammlung",
"C) Ein unveränderliches Tupel",
"D) Ein Schlüssel-Wert-Paar"],
"antwort": "B",
"kategorie": "Programmierung",
"schwierigkeit": 2
},
]
# Quiz erstellen und starten
quiz = Quiz(fragen_daten, max_zeit=20)
hauptmenue(quiz)Erweiterungsideen
Hier sind Ideen, um dein Quiz-Game noch besser zu machen:
- Multiple Choice mit Bildern: Eine GUI-Version mit
tkinterund Bildfragen - Zufällige Reihenfolge der Optionen: Die Antwortmöglichkeiten bei jedem Durchlauf mischen
- Fragen aus Datei laden: Eine externe JSON-Datei mit Fragen, die einfach erweitert werden kann
- Mehrspieler-Modus: Zwei Spieler treten abwechselnd gegeneinander an
- Schwierigkeitsstufen: Einfach, Mittel, Schwer — mit unterschiedlichen Zeitlimits
- Joker-System: Wie bei “Wer wird Millionär” — 50:50, Publikumsjoker usw.
- Fragen-Editor: Ein Menü zum Hinzufügen neuer Fragen zur Datenbank
- Statistiken: Welche Kategorien werden am häufigsten falsch beantwortet?
Was du gelernt hast
In diesem Projekt hast du folgende Konzepte praktisch angewendet:
- Listen und Dictionaries — als Datenstruktur für Fragen und Highscores
- Klassen und Objekte —
FrageundQuizals sauber getrennte Klassen - Dateioperationen — Highscores in JSON speichern und laden
- Das
time-Modul — Antwortzeit messen und Zeitlimits setzen - List Comprehensions — zum eleganten Filtern von Fragen
- Fehlerbehandlung — robuste Eingabevalidierung
- Funktionale Zerlegung — komplexe Logik in kleine, testbare Funktionen aufteilen
- String-Formatierung — ansprechende Konsolenausgabe mit f-Strings
Pro-Tipp: Du kannst die Fragen-Datenbank in eine separate JSON-Datei auslagern und mit einer Funktion laden. So kannst du die Fragen unabhängig vom Code bearbeiten und sogar verschiedene Fragen-Sets erstellen:
# fragen.json erstellen und laden
def fragen_aus_datei(dateipfad):
with open(dateipfad, "r", encoding="utf-8") as f:
return json.load(f)
fragen_daten = fragen_aus_datei("fragen.json")
quiz = Quiz(fragen_daten)Das ist das Separation of Concerns-Prinzip: Daten und Logik voneinander trennen.