En el post anterior vam construir un quiz en Python en mode normal, on cada pregunta es corregeix immediatament. Ara farem un pas més propi d’un entorn acadèmic: implementarem un mode examen, on primer es responen totes les preguntes i només al final es fa la correcció.
Aquest canvi és petit a nivell d’interfície, però molt rellevant a nivell de disseny del programa: ens obliga a separar clarament dues fases diferents del flux del joc.
Objectius d’aprenentatge
- Separar la fase de joc de la fase de correcció.
- Guardar respostes de l’usuari per avaluar-les posteriorment.
- Dissenyar un flux de programa més proper a un entorn d’examen real.
- Reutilitzar la lògica del quiz sense duplicar codi.
1) Pensar el problema: dues fases diferenciades
En el mode normal, el flux era:
- Mostrem una pregunta
- L’usuari respon
- Corregim immediatament
En canvi, en el mode examen el flux és diferent:
- Mostrem totes les preguntes, una a una
- Guardem les respostes de l’usuari
- Quan s’ha acabat el test, corregim tot el conjunt
Aquesta separació ens obliga a pensar en estructures de dades intermèdies i en una arquitectura de codi més clara.
2) Guardar respostes: una llista paral·lela
Una solució simple i efectiva és guardar les respostes de l’usuari en una llista, mantenint el mateix ordre que la llista de preguntes.
respostes_usuari: list[int] = []D’aquesta manera, la resposta a la pregunta i es trobarà a respostes_usuari[i]. Aquesta correspondència ens facilita molt la correcció posterior.
3) Fase de joc: respondre sense feedback
Durant el mode examen no donem cap pista sobre si la resposta és correcta o no. Simplement recollim l’entrada i la guardem.
def jugar_quiz_examen(preguntes: list[dict]) -> list[int]:
"""Fase de joc: demanem totes les respostes sense corregir."""
respostes = []
total = len(preguntes)
print("=== Quiz (Mode Examen) ===")
print("Respon totes les preguntes. La correcció es farà al final.\n")
for i, q in enumerate(preguntes, start=1):
mostrar_pregunta(q, i, total)
resposta = demanar_resposta(len(q["choices"]))
respostes.append(resposta)
return respostesObservem que aquesta funció no sap res de puntuació ni de correcció. Només s’encarrega de recollir dades.
4) Fase de correcció: avaluar al final
Un cop tenim totes les respostes, podem fer una passada de correcció. Aquí reutilitzem la mateixa lògica que ja teníem al mode normal.
def corregir_examen(preguntes: list[dict], respostes: list[int]) -> int:
"""Corregeix totes les respostes i retorna el nombre d'encerts."""
encerts = 0
print("\n=== Correcció ===")
for i, (q, resp) in enumerate(zip(preguntes, respostes), start=1):
correcta = q["answer"]
print(f"\nPregunta {i}: {q['text']}")
print(f"Resposta donada: {q['choices'][resp]}")
print(f"Resposta correcta: {q['choices'][correcta]}")
if resp == correcta:
print("Resultat: ✅ Correcte")
encerts += 1
else:
print("Resultat: ❌ Incorrecte")
if q.get("explain"):
print(f"Motiu: {q['explain']}")
return encerts5) Programa complet: quiz en mode examen
Unim ara les dues fases en un flux complet:
def executar_quiz_examen(preguntes: list[dict]) -> None:
respostes = jugar_quiz_examen(preguntes)
encerts = corregir_examen(preguntes, respostes)
total = len(preguntes)
percent = 0.0 if total == 0 else 100.0 * encerts / total
print("\n=== Resultat final ===")
print(f"Encerts: {encerts}/{total}")
print(f"Percentatge: {percent:.1f}%")Aquesta estructura és més neta, més reutilitzable i molt més fàcil de portar a una interfície web com Streamlit.
6) Què hem practicat realment
- Separació clara de responsabilitats (jugar vs corregir).
- Ús d’estructures de dades per guardar estat intermig.
- Disseny de fluxos de programa més realistes.
- Reutilització de funcions sense duplicar codi.
🎮 Aquest mode forma part de DeGalaLab Arcade, un projecte on convertim exercicis de Python en experiències interactives per aprendre programació pas a pas.
⏭️ Següent post de la sèrie: Portar jocs de Python a la web amb Streamlit.
