Y. B.

PATIL POLYTECHNIC, AKURDI PUNE

SUBMITTED TO
MAHARASHTRA BOARD OF TECHNICAL EDUCTAION

Programming with Python

(22616)

Report On
ENGLISH DICTIONARY USING PYTHON

Under Guidance Of

Mrs. Pooja Ahuja

Diploma in Computer Engineering

2024 – 2025 (Semester– 6)

Y. B. Patil Polytechnic, Akurdi, Pune

Third Year, Department of Computer Engineering

 MAHARASHTRA STATE BOARD OF TECHNICAL EDUCATION

CERTIFICATE
This is to certify that
Sr.No Roll No. Name Enrollment No.

1. Y-B3304 Kamlesh Chandna 2101340125

2. Y-B3307 Prathamesh Gade 2101340127

3. Y-B3344 Mayank Bansal 2201340197

of Sixth Semester Diploma in Computer Engineering Section B in Y. B. Patil

Polytechnic, Akurdi has completed the Micro Project satisfactory in Subject

PWP for the academic Year 2024 – 2025 as prescribed in the MSBTE

Curriculum.

Subject Teacher HOD Principal

Mrs. Pooja Ahuja Mrs. Pooja Ahuja Dr. A. S. Kondekar
 ACKNOWLEDGEMENT

We would like to express our special thanks of gratitude to Mrs. Pooja Ahuja
who gave us a golden opportunity to showcase and let us learn more about our
topic i. e.“English Dictionary Using Python” and also taught us the way to work
in team. We would also like to Underscore dynamic efforts of the team work,
and their expert’s advice to complete this project in time.

Date: Place:- Akurdi, Pune

 INDEX

Sr. No. Content Page. No.

01 Introduction 01

02 Project scope 02

03 Mythology 03

04 Code 06

05 Output 11

06 Use Cases 13

08 Advantages &disadvantages 14

09 References 15

10 Conclusion 16
 INTRODUCTION

The English Dictionary Project is a foundational Python application designed to

manage a personalized dictionary with persistent data storage in a JSON file. It offers
essential functionalities including word lookup, addition of new entries with
definitions, updating existing definitions, deleting words, listing all stored entries, and
importing predefined word sets to quickly populate the dictionary. The application
leverages standard Python libraries such as json, os, and difflib to perform file
operations, manage persistent data, and enhance user experience by suggesting closely
matched words in cases of misspellings.
The project is structured following Object-Oriented Programming (OOP) principles,
promoting modularity, reusability, and better code organization. Core features are
encapsulated within a Dictionary class, which defines methods for performing
various dictionary operations. Users interact with the application through a simple,
menu-driven command-line interface that emphasizes usability and intuitive
navigation.
This project demonstrates key Python programming concepts such as file handling,
error management, user input validation, and the use of persistent storage. By
developing and interacting with this application, learners and developers can
strengthen their understanding of Python’s core features while creating a practical,
functional tool. The English Dictionary Project, though simple in design, provides a
robust learning experience and serves as a solid foundation for more advanced
applications in software development.
 Project Scope
➢ Word Lookup:
Allow users to search for the meaning of words stored in the dictionary,
including handling case-sensitive inputs and providing close matches
for misspelled words.

➢ Adding New Words:

Enable users to add new words along with their definitions to the
dictionary, ensuring that the data is saved for future use.

➢ Updating Word Definitions:

Provide the ability to update definitions of existing words, allowing
users to correct or improve descriptions.

➢ Deleting Words:
Allow users to delete words from the dictionary if they are no longer
needed or are mistakenly added.

➢ Listing All Words:

Provide a feature to display all stored words in alphabetical order, making
browsing easier.

➢ Importing Sample Words:

Include functionality for importing predefined words and their
definitions to quickly populate the dictionary.

➢ Persistent Storage:
Store the dictionary data in a JSON file, ensuring that all changes are
saved even after the program is closed.

➢ User-Friendly Interface:
Implement a simple menu-driven interface that is easy to navigate and
use through the command line.

➢ Error Handling:
Handle common errors like file reading issues, JSON decoding
problems, and invalid user inputs gracefully.
 METHODOLOGY

1. Requirement Analysis:

• Identify the core functionalities required for the dictionary

application, including word lookup, addition, updating, deletion, and
listing.
• Determine the need for persistent data storage using a JSON file.
• Plan for error handling and user-friendly interaction.
2. Designing the System:

• Implement an Object-Oriented Programming (OOP) approach using a

Dictionary class.
• Define methods for each functionality, such as lookup_word(),
add_word(), update_word(), delete_word(), etc.
• Design a simple text-based menu-driven interface for user interaction.
3. Developing the Application:

• Write Python code to define the Dictionary class and implement

methods for all required functionalities.
• Use the json module for reading and writing data to a JSON file.
• Utilize the difflib module to provide close matches for misspelled words.
• Implement file handling techniques to manage dictionary files effectively.
4. Testing and Debugging:

• Test each functionality individually, including word addition,

deletion, update, lookup, and importing sample words.
• Check the application’s behavior when dealing with invalid inputs
or file access issues.
• Test the program’s performance with a large number of words.
5. User Interface Improvement:

• Make the command-line interface intuitive and easy to navigate.

• Provide informative messages for each operation (e.g., “Word added
successfully,” “Word not found,” etc.).
6. Implementation of Data Persistence:
 • Ensure the dictionary data is saved to a JSON file whenever modifications are
made.
• Verify that the application correctly loads existing data when restarted.

7. Error Handling:

• Implement error handling for file reading, writing, and invalid user inputs.
• Provide meaningful error messages to guide the user.
8. Final Testing and Optimization:

• Conduct thorough testing to ensure the program functions as intended.

• Optimize the code for efficiency and readability.
9. Documentation:

• Prepare clear documentation explaining how the program works and

how to use each feature.
• Provide detailed comments within the code for better
understanding and future improvements.
10.Deployment:

• Prepare the application for distribution as a standalone Python program.

• Ensure the JSON file is created if it does not exist during the program’s
execution.
 • Verify that the application correctly loads existing data when restarted.

11.Error Handling:

• Implement error handling for file reading, writing, and invalid user inputs.
• Provide meaningful error messages to guide the user.
12.Final Testing and Optimization:

• Conduct thorough testing to ensure the program functions as intended.

• Optimize the code for efficiency and readability.
13.Documentation:

• Prepare clear documentation explaining how the program works and

how to use each feature.
• Provide detailed comments within the code for better
understanding and future improvements.
14. Deployment:

• Prepare the application for distribution as a standalone Python program.

• Ensure the JSON file is created if it does not exist during the program’s
execution.
 CODE
import json
import os
from difflib import get_close_matches

class Dictionary:
def _init_(self, dictionary_file="dictionary.json"):
self.dictionary_file = dictionary_file
self.dictionary = self.load_dictionary()

def load_dictionary(self):
"""Load dictionary from JSON file or create new if not exists"""
if os.path.exists(self.dictionary_file):
try:
with open(self.dictionary_file, 'r') as file:
return json.load(file)
except json.JSONDecodeError:
print(f"Error reading dictionary file. Creating new dictionary.")
return {}
else:
print(f"Dictionary file not found. Creating new dictionary.")
return {}

def save_dictionary(self):
"""Save dictionary to JSON file"""
with open(self.dictionary_file, 'w') as file:
json.dump(self.dictionary, file, indent=4)
print(f"Dictionary saved to {self.dictionary_file}")
def lookup_word(self, word):
"""Look up a word in the dictionary"""
word = word.lower()

if word in self.dictionary:
return self.dictionary[word]
elif word.title() in self.dictionary:
return self.dictionary[word.title()]
elif word.upper() in self.dictionary:
return self.dictionary[word.upper()]
else:
# Find close matches
close_matches = get_close_matches(word, self.dictionary.keys(), n=3, cutoff=0.6)
if close_matches:
yn = input(f"Did you mean {close_matches[0]}? (Y/N): ")
if yn.lower() == 'y':
return self.dictionary[close_matches[0]]
else:
return f"Word '{word}' not found in dictionary."
else:
return f"Word '{word}' not found in dictionary."

def add_word(self, word, definition):

"""Add a new word to the dictionary"""
word = word.lower()
self.dictionary[word] = definition
self.save_dictionary()
return f"Word '{word}' added to dictionary."
def update_word(self, word, definition):
"""Update the definition of a word"""
word = word.lower()
if word in self.dictionary:
self.dictionary[word] = definition
self.save_dictionary()
return f"Definition of '{word}' updated."
else:
return f"Word '{word}' not found in dictionary."

def delete_word(self, word):

"""Delete a word from the dictionary"""
word = word.lower()
if word in self.dictionary:
del self.dictionary[word]
self.save_dictionary()
return f"Word '{word}' deleted from dictionary."
else:
return f"Word '{word}' not found in dictionary."

def all_words(self):
"""Return a list of all words in the dictionary"""
return sorted(self.dictionary.keys())

def import_words(self, word_list):

"""Import a list of words and definitions"""
count = 0
for word, definition in word_list.items():
self.dictionary[word.lower()] = definition
count += 1
 self.save_dictionary()
return f"{count} words imported to dictionary."

def display_menu():
print("\n===== English Dictionary =====")
print("1. Look up a word")
print("2. Add a new word")
print("3. Update a word")
print("4. Delete a word")
print("5. List all words")
print("6. Import sample words")
print("7. Exit")
print("============================")

def import_sample_words(dictionary):
sample_words = {
"apple": "A round fruit with red, green, or yellow skin and a white flesh.",
"book": "A written or printed work consisting of pages bound together.",
"computer": "An electronic device capable of storing and processing data.",
"dictionary": "A book or electronic resource that lists words and their meanings.",
"elephant": "A very large animal with a long trunk and tusks.",
}
return dictionary.import_words(sample_words)

def main():
dictionary = Dictionary()

while True:
display_menu()
choice = input("Enter your choice (1-7): ")
if choice == '1':
word = input("Enter word to look up: ")
result = dictionary.lookup_word(word)
print(f"\nDefinition: {result}")

elif choice == '2':

word = input("Enter new word: ")
definition = input("Enter definition: ")
print(dictionary.add_word(word, definition))

elif choice == '3':

word = input("Enter word to update: ")
definition = input("Enter new definition: ")
print(dictionary.update_word(word, definition))

elif choice == '4':

word = input("Enter word to delete: ")
print(dictionary.delete_word(word))

elif choice == '5':

words = dictionary.all_words()
print("\nAll Words in Dictionary:")
for i, word in enumerate(words, 1):
print(f"{i}. {word}")

elif choice == '6':

print(import_sample_words(dictionary))

elif choice == '7':

 print("Thank you for using English Dictionary. Goodbye!")
break

else:
print("Invalid choice. Please try again.")

if _name_ == "_main_":
main()
OUTPUT
 USE CASES

• The English Dictionary Project offers a range of practical applications

that cater to a diverse group of users, including students, educators,
language enthusiasts, content creators, and software developers. Its
versatility and ease of use make it an effective tool for both educational
and personal purposes.

• For students, the application serves as a valuable self-learning resource. It

enables quick access to word definitions, helping users expand their
vocabulary and reinforce language comprehension. The inclusion of a
suggestion feature for closely matched words also supports improved spelling
and word recognition, particularly benefiting non-native speakers who may
face challenges with pronunciation and spelling accuracy.
• Writers and content creators can leverage the dictionary as a convenient,
offline reference tool for verifying word meanings or enriching their personal
lexicon. The ability to add custom entries makes it ideal for maintaining
specialized vocabularies, including technical jargon, domain-specific terms,
or even fictional words for creative writing projects. Over time, users can
build a tailored dictionary that aligns with their unique writing needs.
• Educators can use the project as an interactive teaching aid. By importing
subject-specific vocabulary lists, they can provide students with targeted
definitions relevant to coursework. Teachers can also encourage learners to
expand the dictionary collaboratively as new terms are introduced, fostering
engagement and reinforcing retention. Furthermore, the application can be
adapted for exercises such as vocabulary quizzes, matching activities, or
spelling assessments.
• From a developer’s perspective, the project serves as an excellent foundation
for building more advanced dictionary applications. Its modular and object-
oriented design allows for easy extension of features, such as integrating
synonyms, antonyms, pronunciation guides, multilingual support, and API-
based translations. The project also provides a practical opportunity to
explore essential Python concepts including file handling, persistent storage,
user input validation, and command-line interface design.
• Finally, casual users can benefit by maintaining their own personalized
dictionaries for hobbies, language learning, or tracking terminology in
specialized fields. The application offers a simple and efficient way to store,
retrieve, and manage vocabulary without relying on an internet connection.
 ADVANTAGES

1. Simple and User-Friendly: The application provides a straightforward

interface where users can easily look up, add, update, and delete words,
making it beginner-friendly.
2. Customizable Dictionary: Users can personalize their dictionary by
adding new words and definitions, making it useful for specialized topics or
creative writing.
3. Offline Access: Since the dictionary data is stored locally as a JSON file, it
doesn't require an internet connection to function.
4, Scalability: The program can be extended with additional features like
synonyms, antonyms, and pronunciation without major restructuring.
5. Error Handling & Suggestions: The use of get_close_matches() helps
suggest words when users misspell them, improving user experience.

DISADVANTAGES
1. Limited Search Functionality: The program only supports exact matches
or suggestions based on close matches, lacking advanced search features.
2. No Synonym or Antonym Support: Unlike comprehensive dictionaries, this
project lacks support for related words like synonyms and antonyms.
3. JSON File Vulnerability: If the JSON file gets corrupted or deleted, all
saved words will be lost, causing inconvenience.
4. No Multi-User Support: The application is designed for individual use, and
collaborative dictionary building is not supported.
5. Basic User Interface: The command-line interface may not be appealing
to users who prefer graphical interfaces.
 REFERNCES

• https://docs.python.org/3/library/json.html
• https://www.w3schools.com/python/python_file_handling.asp
• https://docs.python.org/3/library/difflib.html
• https://realpython.com/comparing-python-command-line-parsing-libraries/
• https://www.json.org/json-en.html
• https://docs.python.org/3/library/json.html
• https://www.w3schools.com/python/python_file_handling.asp
 CONCLUSION

The English Dictionary Project in Python is a simple yet effective implementation of

a text-based dictionary application that showcases fundamental programming
principles. It demonstrates key concepts such as file handling, persistent data storage
using JSON, error management, and user interaction through a command-line
interface. With core functionalities including word lookup, addition, updating, and
deletion, the application serves as a solid foundation for further development and
customization.
This project not only reinforces essential Python programming skills but also provides
practical experience in building interactive and data-driven applications. Potential
enhancements—such as the integration of synonyms and antonyms, support for
multiple users, and the addition of a graphical user interface (GUI)—would
significantly broaden its usability and appeal.
Overall, the English Dictionary Project offers a valuable learning opportunity for
developers and learners alike, combining core technical skills with hands-on
experience in creating functional, user-centric software solutions.