PYTHON PROGRAMMING

A INTERNSHIP REPORT

Submitted in the partial fulfillment of requirements to

Summer Internship (CS- 353)
III/IV B.Tech (V Semester)
Submitted By
KARTHIK BUDATI ( L23CS202 )

October, 2024
R.V.R. & J.C. COLLEGE OF ENGINEERING

(Autonomous)
(Affiliated to Acharya Nagarjuna University)
Chandramoulipuram :: Chowdavaram
GUNTUR – 522 019

i
INTERNSHIP CERTIFICATE

ii
 ACKNOWLEDGEMENT
The successful completion of any task would be incomplete without proper
suggestions, guidance and environment. Combination of these three factors acts like
backbone to our Internship “PYTHON PROGRAMMING ”.
We would like to express our profound gratitude to Dr.M.Sreelatha, Head of
the Department of Computer Science and Engineering and Dr. Kolla Srinivas,
Principal, for their encouragement and support to carry out this Internship
successfully.
We are very much thankful to CODSOFT PVT LTD., for having allowed us to
conduct the study needed for the Internship.
Finally we submit our heartfelt thanks to all the staff in the Department of
Computer Science and Engineering and to all our friends for their cooperation during
the Internship work.
KARTHIK BUDATI( L23CS202 )

iii
 ABSTRACT
During my Python programming internship, I worked extensively on
developing GUI-based applications, particularly focusing on task management and
interactive tools. My primary project involved creating a task management application
using Python’s Tkinter and CTkinter frameworks. This application allowed users to
efficiently organize and track their tasks through a user-friendly interface. Exploring
both Tkinter and CustomTkinter provided valuable insights into the versatility of
Python in GUI development, including customization, user input handling, and layout
management.
Beyond task management, I developed several additional projects aimed at
improving my understanding of Python’s broader capabilities. One such project was a
Rock-Paper-Scissors game, which introduced me to event handling and user
interaction in games. I also created a password generator that enhanced my skills in
algorithm design and randomization techniques, allowing users to generate secure
passwords. Additionally, I built a command-line calculator, which further solidified
my experience in developing tools that serve practical purposes.
These projects gave me a well-rounded understanding of Python’s capabilities,
particularly in creating interactive and functional applications. Throughout the
internship, I gained valuable problem-solving skills, improved my coding efficiency,
and deepened my understanding of GUI .

iv
 CONTENTS
Page No.
Title Page i
Certificate ii
Acknowledgement iii
Abstract iv
Contents v
List of Figures vii
1 Introduction 1
1.1 Introduction to the Python GUI Frameworks 1
1.1.1 Task Management System Using Python GUI 3
1.1.2 Command-Line Calculator 4
1.1.3 Password Generator Application 4
1.2 Problem definition 5
1.3 Significance of the work 5
2 System Analysis 7
2.1 Requirements Specification 7
2.1.1 Functional Requirements 7
2.1.2 Non-Functional Requirements 8
3 System Design 9
3.1 Architecture of the proposed system 9
3.2 Workflow of the proposed system 9
3.3 Module Description 10
4 Implementation 12
4.1 Development Environment 12
4.2 Code Structure 12
4.3 Challenges Faced 14
5 Code Snippets 15
5.1 Task Management Systems 15
5.2 Command-Line Calculator 18
5.3 Password Generator Application 18
6 Result Analysis 19
6.1 Actual Results obtained from the work 19

v
 6.2 Analysis of the results obtained 21
7 Testing 23
7.1 Testing Methodologies 23
7.2 Testing of Individual Applications 23
7.3 Summary of Testing Results 24
8 Conclusion and Future Work 26
9 References 27

vi
 LIST OF FIGURES
S.No Fig No. Figure Description Page No.
1 6.1 Todo-List Output 19
2 6.2 Calculator Output 20
3 6.3 Password Generator Output 20

vii
 1. Introduction
The increasing demand for interactive and user-friendly applications in
today’s digital world has made graphical user interfaces (GUIs) a vital component of
software development. Python, a versatile programming language, offers various
libraries and frameworks for building robust GUIs. Two of the most popular
frameworks in Python for GUI development are Tkinter and CustomTkinter. These
frameworks provide developers with the tools to create applications that allow users
to interact seamlessly with the underlying program, improving the overall user
experience. During my internship, I explored these frameworks to develop interactive
applications, including a task management system, a command-line calculator, a
password generator, and a rock-paper-scissors game.
1.1 Introduction to the Python GUI Frameworks
Python offers a range of libraries and frameworks that enable developers to
create graphical user interfaces (GUIs) for various applications. These GUI
frameworks allow users to interact with the program through graphical elements such
as buttons, text fields, and menus, rather than relying solely on command-line inputs.
Among the available options, Tkinter stands out as the default and one of the most
widely used libraries for GUI development in Python.
Tkinter is Python’s standard GUI library, and it comes pre-installed with most
Python distributions, making it highly accessible. Tkinter provides a simple yet
powerful way to create GUI applications with basic to moderately complex designs. It
wraps the underlying Tcl/Tk GUI toolkit, which gives it cross-platform capabilities,
meaning applications built with Tkinter can run on Windows, macOS, and Linux
without modification. Tkinter offers a variety of built-in widgets such as buttons,
labels, text boxes, checkboxes, and more.
 Ease of Use: Tkinter's simplicity lies in its easy-to-understand structure.
Developers can start building applications with minimal code, and it
provides enough functionality to meet the needs of most entry-level or
intermediate applications.
 Basic Widgets: Tkinter provides a collection of core widgets, such as labels
for displaying text or images, buttons for executing commands, and listboxes
for selecting items from a list. These widgets are essential building blocks
for most GUIs.

1
  Event Handling: Tkinter enables event-driven programming, which means
the application responds to user actions like clicks or keystrokes. Event
handling allows developers to define the application’s behavior based on
user input, making the interface interactive and dynamic.
 Limitations: While Tkinter is user-friendly, it does have limitations in terms
of customization and modern design aesthetics. Applications built with
Tkinter may appear somewhat outdated or simplistic compared to modern
design standards.
To overcome these limitations, developers often turn to CustomTkinter, a
modern extension of Tkinter that provides more flexibility and design enhancements.
CustomTkinter addresses some of the design constraints of standard Tkinter, offering
more sophisticated widgets and styling options that are more aligned with current
UI/UX trends. It builds on the simplicity of Tkinter while providing developers with
the ability to create modern, polished, and responsive applications.
 Advanced Customization: CustomTkinter allows developers to apply
advanced styling options, such as custom themes and improved layout designs.
This enables more control over the appearance and feel of the application,
resulting in GUIs that look more professional and appealing to users.
 Enhanced Widgets: In addition to the standard widgets provided by Tkinter,
CustomTkinter includes enhanced versions of basic widgets like buttons and
sliders, which can be easily customized to fit the desired look of the
application. It also introduces more complex widgets like navigation bars,
scrollable frames, and tabbed views, which make it easier to build applications
with multiple views or sections.
 Responsive Design: With CustomTkinter, developers can create responsive
interfaces that adapt to different screen sizes, an important feature for
applications used across various devices. This allows for the creation of
scalable and flexible applications that maintain usability regardless of the
platform.
 Modern Look and Feel: One of the main advantages of CustomTkinter is its
support for modern design elements. It introduces sleek styles, gradients,
shadows, and more to give the application a contemporary look. These visual

2
 improvements help bridge the gap between Tkinter's functionality and the
modern expectations of user interfaces.
By combining Tkinter and CustomTkinter, developers can leverage the ease
and accessibility of Tkinter with the added design sophistication of CustomTkinter.
This combination enables developers to create applications that not only function well
but also meet modern UI design standards. The blend of these frameworks is
particularly useful for small to medium-sized projects where rapid development and
flexibility are key.
Additionally, the Python GUI ecosystem includes other options like PyQt and
Kivy, which offer different advantages depending on the project’s complexity.
However, for developers seeking a balance between ease of use, functionality, and
customization without needing to learn a more complex framework, Tkinter and
CustomTkinter are ideal choices.
1.1.1 Task Management System Using Python GUI
The task management system is a vital tool for organizing and tracking tasks.
In this project, I used Tkinter and CustomTkinter to develop a simple and intuitive
GUI that allows users to add, delete, and view tasks.
 GUI Design: The interface was designed with ease of use in mind, featuring
buttons for adding and deleting tasks, and a listbox to display tasks.
 Functionality: Users can input tasks through a text entry box, and tasks are
displayed dynamically in the listbox. Tasks can be removed with a simple
click on a "delete" button.
 Tkinter Widgets Used: The project utilized key Tkinter widgets like buttons,
labels, listboxes, and entry boxes. CustomTkinter provided additional styling
options, allowing for a more modern look and feel.
 Challenges and Solutions: A key challenge was managing the dynamic
nature of the task list and ensuring user inputs were validated. These issues
were solved using Python’s built-in validation methods and effective event
handling.
This project not only allowed me to improve my understanding of Python GUIs
but also taught me how to create practical and useful applications that solve everyday
problems.

3
1.1.2 Command-Line Calculator
Calculators are essential tools for quick and easy arithmetic operations, and
developing one in Python allowed me to solidify my understanding of basic
algorithms and user input handling.
 Functionality: This project allowed users to perform basic arithmetic
operations, including addition, subtraction, multiplication, and division, all
through the command line.
 User Input Handling: Python's input functions were utilized to accept user
input. Proper validation mechanisms ensured that invalid entries, such as
dividing by zero, were caught and handled.
 Error Handling: One of the major challenges was to handle user errors, such
as incorrect inputs or invalid operations. The use of try-except blocks allowed
for smooth error handling.
 Flow Control: The application followed a clear flow where the user is
prompted for inputs and operations, and the results are displayed on the
command line.
The project helped me sharpen my skills in algorithm development, input handling,
and the application of core programming concepts like loops and conditional
statements.
1.1.3 Password Generator Application
In today’s digital age, strong passwords are essential for securing personal and
sensitive information. My password generator project aimed to address this need by
creating a tool that generates secure passwords based on user-defined parameters.
 Password Complexity: The password generator allowed users to specify the
desired length and complexity of the password, including options for
lowercase and uppercase letters, numbers, and special characters.
 Randomization: Python’s random module was used to ensure that the
generated passwords were truly random and met the security standards.
 GUI Integration: The password generator was built using Tkinter for the GUI.
Users could easily specify their desired parameters through the GUI, and the
generated password was displayed on the screen.
 Challenges: Balancing password strength with user preferences, such as
avoiding easily guessable characters, was a challenge. This was addressed by

4
 carefully designing the randomization logic and ensuring it met modern
password standards.
This project enhanced my understanding of security concerns and provided a
practical tool that can be integrated into any security-focused application.
1.2 Problem Definition
The main problem I addressed through these projects was the need for simple,
user-friendly applications that can perform essential tasks like task management,
calculation, password generation, and entertainment (through the rock-paper-scissors
game). In today’s world, users seek efficiency and ease in interacting with software.
By developing GUI-based and command-line applications, I aimed to solve these
problems in a practical and efficient manner.
Key Problems Solved:
 Task Management: How can users efficiently organize and track their daily
tasks?
 Command-Line Arithmetic: How can simple arithmetic operations be made
more accessible through command-line tools?
 Password Security: How can users generate secure, random passwords that
meet security standards with ease?
 Interactive Entertainment: How can Python be used to create simple games
that provide entertainment and practice in game development?
By solving these problems, I was able to contribute to real-world solutions that
could be implemented in various contexts.
1.3 Significance of the Work
The work I undertook during my internship is significant because it showcases
how Python can be used to develop interactive applications that solve real-world
problems. Python’s versatility, combined with GUI frameworks like Tkinter and
CustomTkinter, opens up endless possibilities for creating useful tools that improve
productivity, security, and user experience.
Key Takeaways:
 Practical Application Development: I learned how to take a concept and turn
it into a working application, from task management systems to password
generators.

5
  Improving User Experience: By focusing on user interface design and
interaction, I was able to create applications that are intuitive and easy to use.
 Security Awareness: The password generator project allowed me to dive
deeper into the importance of secure passwords and how randomization
techniques can contribute to data security.
 Interactive Programming: Developing the rock-paper-scissors game allowed
me to work on game logic and user engagement through simple interactions,
highlighting Python's potential in game development.
Overall, the internship provided a comprehensive learning experience, equipping
me with the necessary skills to build and improve upon Python-based applications in
the future.

6
 2. System Analysis
System analysis is a critical phase in the software development lifecycle,
where the system’s requirements are defined and understood. It involves gathering
and analyzing user needs, system requirements, and any potential constraints. The
purpose of system analysis is to ensure the final product meets the user's expectations
and functions as intended. In this section, both functional and non-functional
requirements are outlined to give a clear picture of what the system needs to achieve .
2.1 Requirements Specification
Requirement specification involves defining the system's goals and constraints,
ensuring that both functional and non-functional aspects of the system are clearly
outlined. These specifications act as a blueprint, guiding the design and development
process, ensuring the final system meets user needs and technical requirements.
2.1.1 Functional Requirements
Functional requirements specify the core functionalities that the system must
provide. These include the features, services, and interactions that will enable users to
perform specific tasks.
For Example:

 Task Management System: The system must allow users to add, update, and
delete tasks. Tasks should be displayed in an organized manner (e.g., list or
table).
 Password Generator Application: The system should enable users to specify
password length and choose character types (e.g., uppercase, lowercase,
numbers, special characters).
 Calculator: The system should allow users to perform arithmetic operations
such as addition, subtraction, multiplication, and division.
 Rock-Paper-Scissors Game: The system must let users play against the
computer, and display the winner based on game rules.

7
2.1.2 Non-Functional Requirements
Non-functional requirements define the system's attributes, such as
performance, usability, security, and scalability. While functional requirements focus
on what the system does, non-functional requirements focus on how well the system
performs its tasks.
Examples:
 Performance: The GUI should load within 2 seconds of starting the
application.
 Usability: The system interface must be intuitive and easy to navigate for
users with minimal technical knowledge.
 Security: The password generator must generate secure passwords that meet
the standards for complexity and randomness.
 Reliability: The calculator should handle errors (e.g., division by zero)
without crashing the system.
 Portability: The system must run consistently on Windows, macOS, and
Linux platforms without requiring major modifications

8
 3. System design
System design is a crucial phase in the software development process, where
the system’s architecture, workflow, and individual modules are defined. This phase
provides a clear blueprint for constructing the applications, ensuring that user
requirements are effectively translated into functional components.
3.1 Architecture of the Proposed System
The architecture of the proposed system emphasizes a client-centric design
tailored for desktop applications, utilizing Python's GUI frameworks, primarily
Tkinter and CustomTkinter. The system is organized into three main components:
a. Presentation Layer (User Interface): This layer represents the front end of
the applications, where users interact with the GUI. Built using Tkinter or
CustomTkinter, it includes graphical elements like buttons, input fields, and
display areas. This layer is designed to be intuitive and user-friendly, enabling
seamless interaction with the various applications.
b. Interaction Layer (Event Handling): This component handles user events
and interactions, responding to user inputs such as clicks, key presses, and
form submissions. For instance, in the Task Management System, this layer
manages the logic for adding, editing, and deleting tasks, ensuring that the
user’s actions are accurately captured and reflected in the user interface.
c. Display Layer (Feedback and Results): This layer is responsible for
providing feedback to the user based on their actions. It updates the GUI with
relevant information, such as displaying a list of tasks, showing calculation
results in the Calculator application, or presenting the outcome of the Rock-
Paper-Scissors game. This ensures that users receive immediate and their
inputs.
This architectural design promotes a modular approach, allowing for the easy
addition of new features or enhancements in the future.
3.2 Workflow of the Proposed System
The workflow of the proposed system outlines the sequence of actions users take
within each application and how the system responds to those actions. Each
application follows a user-centric workflow, ensuring that inputs lead to immediate
feedback.
a. Task Management System Workflow:

9
 o User Inputs Task Data: The user enters task details, such as task
name, deadline, and priority, into designated input fields.
o Task Management: The user can save the task, which is then
displayed in a list format, allowing for easy viewing and organization.
o Editing and Deletion: Users can select tasks to edit or delete, with
immediate updates reflected in the user interface.
b. Command-Line Calculator Workflow:
o User Inputs Expression: The user enters a mathematical expression in
a text input field.
o Calculation Process: Upon submission, the calculator processes the
expression and performs the necessary arithmetic operations.
o Displaying Results: The result is displayed on the GUI, with clear
formatting to enhance user understanding.
c. Password Generator Workflow:
o User Chooses Preferences: Users specify password criteria, such as
length and character types, using checkboxes and sliders.
o Password Generation: The system generates a random password
based on user-defined criteria.
o Displaying Password: The generated password is presented to the user,
with an option to copy it to the clipboard.
d. Rock-Paper-Scissors Game Workflow:
o User Selects Option: The user chooses either rock, paper, or scissors
by clicking on the corresponding button.
o Random Selection: The system randomly selects its own choice.
o Displaying Outcome: The system determines the winner and displays
the result along with an option to play again.
This clear workflow enhances the user experience by ensuring that all actions
are intuitive and that users receive immediate feedback.
3.3 Module Description
The system consists of various modules, each responsible for a specific
functionality. This modular design aids in organizing the development process and
allows for easier maintenance and scalability.
a. Task Management System:

10
 o Task Input Module: This module facilitates user input for task details,
utilizing input fields and buttons for submission.
o Task Display Module: Organizes and presents tasks in a visually
appealing list format, allowing users to view their tasks at a glance.
o Task Modification Module: Enables users to edit or delete existing
tasks through simple interactions, ensuring smooth updates to the task
list.
b. Command-Line Calculator:
o Input Module: Handles user inputs for mathematical expressions,
ensuring clarity and ease of use.
o Calculation Module: Processes the entered expression and computes
the result, managing basic arithmetic operations.
o Result Display Module: Presents the calculated result clearly on the
GUI, with appropriate formatting for easy understanding.
c. Password Generator:
o User Preferences Module: Collects user-defined parameters for
password generation through interactive inputs like checkboxes and
sliders.
o Password Generation Module: Utilizes algorithms to create secure
passwords based on the selected criteria.
o Output Module: Displays the generated password, with functionality
for the user to copy it easily.
d. Rock-Paper-Scissors Game:
o User Choice Module: Allows users to select their choice of rock,
paper, or scissors through clickable buttons.
o Random Selection Module: Implements random selection logic for
the system’s choice.
o Result Module: Determines and displays the game result, informing
the user of the outcome and inviting them to play again.
This modular approach ensures that each part of the system can be developed
independently, allowing for efficient testing and future enhancements.

11
 4. Implementations
4.1 Development Environment
The development environment for the project was established to facilitate efficient
coding and testing. The following tools, libraries, and technologies were utilized:
 Programming Language: Python 3.9 was used for its robust capabilities and
ease of use, particularly for rapid application development.
 Libraries:
 Tkinter: The standard GUI toolkit for Python, Tkinter was employed
to create the graphical interfaces for all applications. Its simplicity and
wide support made it an ideal choice for building user-friendly
applications.
 CustomTkinter: An extension of Tkinter, CustomTkinter was used for
enhancing the visual aesthetics of the applications. This library allowed
for modernized widgets, enabling a more sophisticated and appealing
interface.
 Integrated Development Environment (IDE): Visual Studio Code was the
primary IDE used for development. Its user-friendly interface, rich extensions,
and built-in terminal made it a perfect choice for coding in Python. The IDE
also provided integrated version control through Git, facilitating collaborative
development.
 Version Control: Git was utilized for version control, allowing for effective
collaboration among team members and maintaining a history of code changes.
 Testing Framework: While primarily GUI-based, unit tests were conducted
using the built-in unittest module to ensure that each functional component
performed as expected.
This combination of tools and libraries created a conducive environment for
developing the applications efficiently while ensuring quality code.
4.2 Code Structure
The code structure was organized to promote clarity and ease of navigation
throughout the development process. The following is an overview of the directory
structure and main files utilized in the project:
The project directory is organized in a structured manner to facilitate clarity
and maintainability, ensuring that each component is easily accessible and logically

12
grouped. At the root level, the project_root directory contains several subdirectories
dedicated to different applications. The task_management folder houses essential files
related to the task management functionality. It includes task_manager.py, the main
file that orchestrates the overall task management processes, and task_display.py,
which is responsible for rendering tasks in the GUI. Additionally, task_input.py
handles user inputs for creating and managing tasks, while task_utils.py provides
utility functions that support task-related operations.
The calculator directory encompasses the calculator application, with
calculator.py serving as the primary file for its core functionality. The
calculator_ui.py module is dedicated to constructing the graphical interface for the
calculator, while calculation_logic.py contains the underlying logic for performing
various arithmetic operations. Similarly, the password_generator folder contains the
files necessary for the password generation application, including
password_generator.py for core functionality, password_ui.py for building the user
interface, and password_utils.py for related utility functions.
In the rock_paper_scissor directory, the structure mirrors that of the other
applications, with rps_game.py managing the game logic, rps_ui.py defining the GUI
components, and rps_logic.py responsible for determining the outcome of each game
round. The tests folder is organized to contain unit tests for each application, ensuring
that the functionalities are thoroughly verified; it includes test_task_management.py,
test_calculator.py, test_password_generator.py, and test_rps_game.py, each focusing
on their respective modules.
At the root level, requirements.txt lists all the dependencies required for the
project, ensuring that the environment can be easily set up. Finally, main.py serves as
the entry point for launching all the applications, providing a central location from
which users can access each tool seamlessly. This organized directory structure not
only enhances collaboration among developers but also streamlines the development
and testing processes, making it easier to manage and extend the project in the future.

13
4.3 Challenges Faced
During the implementation of the applications, several technical and design
challenges emerged. Here are some of the key challenges and the strategies used to
overcome them:
 Integrating CustomTkinter with Tkinter: Initially, there were issues related
to mixing the CustomTkinter library with the standard Tkinter components.
Some widgets did not behave as expected when combined. To resolve this, we
focused on maintaining a clear separation of responsibilities between
CustomTkinter and Tkinter components. By using CustomTkinter for the main
GUI and Tkinter for basic dialogs, we achieved a seamless integration.
 Event Handling in GUI: Implementing effective event handling was crucial
for ensuring that user interactions were captured correctly. We faced
difficulties when trying to manage multiple events simultaneously, especially
in the Task Management System. To address this, we implemented a
structured approach to event binding, ensuring that each GUI element had
dedicated event handler functions, which simplified the logic and improved
maintainability.
 Testing GUI Applications: Testing GUI applications posed unique challenges,
as traditional unit testing methods were less effective for user interface
components. We addressed this by combining unit tests for the underlying
logic with manual testing of the GUI. We also developed specific test cases
that focused on verifying the expected outcomes of user interactions.
 Design Consistency: Ensuring a consistent design across different
applications proved challenging, particularly when adapting CustomTkinter
widgets. To tackle this, we established design guidelines early in the
development process, detailing the expected styles, colors, and layouts.
Regular design reviews helped maintain consistency throughout the
development lifecycle.
 User Feedback Integration: During testing phases, incorporating user
feedback into the design and functionality of the applications was challenging.
We established a feedback loop with users, allowing them to provide insights
after testing. This iterative process enabled us to make meaningful adjustments
to improve user experience.

14
 5. Code Snippets
This section provides a comprehensive overview of the code implementations
and their corresponding outputs for each application developed during the internship.
Each subsection focuses on a specific application, detailing its functionality through
relevant code snippets while also showcasing the expected outputs to demonstrate
how the application operates in real-time.
5.1 Task Management System:
The Task Management System is designed to help users efficiently organize
and track their tasks. The code implementation focuses on functionalities such as
adding, displaying, and removing tasks. Each snippet included in this section
highlights key functions within the application, showcasing how users can interact
with the system to manage their tasks effectively. For example, the code snippet for
adding a task demonstrates how user inputs are captured and stored. The
corresponding output showcases the task list reflecting the newly added task,
illustrating the real-time functionality of the application. This effective integration of
code and output not only reinforces the practicality of the application but also
provides a clear understanding of its underlying logic.
Code:

from customtkinter import *

from tkinter import *
from tkinter import messagebox
app = CTk()
app.title("TO-DO LIST")
app.geometry("350x450")
app.config(bg="white")
font1 = ("Arial", 30, "bold")
font2 = ("Arial", 18, "bold")
font3 = ("Arial", 10, "bold")
def addTask():
s = entry.get()
if s:
box.insert(0, s)
entry.delete(0, END)

15
saveTask()
else:
messagebox.showerror("ERROR", "Choose a task to delete")
def RemoveTask():
s = box.curselection()
if s:
box.delete(s)
saveTask()
else:
messagebox.showerror("ERROR", "Choose a Task to delete")
def saveTask():
f = open("tasks.txt", "w")
tasks = box.get(0, END)
for task in tasks:
f.write(task + "\n")
def loadTasks():
try:
f = open("tasks.txt", "r")
tasks = f.readlines()
for task in tasks:
box.insert(0, task.strip())
except FileNotFoundError:
messagebox.showerror("ERROR", "Cannot load Tasks")
title = CTkLabel(
app, font=font1, text="TO-DO-LIST", text_color="black",
bg_color="white")
title.place(x=90, y=20)
add = CTkButton(
app,
font=font2,
text="Add Task",
text_color="white",
bg_color="red",

16
 cursor="hand2",
corner_radius=5,
hover_color="green",
width=120,
command=addTask,)
add.place(x=40, y=80)
remove = CTkButton(
app,
font=font2,
text="Remove Task",
text_color="white",
bg_color="red",
cursor="hand2",
corner_radius=5,
hover_color="green",
width=120,
command=RemoveTask,
)
remove.place(x=180, y=80)
entry = CTkEntry(
app,
font=font2,
text_color="black",
fg_color="white",
bg_color="white",
border_color="black",
width=280,
border_width=2,)
entry.place(x=40, y=120)
box = Listbox(app, width=39, height=15, font=font3)
box.place(x=80, y=200)
loadTasks()
app.mainloop()

17
5.2 Command-Line Calculator:
The Command-Line Calculator allows users to perform various arithmetic
operations through a straightforward command-line interface. In this subsection, the
code snippets will highlight the implementation of different calculation functions,
such as addition, subtraction, multiplication, and division. Each snippet is
accompanied by example outputs to illustrate how the calculator responds to user
inputs. By showcasing the interaction between the user and the application, this
section effectively demonstrates the usability and efficiency of the command-line
interface for performing calculations. Additionally, any error handling implemented
in the code is displayed through output examples, ensuring that users understand how
the application manages invalid inputs.
Code:
n1 = input("Enter a
Number:") n2 = input("Enter a
Number:") op = input("Enter
Operator:")
print("Result of {0}{1}{2} = {3}".format(n1, op, n2, eval(n1 + op + n2)))
5.3 Password Generator:
The Password Generator application aims to provide users with secure and
randomized passwords for enhanced security. This subsection features code snippets
that outline the core logic used to generate passwords, including the selection of
characters from different categories (e.g., uppercase, lowercase, digits, special
characters). Each code snippet is followed by outputs that exemplify the generated
passwords, demonstrating the application’s ability to produce varied and secure
password options based on user-defined criteria, such as length and character types.
This section highlights the practical implementation of security principles in software
development, showcasing how users can benefit from automated password generation.
Code:
import random
1 , password = int(input("Enter Lenght of Password:")), ""
for i in range(1):
num = random.randint(33,127)
password = password + chr(num)
print("Generated Password is {0}".format(password))

18
 6. Result Analysis
In this section, we present the actual results obtained from the various
applications developed during the internship. This includes a detailed analysis of the
performance and functionality of each application, supported by relevant plots and
visual data where applicable.
6.1 Actual Results Obtained from the Work
The applications developed during the internship yielded significant results
that demonstrate their functionality and user-friendliness. Each application produced
outputs that align with the intended objectives.
a. Task Management System: Users were able to successfully add, view, edit,
and delete tasks, effectively demonstrating the core functionalities of the
system. The graphical user interface (GUI) provided a clean and intuitive
layout, which facilitated smooth interactions. The resulting task list displayed
in the GUI confirmed the successful execution of user commands. Screenshots
illustrating the task addition process and the updated task list are provided in
this section, showcasing how the system manages tasks effectively. User
testing revealed a high satisfaction rate, with feedback highlighting the ease of
use and the importance of visual cues in managing tasks. Users were
particularly impressed with the ability to categorize tasks, which enhanced
their productivity.

Fig 6.1. To-Do-List Output

19
b. Command-Line Calculator: The Command-Line Calculator was developed
to perform various arithmetic operations, including addition, subtraction,
multiplication, and division. Each operation was executed without error,
demonstrating the application's reliability. Outputs of different calculations are
included to validate the correctness of the implemented logic. For instance, a
test case involving complex expressions showcased the calculator's ability to
handle operator precedence effectively. A plot displaying the performance of
calculations over time could also be included here if relevant, demonstrating
the efficiency of the command-line interface. The average response time for
calculations remained under a second, confirming its efficiency. User
feedback indicated that the command-line interface was intuitive for those
familiar with command-based applications.

Fig 6.2. Command-Line Calculator Output

c. Password Generator: The Password Generator application produced
randomized passwords based on user-defined criteria, ensuring a high level of
security. Users were able to specify the length of the password and whether to
include numbers, symbols, and uppercase or lowercase letters. Examples of
generated passwords are included to illustrate the diversity and randomness
achieved by the application. The application successfully created passwords
that met various security standards, significantly reducing the risk of
unauthorized access. Visual representation of password strength (e.g., using
plots or graphs) can further emphasize the security effectiveness of the
generated passwords. Feedback from users highlighted the importance of
having customizable options, which enhanced the application's utility. Users
reported feeling more secure knowing that they could generate complex
passwords tailored to their needs.

Fig 6.3. Password Generator Output

20
6.2 Analysis of the Results Obtained
The analysis of the results obtained from each application provides insights
into their effectiveness and performance.
The Task Management System proved to be efficient, allowing users to
manage tasks seamlessly. User feedback indicated that the GUI was intuitive,
facilitating easy navigation and interaction. The implementation of task filtering and
sorting features improved the user experience significantly, as seen in the user
engagement metrics collected during testing. Users particularly valued the ability to
prioritize tasks and set deadlines, which contributed to better time management. The
application's success in achieving high user satisfaction rates demonstrates the
effectiveness of the design choices made during development.
The Command-Line Calculator exhibited high performance in executing
calculations quickly and accurately. Error handling features were also tested,
demonstrating the application's robustness in managing invalid inputs. The average
response time for calculations remained under a second, confirming its efficiency.
Moreover, user testing confirmed that even users unfamiliar with command-line
interfaces could easily navigate and utilize the calculator after a brief introduction.
This indicates that the design and implementation choices successfully catered to a
broad audience.
Analysis of the generated passwords indicated a strong level of randomness,
meeting security standards. The inclusion of diverse character sets contributed to the
creation of complex passwords, as verified by testing against common password-
cracking methods. The generated passwords were tested using various password
strength assessment tools, confirming their resistance to brute-force attacks. Feedback
from users highlighted the importance of having customizable options for password
length and complexity, enhancing the application's utility. The ability to save
generated passwords securely could be a future enhancement that would further
solidify the application's value to users.
The analysis revealed that users enjoyed the simplicity and interactive nature
of the game. Many users expressed their desire for additional features, such as a
leaderboard or multiplayer options, which could enhance engagement and
competitiveness. The game's ability to provide instant feedback on choices and

21
outcomes was positively received, with users appreciating the visual representation of
results.
Overall, the results obtained from the developed applications validated the
design and implementation choices made during the project. Continuous testing and
user feedback will provide further opportunities for refinement and enhancement,
ensuring that the applications meet user needs effectively. Future iterations of these
applications may also consider integrating user analytics to gather more detailed
insights into user behavior and preferences, allowing for data-driven improvements.

22
 7. Testing
Testing is a crucial phase in the software development lifecycle, as it ensures
the functionality, reliability, and performance of the applications developed during the
internship. In this section, we discuss the various testing methodologies employed, the
specific tests conducted for each application, and the overall outcomes of the testing
process.
7.1 Testing Methodologies
The testing approach for the applications followed a combination of manual
testing, unit testing, and user acceptance testing (UAT).
 Manual Testing: This involved systematically executing test cases without
the use of automated tools. Testers engaged with the applications as end-users,
interacting with all features to identify bugs and usability issues. This
approach was beneficial for assessing user experience and identifying design-
related concerns.
 Unit Testing: Each module was subjected to unit testing to verify that
individual components functioned as expected. Python’s unittest framework
was utilized to create and run test cases for critical functions across all
applications. This ensured that any changes or updates to the code did not
introduce new bugs.
 User Acceptance Testing (UAT): Once the applications reached a stable state,
UAT was conducted with a group of users who represented the target audience.
This phase allowed real users to evaluate the applications based on their needs
and expectations, providing valuable feedback that informed further
refinements.
7.2 Testing of Individual Applications
The testing of the Task Management System focused on validating core
functionalities, including adding, viewing, editing, and deleting tasks. Specific
scenarios tested involved adding tasks with both valid and invalid inputs to ensure
that appropriate error messages were displayed. Additionally, the task display was
checked to verify that tasks updated in real-time after user actions. Sorting and
filtering functionalities were also tested to confirm that they operated as intended. The
results indicated that all core functionalities worked smoothly, with users appreciating
the feedback provided through the GUI during task management operations.

23
 For the Command-Line Calculator, unit tests covered a wide range of
arithmetic operations, including edge cases. Key testing scenarios included
performing basic arithmetic operations (addition, subtraction, multiplication, and
division) with various inputs, such as negative numbers and decimals. Invalid inputs,
like strings or special characters, were also tested to ensure robust error handling. The
speed of calculations was assessed by timing the execution of complex operations to
confirm performance metrics. The results showed that the calculator accurately
performed calculations and handled invalid inputs gracefully, confirming its reliability
for users.
The Password Generator application underwent testing to ensure it produced
strong, randomized passwords. Testing scenarios included generating passwords with
varying criteria, such as length and the inclusion of special characters, to verify the
diversity and randomness of outputs. Additionally, password strength was checked
using external tools to ensure compliance with security standards. Testing results
confirmed that the application consistently produced secure passwords with a high
level of randomness, satisfying user security expectations.
7.3 Summary of Testing Results
The testing phase was an extensive and thorough examination of all applicatio
ns to ensure they met user requirements and performed as intended. The process incor
porated various testing methodologies, including manual testing, unit testing, and Use
r Acceptance Testing (UAT), each providing unique insights and validation points tha
t contributed to a comprehensive understanding of the applications' strengths and area
s for improvement.
Assessment of each application's usability and functionality. Testers followed
predefined scripts to perform typical user actions, which helped uncover any deviation
s from expected behavior. This approach was particularly effective in identifying user
interface issues and ensuring that the applications operated smoothly across different
environments. By engaging directly with the software, testers were able to provide det
ailed feedback on the user experience, pinpointing areas that required refinement.
Unit testing played a crucial role in verifying the correctness of individual com
ponents. Automated unit tests isolated each unit of code and validated its output, ensu
ring that the core logic of the applications was sound and reliable. This method allowe
d for early detection and rectification of bugs, significantly contributing to the overall

24
stability and robustness of the software. The automated nature of unit testing provided
a consistent and repeatable framework for testing, ensuring that every aspect of the c
ode was thoroughly examined.
User Acceptance Testing (UAT) was perhaps the most insightful aspect of the
testing phase. By involving actual users in the testing process, we gained invaluable
world usability and appeal of our applications. Users were asked to perform typical ta
sks and provide feedback on their experiences, highlighting both positive aspects and
areas needing improvement. This feedback was instrumental in shaping our understan
ding of user needs and preferences, guiding future enhancements.
Specific suggestions from users during UAT included the addition of reminder
notifications and task prioritization options in the Task Management System, and incr
eased customization options in the Password Generator. Users appreciated the robustn
ess and reliability of the CommandLine Calculator, praising its accurate computations
and straightforward interface. The nature of the game was alsoreceived, with users e
njoying the engagement and entertainment value it provided.
In conclusion, the testing process was integral to ensuring the quality, usability
and reliability of the applications. The combination of manual testing, unit testing, an
d UAT provided a comprehensive evaluation framework that identified both strengths
and areas for improvement. Continuous user feedback and performance evaluations
will guide future updates, helping the applications evolve to meet user needs effective
ly. This iterative process of incorporating feedback and making improvements will en
sure that the applications not only meet but exceed user expectations, maintaining a hi
gh standard of quality and innovation. The detailed feedback and insights gained from
this testing phase will be pivotal in driving the next iterations of the software, ensurin
g they continue to resonate well with users and address their evolving needs.

25
 8. Conclusion and Future Work
In conclusion, the internship project focused on developing a suite of Python
GUI applications, including a Task Management System, a Command-Line
Calculator, a Password Generator, and a Rock-Paper-Scissors game. Each application
was successfully implemented using Python's Tkinter and CustomTkinter libraries,
showcasing the versatility and power of these frmeworks for creating user-friendly
interfaces. The Task Management System effectively enables users to organize and
prioritize tasks, enhancing productivity. The Command-Line Calculator demonstrated
efficient computation capabilities, providing quick responses to various arithmetic
operations. The Password Generator produced secure and randomized passwords,
addressing the growing need for digital security. Overall, the applications not only
fulfilled their intended functions but also received positive feedback from users
regarding usability and performance.
Looking ahead, several enhancements and additional features can be
integrated into these applications to further improve their functionality and user
experience.
a. Task Management System: Future work could involve the incorporation of
advanced features such as task prioritization, reminders, and deadline tracking.
Implementing a database for persistent storage would allow users to retain
their tasks across sessions, enhancing overall usability.
b. Command-Line Calculator: To improve the calculator, adding
functionalities like graphing capabilities and more complex mathematical
operations (e.g., trigonometric functions, logarithms) could provide users with
a comprehensive tool for various calculation needs.
c. Password Generator: Enhancements could include the integration of a
password strength evaluation tool, providing users feedback on the security of
generated passwords. Additionally, offering options to save generated
passwords securely could enhance user convenience.
d. User Interface Improvements: Across all applications, further refinement of
the user interface to make it more visually appealing and intuitive could
improve user satisfaction. This could include adopting modern design
principles and user testing to gather feedback on usability.

26
 e. Cross-Platform Compatibility: Exploring options for making the
applications cross-platform would allow users to access them on different
operating systems, broadening the user base and accessibility.
By addressing these future work areas, the project can evolve into a more
robust and comprehensive suite of applications that meets the diverse needs of users.
The foundational work completed during the internship serves as a strong platform for
further development and innovation.

27
 9. References
• Tkinter Documentation : Retrieved from https://docs.python.org/3
/library/tkinter.html.
• CustomTkinter GitHub Repository : Retrieved from https://github .com/
TomSchimansky/CustomTkinter.
• Python Official Documentation : Python Software Foundation. Retrieved from
https://www.python.org/doc/.
• Password Generator Best Practices : National Institute of Standards and
Technology (NIST). Retrieved from https://pages.nist.gov/800-63-3/sp800-
63b.html .
• User Interface Design Principles : Nielsen Norman Group. Retrieved from
https://www.nngroup.com/articles/ten-usability-heuristics/.
• Software Development Lifecycle : InTechOpen. Retrieved from
https://www.intechopen.com/chapters/67732.
• Graphing Calculator Functions : Retrieved from https://www.desm
os.com/calculator .
• Task Management Software Best Practices : Project Management Institute.
Retrieved from https://www.pmi.org/learning/library/task-management-software-
best-practices-11967.

28