Greater Noida Institute of Technology

(Knowledge Park-2, Greater Noida, UP)

Project Report
on

PHONE BOOK APPLICATION

Submitted by: Under the guidance of -

Ankita Thakur (1901320149003) Mr. Harendra Singh

Loveleen Sharma(1901320149010) (Assistant Professor)
Muskan Jaiswal(1901320149015)
 CERTIFICATE OF ORIGINALITY

We hereby declare that the Project entitled “Phonebook Application”

submitted to the MCA Department, Greater Noida Institute of Technology,
Greater Noida. Our work was carried out under the guidance of our
respected Head of Department Mr. Harendra Singh.

Place: Greater Noida Developed By:

Date: 11- Dec 2020 Ankita Thakur
Muskan Jaiswal
Loveleen Sharma

This is to certify that the above statement made by students is correct to

the best of my knowledge.

Project Viva-voce held on _______________

Internal Examiner External Examiner

 ACKNOWLEDGMENT

It is our pleasure to express our heartfelt thanks to Mr. Harendra Singh.

Assistant Professor, Department of Computer Science. Special thanks go to
the Management of Greater Noida institute of technology for providing us
with a good study environment and laboratory facilities.
It gives us a great sense of pleasure to present the report of “Phonebook
Application” undertaken during M.C.A. Final year.
Bearing in mind we are using this opportunity to express our deepest
gratitude and special thanks to Mr. Harendra Singh, Head of Department of
M.C.A, GREATER NOIDA INSTITUTE OF ENGINEERING & TECHNOLOGY
who took a keen interest in our project work and guided us all along for
developing a good system.

Thank you
 Preface

This project is based on the phonebook application. It manages all the

information about the contacts. It keeps all the contacts saved in the list,
personal as well as business-related.

This phonebook application project was developed by using Python with

Tkinter (Tkinter the standard Python interface to the Tk GUI toolkit) based
programming language.

The main benefit of this Phonebook Application is that a person can replace
the hard book use for writing the contacts to this application. In this
application, the user can easily save a person’s contact and information
like Name, E-mail, and Address easily there is no need to remember or
write the contact of the person.
 TABLE OF CONTENTS

CHAPTER 1 CATEGORY OF PROJECT

CHAPTER 2 INTRODUCTION
2.1 Abstract

2.2 Project Objective

2.3 Project Scope

CHAPTER 3 REQUIREMENTS

3.1 User Interface

3.2 Hardware Requirements

3.3 Software Requirements

3.4 Functional Requirements

3.5 Non-Functional Requirements

CHAPTER 4 SOFTWARE DEVELOPMENT LIFE

CYCLE

4.1 Diagram

4.2 Requirement Analysis and Specification

4.3 Designing

4.4 Coding

4.5 Testing

4.6 Implementation

4.7 Maintenance
CHAPTER 5 CONCLUSION

CHAPTER 6 SOURCE CODE

CHAPTER 7 OUTPUTS

CHAPTER 8 FUTURE SCOPE

CHAPTER 9 REFERENCES
1.CATEGORY OF PROJECT:

❖ PHONEBOOK APPLICATION

Phonebook application is a very simple tool that helps you

understand the basic concepts of creation, file extensions and data
structure. This software teaches you how to add, view, edit or modify,
receive and delete data from files.
Adding new items, viewing them, editing and updating, searching for
saved contacts and deleting data in the phonebook is one of the main
features of the main phonebook application.
2.PROJECT INTRODUCTION:

Phone Book is a project that is provided by technical assignment help

to us in that we get a simple SQL based solution to store our contacts.
We can use it to replace our hard phonebook or even use it as an office-
wide phone directory. This will help the user to easily search and
manage contacts using this system.

This system is developed using the general need required by the user
while using the phone directory book. To keep update the phone book
directory, the admin will have the authority to add and delete as well
as modify the existing records within the phone book directory. The
users of the directory will only have the authority to search for any
particular record and listing details of all available records.

To provide the search result within a short interval of time optimized

search algorithm codes have been used that will able to provide the
results within seconds.

2.1 ABSTRACT OF PHONEBOOK APPLICATION:

Phone Book System is a small web application. In the olden days, we
stored all our important contact details in books and paper. Here we
proposed a new system by using this application we can store all the
details in a central repository.

In the manual method if we forget book information then it is very

difficult to get the
information details. By using this application we can see our contacts
and where in the
world Here we will have security to the login page and no one can see
our contacts without proper authentication. In this project, we can save
 our contacts and we can search them by name and we can see all of
them at a time.
2.2The objective of the Phone Book Application

This system is developed using the general need of requirement by the user
while using the Phone directory book and provided a lot of facility to their
user. The objective of my Project
Phone Book is to record the details of various activities of the user.

* Fast speed Data Processing

* To record the details of various activities of the user
* It will simplify the task and reduce the paperwork
* The system is very user friendly

* Easily accessed by administrators, academics, student, and

applicants

2.3 SCOPE FOR DEVELOPMENT OF THE PROJECT

• Python Developers are building outstanding careers through the

development Activity. Demand for new apps and Enhancing the
existing app is increasing.
• Ease to connect with people as well as businesses.
• If we want to more easily data excess, then we can also use cloud
storage other- than SQL data server.
• We can also make changes in this project according to the
requirements of
• user/customer.
• No redundancy.
 • The main aim of the project is to store the complete information
under a single contact number.

3. SOFTWARE REQUIREMENT:

After analyzing the requirements for our project, we had concluded that
our project users require the following requirements.

3.1 USER INTERFACE

• Tkinter has used for developing the graphical user interface for the
system

• python is used for creating all the Validations and client-side scripting
Functionality

3.2HARDWARE REQUIREMENT

❖ Modern Operating System:

• Windows 7 or 10
•Mac OS
❖ x86 64-bit CPU (Intel / AMD architecture)
❖ 4 GB RAM

3.3 SOFTWARE REQUIREMENT

• VS CODE
Python is a popular programming language available for most modern
computer operating systems. Visual Studio Code is a code editor redefined
and optimized for building and debugging modern web and cloud
applications.
3.4 FUNCTIONAL REQUIREMENTS
* A functional requirement document helps you to define the functionality
of a system or one of its subsystem

* Details of operations conducted on every screen

* It should have descriptions of system reports or other outputs

* It should clearly define who will be allowed to create/modify/delete the

data in the system

3.5 NONFUNCTIONAL REQUIREMENTS

• Scalability

• Reliability

• Availability

• Maintainability

4. SOFTWARE DEVELOPMENT LIFE CYCLE:

Successful product development with customer satisfaction aspects may

sound easier said than done as it involves quite a bit of time, energy, and
brains. Many models and techniques are followed for software
development these days but the most widely used is named Software
Development Life Cycle (SDLC) or Waterfall Model.
In other words, a life cycle model maps the various activities performed on
a software product from its inception to retirement. Different life cycle
models may plan the necessary development activities to phases in
different ways. Thus, no element in which the life cycle model is followed,
the essential activities are contained in all life cycle models though the
action may be carried out in distinct orders in different life cycle models.
During any life cycle stage, more than one activity may also be carried out.

SDLC is a systematic process for building software that ensures the quality
and correctness of the software built. SDLC process aims to produce high-
quality software that meets customer expectations. The system
development should be complete in the pre-defined time frame and cost.
SDLC consists of a detailed plan which explains how to plan, build, and
maintain specific software. Every phase of the SDLC life Cycle has its own
process and deliverables that feed into the next phase.

SDLC stands for Software Development Life Cycle and is also referred to
as the Application Development life-cycle. The SDLC aims to produce a
high-quality software that meets or exceeds customer expectations,
reaches completion within times and cost estimates.

• SDLC is the acronym of Software Development Life Cycle.

• It is also called as Software Development Process.

• SDLC is a framework defining tasks performed at each step in the

software development process.

• ISO/IEC 12207 is an international standard for software life-cycle

processes. It aims to be the standard that defines all the tasks
required for developing and maintaining software.
A systems development life cycle is composed of a number of clearly
defined and distinct work phases which are used by systems
engineers and systems developers to plan for, design, build, test, and
deliver information systems. Like anything that is manufactured on
an assembly line, an SDLC aims to produce high-quality systems that
meet or exceed customer expectations, based on customer
requirements, by delivering systems which move through each
clearly defined phase, within scheduled time frames and cost
estimates. Computer systems are complex and often (especially with
the recent rise of service-oriented architecture) link multiple
traditional systems potentially supplied by different software
vendors. To manage this level of complexity, a number of SDLC
models or methodologies have been created, such
as waterfall, spiral, Agile software development, rapid
prototyping, incremental, and synchronize and stabilize. SDLC can be
described along a spectrum of agile to iterative to sequential
methodologies. The SDLC is not a methodology per se, but rather a
 description of the phases in the life cycle of a software application.
These phases (broadly speaking) are, investigation, analysis, design,
build, test, implement, and maintenance and support. A process
followed in software projects is SDLC. Each phase of SDLC
produces deliverables required by the next phase in the life cycle.
Requirements are translated into design. Code is produced according
to the design. Testing should be done on a developed product based
on the requirement. The deployment should be done once the testing
was completed. It aims to produce a high-quality system that meets
or exceeds customer expectations, works effectively and efficiently in
the current and planned information technology infrastructure, and
is inexpensive to maintain and cost-effective to enhance.

Needs of Software Development Life Cycle

The development team must determine a suitable life cycle model for
a particular plan and then observe to it. Without using an exact life
cycle model, the development of a software product would not be in a
systematic and disciplined manner. When a team is developing a
software product, there must be a clear understanding among team
representative about when and what to do. Otherwise, it would point
to chaos and project failure.

It comprises mainly of the following seven steps:

SDLC Phases :
4.1 DIAGRAM-
4.2: Requirement collection and analysis:
The requirement is the first stage in the SDLC process. It is conducted by
the senior team members with inputs from all the stakeholders and domain
experts in the industry. Planning for the quality assurance requirements
and recognization of the risks involved is also done at this stage.
This stage gives a clearer picture of the scope of the entire project and the
anticipated issues, opportunities, and directives that triggered the project.

Requirements Gathering stage need teams to get detailed and precise

requirements. This helps companies to finalize the necessary timeline to
finish the work of that system.

Business Analyst collects the requirement from the Customer/Client as per

the client's business needs and documents the requirements in the
Business Requirement Specification (document name varies depends upon
the Organization. Some examples are Customer Requirement Specification
(CRS), Business Specification (BS), etc., and provides the same to
Development Team.

Feasibility study:
Once the requirement analysis phase is completed the next SDLC step is to
define and document software needs. This process was conducted with the
help of the 'Software Requirement Specification' document also known as
the 'SRS' document. It includes everything which should be designed and
developed during the project life cycle.

There are mainly five types of feasibilities checks:

• Economic : Can we complete the project within the budget or not?

• Legal : Can we handle this project as cyber law and other
regulatory framework/compliances.
• Operation feasibility : Can we create operations which is
expected by the client?
• Technical : Need to check whether the current computer system
can support the software.
• Schedule : Decide that the project can be completed within the
given schedule or not.
4.3- Design:

In this third phase, the system and software design documents are
prepared as per the requirement specification document. This helps define
overall system architecture.

This design phase serves as input for the next phase of the model.

There are two kinds of design documents developed in this phase:

High-Level Design (HLD)

• Brief description and name of each module

• An outline about the functionality of every module
• Interface relationship and dependencies between modules
• Database tables identified along with their key elements
• Complete architecture diagrams along with technology details

Low-Level Design(LLD)

• Functional logic of the modules

• Database tables, which include type and size
• Complete detail of the interface
• Addresses all types of dependency issues
• Listing of error messages
• Complete input and outputs for every module
SOFTWARE DESIGN:
Software design is a process to transform user requirements into some
suitable form, which helps the programmer in software coding and
implementation. For assessing user requirements, an SRS (Software
Requirement Specification) document is created whereas, for coding and
implementation, there is a need for more specific and detailed
requirements in software terms. The output of this process can directly be
used for implementation in programming languages.
Software design is the first step in SDLC (Software Design Life Cycle),
which moves the concentration from the problem domain to the solution
domain. It tries to specify how to fulfill the requirements mentioned in
SRS.
Software design responsiveness involves the timeliness of the software
product’s response to user inputs, external interface stimuli, or
interactions with elements of the computing environment. The software
structural design must be evaluated to determine if the design can be
enhanced to improve the software product’s responsiveness to requested
actions. The following guidelines are provided that address enhancing the
software responsiveness to user-based requests.

1. Provide timely feedback concerning the requested action:

• Promptly acknowledge user input.
• Provide data processing progress indicators for actions taking a
significant amount of time.
• Respond initially by providing the most important information
then disclosing additional information when it becomes available.
• Alert the user concerning the anticipated delay needed to
respond to complicated requests.

2. Prioritize data processing actions:

• Postpone low-priority data processing actions until computing
resources are available.
• Anticipate data processing needs and perform actions in advance,
when possible.
 3. Optimize task queue backlog:
• Reorder the task queue based on priority.
• Flush tasks that are overtaken by events or may no longer be
needed.

4. Multitasking performance supervision:

• Monitor multitasking progress and adjust resource allocations to
optimize task execution and termination.
• Balance task duration and resource commitments.
• Predict task durations and determine task discreteness,
concurrency, and synchronization tactics.
• Establish resource monitoring and intercession supervision
procedures by anticipating resource conflicts and deadlock
situations.

Software Design Levels

Software design yields three levels of results:
• Architectural Design: The architectural design is the highest
abstract version of the system. It identifies the software as a system
with many components interacting with each other. At this level, the
designers get the idea of the proposed solution domain.
• High-level Design: The high-level design breaks the ‘single entity-
multiple component’ concept of architectural design into a less-
abstracted view of sub-systems and modules and depicts their
interaction with each other. The high-level design focuses on how the
system along with all of its components can be implemented in the
form of modules. It recognizes the modular structure of each sub-
system and their relation and interaction among each other.

• Detailed Design : Detailed design deals with the implementation

 part of what is seen as a system and its sub-systems in the previous
two designs. It is more detailed towards modules and their
implementations. It defines logical structure of each module and their
interfaces to communicate with other modules.

The SRS (Software Requirement Specification) prepared in

the previous step which tells the requirements is now design
using the specific format. The goal of this phase is how to
convert the requirement into the structure so that the
software can fulfill all the requirements. The output of this
phase is SDD (Software Design Description).

Correctness : Correctness from software engineering perspective can be

defined as the adherence to the specifications that determine how users
can interact with the software and how the software should behave when it
is used correctly.

If the software behaves incorrectly, it might take considerable amount of

time to achieve the task or sometimes it is impossible to achieve it. A
program is correct when it behaves exactly as intended, and no other way. A
minimum prerequisite to reach correctness is safety. Engineers should not
trust their own code or let others think it is trustworthy without evidence.
For software to be considered correct, an engineer must demonstrate that
their program works as intended, matching specifications. There are several
tools that can help an engineer demonstrate the correctness of their code.

Important rules:
Below are some of the important rules for effective programming which
are consequences of the program correctness theory.
• Defining the problem completely.
• Develop the algorithm and then the program logic.
• Reuse the proved models as much as possible.
• Prove the correctness of algorithms during the design phase.
• Developers should pay attention to the clarity and simplicity of your
program.
• Verifying each part of a program as soon as it is developed.

Portability : Portability testing is a process of testing with ease with

which the software or product can be moved from one environment to
another. It is measured in terms of maximum amount of effort required to
transfer from one system to another system.
The portability testing is performed regularly throughout the software
development life cycle in an iterative and incremental manner.

Portability Testing attributes:

• Adaptability
 • Installability
• Replaceability
• Co-existence

Portability Testing Checklists:

• Verify if the application is able to fulfil the portability requirements.
• Determine the look and feel of the application in the various browser
types and various browser versions.
• Report the defects to the development teams so that they can be
associated and defects can be fixed.
• The failures during the portability testing can help to identify defects
that were not detected during unit and integration testing.

Efficiency : Efficiency is very often confused with effectiveness. In

general, efficiency is a measurable concept, quantitatively determined by
the ratio of useful output to total useful input. Effectiveness is the simpler
concept of being able to achieve a desired result, which can be expressed
quantitatively but does not usually require more complicated mathematics
than addition.
Efficiency testing tests the amount of resources required by a program to
perform a specific function. In software companies, this term is used to
show the effort put in to develop the application and to quantify its user-
satisfaction.
This mainly focuses on resource availability, tools, people, time, type of
project, complexity, situation, customer requirement etc. It is a measure of
how well the team does the required work to get useful output. Efficiency is
one of the parameters. It can never be more than a 100%. By definition,
efficiency is the ratio of output to input expressed in percentage.

It is not just one single formula but a number of calculations at each step
and activity of testing. We can take an example of a team where the
manager would want to deliver the product on time, within budget, without
compromising with the quality.

Test efficiency is a quality of the QA team, i.e. to carry out all testing
activities in an efficient manner. It is not only about test case execution
alone. This includes test planning, test cases creation, review, execution,
defects tracking, comprehension and most importantly, team work.

Flexibility : Flexibility in project management allows managers to more

consistently organize workloads and resources. They can evenly spread out
the peaks and troughs in demand and stagger the start dates of different
projects. This makes their cashflow and schedule more consistent and their
lives less stressful.

Project Flexibility refers to a project’s ability to vary its output in a cost-

effective manner within its lifecycle or a given time-frame. It is a qualitative
characteristic that determines how fast the project is able to adapt to
variances and changes happening within the project environment.

A flexible project can always produce a desired outcome within a changing

environment. Flexibility makes it possible for the project to efficiently
respond to changes and move towards successful accomplishment. It
involves making trade-off discussions regarding key project constraints
such as

• Scope
• Resources
• Schedule

A project reaches flexibility when its constraints are clearly defined in the
project plan that includes actions for managing any variances in scope,
resources, and schedule.

Project flexibility matrix is often designed for defining and evaluating the
key constraints. Such a matrix clarifies what constraints are flexible and
can possibly be altered during the project lifecycle. The matrix is usually
designed at the project definition stage and used throughout the project as
a mechanism for reviewing value of each constraint.

Consistency : Consistency, defined as the requirement that a series of

measurements of the same project carried out by different raters using the
same method should produce similar results, is one of the most important
aspects to be taken into account in the measurement methods of the
software. Functional measurements are necessary for project management,
which includes two principal functions : planning and control. Both of them
require the ability to measure the software in an accurate and reliable way.
Project management planning emphasizes the estimation of budgets. The
development control requires measurement the project progress and
permits to evaluate the efficiency of the tools used in the project
development so as to improve the productivity.

• To be simple and easy to use. They should be easy to learn and their
application should not involve a great effort or much time.

• To be convincing. The metrics must be in agreement with what our

intuition suggest.

• To be reliable. Starting from the same information, several meter

should obtain really similar results.

• To agree with the principles of the measurement theory. Mainly, as

regards the performance of mathematical operations allowed by the
corresponding scale type.
Maintainability : Maintainability means fixing, updating, servicing and
to modify the system or update the software for performance
improvements or for the correction of faults”. Maintainability also includes
the addition of new functionality or the adaptation of software to meet new
requirements for the customer needs.

Software maintainability is the degree of an application to repaired or

enhanced it. Maintainability increases the reliability, efficiency or safety of
the software. It is also used to make future maintenance easier. It is used to
increase the lifetime of the software.

Maintainability repair or replace the faulty components and make the

software even better as compared to the previous condition of the
software.
Software maintenance is required when the customer demands new
features and new functions in the software. Sometimes maintenance is
required when the hardware of the system is changed then the
modification of software is needed.
Market conditions and organization changes are also the reasons for
software modification. It also includes that when the issue is detected,
immediately fix it before it becomes a big problem. Sometimes viruses and
malware are detected in the software which causes problems for the user
than software maintenance is required to fix it or improve the
performance.

Advantages of Software Maintainability

Software maintenance includes :

• Performance improvements
• Various bug fixing
• Up to date with current trends
• No need to spend extra bucks
• Contributes positively for the reputation of companies
Disadvantage of Software Maintainability
• More money upfront
• Over-maintenance
• More worker

4.4: Coding:
Once the system design phase is over, the next phase is coding. In this
phase, developers start build the entire system by writing code using the
chosen programming language. In the coding phase, tasks are divided into
units or modules and assigned to the various developers. It is the longest
phase of the Software Development Life Cycle process.

In this phase, Developer needs to follow certain predefined coding

guidelines. They also need to use programming tools like compiler,
interpreters, debugger to generate and implement the code.

Once the software is complete, and it is deployed in the testing

environment. The testing team starts testing the functionality of the entire
system. This is done to verify that the entire application works according to
the customer requirement.

During this phase, QA and testing team may find some bugs/defects which
they communicate to developers. The development team fixes the bug and
send back to QA for a re-test. This process continues until the software is
bug-free, stable, and working according to the business needs of that
system.

When the software is ready, it is sent to the testing department where Test
team tests it thoroughly for different defects. They either test the software
manually or using automated testing tools depends on the process defined
in STLC (Software Testing Life Cycle) and ensure that each and every
component of the software works fine. Once the QA makes sure that the
software is error-free, it goes to the next stage, which is Implementation.
The outcome of this phase is the Quality Product and the Testing Artifacts

4.5. TESTING:

The purpose of testing is to discover errors. Testing is the process of trying

to discover every conceivable fault or weakness in a work product.it
provides a way to check the functionality of components, sub-assemblies,
assemblies, and/or a finished product.It is a process of exercising software
with the intent of ensuring that the software system meets its requirements
and user expectations and does not fail unacceptably.

Testing is vital for the success of any software. No system design is perfect.
Testing enhances the integrity of a system by detecting deviations in design
and errors in the system.

Testing is a group of techniques to determine the correctness of the

application under the predefined script but, testing cannot find all the
defect of application. The main intent of testing is to detect failures of the
application so that failures can be discovered and corrected. It does not
demonstrate that a product functions properly under all conditions but
only that it is not working in some specific conditions.

Testing furnishes comparison that compares the behavior and state of

software against mechanisms because the problem can be recognized by
the mechanism. The mechanism may include past versions of the same
specified product, comparable products, and interfaces of expected
purpose, relevant standards, or other criteria but not limited up to these.

Testing includes an examination of code and also the execution of code in

various environments, conditions as well as all the examining aspects of the
code. In the current scenario of software development, a testing team may
be separate from the development team so that Information derived from
testing can be used to correct the process of software development.

The success of software depends upon acceptance of its targeted audience,

easy graphical user interface, strong functionality load test, etc. For
example, the audience of banking is totally different from the audience of a
video game. Therefore, when an organization develops a software product,
it can assess whether the software product will be beneficial to its
purchasers and other audience.

Testing Objectives

1.Testing Is the process of executing the program with the intent of finding
errors.

2.To evaluate the work products such as requirements, design, user stories,
and code.

3.To verify the fulfilment of all specified requirements.

4.To validate if the test object is complete and works as per the expectation
of the users and the stakeholders.

5. To build confidence in the quality level of the test object

6. To prevent defect in the software product.

7. To provide sufficient information to stakeholders to allow them to make

informed decisions specially regarding the level of quality of the test object.

8. To reduce the level of insufficient software quality.

9. To comply with contractual , legal, or regularity, requirement or

standards, and to verify the test objects compliance with such requirement
or standard.
10. To find defects in the software product .

Testing Approaches

• Black-box testing

It is carried out to test the functionality of the program. It is also called

‘Behavioral’ testing. The tester, in this case, has a set of input values and
respective desired results. On providing input, if the output matches with
the desired results, the program is tested ‘ok’, and problematic otherwise.

In this testing method, the design and structure of the code are not known
to the tester, and testing engineers and end-users conduct this test on the
software.

Black-box testing techniques:

 • Equivalence class : The input is divided into similar classes. If one
element of a class passes the test, it is assumed that all the class is
passed.
• Boundary values : The input is divided into higher and lower end
values. If these values pass the test, it is assumed that all values in
between may pass too.
• Cause-effect graphing : In both previous methods, only one input
value at a time is tested. Cause (input) – Effect (output) is a testing
technique where combinations of input values are tested in a
systematic way.
• Pair-wise Testing : The behavior of software depends on multiple
parameters. In pairwise testing, the multiple parameters are tested
pair-wise for their different values.
• State-based testing : The system changes state on provision of
input. These systems are tested based on their states and input.

White-box testing

It is conducted to test the program and its implementation, to improve

code efficiency or structure. It is also known as ‘Structural’ testing.
In this testing method, the design and structure of the code are known to
the tester. Programmers of the code conduct this test on the code.

The below are some White-box testing techniques:

• Control-flow testing : The purpose of the control-flow testing

to set up test cases which covers all statements and branch
conditions. The branch conditions are tested for both being
true and false, so that all statements can be covered.

• Data-flow testing : This testing technique emphasis to cover

all the data variables included in the program. It tests where
the variables were declared and defined and where they were
used or changed.

Alpha Testing

Alpha Testing is defined as a type of software testing performed to

identify bugs before releasing the product to real users or the public.
Acceptance testing is also sometimes called alpha testing.

Alpha testing is conducted in the organization and tested by a

representative group of end-users at the developer's side and sometimes
by an independent team of testers.
Alpha testing is simulated or real operational testing at an in-house site. It
comes after the unit testing, integration testing, etc. Alpha testing used
after all the testing are executed.

It can be a white box, or Black-box testing depends on the requirements -

particular lab environment and simulation of the actual environment
required for this testing.

Alpha testing follows the following process:

1. Requirement Review :Review the design of the specification and

functional requirement
2. Test Development : Test development is base on the outcome of the
requirement review. Develop the test cases and test plan.
3. Test case design : Execute the test plan and test cases.
4. Logging Defects : Logging the identified and detected bug found in
the application.
5. Bug Fixation : When all the bugs are identified and logged, then
there is a need to fix the bug.
6. Retesting: When all the issues are solved, and fixed retesting is done.
Beta Testing
Beta testing also known as user testing takes place at the end users site by
the end users to validate the usability, functionality, compatibility, and
reliability testing.
Beta testing adds value to the software development life cycle as it allows
the "real" customer an opportunity to provide inputs into the design,
functionality, and usability of a product. These inputs are not only critical
to the success of the product but also an investment into future products
when the gathered data is managed effectively.
Testing Levels:

• Unit Testing
Unit Testing is a software testing technique by means of which
individual units of software i. group of computer program modules, usage
procedures and operating procedures are tested to determine whether
they are suitable for use or not. It is a testing method using which every
independent modules are tested to determine if there are any issue by
the developer himself. It is correlated with functional correctness of the
independent modules.
While coding, the programmer performs some tests on that unit of the
program to know if it is error free. Testing is performed under the white-
box testing approach. Unit testing helps developers decide that individual
units of the program are working as per requirement and are error-free.

Unit Testing is defined as a type of software testing where individual

components of a software are tested.

Unit Testing of software product is carried out during the development of

an application. An individual component may be either an individual
function or a procedure. Unit Testing is typically performed by the
developer.

Objective of Unit Testing:

The objective of Unit Testing is:
• To isolate a section of code.
• To verify the correctness of code.
• To test every function and procedure.
• To fix bug early in development cycle and to save costs.
• To help the developers to understand the code base and enable
them to make changes quickly.
• To help for code reuse.
Integration Testing
Integration testing is the process of testing the interface between two
software units or module. It’s focus on determining the correctness of the
interface. The purpose of the integration testing is to expose faults in the
interaction between integrated units. Once all the modules have been unit
tested, integration testing is performed.

Even if the units of software are working fine individually, there is a need
to find out if the units
if integrated would also work without errors. For example, argument
passing and data
updation, etc.
Upon completion of unit testing, the units or modules are to be integrated
which gives raise to integration testing. The purpose of integration testing
is to verify the functional, performance, and reliability between the
modules that are integrated.
Integration testing is the second level of the software testing process
comes after unit testing. In this testing, units or individual components of
the software are tested in a group. The focus of the integration testing
level is to expose defects at the time of interaction between integrated
components or units.

• We go for the integration testing only after the functional testing is

completed on each module of the application.
• We always do integration testing by picking module by module so
that a proper sequence is followed, and also we don't miss out on any
integration scenarios.
• First, determine the test case strategy through which executable test
cases can be prepared according to test data.
• Examine the structure and architecture of the application and
identify the crucial modules to test them first and also identify all
possible scenarios.
 • Design test cases to verify each interface in detail.
• Choose input data for test case execution. Input data plays a
significant role in testing.
• If we find any bugs then communicate the bug reports to developers
and fix defects and retest.
• Perform positive and negative integration testing.

System testing
System testing is performed on a complete, integrated system. It allows
checking the system's compliance as per the requirements. It tests the
overall interaction of components. It involves load, performance, reliability,
and security testing.

System Testing (ST) is a black box testing technique performed to evaluate

the complete system the system's compliance against specified
requirements. In System testing, the functionalities of the system are
tested from an end-to-end perspective.

System Testing is usually carried out by a team that is independent of the

development team in order to measure the quality of the system unbiased.
It includes both functional and Non-Functional testing.

In system testing, integration testing passed components are taken as

input. The goal of integration testing is to detect any irregularity between
the units that are integrated together. System testing detects defects
within both the integrated units and the whole system. The result of
system testing is the observed behavior of a component or a system
when it is tested.

System Testing is carried out on the whole system in the context of

either system requirement specifications or functional requirement
specifications or in the context of both. System testing tests the design
and behavior of the system and also the expectations of the customer. It
is performed to test the system beyond the bounds mentioned in
the software requirements specification (SRS).
 System Testing is performed after the integration testing and before the
acceptance testing.

System Testing Process:

System Testing is performed in the following steps:

• Test Environment Setup:

Create testing environment for the better quality testing.
• Create Test Case:
Generate test case for the testing process.
• Create Test Data:
Generate the data that is to be tested.
• Execute Test Case:
After the generation of the test case and the test data, test cases are
executed.
• Defect Reporting:
Defects in the system are detected.
• Regression Testing:
It is carried out to test the side effects of the testing process.
• Log Defects:
Defects are fixed in this step.
• Retest:
Acceptance testing

Acceptance testing is a test conducted to find if the requirements of a

specification or contract are met as per its delivery. Acceptance testing is
basically done by the user or customer.

This is a type of testing done by users, customers, or other authorised

entities to determine application/software needs and business processes.

Acceptance testing is the most important phase of testing as this decides

whether the client approves the application/software or not. It may involve
functionality, usability, performance, and U.I of the application. It is also
known as user acceptance testing (UAT), operational acceptance testing
(OAT), and end-user testing.
It is one of the final stages of the software’s testing cycle and often occurs
before a client or customer accepts the new application. Acceptance tests
are black-box system tests. Users of the system perform tests in line with
what would occur in real-time scenarios and verify whether or not the
software/application meets all specifications.
Acceptance Criteria

Acceptance criteria are defined on the basis of the following attributes

• Functional Correctness and Completeness

• Data Integrity

• Data Conversion

• Usability

• Performance

• Timeliness

• Confidentiality and Availability

• Installability and Upgradability

• Scalability

• Documentation

Acceptance Test Plan – Attributes

The acceptance test activities are carried out in phases. Firstly, the basic
tests are executed, and if the test results are satisfactory then the
execution of more complex scenarios are carried out.
The Acceptance test plan has the following attributes:

• Introduction

• Acceptance Test Category

• operation Environment

• Test case ID

• Test Title
 • Test Objective

• Test Procedure

• Test Schedule

• Resources

The acceptance test activities are designed to reach at one of the

conclusions:
1. Accept the system as delivered
2. Accept the system after the requested modifications have been made
3. Do not accept the system

Acceptance Test Report – Attributes

The Acceptance test Report has the following attributes:

• Report Identifier

• Summary of Results

• Variations

• Recommendations

• Summary of To-do List

• Approval Decision
MANUAL TESTING:

Manual Testing is a type of software testing in which test cases are

executed manually by a tester without using any automated tools. The
purpose of Manual Testing is to identify the bugs, issues, and defects in the
software application. Manual software testing is the most primitive
technique of all testing types and it helps to find critical bugs in the
software application.

Manual testing is the process of testing the software manually to identify

the bug, issues and defects in the software product. The aim of a software
tester is to break the system and understand the response of system to
various scenarios.
The observed behaviour of the system is always cross-checked against the
expected or desired system behaviour. If there is a difference in both, the
tester raises the issue and reports it as a bug. A tester can employ several
manual software testing techniques to test every aspect of the software be
it functional or non-functional.

A software testing process typically includes a series of steps to make sure

that the product has been thoroughly tested. The first step is to gain
business understanding of the application. The next step is to create a test
plan that can be used a guidebook for the testing process. This test plan is
created by the test manager or the QA manager.

After the test plan is drawn up, test scenarios and test cases are created
manually. When the product is developed, and comes for the QA, testers
execute those test cases and log the status of test cases as ‘Pass/Fail’. When
a test case fails, an issue or bug is raised. This bug is assigned to a
developer who fixes it and the tester retests it. The cycle continues until all
the bugs are closed.

Any new application must be manually tested before its testing can be
automated. Manual Software Testing requires more effort but is necessary
to check automation feasibility.
4.6: Installation/Deployment:

Once the software testing phase is over and no bugs or errors left in the
system then the final deployment process starts. Based on the feedback
given by the project manager, the final software is released and checked for
deployment issues if any.
After successful testing, the product is delivered/deployed to the customer
for their use. Deployment is done by the Deployment/Implementation
engineers.
Once when the customers start using the developed system then the actual
problems will come up and needs to be solved from time to time.
Fixing the issues found by the customer comes in the maintenance phase.
100% testing is not possible – because, the way testers test the product is
different from the way customers use the product. Maintenance should be
done as per SLA (Service Level Agreement).

4.7 SYSTEM MAINTENANCE:

Software maintenance is a part of the Software Development Life Cycle. Its

main purpose is to modify and update software applications after delivery
to correct faults and to improve performance.

The results obtained from the evaluation process help the organization to
determine whether its information systems are effective and efficient or
otherwise. The process of monitoring, evaluating, and modifying of
existing information systems to make required or desirable improvements
may be termed as System Maintenance.

Software is a model of the real world. When the real world changes, the
software require alteration wherever possible.

Software Maintenance is an inclusive activity that includes error

corrections, enhancement of capabilities, deletion of obsolete capabilities,
and optimization.

Maintenance means restoring something to its original conditions.

Enhancement means adding, modifying the code to support the changes in
the user specification. System maintenance conforms the system to its
original requirements and enhancement adds to system capability by
incorporating new requirements.

Thus, maintenance changes the existing system, enhancement adds

features to the existing system, and development replaces the existing
system. It is an important part of system development that includes the
activities which corrects errors in system design and implementation,
updates the documents, and tests the data.

5.CONCLUSION:

A person having several contacts will enjoy the flavor of this application,
because the members in their list may confuse the user with the similar
name thought belonging to different categories, to overcome this person to
person can be classified according to their respective categories.
6.SOURCE CODE
 main.py

from tkinter import*

import datetime
from mypeople import MyPeople
from addpeople import AddPeople
from aboutus import About

date = datetime.datetime.now().date()
date = str(date)

class Application(object):
def __init__(self,root):
self.root = root

#frames

self.top = Frame(root, height=180,bg='white')

self.top.pack(fill=X)

self.bottom = Frame(root,height=600,bg='#34eb95')
self.bottom.pack(fill=X)

#top frame design

self.top_image = PhotoImage(file='icons/contact.png')
self.top_image_label=Label(self.top,image=self.top_image,bg='white')
self.top_image_label.place(x=120,y=10)

self.heading = Label(self.top,text=' My Phonebook App ',font='arial 20

bold',bg='white',fg='#22853d')
self.heading.place(x=280,y=55)

self.date_lbl = Label(self.top, text=" Date: "+date, font='arial 12 bo

ld',fg = '#22853d', bg='white')
self.date_lbl.place(x=430,y=148)

#button - View People

self.viewButton = Button(self.bottom, text= " My contacts ", fg="#00
0000", bg='white', font='arial 20 bold',
command=self.my_people)
self.viewButton.place(x=200,y=70)

#button - Add People

 self.addButton = Button(self.bottom, text=" Add Contacts", fg= "#00000
0", bg='white', font='arial 20 bold',
command = self.addpeoplefunction)
self.addButton.place(x=200,y=184)

#button - About us
self.aboutButton = Button(self.bottom, text=" About us ",fg="#00
0000", bg='white', font='arial 20 bold',
command=self.about_us)
self.aboutButton.place(x=200,y=300)

#button - Exit
self.ExitButton = Button(self.bottom, text=" Exit ", fg
= "#000000",bg='white',
font='arial 20 bold',command=self.root.destroy)
self.ExitButton.place(x=200,y=410)

def my_people(self):
people = MyPeople()

def about_us(self):
aboutpage = About()

def addpeoplefunction(self):
addpeoplewindow = AddPeople()

def exit(self):
ask=messagebox.askyesno("exit","Do you really want to exit")
if ask>0:
self.root.destroy()

def main():
root=Tk()
app=Application(root)
root.title("Phonebook App")
root.geometry("600x750+350+200")
root.resizable(False,False)
root.mainloop()

if __name__ == '__main__':
main()
 mycontact.py

from tkinter import*

import sqlite3
from addpeople import AddPeople
from update import Update
from display import Display
from tkinter import messagebox
con = sqlite3.connect('database.db')
cur = con.cursor()

class MyPeople(Toplevel):
def __init__(self):
Toplevel.__init__(self)

self.geometry("600x750+350+200")
self.title("My People")
self.resizable(False,False)

self.top = Frame(self, height=180,bg='white')

self.top.pack(fill=X)

self.bottom = Frame(self,height=600,bg='#18877c')
self.bottom.pack(fill=X)

#top frame design

self.top_image = PhotoImage(file='icons/people.png')
self.top_image_label=Label(self.top,image=self.top_image,bg='white')
self.top_image_label.place(x=120,y=10)

self.heading = Label(self.top,text=' My Contacts ',font='arial 23 bold

',bg='white',fg='#10778f')
self.heading.place(x=280,y=55)

self.scroll = Scrollbar(self.bottom, orient=VERTICAL)

self.listbox = Listbox(self.bottom, width=60, height=35)

self.listbox.grid(row=0, column=0, padx=(30,0))
self.scroll.config(command=self.listbox.yview)
self.listbox.config(yscrollcommand=self.scroll.set)
persons = cur.execute("select * from 'addressbook'").fetchall()
print(persons)
count = 0
for person in persons:
self.listbox.insert(count,str(person[0])+"."+person[1]+" "+person[
2])
count += 1
self.scroll.grid(row=0,column=1,sticky=N+S)

Addcontact = Button(self.bottom, text="Add" , width=12 , font='sans 12

bold',command = self.add_people)
Addcontact.grid(row=0,column=2,padx=25,pady=20,sticky=N)

upcontact = Button(self.bottom,text="Update" , width=12 , font='sans 1

2 bold',command = self.update_function)
upcontact.grid(row=0,column=2,padx=25,pady=60,sticky=N)

discontact = Button(self.bottom,text="Display" , width=12 , font='sans

12 bold',command = self.display_person)
discontact.grid(row=0,column=2,padx=25,pady=100,sticky=N)

delcontact = Button(self.bottom,text="Delete" , width=12 , font='sans

12 bold' ,command= self.delete_person)
delcontact.grid(row=0,column=2,padx=25,pady=140,sticky=N)

ExitButton = Button(self.bottom, text="Exit ",width=12, font='sans 12

bold',command=self.destroy)
ExitButton.grid(row=0,column=2,padx=25,pady=180,sticky=N)

def delete_person(self):
selected_item = self.listbox.curselection()
person = self.listbox.get(selected_item)
person_id = person.split(".")[0]

query = "delete from addressbook where person_id = {}".format(person_i

d)
string_for_mbox = "are you sure you wanna delete" , person.split(".")[
1], "?"
answer = messagebox.askquestion("warning","are you sure you wanna dele
te?" )
if answer == 'yes':
try:
cur.execute(query)
con.commit()
messagebox.showinfo("success","Deleted")
 self.destroy()

except Exception as e:
messagebox.showinfo("Info",str(e))

def add_people(self):
add_page = AddPeople()
self.destroy()

def update_function(self):
selected_item = self.listbox.curselection()
person = self.listbox.get(selected_item)
person_id =person.split(".")[0]

update = Update(person_id)

def exit(self):
ask=messagebox.askyesno("exit","Do you really want to exit")
if ask>0:
self.destroy()

def display_person(self):
selected_item = self.listbox.curselection()
person = self.listbox.get(selected_item)
person_id =person.split(".")[0]

displaypage = Display(person_id)
 addcontact.py

from tkinter import *

import sqlite3
from tkinter import messagebox
con = sqlite3.connect('database.db')
cur = con.cursor()

class AddPeople(Toplevel):
def __init__(self):
Toplevel.__init__(self)

self.geometry("600x700+350+200")
self.title("Add new People")
self.resizable(False,False)

self.top = Frame(self, height=180, bg="white")

self.top.pack(fill=X)

self.bottom = Frame(self, height=600, bg='#d2a5e6')

self.bottom.pack(fill=X)

self.top_image = PhotoImage(file='icons/team.png')
self.top_image_label = Label(self.top, image=self.top_image, bg="white
")
self.top_image_label.place(x=100,y=10)

self.heading = Label(self.top,text=' Add New Contacts ',font='arial 23

bold',bg='white',fg='#0e7387')
self.heading.place(x=280,y=55)

#id

#name
self.label_name =Label(self.bottom, text="Name",font='sans 15 bold',bg
='#d2a5e6',fg='white')
self.label_name.place(x=49,y=40)

self.entry_name = Entry(self.bottom, width=30, bd=5)

self.entry_name.insert(0,"Enter Name")
self.entry_name.place(x=160,y=40)
#id
 self.label_sname =Label(self.bottom, text="Surname",font='sans 15 bold
',bg='#d2a5e6',fg='white')
self.label_sname.place(x=49,y=80)

self.entry_sname = Entry(self.bottom, width=30, bd=5)

self.entry_sname.insert(0,"Enter Surname")
self.entry_sname.place(x=160,y=80)
#email
self.label_email =Label(self.bottom, text="E-
mail id",font='sans 15 bold',bg='#d2a5e6',fg='white')
self.label_email.place(x=49,y=120)

self.entry_email = Entry(self.bottom, width=30, bd=5)

self.entry_email.insert(0,"Enter E-mail")
self.entry_email.place(x=160,y=120)
#mobile
self.label_mob =Label(self.bottom, text="Mobile no.",font='sans 15 bol
d',bg='#d2a5e6',fg='white')
self.label_mob.place(x=49,y=160)

self.entry_mob = Entry(self.bottom, width=30, bd=5)

self.entry_mob.insert(0,"Enter number")
self.entry_mob.place(x=160,y=160)

#address
self.label_add =Label(self.bottom, text="Address",font='sans 15 bold',
bg='#d2a5e6',fg='white')
self.label_add.place(x=49,y=200)

self.entry_add = Text(self.bottom, width=24, height=8)

self.entry_add.place(x=160,y=200)

#button
button = Button(self.bottom, text="Add person",font='sans 15 bold',com
mand=self.add_people)
button.place(x=250, y=450)
def add_people(self):
name = self.entry_name.get()
sname = self.entry_sname.get()
email = self.entry_email.get()
mob = self.entry_mob.get()
add = self.entry_add.get(1.0, 'end-1c')

if name and sname and email and mob and add !="":
try:
#add it to database
 #insert into 'addressbook' (person_name,person_email,person_m
obile,address,surname) values ()

query = "insert into 'addressbook' (person_name,person_sname,p

erson_email, person_mob1,address) values (?,?,?,?,?)"
cur.execute(query, (name, sname, email, mob, add))
con.commit()
messagebox.showinfo("success","contact added")

self.destroy()

except EXCEPTION as e:
messagebox.showerror("Error",str(e))
else:
messagebox.showerror("Error", "fill all the fields", icon='warning
')
 display.py

from tkinter import*

import sqlite3
from tkinter import messagebox
from addpeople import AddPeople

con = sqlite3.connect('database.db')
cur = con.cursor()
class Display(Toplevel):
def __init__(self,person_id):

Toplevel.__init__(self)
self.geometry("600x700+350+200")
self.title("Display Person")
self.resizable(False,False)

print("person_id =",person_id)

query = "select * from addressbook where person_id = '{}'".format(pers

on_id)
result = cur.execute(query).fetchone()
print(result)
self.person_id = person_id
person_name = result[1]
person_sname = result[2]
person_email = result[3]
person_mob = result[4]
address = result[5]

print("person name",person_name)

self.top = Frame(self, height=180, bg="white")

self.top.pack(fill=X)

self.bottom = Frame(self, height=600, bg='#17c2a8')

self.bottom.pack(fill=X)

self.top_image = PhotoImage(file='icons/people.png')
self.top_image_label = Label(self.top, image=self.top_image, bg="white
")
 self.top_image_label.place(x=100,y=10)

self.heading = Label(self.top,text=' Display Contact ',font='arial 23

bold',bg='white',fg='#10778f')
self.heading.place(x=280,y=55)

#id

#name
self.label_name =Label(self.bottom, text="Name:",font='sans 15 bold',b
g='#17c2a8',fg='white')
self.label_name.place(x=140,y=40)

self.entry_name = Entry(self.bottom, width=30, bd=8)

self.entry_name.insert(0,person_name)
self.entry_name.config(state = "disabled")
self.entry_name.place(x=250,y=40)
#id
self.label_sname =Label(self.bottom, text="Surname:",font='sans 15 bol
d',bg='#17c2a8',fg='white')
self.label_sname.place(x=140,y=90)

self.entry_sname = Entry(self.bottom, width=30, bd=8)

self.entry_sname.insert(0,person_sname)
self.entry_sname.config(state = "disabled")
self.entry_sname.place(x=250,y=90)
#email
self.label_email =Label(self.bottom, text="E-
mail id:",font='sans 15 bold',bg='#17c2a8',fg='white')
self.label_email.place(x=140,y=140)

self.entry_email = Entry(self.bottom, width=30, bd=8)

self.entry_email.insert(0,person_email)
self.entry_email.config(state = "disabled")
self.entry_email.place(x=250,y=140)
#mobile
self.label_mob =Label(self.bottom, text="Mobile no.:",font='sans 15 bo
ld',bg='#17c2a8',fg='white')
self.label_mob.place(x=140,y=190)

self.entry_mob = Entry(self.bottom, width=30, bd=8)

self.entry_mob.insert(0,person_mob)
self.entry_mob.config(state = "disabled")
self.entry_mob.place(x=250,y=190)

#address
self.label_add =Label(self.bottom, text="Address:",font='sans 15 bold'
,bg='#17c2a8',fg='white')
self.label_add.place(x=140,y=240)

self.entry_add = Text(self.bottom, width=24, height=8)

self.entry_add.insert(1.0,address)
self.entry_add.config(state = "disabled")
self.entry_add.place(x=250,y=240)
 update.py

from tkinter import*

import sqlite3
from tkinter import messagebox
from addpeople import AddPeople

con = sqlite3.connect('database.db')
cur = con.cursor()
class Update(Toplevel):
def __init__(self,person_id):

Toplevel.__init__(self)
self.geometry("600x700+350+200")
self.title("Update Person")
self.resizable(False,False)

print("person_id =",person_id)

query = "select * from addressbook where person_id = '{}'".format(pers

on_id)
result = cur.execute(query).fetchone()
print(result)
self.person_id = person_id
person_name = result[1]
person_sname = result[2]
person_email = result[3]
person_mob = result[4]
address = result[5]

print("person name",person_name)

self.top = Frame(self, height=180, bg="white")

self.top.pack(fill=X)

self.bottom = Frame(self, height=600, bg="#3287a8")

self.bottom.pack(fill=X)

self.top_image = PhotoImage(file='icons/team.png')
self.top_image_label = Label(self.top, image=self.top_image, bg="white
")
self.top_image_label.place(x=100,y=10)

self.heading = Label(self.top,text=' Update Contact ',font='arial 23 b

old',bg='white',fg='#3287a8')
self.heading.place(x=280,y=55)
 #id

#name
self.label_name =Label(self.bottom, text="Name",font='sans 15 bold',bg
='#3287a8',fg='white')
self.label_name.place(x=49,y=40)

self.entry_name = Entry(self.bottom, width=30, bd=5)

self.entry_name.insert(0,person_name)
self.entry_name.place(x=160,y=40)
#id
self.label_sname =Label(self.bottom, text="Surname",font='sans 15 bold
',bg='#3287a8',fg='white')
self.label_sname.place(x=49,y=80)

self.entry_sname = Entry(self.bottom, width=30, bd=5)

self.entry_sname.insert(0,person_sname)
self.entry_sname.place(x=160,y=80)
#email
self.label_email =Label(self.bottom, text="E-
mail id",font='sans 15 bold',bg='#3287a8',fg='white')
self.label_email.place(x=49,y=120)

self.entry_email = Entry(self.bottom, width=30, bd=5)

self.entry_email.insert(0,person_email)
self.entry_email.place(x=160,y=120)

#mobile
self.label_mob =Label(self.bottom, text="Mobile no.",font='sans 15 bol
d',bg='#3287a8',fg='white')
self.label_mob.place(x=49,y=160)

self.entry_mob = Entry(self.bottom, width=30, bd=5)

self.entry_mob.insert(0,person_mob)
self.entry_mob.place(x=160,y=160)

#address
self.label_add =Label(self.bottom, text="Address",font='sans 15 bold',
bg='#3287a8',fg='white')
self.label_add.place(x=49,y=200)

self.entry_add = Text(self.bottom, width=24, height=8)

self.entry_add.insert(1.0,address)
self.entry_add.place(x=160,y=200)
 #button
button = Button(self.bottom, text="Update Contact",font='sans 15 bold'
,command=self.update_people)
button.place(x=250, y=450)

def update_people(self):
id = self.person_id
name = self.entry_name.get()
sname = self.entry_sname.get()
email = self.entry_email.get()
mob = self.entry_mob.get()
add = self.entry_add.get(1.0, 'end-1c')
query = "update addressbook set person_name = '{}',person_sname = '{}'
, person_email = '{}', person_mob1 = '{}'
, address = '{}' where person_id = {}".format(name, sname, email, mob, add, id
)

try:
cur.execute(query)
con.commit()
messagebox.showinfo("success"," contact updated")

except Exception as e:
print(e)
 aboutus.py

from tkinter import *

class About(Toplevel):
def __init__(self):
Toplevel.__init__(self)

self.geometry("550x550+350+200")
self.title("About Us")
self.resizable(False,False)

self.top = Frame(self, height=550, width =550, bg='#4c1663')

self.top.pack(fill=BOTH)

self.text = Label(self.top, text='Hey, this is about us page',font = "

monoscope 18 bold underline" ,bg='#4c1663',fg='#cbd663')
self.text.place(x=140, y=60)

self.text = Label(self.top, text='This application is made by the '

'\n MCA students for the educational purpose.'
'\n'
'\n This application is the project for'
'\n software Engineering.'
'\n'
'\n you can contact us on'
'\n'
'\n Facebook - https://facebook.com/MCA'
'\n'
'\n Instagram -
MCA_GROUP',font = "monoscope 14", bg='#4c1663',fg="white")
self.text.place(x=100, y=130)
7.Outputs
8.FUTURESCOPE:

• Python Developers are building outstanding careers through the

development Activity. Demond for new apps and enhancing the
existing app is increasing.

• Ease to connect with people as well as businesses.

• If Someone wants to more easily data excess, then we can also use
cloud storage other than SQL data server.

• We can also make changes in this project according to the

requirement of use/customer.
10.REFERENCES

References made from:

Sites referred:

https://learning.oreilly.com/library/view/tkinter-gui-application

https://subscription.packtpub.com/

https://www.youtube.com/channel/UCsRY-UVUNYi0NW7RwxNLBQA

https://www.w3schools.com/python/default.asp