“The Fear of the Lord is the beginning of wisdom.

” Pro - 1:7

BLESSINGS INTERNATIONAL SR. SEC.

SCHOOL
Affiliated to CBSE, New Delhi (No. 1930991)
Blessings Nagar, Keerapakkam, Thirukalukundram, Chengalpattu – 603 109

QUIZ GAME WITH GUI

INVESTIGATORY PROJECT
SUBJECT: Computer Science

Subject Teacher Sign:

Principal Seal & Sign: Name: [Link]

Std: XII
Session: 2025 - 2026

1
 BLESSINGS INTERNATIONAL SR. SEC.
SCHOOL
Affiliated to CBSE, New Delhi – 1930991
Blessings Nagar, Keerapakkam, Thirukalukundram, Chengalpattu – 603 109

INVESTIGATORY PROJECT

Name : [Link]

Register No : 344 Year : 2025 - 2026

School : BLESSINGS INTERNATIONAL SR. SEC. SCHOOL

This is Certified to be the bonafide work of the student in this Investigatory Project and

submitted for the practical examination held on

at COMPUTER SCIENCE LABORATORY

……………………………. ………………………………

Principal / H. M Teacher – in –charge

Internal External Total

Practical Examination Marks

…………………………… ……………………………..

Internal Examiner External Examiner

2
 ACKNOWLEDGEMENT
With my sincere regards, I wish to acknowledge our indebtedness and
gratitude to the contributions of people who helped us at every stage of the
project. My deepest thanks to our Principal Mrs. Kiruba Princess and
Headmistress Mrs. Ponni Stephen for providing us all the facilities and kind
moral support for carrying out this project work.
It gives me a great sense of pleasure to present the report of the Project
Work. I owe special debt of gratitude to our Computer Science teacher
[Link] anitha for her constant support and guidance throughout my
work. It is only her cognizant efforts that my endeavours have seen light of
the day.
I would also like to thank our parents and friends who helped us a lot,
without their help and support it would not have been possible for us to

complete this project.

3
 ABSTRACT
Quiz Game Application is a Python-based educational game developed using
the Tkinter library to test users’ knowledge in two categories: atomic numbers of
chemical elements and Morse code. The application features a full-screen
graphical interface where users can enter their name, choose a quiz type, and
specify the number of questions. It randomly generates questions from predefined
datasets and provides instant feedback for each response. The quiz tracks the
user’s score and time taken, displaying a summary upon completion. It offers a
simple, interactive, and user-friendly experience with clear navigation and
engaging visuals. The project showcases essential programming concepts like
GUI development, data handling, and event-driven design. It is both educational
and entertaining, suitable for users of all ages. The application is lightweight and
designed for easy extension. Future improvements may include additional quiz
categories, difficulty levels, and score tracking features.

4
 INDEX

[Link]. CONTENTS PAGE

NO.
1. INTRODUCTION 6

2. PROPOSED SYSTEM 8

3. DEVELOPMENT PROCESS 8

3.1. SYSTEM REQUIREMENTS 8

i. HARDWARE REQUIREMENTS 8

ii. SOFTWARE REQUIREMENTS 8

iii. SOFTWARE ANALYSIS 8

3.2. SYSTEM DESIGN 11

A. FLOWCHART 12

4. IMPLEMENTATION AND SYSTEM TESTING 13

4.1. IMPLEMENTATION 13

4.2. TESTING 13

5. EXPLANATION 13

6. PYTHON PROGRAM 14

6.1. OUTPUT 21

7. CONCLUSION 24

8. BIBILOGRAPHY 24

A. BOOKS 24

B. ONLINE RESOURCES 24

5
1. INTRODUCTION:

The software Quiz Game Application is developed to provide an interactive and

educational platform for users to test their knowledge in specific subjects such as atomic
numbers and Morse code. It is a desktop-based application built using Python’s Tkinter
library, offering a visually appealing and user-friendly interface. This system is designed
for use in educational institutions, workshops, or personal learning environments where
users can engage in self-assessment without instructor supervision.

How does the Quiz Game Application work?

The application follows an event-driven programming model. When the user starts the
program, they are prompted to enter their name, choose the type of quiz, and select the
number of questions. The system then randomly generates questions from predefined
datasets and evaluates user responses in real time. It keeps track of the user's score and
time taken to complete the quiz.

After completion, a performance summary is displayed. The interface is designed for

smooth navigation, and the entire process is automated, making it efficient for individual
learning and practice sessions.

Here are the striking benefits of ATM:

PROBLEM DEFINITION:
Our project Quiz Game Application aims at developing a dynamic,
interactive, and user-friendly educational tool for learners of all age groups. It
offers a platform where users can test and improve their knowledge in specific
domains such as atomic numbers and Morse code without needing a teacher or
instructor. Traditionally, quizzes are conducted in classrooms or on paper, which
lack instant feedback and engagement. This system addresses those limitations by
providing instant evaluation, real-time scoring, and flexibility to choose topics
and number of questions, making learning more efficient and engaging.

6
1. Requirement Analysis.
The Quiz Game Application is designed to run as a desktop-based program
using Python’s Tkinter library. It requires basic hardware to support GUI
execution and doesn’t depend on the internet, ensuring accessibility even offline.
The system’s requirements were gathered by observing learning patterns and
needs of students and quiz enthusiasts, focusing on topics that are essential but
often overlooked, such as periodic elements and Morse code. These inputs helped
in building a system that is lightweight, simple to use, and effective in delivering
educational value.

2. System Design.
The Quiz Game Application is designed to maintain a balance between
simplicity and functionality. The interface is clean, colorful, and intuitive,
enabling users to navigate through the quiz with ease. Users are prompted step-
by-step—from entering their name, selecting quiz type, to choosing the number
of questions. The system dynamically displays questions, collects answers,
evaluates correctness, and finally shows performance with a score and time taken.
The design focuses on clarity, minimal clicks, and interactive learning, ensuring
smooth use even by children or first-time users.

3. Maintenance:
The Quiz Game Application enters a continuous improvement phase post-
development. Although it functions independently, issues such as bugs, UI glitches, or
updates to question datasets may arise over time and must be addressed. Maintenance
involves checking data accuracy, improving the GUI responsiveness, and potentially
expanding the quiz topics. The application’s backend is designed to be easily updatable,
ensuring that any modifications can be incorporated without altering the entire structure.
Regular updates can enhance the user experience and keep the content fresh and relevant..

7
2. PROPOSED SYSTEM:
The system provides an interactive, user-friendly platform for taking
quizzes and assessing knowledge efficiently. It offers instant feedback and tracks
performance for effective self-assessment.

 Users can choose between Atomic Number and Morse Code quizzes and set
the number of questions.
 The system provides instant feedback on answers, tracks total score and time
taken.
 It offers a performance summary at the end, with a user-friendly interface that
works offline.

3. DEVELOPMENT PROCESS:
3.1 SYSTEM REQUIREMENTS:
i. HARDWARE REQUIREMENTS:
a. Processor :- Intel Pentium 4 or later or compatible
b. RAM :- 1GB or more

c. Monitor :- SVGA colour monitor

d. Pointing device :- Touch pad or Keys

ii. SOFTWARE REQUIREMENTS:

a. Operating system:- Microsoft Windows XP
b. Programming language:- Python
c. Back end :- MYSQL SERVER

iii SOFTWARE ANALYSIS:

a. PYTHON:

8
 Python is an interpreted, object-oriented, high-level programming language
with dynamic semantics. Its high-level built in data structures, combined with
dynamic typing and dynamic binding, make it very attractive for Rapid
Application Development, as well as for use as a scripting or glue language to
connect existing components together.

Python's simple, easy to learn syntax emphasizes readability and therefore

reduces the cost of program maintenance. Python supports modules and packages,
which encourages program modularity and code reuse. The Python interpreter and
the extensive standard library are available in source or binary form without
charge for all major platforms, and can be freely distributed.

A source level debugger allows inspection of local and global variables,

evaluation of arbitrary expressions, setting breakpoints, stepping through the code
a line at a time, and so on. The debugger written in Python itself, testifying to
Python's introspective power. On the other hand, often the quickest way to debug
a program is to add a few print statements to the source: the fast edit-test-debug
cycle makes this simple approach very effective.

b. MYSQL SERVER:

MySQL is a relational database management system based on the Structured

Query Language, which is the popular language for accessing and managing the
records in the database. MySQL is open-source and free software under the GNU
license. It is supported by Oracle Company.

MySQL includes all topics of MySQL database that provides for how to
manage database and to manipulate data with the help of various SQL queries.
These queries are: insert , update , delete, select, create tables, drop tables, etc
9
c. MICROSOFT WINDOWS XP:

Microsoft Windows is a group of several proprietary graphical operating

systemfamilies developed and marketed by Microsoft. Each family caters to a
certain sector of the computing industry. For instance, Windows NT for
consumers, Windows Server for servers, and Windows IoT for embedded
systems. Defunct Windows families include Windows 9x, Windows Mobile, and
Windows Phone.

The first version of Windows was released on November 20, 1985, as a

graphical operating system shell for MS-DOS in response to the growing interest
in graphical user interfaces (GUIs).

Windows is the most popular desktop operating system in the world, with a
70% market share as of March 2023, according to StatCounter. However,
Windows is not the most used operating system when including both mobile and
desktop OSes, due to Android's massive growth. The next major version of
Windows NT, Windows XP, was released to manufacturing (RTM) on August
24, 2001 and to the general public on October 25, 2001. The introduction of
Windows XP aimed to unify the consumer- oriented Windows 9x series with the
architecture introduced by Windows NT, a change which Microsoft promised
would provide better performance over its DOS- based predecessors.

Windows XP would also introduce a redesigned user interface (including an

updated Start menu and a "task-oriented" Windows Explorer), streamlined
multimedia and networking features, Internet Explorer 6, integration with
Microsoft's .NET Passport services, a "compatibility mode" to help provide
backwards compatibility with software designed for previous versions of
10
Windows, and Remote Assistance [Link] retail, Windows XP was
marketed in two main editions: the "Home" edition was targeted towards
consumers, while the "Professional" edition was targeted towards business
environments and power users, and included additional security and networking
features. Home and Professional were later accompanied by the "Media Center"
edition (designed for home theater PCs, with an emphasis on support for DVD
playback, TV tuner cards, DVR functionality, and remote controls), and the
"Tablet PC" edition (designed for mobile devices meeting its specifications for a
tablet computer, with support for stylus pen input and additional pen-enabled
applications).

Mainstream support for Windows XP ended on April 14, 2009. Extended

support ended on April 8, 2014. After Windows 2000, Microsoft also changed its
release schedules for server operating systems; the server counterpart of Windows
XP, Windows Server 2003, was released in April 2003. It was followed in
December 2005, by Windows Server 2003 R2.

3.2 SYSTEM DESIGN

The system design outlines the architecture and flow of the quiz application to
ensure efficient, user-friendly interactions and smooth performance.

Architecture Overview:
The system follows a client-side application model that operates offline, with
Python handling the quiz logic and MySQL Server managing data storage
(questions, answers, user scores).

Key Components:
 UserInterface:
A simple and intuitive interface allowing users to select quiz types, choose
the number of questions, and receive instant feedback on their answer.

11
  Quiz Engine:
Handles quiz generation, randomizes questions, validates user inputs,
tracks the score, and measures the time taken.
 Feedback & Results Module:
Provides real-time feedback (correct/wrong) for each question and displays
a detailed summary at the end, including total score and performance
statistics.
 DataStorage:
Uses MySQL to store quiz questions, correct answers, and user
performance data, facilitating easy updates and future scalability.

Workflow:
 User selects quiz type and number of questions.
 The system fetches the relevant questions from the database.
 User attempts each question with immediate feedback after every response.
 The system tracks score and time throughout the quiz.
 At the end, a performance summary is displayed.
A. FLOWCHART

12
4. IMPLEMENTATION AND SYSTEM TESTING:
4.1 IMPLEMENTATION
The development of the Quiz Application follows standard software engineering
practices and modular design principles. The system is divided into multiple
components such as the user interface, quiz engine, feedback system, and database
integration. Each component is developed individually as a standalone unit.

During implementation, Python is used to handle the logic, while MySQL Server
is used for backend data storage. Each module is thoroughly tested for functionality
during development—this process is known as Unit Testing. Unit Testing ensures that
every part of the system performs its intended function before integration into the full
application.
4.2 TESTING
The Quiz Application undergoes various types of testing to ensure quality,
reliability, and a smooth user experience. The goal is to detect and fix any bugs,
performance issues, or logical errors before deployment.
Key Testing Steps:
 Test Plan Creation
 Cross-Platform Execution
 Debugging and Optimization

5. EXPLANATION:

This project is a Python-based Quiz Application designed to help users

assess their knowledge in a fun, interactive, and offline environment. The system
allows users to choose between two quiz types: Atomic Numbers and Morse
Code, based on their interest or learning focus. Users can also set the number of
questions they wish to attempt, giving them control over the quiz length.
Once the quiz starts, questions are displayed one by one, and users receive instant

13
feedback after each response, indicating whether their answer is correct or
incorrect. The application keeps track of the total score and the time taken, and
presents a performance summary at the end of the quiz to help users understand
their progress.

The front-end interface is simple and easy to navigate, making it suitable

for all age groups. The back-end is handled by MySQL, which stores quiz
questions, answers, and possibly user performance data.

6. PYTHON PROGRAM:

import tkinter as tk
import random
import time

# Full Atomic Data

atomic_data = {
"Hydrogen": 1, "Helium": 2, "Lithium": 3, "Beryllium": 4, "Boron": 5,
"Carbon": 6, "Nitrogen": 7, "Oxygen": 8,
"Fluorine": 9, "Neon": 10, "Sodium": 11, "Magnesium": 12, "Aluminium": 13,
"Silicon": 14, "Phosphorus": 15,
"Sulfur": 16, "Chlorine": 17, "Argon": 18, "Potassium": 19, "Calcium": 20,
"Scandium": 21, "Titanium": 22,
"Vanadium": 23, "Chromium": 24, "Manganese": 25, "Iron": 26, "Cobalt": 27,
"Nickel": 28, "Copper": 29,
"Zinc": 30, "Gallium": 31, "Germanium": 32, "Arsenic": 33, "Selenium": 34,
"Bromine": 35, "Krypton": 36,
"Rubidium": 37, "Strontium": 38, "Yttrium": 39, "Zirconium": 40, "Niobium":
41, "Molybdenum": 42,
"Technetium": 43, "Ruthenium": 44, "Rhodium": 45, "Palladium": 46, "Silver":
47, "Cadmium": 48, "Indium": 49,
"Tin": 50, "Antimony": 51, "Tellurium": 52, "Iodine": 53, "Xenon": 54,
"Caesium": 55, "Barium": 56,
"Lanthanum": 57, "Cerium": 58, "Praseodymium": 59, "Neodymium": 60,
"Promethium": 61, "Samarium": 62,
"Europium": 63, "Gadolinium": 64, "Terbium": 65, "Dysprosium": 66,
"Holmium": 67, "Erbium": 68, "Thulium": 69,
14
 "Ytterbium": 70, "Lutetium": 71, "Hafnium": 72, "Tantalum": 73, "Tungsten":
74, "Rhenium": 75, "Osmium": 76,
"Iridium": 77, "Platinum": 78, "Gold": 79, "Mercury": 80, "Thallium": 81,
"Lead": 82, "Bismuth": 83,
"Polonium": 84, "Astatine": 85, "Radon": 86, "Francium": 87, "Radium": 88,
"Actinium": 89, "Thorium": 90,
"Protactinium": 91, "Uranium": 92, "Neptunium": 93, "Plutonium": 94,
"Americium": 95, "Curium": 96,
"Berkelium": 97, "Californium": 98, "Einsteinium": 99, "Fermium": 100,
"Mendelevium": 101, "Nobelium": 102,
"Lawrencium": 103, "Rutherfordium": 104, "Dubnium": 105, "Seaborgium":
106, "Bohrium": 107, "Hassium": 108,
"Meitnerium": 109, "Darmstadtium": 110, "Roentgenium": 111,
"Copernicium": 112, "Nihonium": 113,
"Flerovium": 114, "Moscovium": 115, "Livermorium": 116, "Tennessine": 117,
"Oganesson": 118
}

# Full Morse Code

morse_data = {
'A': '.-', 'B': '-...', 'C': '-.-.', 'D': '-..', 'E': '.', 'F': '..-.', 'G': '--.', 'H': '....',
'I': '..', 'J': '.---', 'K': '-.-', 'L': '.-..', 'M': '--', 'N': '-.', 'O': '---', 'P': '.--.',
'Q': '--.-', 'R': '.-.', 'S': '...', 'T': '-', 'U': '..-', 'V': '...-', 'W': '.--', 'X': '-..-',
'Y': '-.--', 'Z': '--..', '0': '-----', '1': '.----', '2': '..---', '3': '...--', '4': '....-',
'5': '.....', '6': '-....', '7': '--...', '8': '---..', '9': '----.'
}

class QuizApp:
def __init__(self, root):
[Link] = root
[Link]("Quiz Game")
[Link]("-fullscreen", True)
[Link](bg="white")

self.user_name = ""
self.quiz_type = ""
self.num_questions = 5
[Link] = 0
15
 self.current_question = 0
self.correct_answer = ""
[Link] = []
self.start_time = 0
self.started_typing = False

self.init_home_screen()

def clear_screen(self):
for widget in [Link].winfo_children():
[Link]()

def add_exit_button(self):
exit_btn = [Link]([Link], text="❌ Exit", font=("Arial", 16), bg="red",
fg="white",
command=[Link])
exit_btn.pack(side="bottom", anchor="w", padx=10, pady=10)

def init_home_screen(self):
self.clear_screen()

[Link]([Link], text="Welcome to the Quiz Game!", font=("Arial", 40),

bg="white").pack(pady=50)
[Link]([Link], text="Enter your name:", font=("Arial", 28),
bg="white").pack(pady=20)

self.name_entry = [Link]([Link], font=("Arial", 24), bg="#D0E6FF",

justify="center")
self.name_entry.pack(ipady=10, ipadx=20)
self.name_entry.bind("<Return>", lambda e: self.goto_quiz_selection())

self.add_exit_button()

def goto_quiz_selection(self):
self.user_name = self.name_entry.get().strip()
if not self.user_name:
return
self.clear_screen()
16
 [Link]([Link], text=f"Hello {self.user_name}! Choose your quiz:",
font=("Arial", 32), bg="white").pack(pady=60)

[Link]([Link], text="❌ Atomic Number Test", font=("Arial", 24),

bg="#007BFF", fg="white",
command=lambda: self.ask_question_count("atomic")).pack(pady=20,
ipadx=30, ipady=10)

[Link]([Link], text="❌ Morse Code Test", font=("Arial", 24),

bg="#007BFF", fg="white",
command=lambda: self.ask_question_count("morse")).pack(pady=20,
ipadx=30, ipady=10)

self.add_exit_button()

def ask_question_count(self, quiz_type):

self.quiz_type = quiz_type
self.clear_screen()

[Link]([Link], text="How many questions do you want?", font=("Arial",

28), bg="white").pack(pady=60)

self.count_entry = [Link]([Link], font=("Arial", 24), justify="center",

bg="#D0E6FF")
self.count_entry.pack(ipady=10, ipadx=20)
self.count_entry.bind("<Return>", lambda e: self.start_quiz_setup())

self.add_exit_button()

def start_quiz_setup(self):
try:
count = int(self.count_entry.get())
if count <= 0:
return

except ValueError:

17
return
self.num_questions = count
[Link] = 0
self.current_question = 0
self.started_typing = False
self.start_time = None

if self.quiz_type == "atomic":
items = list(atomic_data.items())
[Link](items)
[Link] = [{"q": f"What is the atomic number of {el}?", "a":
str(num)} for el, num in items[:count]]
else:
items = list(morse_data.items())
[Link](items)
[Link] = [{"q": f"What is the Morse code for '{char}'?", "a": code}
for char, code in items[:count]]

self.start_quiz()

def start_quiz(self):
self.clear_screen()

self.question_label = [Link]([Link], text="", font=("Arial", 36),

bg="white", wraplength=1200)
self.question_label.pack(pady=100)

self.answer_entry = [Link]([Link], font=("Arial", 28), justify="center",

bg="#D0E6FF")
self.answer_entry.pack(ipady=10, ipadx=20)
self.answer_entry.bind("<KeyRelease>", self.check_answer)

self.timer_label = [Link]([Link], text="Time: 0s", font=("Arial", 20),

bg="white", fg="gray")
self.timer_label.pack(pady=30)

self.feedback_label = [Link]([Link], text="", font=("Arial", 24),

bg="white")
18
 self.feedback_label.pack()

[Link]([Link], text="Skip", font=("Arial", 20), bg="#007BFF",

fg="white", command=self.skip_question).pack(pady=30)

self.add_exit_button()
self.update_timer()
self.display_question()

def display_question(self):
if self.current_question < len([Link]):
q = [Link][self.current_question]
self.correct_answer = q["a"]
self.question_label.config(text=f"Q{self.current_question + 1}: {q['q']}")
self.answer_entry.delete(0, [Link])
self.feedback_label.config(text="")
self.started_typing = False
else:
self.show_results()

def check_answer(self, event):

user_input = self.answer_entry.get().strip()
if not user_input:
return

if self.start_time is None:
self.start_time = [Link]() # start timer at first typing

# For Morse code quiz, answer must match exactly

if self.quiz_type == "morse":
if user_input == self.correct_answer:
[Link] += 1
self.feedback_label.config(text="Correct! ❌", fg="green")
self.current_question += 1
[Link](800, self.display_question)
else:
# Atomic quiz: allow numeric string exact match
19
 if user_input == self.correct_answer:
[Link] += 1
self.feedback_label.config(text="Correct! ❌", fg="green")
self.current_question += 1
[Link](800, self.display_question)

def skip_question(self):
self.current_question += 1
self.display_question()

def update_timer(self):
if self.start_time is None:
elapsed = 0

else:
elapsed = int([Link]() - self.start_time)
self.timer_label.config(text=f"Time: {elapsed}s")
if self.current_question < len([Link]):
[Link](1000, self.update_timer)

def show_results(self):
self.clear_screen()

percent = ([Link] / self.num_questions) * 100

total_time = 0 if self.start_time is None else int([Link]() - self.start_time)

result_text = f"""
Quiz Completed!

Name: {self.user_name}

Quiz Type: {'Atomic Number' if self.quiz_type == 'atomic' else 'Morse Code'}

Your Score: {[Link]} / {self.num_questions}

Percentage: {percent:.2f}%

Time Taken: {total_time} seconds

20
"""

[Link]([Link], text=result_text, font=("Arial", 32), bg="white",

justify="center").pack(pady=50)

# Back to Home button

[Link]([Link], text="❌ Back to Home", font=("Arial", 20),
bg="#007BFF", fg="white",
command=self.init_home_screen).pack(pady=20)

# Exit button
self.add_exit_button()

def main():
root = [Link]()
app = QuizApp(root)
[Link]()
if __name__ == "__main__":
main()

6.1 OUTPUT

21
22
23
7. CONCLUSION:
The quiz application effectively delivers an interactive and offline platform
for users to assess their knowledge on topics like Atomic Numbers and Morse
Code. With a simple and user-friendly interface, it caters to all age groups and
ensures ease of use. The system offers instant feedback, tracks scores and time,
and provides a comprehensive summary at the end of each quiz, enhancing the
overall learning experience. Developed using Python and MySQL, the
application ensures smooth performance and efficient data handling. A modular
development approach allowed for focused unit testing and easier debugging.
The application was thoroughly tested for functionality, reliability, and
responsiveness across systems. All core features were implemented successfully,
meeting the project's objectives. The tool serves as a reliable self-assessment
resource without the need for internet connectivity. Future improvements could
include expanding quiz topics and incorporating user progress tracking for better
engagement.

8. BIBLIOGRAPHY:

[Link] :
i. NCERT Computer Science: Textbook For Class XI Link:
[Link]

ii. NCERT Computer Science: Textbook For Class XII Link:

[Link]

[Link] RESOURCES:

i. Scribd
Link: [Link]
Mini-Project ]

24
ii. Python:
Link: [Link]

iii. Windows XP:

Link: [Link]
us/Download/[Link]?id=18242
iv. MYSQL Server:
Link:[Link]
dium=ads&utm_term=mysql%20
hosting&gclid=Cj0KCQiAsburBhCIARIsAExmsu5s34WtjbtZofAtwZ
8pgHnKf8JDdRYZivl1O9t5Jc1S4fJHZS7GUOQaAvnUEALw_wc

25
26