Créer un quiz interactif en Python peut sembler complexe sans une structure adéquate.
Sans une bonne organisation, le code peut devenir difficile à maintenir et l’expérience utilisateur peut en souffrir.
Cet article vous guide pour développer un quiz game en utilisant Tkinter et la programmation orientée objet, garantissant une application fluide et attrayante.
Créez des interfaces graphiques interactives avec Python et TKinter !
Quiz Game avec Tkinter et POO
Objectif du Projet :
L’objectif de ce projet est de développer un jeu de quiz interactif en Python, intégrant l’interface graphique Tkinter et structuré selon les principes de la programmation orientée objet (POO). Ce projet offre l’opportunité de combiner plusieurs compétences techniques tout en réalisant une application ludique. L’application doit présenter à l’utilisateur une série de 10 questions avec quatre choix de réponses. Pour enrichir l’expérience utilisateur, chaque réponse est suivie d’une anecdote qui s’affiche brièvement.
Fonctionnalités Jeu Interactif Python
Pour rendre l’application attrayante et intuitive, il est important de comprendre les éléments clés qui composeront ce jeu.
Structure des Données :
Les données des questions et réponses doivent être bien organisées pour permettre une gestion efficace et une expérience fluide. Pour cela, toutes les questions et réponses seront stockées dans un fichier CSV. Ce fichier permettra de structurer et de lire les données facilement, garantissant la flexibilité d’ajouter ou de modifier des questions ultérieurement.
Voici un aperçu du contenue de fichier csv :
Le fichier CSV doit inclure les colonnes suivantes :
- ID :Identifiant unique pour chaque question.
- C :Contenu de la question.
- D, E, F, G :Quatre propositions de réponse (la première étant toujours correcte).
- I :Anecdote associée, qui apparaîtra après que l’utilisateur aura répondu.
Interface Utilisateur :
Pour que l’expérience utilisateur soit plaisante, l’interface doit être interactive et visuellement claire. Chaque question s’affiche à l’écran accompagnée de quatre boutons de réponse. Voici de l’interface que vous devez réaliser :
Les fonctionnalités spécifiques de l’interface utilisateur incluent :
- Affichage des questions :Chaque question est présentée de manière claire, avec des boutons pour permettre une réponse rapide et intuitive.
- Indicateur de progression :Un indicateur affiche combien de questions ont été répondues et combien de bonnes réponses ont été données jusqu’à présent. Cela donne à l’utilisateur une idée de son avancement, par exemple : « Question n° 5/10, 3 bonne(s) réponse(s) ».
- Retour visuel des réponses :Pour renforcer l’interactivité :Si l’utilisateur sélectionne la bonne réponse, le bouton correspondant devient vert.En cas de mauvaise réponse, le bouton de la réponse choisie devient rouge, tandis que la bonne réponse est mise en évidence en vert.
- Anecdote informative :Une anecdote est affichée après chaque réponse, offrant une transition agréable et informative avant la question suivante. L’anecdote reste à l’écran pendant 5 secondes.
- Message de fin :Une fois les 10 questions terminées, l’utilisateur peut consulter son score final et un message de remerciement s’affiche : « Merci d’avoir joué ! ».
Contraintes Techniques du Quiz
Pour garantir une expérience de jeu cohérente et stimulante, certaines contraintes doivent être respectées.
- Nombre de questions :Chaque partie doit contenir exactement 10 questions, ni plus ni moins, pour maintenir une durée de jeu raisonnable.
- Pas de répétition :Aucune question ne doit être répétée au cours d’une même partie afin de conserver l’intérêt de l’utilisateur.
- Programmation Orientée Objet (POO) :Pour maintenir un code propre et modulaire, le projet sera divisé en deux fichiers :quizz.py: Ce fichier contiendra la classeQuizInterface, responsable de la gestion et de la création de l’interface utilisateur.data.py: Ce fichier inclura la classeQuestion, qui s’occupera de charger les questions à partir du fichier CSV et de les sélectionner aléatoirement sans répétition.
- Gestion du temps :L’affichage de l’anecdote est limité à 5 secondes avant que le jeu ne passe à la question suivante, garantissant un rythme régulier.
Ces contraintes permettent de structurer le projet de manière à assurer un développement clair et organisé, tout en offrant une expérience utilisateur optimale.
Structure de Code en POO
Il est essentiel de comprendre comment les classes seront structurées pour organiser le projet.
Classe QuizInterface (dans quizz.py) :
Cette classe joue un rôle central en gérant l’interface utilisateur.
- Héritage :En tant que sous-classe de Tk, QuizInterface est capable de créer et gérer l’ensemble de l’interface.
- Fonctionnalités :
- Des méthodes pour afficher les questions et leurs options de réponse.
- Des fonctions pour gérer les clics sur les boutons, mettre à jour le score et afficher l’anecdote après chaque réponse.
- Gestion de la transition entre les questions avec un délai contrôlé.
Classe Question (dans data.py) :
Pour garantir la gestion efficace des questions, cette classe est chargée de lire les données du fichier CSV.
- Chargement des données :Lit le fichier CSV pour extraire les questions.
- Sélection aléatoire :Choisit aléatoirement les questions tout en veillant à ce qu’aucune ne soit répétée dans une même partie.
- Données retournées :Fournit le texte de la question, les choix de réponses et l’anecdote à afficher.
Cette séparation des responsabilités entre les classes permet un code plus lisible et plus facile à maintenir.
Instructions Utilisateur Quiz Tkinter
Pour faciliter l’utilisation de l’application, voici les étapes à suivre :
- Lancez le programme en exécutant quizz.py .
- Sélectionnez la réponse souhaitée en cliquant sur l’un des boutons de réponse.
- Prenez connaissance de l’anecdote affichée après chaque réponse avant de passer à la question suivante.
- À la fin des 10 questions, consultez le score final et lisez le message de remerciement.
Ces instructions guideront l’utilisateur à travers une expérience ludique et enrichissante.
Modules pour Interface Graphique
Pour débuter la réalisation de cet exercice, nous commençons par la création du premier fichier, quiz.py, qui contiendra la structure principale de l’interface graphique du jeu de quiz. Ce fichier se concentre sur la gestion de l’affichage des questions et des réponses, tout en intégrant les éléments essentiels pour offrir une expérience interactive à l’utilisateur. Nous allons d’abord importer les modules nécessaires pour que le programme fonctionne correctement et poser ainsi les bases de notre application.
Commençons par examiner comment le code s’appuie sur les modules et bibliothèques nécessaires pour fonctionner :
from tkinter import *
from data import Question
import tkinter.messagebox as messagebox
- from tkinter import * :Importe tous les composants de la bibliothèque Tkinter, qui permettent de créer l’interface graphique.
- from data import Question :Importe la classe Question depuis le module data, utilisée pour gérer les questions du quiz qu’on va le coder par la suite.
- import tkinter.messagebox as messagebox :Importe le module messagebox de Tkinter, nécessaire pour afficher des messages contextuels (comme des boîtes de dialogue).
Classe Principale & Attributs POO
Une fois les modules nécessaires importés, il est temps de définir la structure principale de l’application, incarnée par la classe QuizInterface :
classQuizInterface(Tk):
La classe QuizInterface hérite de Tk, ce qui signifie qu’elle est une extension de la classe principale de Tkinter, capable de gérer la fenêtre et les widgets. Passons maintenant à la définition des attributs de la classe, qui joueront un rôle central dans le suivi de l’état du jeu et la gestion des questions :
question = Question()
good_answer = 0
question_number = 1
Dans cette portion de code :
- question = Question() :Crée une instance de la classe Question pour charger et gérer les questions du quiz.
- good_answer = 0 :Initialise un compteur pour le nombre de réponses correctes.
- question_number = 1 :Définit le numéro de la première question à 1, pour suivre la progression du quiz.
Constructeur __init__ en Python
Avec les attributs de la classe établis, explorons comment le constructeur __init__ initialise l’interface graphique et prépare l’application à fonctionner :
def__init__(self):
super().__init__()
self.title("Quiz Game")
Avec :
- def __init__(self) :Définit le constructeur de la classe, appelé lors de l’initialisation d’une instance de QuizInterface.
- super().__init__() :Appelle le constructeur de la classe parente Tk pour configurer la fenêtre principale.
- self.title(« Quiz Game ») :Définit le titre de la fenêtre, permettant de savoir immédiatement de quoi il s’agit.
Configurer Fenêtre Tkinter
Pour garantir que l’interface est bien présentée à l’utilisateur, il est nécessaire de configurer la taille et la position de la fenêtre :
screen_width = self.winfo_screenwidth()
screen_height = self.winfo_screenheight()
w =int(screen_width/2 - 800/2)
h =int(screen_height/2 - 500/2)
self.geometry("800x500+" +str(w)+ "+" +str(h))
self.resizable(False, False)
Ainsi dans cette portion on :
- self.winfo_screenwidth() et self.winfo_screenheight() :Obtiennent la largeur et la hauteur de l’écran de l’utilisateur.
- Calculs de w et h :Permettent de centrer la fenêtre de 800×500 pixels au milieu de l’écran.
- self.geometry(« 800×500+ » + str(w)+ « + » +str(h)) :Définit la taille et la position de la fenêtre.
- self.resizable(False, False) :Empêche l’utilisateur de redimensionner la fenêtre, garantissant une présentation uniforme.
Créer Interface Jeu Tkinter
Une fois la fenêtre configurée, passons à la création des composants qui composent l’interface du quiz :
self.lbl_resultat = Label(self,text="Question n° " +str(self.question_number) + "/10 " +str(self.good_answer) + " bonne(s) reponse(s)")
self.lbl_resultat.pack()
self.txt_question = Message(self,text="Une question ?",font=("Calibri", 16, "bold"),width=750)
self.txt_question.pack()
Dans cette section de code, un composant Label est créé pour afficher le numéro de la question actuelle et le score de l’utilisateur, assurant ainsi un suivi clair de la progression du quiz. Ce label est positionné dans la fenêtre grâce à la méthode pack() . Ensuite, un composant Message est utilisé pour afficher le texte de la question, avec une mise en forme définie par font=(« Calibri », 16, « bold ») , qui spécifie la police, la taille, et le style en gras pour une meilleure lisibilité. Ce message est également positionné dans la fenêtre à l’aide de pack() pour garantir une disposition cohérente.
Boutons Réponse Quiz Python
Pour rendre le quiz interactif, des boutons permettant de choisir une réponse doivent être ajoutés :
font_button = "Calibri 12"
self.frm1 = Frame(self)
self.frm1.pack(pady=20)
self.btn1 = Button(self.frm1,text="Reponse 1",font=font_button,width=30,height=5,command=lambda: self.check_answer(self.btn1))
self.btn1.pack(side=LEFT,padx=40)
Dans cette partie du code, un composant Frame est créé pour servir de conteneur, facilitant l’organisation des boutons de réponse de manière structurée. Ce Frame est entouré d’un espacement vertical grâce au paramètre pady=20, ce qui améliore la lisibilité en créant une séparation visuelle autour des boutons. À l’intérieur du Frame, chaque Button représente une option de réponse et est associé à une commande check_answer, appelée lorsque le bouton est cliqué. Chaque bouton est positionné à gauche (side=LEFT) avec un espacement horizontal padx=40, offrant ainsi une disposition espacée et visuellement équilibrée.
La même logique est appliquée pour les autres boutons de réponse :
self.btn3 = Button(self.frm2,text="Reponse 3",font=font_button,width=30,height=5,command=lambda: self.check_answer(self.btn3))
self.btn3.pack(side=LEFT,padx=40)
self.btn4 = Button(self.frm2,text="Reponse 4",font=font_button,width=30,height=5,command=lambda: self.check_answer(self.btn4))
self.btn4.pack(side=LEFT,padx=40)
Anecdotes en Quiz Interactif
Une fois les boutons créés, ajoutons un espace pour afficher une anecdote après chaque réponse :
self.txt_anectode = Message(self,font="Calibri 16",width=750)
self.txt_anectode.pack(side=BOTTOM,pady=20)
Un composant Message est utilisé pour afficher l’anecdote associée à chaque question, apportant une information complémentaire après la réponse de l’utilisateur. Ce message est positionné en bas de la fenêtre (side=BOTTOM) avec un espacement vertical défini par pady=20, assurant une présentation propre et une séparation visuelle agréable dans l’interface.
Charger Questions CSV Quiz
Enfin, pour que le quiz commence avec la première question, le code suivant est utilisé :
self.q = self.question.load_question()
self.show_question()
self.btn_color = self.btn1.cget("bg")
self.buttons = [self.btn1, self.btn2, self.btn3, self.btn4]
L’instruction self.q = self.question.load_question() charge la première question du quiz, qui est ensuite affichée dans l’interface via self.show_question() . La couleur de fond par défaut du bouton btn1 est récupérée avec self.btn1.cget(« bg ») , ce qui permet de réinitialiser les couleurs des boutons après chaque question. Enfin, la liste self.buttons regroupe les boutons btn1 , btn2 , btn3 , et btn4 , facilitant ainsi leur gestion au cours du programme.
Affichage Questions & Réponses
Le fichier data.py est le composant responsable de l’extraction et de la gestion des questions de notre fichier CSV. Il agit comme le moteur qui alimente l’application en questions, permettant de les charger, de les structurer et de les préparer pour l’affichage dans l’interface utilisateur. Grâce à ce fichier, chaque question est lue, mélangée, et rendue unique pour chaque session de jeu, garantissant une expérience interactive et dynamique. Ce module contient des méthodes pour lire les données, mélanger les réponses et gérer l’affichage aléatoire des questions, contribuant ainsi à la fluidité et à l’efficacité du quiz.
Importation des modules nécessaires
Pour commencer, voyons comment le fichier data.py s’appuie sur des modules spécifiques pour fonctionner correctement :
import csv
import random
Avec :
- import csv :Importe le module csv qui permet de lire et de manipuler les fichiers CSV, utiles pour charger les questions du quiz.
- import random :Importe le module random qui est utilisé pour mélanger les réponses et choisir des questions de manière aléatoire.
Définition de la classe Question et Déclaration de l'attribut de classe list_questions
Passons maintenant à la définition de la classe Question, qui représente la structure de chaque question et contient les méthodes nécessaires pour gérer les questions du quiz ainsi Nous définissons un attribut de classe pour stocker toutes les questions chargées depuis le fichier CSV :
classQuestion():
list_questions = []
La déclaration class Question(): définit la classe Question , qui regroupe les attributs et méthodes essentiels pour gérer les questions du quiz. Une liste vide, list_questions , est ensuite initialisée pour stocker les objets Question chargés, facilitant ainsi la gestion et l’accès aux différentes questions du quiz.
Constructeur __init__
Ensuite, nous passons à la méthode d’initialisation de la classe, qui définit les attributs par défaut pour chaque instance de Question :
def__init__(self):
self.id = None
self.question = None
self.rep1 = None
self.rep2 = None
self.rep3 = None
self.rep4 = None
self.anecdote = None
self.reponse = None
La méthode __init__() agit comme un constructeur qui initialise chaque attribut de l’instance avec la valeur None . Les attributs id , question , rep1 , rep2 , rep3 , rep4 , anecdote , et reponse représentent, respectivement, l’identifiant de la question, le texte de la question, les différentes réponses possibles, l’anecdote associée, et la réponse correcte.
Méthode load_question
Voyons maintenant comment la méthode load_question permet de lire le fichier CSV, de charger les questions et de mélanger les réponses :
defload_question(self):
with open("questions.csv",encoding="utf-8") as csvfile:
reader = csv.reader(csvfile,delimiter=";",quotechar="'")
La ligne with open(« questions.csv », encoding= »utf-8″) as csvfile: ouvre le fichier questions.csv en mode lecture en utilisant l’encodage UTF-8, ce qui garantit une bonne lecture des caractères spéciaux. Ensuite, reader = csv.reader(csvfile, delimiter= »; », quotechar= »‘ ») crée un lecteur CSV qui utilise ; comme délimiteur de champs et ‘ comme caractère de citation, facilitant ainsi l’extraction des données structurées du fichier.
Boucle de lecture des questions
Nous lisons chaque ligne du fichier CSV et créons une instance de Question pour chaque entrée :
defload_question(self):
with open("questions.csv",encoding="utf-8") as csvfile:
reader = csv.reader(csvfile,delimiter=";",quotechar="'")
for item in reader:
q = Question()
q.id = item[0]
q.question = item[2]
q.rep1 = item[3]
q.rep2 = item[4]
q.rep3 = item[5]
q.rep4 = item[6]
q.anecdote = item[8]
q.reponse = item[3]
La boucle for item in reader parcourt chaque ligne du fichier CSV pour traiter les données ligne par ligne. Pour chaque ligne, une nouvelle instance q = Question() est créée, et les attributs de cette instance ( id , question , rep1 , rep2 , rep3 , rep4 , anecdote , et reponse ) sont ensuite remplis avec les données correspondantes de la ligne, facilitant ainsi le stockage structuré de chaque question du quiz.
Mélange des réponses
Pour que les réponses soient présentées dans un ordre aléatoire, nous utilisons la méthode random.sample et enfin, nous choisissons une question aléatoire dans la liste pour la retourner :
q.rep1, q.rep2, q.rep3, q.rep4 = random.sample([q.rep1, q.rep2,q.rep3,q.rep4],k=4)
self.list_questions.append(q)
q= random.choice(self.list_questions)
return q
La fonction random.sample([q.rep1, q.rep2, q.rep3, q.rep4], k=4) mélange aléatoirement les réponses d’une question, puis les réassigne aux attributs rep1 , rep2 , rep3 et rep4 de l’instance q pour les présenter dans un ordre différent. Ensuite, self.list_questions.append(q) ajoute cette instance q à la liste list_questions pour stocker toutes les questions chargées. Lorsqu’une question doit être sélectionnée, random.choice(self.list_questions) en choisit une aléatoirement dans la liste. Enfin, return q retourne l’instance de la question sélectionnée, prête à être affichée dans le quiz.
Méthode remove_question POO
La méthode suivante permet de retirer une question de la liste après qu’elle a été posée, pour éviter les répétitions :
defremove_question(self,q):
self.list_questions.remove(q)
la méthode remove_question(self, q) est définie pour supprimer une question spécifique de la liste des questions. Elle utilise self.list_questions.remove(q) pour retirer l’instance q de la liste list_questions , permettant ainsi de mettre à jour la liste en enlevant la question donnée.
Code Complet Quiz Tkinter
Le code suivant présente l’implémentation complète de la gestion des questions pour un quiz interactif. Il comprend la classe Question , qui contient les attributs nécessaires pour représenter chaque question ainsi que les réponses possibles. La méthode load_question() est utilisée pour lire les questions à partir d’un fichier CSV, les mélanger de manière aléatoire, et les charger dans une liste. Une fois les questions chargées, une question est sélectionnée de manière aléatoire pour être affichée à l’utilisateur. La méthode remove_question() permet de retirer une question de la liste après qu’elle ait été posée, assurant ainsi qu’aucune question ne soit répétée durant la session de quiz. Le code exploite les modules csv pour le traitement des fichiers et random pour la gestion aléatoire des questions et des réponses.
Voici l’implémentation complète du code :
import csv
import random
classQuestion():
list_questions = []
def__init__(self):
self.id = None
self.question = None
self.rep1 = None
self.rep2 = None
self.rep3 = None
self.rep4 = None
self.anecdote = None
self.reponse = None
defload_question(self):
with open("FR_1038/QuizGame/questions.csv",encoding="utf-8") as csvfile:
reader = csv.reader(csvfile,delimiter=";",quotechar="'")
for item in reader:
q=Question()
q.id = item[0]
q.question = item[2]
q.rep1 = item[3]
q.rep2 = item[4]
q.rep3 = item[5]
q.rep4 = item[6]
q.anecdote = item[8]
q.reponse = item[3]
q.rep1, q.rep2, q.rep3, q.rep4 = random.sample([q.rep1, q.rep2,q.rep3,q.rep4],k=4)
self.list_questions.append(q)
q= random.choice(self.list_questions)
return q
defremove_question(self,q):
self.list_questions.remove(q)
Méthodes Principales Fonctionnement
Après avoir défini les widgets et les attributs nécessaires, passons maintenant aux méthodes qui gèrent l’affichage des questions, la vérification des réponses et le passage à la question suivante :
Méthode show_question
La méthode show_question est essentielle pour mettre à jour l’interface utilisateur avec une nouvelle question et ses réponses :
def show_question( self ):
self.btn1.config( text =self.q.rep1)
self.btn2.config( text =self.q.rep2)
self.btn3.config( text =self.q.rep3)
self.btn4.config( text =self.q.rep4)
self.txt_question.config( text =self.q.question)
La méthode show_question(self) est responsable de l’affichage de la question actuelle ainsi que de ses réponses. Elle commence par configurer chaque bouton de réponse en assignant à chaque bouton (par exemple, btn1, btn2, etc.) une réponse spécifique en utilisant self.btn1.config(text=self.q.rep1), self.btn2.config(text=self.q.rep2), etc. Cela permet de rendre les réponses visibles sur les boutons correspondants. Ensuite, la méthode met à jour le champ de texte principal (self.txt_question) en configurant son texte pour afficher la question actuelle à l’aide de self.txt_question.config(text=self.q.question). Ainsi, cette méthode assure que la question et les réponses soient correctement affichées à l’utilisateur à chaque fois que celle-ci doit être présentée.
Méthode check_answer
Après l’affichage de la question, il est important de comprendre comment le programme gère les réponses de l’utilisateur c’est ce qui va être contrôler par La méthode check_answer, cette méthode joue un rôle central dans la vérification de la réponse sélectionnée par l’utilisateur et dans la mise à jour visuelle de l’interface :
defcheck_answer(self,button):
if button.cget("text") == self.q.reponse:
button.config(bg="LightGreen",state=DISABLED)
self.good_answer += 1
else:
button.config(bg="Tomato")
for btn in self.buttons:
btn.config(state=DISABLED)
if btn.cget("text") == self.q.reponse:
btn.config(bg="LightGreen")
self.question.remove_question(self.q)
self.txt_anectode.config(text=self.q.anecdote)
self.after(5000, self.next_question)
La méthode check_answer(self, button) est appelée lorsqu’un bouton de réponse est cliqué. Elle vérifie si le texte du bouton correspond à la bonne réponse. Si la réponse est correcte, le bouton devient vert et est désactivé, et le compteur de bonnes réponses est incrémenté. Si la réponse est incorrecte, le bouton devient rouge. Ensuite, tous les boutons sont désactivés et la bonne réponse est mise en surbrillance. La question est retirée de la liste pour éviter les répétitions, et l’anecdote associée est affichée. Après un délai de 5 secondes, la méthode passe à la question suivante. Une fois la réponse traitée, voyons comment l’application passe à la question suivante.
Méthode next_question
La méthode next_question gère la transition entre les questions et met à jour l’affichage des scores :
defnext_question(self):
self.question_number += 1
self.lbl_resultat.config(text="Question n° " +str(self.question_number) + "/10 " +str(self.good_answer) + " bonne(s) reponse(s)")
if self.question_number == 11:
msg = "Resultat " +str(self.good_answer) + " bonne(s) réponse(s) sur 10 questions\n Merci d'avoir joué à ce quiz."
messagebox.showinfo("Partie terminée", msg)
self.quit()
for btn in self.buttons:
btn.config(bg=self.btn_color,state=NORMAL)
self.txt_anectode.config(text="")
self.q = self.question.load_question()
self.show_question()
La méthode next_question(self) prépare l’interface pour la question suivante en incrémentant le numéro de la question. Elle met à jour l’affichage du numéro et du score. Si la dernière question est atteinte, un message de fin de quiz avec le score final est affiché, puis l’application se ferme. Ensuite, l’état des boutons est réinitialisé (ils deviennent cliquables et leur couleur de fond est rétablie). L’anecdote est effacée, une nouvelle question est chargée et la méthode show_question() est appelée pour afficher la question suivante.
Exécution principale du programme
Pour que le programme fonctionne, il doit être lancé correctement avec un point d’entrée défini :
if __name__ == "__main__":
quiz_interface = QuizInterface()
quiz_interface.mainloop()
La condition if __name__ == « __main__ »: vérifie que le fichier est exécuté directement, et non importé comme module. Si c’est le cas, une instance de la classe QuizInterface est créée. Ensuite, la méthode mainloop() est appelée pour démarrer la boucle principale de l’interface Tkinter, rendant ainsi l’application interactive.
Code Final du Jeu Quiz
En fin, voici le code complet qui permet de réaliser l’exercice demandé. Ce programme implémente un quiz interactif avec une interface graphique en utilisant Tkinter. Il gère l’affichage des questions, la vérification des réponses, le calcul du score et la transition entre les questions. Chaque méthode du programme joue un rôle essentiel dans l’expérience de l’utilisateur, depuis l’affichage de la question jusqu’à l’affichage du score final à la fin du quiz. Ce code offre une structure solide pour un jeu de quiz, tout en permettant une gestion fluide des réponses et un retour immédiat sur la performance de l’utilisateur.
from tkinter import *
from data import Question
import tkinter.messagebox as messagebox
classQuizInterface(Tk):
question = Question()
good_answer = 0
question_number = 1
def__init__(self):
super().__init__()
self.title("Quiz Game")
screen_width = self.winfo_screenwidth()
screen_height = self.winfo_screenheight()
w =int(screen_width/2 - 800/2)
h =int(screen_height/2 - 500/2)
self.geometry("800x500+" +str(w)+ "+" +str(h))
self.resizable(False,False)
self.lbl_resultat = Label(self,text="Question n° " +str(self.question_number) + "/10 " +str(self.good_answer) + " bonne(s) reponse(s)")
self.lbl_resultat.pack()
self.txt_question = Message(self,text="Une question ?",font=("Calibri", 16, "bold"),width=750)
self.txt_question.pack()
font_button = "Calibri 12"
self.frm1 = Frame(self)
self.frm1.pack(pady=20)
self.btn1 = Button(self.frm1,text="Reponse 1",font= font_button,width=30,height=5,command=lambda: self.check_answer(self.btn1))
self.btn1.pack(side=LEFT,padx=40)
self.btn2 = Button(self.frm1,text="Reponse 2",font= font_button,width=30,height=5,command=lambda: self.check_answer(self.btn2))
self.btn2.pack(side=LEFT,padx=40)
self.frm2 = Frame(self)
self.frm2.pack(pady=20)
self.btn3 = Button(self.frm2,text="Reponse 3",font= font_button,width=30,height=5,command=lambda: self.check_answer(self.btn3))
self.btn3.pack(side=LEFT,padx=40)
self.btn4 = Button(self.frm2,text="Reponse 4",font= font_button,width=30,height=5,command=lambda: self.check_answer(self.btn4))
self.btn4.pack(side=LEFT,padx=40)
self.txt_anectode = Message(self,font="Calibri 16",width=750)
self.txt_anectode.pack(side=BOTTOM,pady=20)
self.q = self.question.load_question()
self.show_question()
self.btn_color = self.btn1.cget("bg")
self.buttons = [self.btn1, self.btn2, self.btn3, self.btn4]
Exécuter Code Quiz Tkinter
Pour mieux illustrer le fonctionnement du programme, voici quelques figures montrant l’exécution finale de l’application. Ces images permettent de visualiser l’interface utilisateur, la présentation des questions, ainsi que l’interaction avec les boutons de réponse. Elles montrent également comment le score est mis à jour après chaque question et comment le programme réagit lorsque la dernière question est atteinte. Ces figures d’écran donnent un aperçu concret de l’expérience utilisateur et de l’efficacité du système de quiz en action.
Voici une capture d’écran montrant une question du quiz en cours. L’utilisateur a sélectionné la bonne réponse, « Du Beaujolais », qui est mise en évidence en vert, tandis que les autres options restent inchangées. En dessous de la question, l’anecdote associée à la réponse correcte est affichée pour enrichir l’expérience utilisateur.
Dans cet exemple, lorsque l’utilisateur sélectionne la réponse incorrecte « Le rouge », cette option est colorée en rouge pour indiquer l’erreur. La réponse correcte, « Le rosé », est mise en évidence en vert, permettant à l’utilisateur de reconnaître immédiatement la bonne réponse. Juste en dessous des options de réponse, une anecdote explicative s’affiche, ajoutant un contexte ou des informations supplémentaires pour enrichir la compréhension de la question. Cette explication aide l’utilisateur à apprendre de ses erreurs en offrant des détails qui peuvent corriger des idées fausses ou approfondir sa connaissance du sujet.
Comme il est montré dans la figure suivante, à la fin du jeu, le programme affiche le score obtenu par l’utilisateur. Par exemple, après avoir répondu aux questions, une fenêtre récapitulative apparaît pour indiquer le nombre de réponses correctes sur le total des questions posées. Cela permet à l’utilisateur de connaître sa performance globale et de recevoir un message de remerciement pour sa participation.
Formez-vous gratuitement avec Alphorm !
Maîtrisez les compétences clés en IT grâce à nos formations gratuites et accélérez votre carrière dès aujourd'hui.
FAQ
Comment créer un quiz interactif en Python ?
Comment structurer les données de questions et réponses ?
Comment améliorer l'expérience utilisateur dans un quiz ?
Comment utiliser la POO pour un projet de quiz ?
Quelles sont les contraintes techniques à respecter pour un quiz ?
Conclusion
En développant un quiz game avec Tkinter et la POO, vous pouvez offrir une expérience ludique et éducative aux utilisateurs. Quel aspect aimeriez-vous explorer davantage dans la création de jeux interactifs ?
