Institut de Technologie de Greater Noida

(Knowledge Park-2, Greater Noida, UP)

Rapport de projet
sur

APPLICATION DE PROTABLE

Soumis par : Sous la direction de -

Ankita Thakur M. Harendra Singh

Loveleen Sharma(1901320149010) (Professeur Assistant)
Muskan Jaiswal(1901320149015)
 CERTIFICAT D'ORIGINALITÉ

Nous déclarons par la présente que le projet intitulé « Application Annuaire »

soumis au Département MCA, Institut de Technologie de Greater Noida,
Greater Noida. Notre travail a été réalisé sous la direction de notre
respecté Responsable de Département M. Harendra Singh.

Lieu : Greater Noida Développé par :

11- Déc 2020 Ankita Thakur
Muskan Jaiswal
Loveleen Sharma

Ceci est pour certifier que la déclaration ci-dessus faite par les étudiants est correcte.
au meilleur de ma connaissance.

Le projet Viva-voce a eu lieu le _______________

Examinateur interne Examinateur externe

 RECONNAISSANCE

Nous avons le plaisir d'exprimer nos sincères remerciements à M. Harendra Singh.

Professeur Assistant, Département d'informatique. Un grand merci à
la direction de l'institut de technologie de Greater Noida pour nous avoir fourni
avec un bon environnement d'étude et des installations de laboratoire.

Nous avons un grand plaisir à présenter le rapport de "Annuaire"

Application réalisée pendant la dernière année de M.C.A.
Tout en gardant à l'esprit que nous profitons de cette occasion pour exprimer notre plus profonde
remerciement et remerciements spéciaux à M. Harendra Singh, Responsable du Département de
M.C.A, INSTITUT D'INGÉNIERIE ET DE TECHNOLOGIE DE GREATER NOIDA
qui s'est fortement intéressé à notre travail de projet et nous a guidés tout au long de
développer un bon système.

Merci
 Préface

Ce projet est basé sur l'application annuaire. Il gère tous les

informations sur les contacts. Il garde tous les contacts enregistrés dans la liste,
personnelle ainsi que professionnelle.

Ce projet d'application de carnet d'adresses a été développé en utilisant Python avec

Basé sur Tkinter (Tkinter, l'interface standard de Python pour l'outil GUI Tk)
langage de programmation.

Le principal avantage de cette application de répertoire téléphonique est qu'une personne peut remplacer

le livre dur utilisé pour écrire les contacts dans cette application. Dans ce
application, l'utilisateur peut facilement enregistrer le contact et les informations d'une personne

comme Nom, E-mail et Adresse facilement, il n'est pas nécessaire de se souvenir ou

écrire le contact de la personne.

 TABLE DES MATIÈRES

CHAPITRE 1 CATÉGORIE DE PROJET

CHAPITRE 2 INTRODUCTION
2.1 Résumé

2.2 Objectif du projet

2.3 Portée du projet

CHAPITRE 3 EXIGENCES
3.1 Interface utilisateur

3.2 Exigences matérielles

3.3 Exigences logicielles

3.4 Exigences fonctionnelles

3.5 Exigences non fonctionnelles

CHAPITRE 4 VIE DU DÉVELOPPEMENT LOGICIEL
CYCLE

4.1 Diagramme

4.2 Analyse et spécification des exigences

4.3 Conception

4.4 Codage

4.5 Test

4.6 Mise en œuvre

4.7 Maintenance
CHAPITRE 5 CONCLUSION

CHAPITRE 6 CODE SOURCE

CHAPITRE 7 SORTIES

CHAPITRE 8 PERSPECTIVES D'AVENIR

CHAPITRE 9 RÉFÉRENCES
1.CATÉGORIE DE PROJET :

❖ APPLICATION ANNuaire TELEPHONIQUE

L'application Carnet d'adresses est un outil très simple qui vous aide à
comprendre les concepts de base de la création, des extensions de fichiers et des données
structure. Ce logiciel vous apprend à ajouter, visualiser, modifier ou changer,
recevoir et supprimer des données de fichiers.
Ajouter de nouveaux éléments, les visualiser, les modifier et les mettre à jour, rechercher des
Les contacts enregistrés et la suppression des données dans le répertoire téléphonique sont l'un des principaux
caractéristiques de l'application principale du carnet d'adresses.
2.INTRODUCTION AU PROJET :

Le annuaire téléphonique est un projet fourni par l'aide à la rédaction de missions techniques.
pour nous en ce sens que nous obtenons une solution simple basée sur SQL pour stocker nos contacts.
Nous pouvons l'utiliser pour remplacer notre annuaire téléphonique papier ou même l'utiliser comme bureau-

annuaires téléphoniques larges. Cela aidera l'utilisateur à rechercher facilement et

gérer les contacts en utilisant ce système.

Ce système est développé en fonction du besoin général requis par l'utilisateur.

en utilisant le annuaire téléphonique. Pour maintenir à jour le répertoire téléphonique
dans le répertoire, l'administrateur aura l'autorité d'ajouter et de supprimer également
modifier les enregistrements existants dans le répertoire des annuaires téléphoniques. Le
les utilisateurs du répertoire n'auront l'autorité que pour rechercher n'importe quel
détails particuliers d'enregistrement et de liste de tous les enregistrements disponibles.

Pour fournir le résultat de la recherche dans un court intervalle de temps optimisé

des codes d'algorithmes de recherche ont été utilisés qui seront capables de fournir le
résultats en quelques secondes.

2.1 RÉSUMÉ DE L'APPLICATION ANNULAIRE :

Le système de répertoire téléphonique est une petite application web. Dans les temps anciens, nous

nous avons stocké tous nos coordonnées importantes dans des livres et du papier. Ici nous
propose un nouveau système en utilisant cette application nous pouvons stocker tout le
détails dans un dépôt central.

Dans la méthode manuelle, si nous oublions des informations sur le livre, alors c'est très

difficile d'obtenir le
détails d'information. En utilisant cette application, nous pouvons voir nos contacts
et où dans le
monde Ici nous aurons la sécurité de la page de connexion et personne ne pourra voir
nos contacts sans authentification appropriée. Dans ce projet, nous pouvons enregistrer
 nos contacts et nous pouvons les rechercher par nom et nous pouvons voir tout cela
à la fois.
2.2 L'objectif de l'application Annuaire Téléphonique

Ce système est développé en utilisant le besoin général d'exigence de l'utilisateur

tout en utilisant le annuaire téléphonique et en offrant beaucoup de facilités à leurs ...
L'objectif de mon projet
Le annuaire téléphonique est destiné à enregistrer les détails des diverses activités de l'utilisateur.

* Traitement de données à grande vitesse

* Pour enregistrer les détails des différentes activités de l'utilisateur

Cela simplifiera la tâche et réduira la paperasse

Le système est très convivial

* Facilement accessible par les administrateurs, les universitaires, les étudiants, et

demandeurs

2.3 PORTÉE DU DÉVELOPPEMENT DU PROJET

• Les développeurs Python construisent des carrières exceptionnelles grâce à

Activité de développement. Demande de nouvelles applications et amélioration de

l'application existante est en augmentation.

• Facilité de se connecter avec les gens ainsi qu'avec les entreprises.

• Si nous voulons accéder plus facilement aux données, nous pouvons également utiliser le cloud.
serveur de données autre que SQL.
• Nous pouvons également apporter des modifications à ce projet en fonction de

exigences de
• utilisateur/client.
• Pas de redondance.
 • L'objectif principal du projet est de stocker l'ensemble des informations
sous un seul numéro de contact.
3. EXIGENCE LOGICIELLE :

Après avoir analysé les exigences de notre projet, nous avons conclu que
nos utilisateurs de projet nécessitent les exigences suivantes.

3.1 INTERFACE UTILISATEUR

• Tkinter a été utilisé pour développer l'interface graphique utilisateur pour le

système
• Python est utilisé pour créer toutes les validations et le scripting côté client
Fonctionnalité

3.2 EXIGENCE EN MATÉRIEL

❖ Système d'exploitation moderne :

• Windows 7 ou 10
• Mac OS
❖ CPU x86 64 bits (architecture Intel / AMD)
❖ 4 Go de RAM

3.3 EXIGENCES LOGICIELLES

• VS CODE
Python est un langage de programmation populaire disponible pour la plupart des modernes
systèmes d'exploitation informatiques. Visual Studio Code est un éditeur de code redéfini
et optimisé pour la construction et le débogage d'applications web et cloud modernes

applications.
3.4 EXIGENCES FONCTIONNELLES
Un document d'exigences fonctionnelles vous aide à définir la fonctionnalité
d'un système ou de l'un de ses sous-systèmes

* Détails des opérations effectuées sur chaque écran

Il devrait avoir des descriptions des rapports système ou d'autres résultats

Il devrait clairement définir qui sera autorisé à créer/modifier/supprimer le

données dans le système

3.5 EXIGENCES NON FONCTIONNELLES

Scalabilité

• Fiabilité

Disponibilité

Maintenabilité

4. CYCLE DE VIE DU DÉVELOPPEMENT LOGICIEL :

Le développement de produits réussis avec des aspects de satisfaction client peut

sonne plus facile à dire qu'à faire car cela demande pas mal de temps, d'énergie, et
cerveaux. De nombreux modèles et techniques sont suivis pour le logiciel
le développement de nos jours mais le plus utilisé s'appelle logiciel
Cycle de vie du développement (SDLC) ou modèle en cascade.
En d'autres termes, un modèle de cycle de vie cartographie les diverses activités effectuées sur
un produit logiciel depuis sa création jusqu'à sa retraite. Différents cycles de vie
les modèles peuvent planifier les activités de développement nécessaires aux phases dans
différentes manières. Ainsi, aucun élément dans lequel le modèle de cycle de vie est suivi,
les activités essentielles sont contenues dans tous les modèles de cycle de vie bien que le
L'action peut être effectuée dans des ordres distincts dans différents modèles de cycle de vie.
À chaque étape du cycle de vie, plusieurs activités peuvent également être réalisées.

Le SDLC est un processus systématique pour construire des logiciels qui garantit la qualité.
et la précision du logiciel construit. Le processus SDLC vise à produire un logiciel de haute qualité.

un logiciel de qualité qui répond aux attentes des clients. Le système

Le développement doit être terminé dans le cadre de temps et de coûts pré-définis.
Le SDLC consiste en un plan détaillé qui explique comment planifier, construire et
maintenir des logiciels spécifiques. Chaque phase du cycle de vie du SDLC a la sienne
processus et livrables qui alimentent la phase suivante.

SDLC signifie Cycle de vie du développement logiciel et est également appelé

comme le cycle de vie du développement d'applications. Le SDLC vise à produire un
un logiciel de haute qualité qui répond ou dépasse les attentes des clients,
atteint l'achèvement dans les délais et les estimations de coûts.

• SDLC est l'acronyme du cycle de vie du développement logiciel.

• Il est également appelé processus de développement logiciel.

• Le SDLC est un cadre définissant les tâches effectuées à chaque étape dans le
processus de développement logiciel.

• ISO/IEC 12207 est une norme internationale pour le cycle de vie des logiciels
processus. Il vise à être la norme qui définit toutes les tâches
nécessaire pour le développement et la maintenance de logiciels.
Un cycle de vie de développement des systèmes est composé d'un certain nombre de clairement
phases de travail définies et distinctes utilisées par les systèmes
ingénieurs et développeurs de systèmes pour planifier, concevoir, construire, tester, et
systèmes d'information de livraison. Comme tout ce qui est fabriqué sur
une chaîne de production, un SDLC vise à produire des systèmes de haute qualité qui
rencontrer ou dépasser les attentes des clients, en fonction des clients
exigences, en livrant des systèmes qui se déplacent à travers chacun
phase clairement définie, dans des délais et des coûts prévus
estimations. Les systèmes informatiques sont complexes et souvent (surtout avec
la montée récente de l'architecture orientée service) relie plusieurs
systèmes traditionnels potentiellement fournis par différents logiciels
fournisseurs. Pour gérer ce niveau de complexité, un certain nombre de SDLC
modèles ou méthodologies avoir été créé tel
comme une cascade logiciel développement rapide
prototypage, incrémental, et synchroniser et stabiliser. Le SDLC peut être
décrit le long d'un spectre allant de l'agile à l'itératif en passant par le séquentiel
méthodologies. Le SDLC n'est pas une méthodologie à proprement parler, mais plutôt un
 description des phases du cycle de vie d'une application logicielle.
Ces phases (en termes larges) sont : investigation, analyse, conception,
construire, tester, mettre en œuvre, et maintenance et support. Un processus
suivi dans les projets logiciels est le SDLC. Chaque phase du SDLC
produit les résultats requis par la prochaine phase du cycle de vie.
Les exigences sont traduites en conception. Le code est produit conformément.
au design. Les tests doivent être effectués sur un produit développé basé
sur l'exigence. Le déploiement doit être effectué une fois les tests
a été complété. Il vise à produire un système de haute qualité qui répond
ou dépasse les attentes des clients, travaille efficacement et de manière efficiente dans
l'infrastructure des technologies de l'information actuelle et prévue, et
est peu coûteux à entretenir et rentable à améliorer.

Besoins du cycle de vie du développement logiciel

L'équipe de développement doit déterminer un modèle de cycle de vie approprié pour

un plan particulier et ensuite l'observer. Sans utiliser une vie exacte
dans le modèle en cycle, le développement d'un produit logiciel ne serait pas dans un
manière systématique et disciplinée. Lorsqu'une équipe développe un
produit logiciel, il doit y avoir une compréhension claire parmi l'équipe
représentant sur quand et quoi faire. Sinon, cela indiquerait
au chaos et à l'échec du projet.

Il se compose principalement des sept étapes suivantes :

Phases du SDLC
4.1 DIAGRAM-
4.2 : Collecte et analyse des exigences :
L'exigence est la première étape du processus SDLC. Elle est réalisée par
les membres seniors de l'équipe avec les contributions de toutes les parties prenantes et du domaine
experts de l'industrie. Planification des exigences en matière d'assurance qualité
et la reconnaissance des risques impliqués est également faite à ce stade.
Cette étape donne une image plus claire de l'étendue de l'ensemble du projet et le
problèmes anticipés, opportunités et directives qui ont déclenché le projet.
L'étape de collecte des exigences nécessite que les équipes soient détaillées et précises.
exigences. Cela aide les entreprises à finaliser le calendrier nécessaire pour
terminez le travail de ce système.

L'analyste commercial recueille les exigences du client conformément à

les besoins commerciaux du client et documente les exigences dans le
Spécification des exigences commerciales (le nom du document varie selon)
l'Organisation. Quelques exemples sont le Cahier des charges des exigences client
(CRS), Spécification Commerciale (BS), etc., et fournit cela à
Équipe de développement.

Étude de faisabilité :

Une fois la phase d'analyse des besoins terminée, la prochaine étape du SDLC est de
définir et documenter les besoins logiciels. Ce processus a été mené avec le
aide du document 'Spécification des exigences logicielles' également connu sous le nom de
le document 'SRS'. Il comprend tout ce qui doit être conçu et
développé pendant le cycle de vie du projet.

Il existe principalement cinq types de vérifications de faisabilité :

• Économique : Pouvons-nous compléter le projet dans le budget ou non ?

• Juridique : Pouvons-nous gérer ce projet comme droit des cybernétique et autres
cadre réglementaire/conformités.
• Faisabilité de l'opération : Pouvons-nous créer des opérations qui sont
attendu par le client ?
• Technique : Besoin de vérifier si le système informatique actuel
peut prendre en charge le logiciel.
• Calendrier : Décidez que le projet peut être terminé dans les
qu'il y ait un horaire ou non.
4.3-Conception :

Dans cette troisième phase, les documents de conception du système et des logiciels sont
préparé conformément au document de spécification des exigences. Cela aide à définir
architecture système globale.

Cette phase de conception sert d'entrée pour la phase suivante du modèle.

Il existe deux types de documents de conception développés à ce stade :

Conception de Haut Niveau (HLD)

• Brève description et nom de chaque module

• Un aperçu de la fonctionnalité de chaque module
• Relation d'interface et dépendances entre les modules
• Tables de base de données identifiées avec leurs éléments clés
• Diagrammes d'architecture complets avec détails technologiques

Conception de bas niveau (LLD)

• Logique fonctionnelle des modules

• Tables de base de données, qui incluent le type et la taille
• Détails complets de l'interface
• Adresse tous les types de problèmes de dépendance
• Liste des messages d'erreur
• Entrées et sorties complètes pour chaque module
CONCEPTION LOGICIELLE :

La conception logicielle est un processus visant à transformer les exigences des utilisateurs en quelque chose.

forme adaptée, qui aide le programmeur dans le codage logiciel et

mise en œuvre. Pour évaluer les besoins des utilisateurs, un SRS (Spécification des Exigences du Logiciel)
Un document de spécification des exigences est créé alors que, pour le codage et
mise en œuvre, il y a un besoin de plus spécifique et détaillé
exigences en termes de logiciel. Le résultat de ce processus peut directement être
utilisé pour l'implémentation dans les langages de programmation.

La conception logicielle est la première étape du SDLC (Cycle de Vie de Conception Logicielle),
qui déplace la concentration du domaine du problème vers la solution
domaine. Il essaie de spécifier comment satisfaire les exigences mentionnées dans
SRS.
La réactivité de la conception logicielle implique la rapidité du logiciel.
réaction du produit aux entrées utilisateur, aux stimuli d'interface externe, ou
interactions avec les éléments de l'environnement informatique. Le logiciel
la conception structurelle doit être évaluée pour déterminer si le design peut être
amélioré pour améliorer la réactivité du produit logiciel aux demandes
actions. Les lignes directrices suivantes sont fournies pour améliorer le
réactivité du logiciel aux demandes des utilisateurs.

1. Fournir un retour d'information opportun concernant l'action demandée :

• Accuser immédiatement réception de la saisie de l'utilisateur.

• Fournir des indicateurs de progression du traitement des données pour les actions prenant un
une quantité significative de temps.

• Répondez d'abord en fournissant les informations les plus importantes.

puis divulguer des informations supplémentaires lorsqu'elles deviennent disponibles.

• Alertez l'utilisateur concernant le délai anticipé nécessaire pour

répondre à des demandes compliquées.

2. Prioriser les actions de traitement des données :

• Reporter les actions de traitement des données de faible priorité jusqu'à ce que le calcul
les ressources sont disponibles.

• Anticiper les besoins en traitement des données et effectuer des actions à l'avance,
quand c'est possible.
 3. Optimiser le retard de la file d'attente des tâches :

• Réorganisez la file d'attente des tâches en fonction de la priorité.

• Éliminer les tâches qui sont dépassées par les événements ou qui ne sont peut-être plus d'actualité.
nécessaire.

4. Supervision des performances multitâches :

• Surveillez l'avancement du multitâche et ajustez les allocations de ressources pour

optimiser l'exécution et la terminaison des tâches.

• Équilibrez la durée des tâches et les engagements en ressources.

• Prédire les durées des tâches et déterminer la discontinuité des tâches,
concurrence et tactiques de synchronisation.
• Établir la surveillance des ressources et la supervision de l'intercession
procédures en anticipant les conflits de ressources et l'impasse
situations.

Niveaux de conception de logiciel

La conception logicielle produit trois niveaux de résultats :

• Conception architecturale : La conception architecturale est la plus élevée

version abstraite du système. Il identifie le logiciel en tant que système
avec de nombreux composants interagissant les uns avec les autres. À ce niveau, le
les designers comprennent l'idée du domaine de la solution proposée.

• Conception de haut niveau : La conception de haut niveau décompose l'entité unique -

concept de composant multiple en conception architecturale dans un moins-
vue abstraite des sous-systèmes et des modules et décrit leur
interaction les uns avec les autres. La conception de haut niveau se concentre sur la façon dont le
le système ainsi que tous ses composants peuvent être mis en œuvre dans le
forme de modules. Elle reconnaît la structure modulaire de chaque sous-
système et leur relation et interaction entre eux.

• Conception détaillée : La conception détaillée concerne l'implémentation

 une partie de ce qui est considéré comme un système et ses sous-systèmes dans le précédent
deux conceptions. Il est plus détaillé concernant les modules et leur
implémentations. Il définit la structure logique de chaque module et leur
interfaces pour communiquer avec d'autres modules.

Le SRS (Spécification des Exigences Logiciels) préparé en

l'étape précédente qui indique les exigences est maintenant la conception

utiliser le format spécifique. L'objectif de cette phase est comment

convertir l'exigence dans la structure afin que le
Le logiciel peut répondre à tous les besoins. Le résultat de cela
phase estSDD (Description de la conception logicielle).

La justesse : La justesse du point de vue de l'ingénierie logicielle peut être

défini comme l'adhésion aux spécifications qui déterminent comment les utilisateurs
peut interagir avec le logiciel et comment le logiciel doit se comporter lorsque cela
est utilisé correctement.

Si le logiciel se comporte de manière incorrecte, cela pourrait prendre une quantité considérable de

temps pour accomplir la tâche ou parfois il est impossible de l'accomplir. A

un programme est correct lorsqu'il se comporte exactement comme prévu, et de aucune autre manière.
La condition minimale requise pour atteindre la correction est la sécurité. Les ingénieurs ne devraient pas

faire confiance à leur propre code ou laisser les autres penser qu'il est fiable sans preuve.
Pour qu'un logiciel soit considéré comme correct, un ingénieur doit démontrer que
leur programme fonctionne comme prévu, correspondant aux spécifications. Il y a plusieurs
des outils qui peuvent aider un ingénieur à démontrer la validité de son code.

Règles importantes :
Ci-dessous, quelques-unes des règles importantes pour une programmation efficace qui
sont des conséquences de la théorie de la correction des programmes.

• Définir le problème complètement.

• Développez l'algorithme puis la logique du programme.

• Réutilisez les modèles prouvés autant que possible.

• Prouvez la validité des algorithmes durant la phase de conception.

• Les développeurs doivent prêter attention à la clarté et à la simplicité de votre

programme.
• Vérifier chaque partie d'un programme dès qu'elle est développée.

Portabilité : Les tests de portabilité sont un processus de test effectué facilement avec
quel logiciel ou produit peut être déplacé d'un environnement à l'autre
un autre. Il est mesuré en termes de la quantité maximale d'effort requise pour
transférer d'un système à un autre système.
Les tests de portabilité sont effectués régulièrement tout au long du logiciel.
cycle de vie de développement de manière itérative et incrémentale.

Attributs des tests de portabilité :

• Adaptabilité
 • Installabilité
• Remplaçabilité
• Co-existence

Listes de contrôle pour les tests de portabilité :

• Vérifiez si l'application est capable de répondre aux exigences de portabilité.

• Déterminez l'apparence et la convivialité de l'application dans les différents navigateurs
types et différentes versions de navigateurs.

• Signalez les défauts aux équipes de développement afin qu'elles puissent être
les défauts associés peuvent être corrigés.
• Les échecs lors des tests de portabilité peuvent aider à identifier les défauts
qui n'ont pas été détectés durant les tests unitaires et d'intégration.

Efficacité : L'efficacité est très souvent confondue avec l'efficience.

En général, l'efficacité est un concept mesurable, déterminé quantitativement par
le rapport entre la sortie utile et l'entrée utile totale. L'efficacité est plus simple
concept d'être capable d'atteindre un résultat souhaité, qui peut être exprimé
quantitativement mais ne nécessite généralement pas de mathématiques plus compliquées
que l'addition.
Le test d'efficacité évalue le nombre de ressources requises par un programme pour
exécuter une fonction spécifique. Dans les entreprises de logiciels, ce terme est utilisé pour
montrez l'effort déployé pour développer l'application et pour quantifier son utilisateur
satisfaction.
Ceci se concentre principalement sur la disponibilité des ressources, des outils, des personnes, du temps, du type de

projet, complexité, situation, exigences du client, etc. C'est une mesure de

à quel point l'équipe effectue le travail requis pour obtenir un résultat utile. L'efficacité est
l'un des paramètres. Il ne peut jamais être supérieur à 100 %. Par définition,
l'efficacité est le rapport de la production à l'entrée exprimé en pourcentage.

Ce n'est pas une seule formule mais un certain nombre de calculs à chaque étape.
et l'activité de test. Prenons l'exemple d'une équipe où le
le gestionnaire voudrait livrer le produit à temps, dans le budget, sans
comprendre avec la qualité.
L'efficacité des tests est une qualité de l'équipe QA, c'est-à-dire de réaliser tous les tests.
des activités de manière efficace. Il ne s'agit pas seulement de l'exécution des cas de test
seul. Cela inclut la planification des tests, la création de cas de test, la révision, l'exécution,
suivi des défauts, compréhension et surtout, travail d'équipe.

La flexibilité : La flexibilité dans la gestion de projet permet aux gestionnaires de

organiser systématiquement les charges de travail et les ressources. Ils peuvent se répartir uniformément.

les pics et les creux dans la demande et échelonner les dates de début des différentes
projets. Cela rend leur flux de trésorerie et leur calendrier plus cohérents et leur
vit moins stressante.

La flexibilité du projet fait référence à la capacité d'un projet à varier sa production en fonction des coûts.
manière efficace au cours de son cycle de vie ou d'un délai donné. C'est un qualitatif
caractéristique qui détermine à quelle vitesse le projet est capable de s'adapter à
variances et changements survenant dans l'environnement du projet.

Un projet flexible peut toujours produire un résultat souhaité dans un environnement changeant.
environnement. La flexibilité permet au projet d'être efficacement
répondre aux changements et se diriger vers un accomplissement réussi. Cela
implique des discussions sur les compromis concernant les contraintes clés du projet
tel que

• Portée
• Ressources
• Horaire

Un projet atteint la flexibilité lorsque ses contraintes sont clairement définies dans le
plan de projet qui inclut des actions pour gérer toute variation dans le périmètre,
ressources et emploi du temps.

La matrice de flexibilité du projet est souvent conçue pour définir et évaluer le

contraintes clés. Une telle matrice clarifie quelles contraintes sont flexibles et
peut éventuellement être modifié durant le cycle de vie du projet. La matrice est généralement
conçu au stade de la définition du projet et utilisé tout au long du projet comme
un mécanisme pour évaluer la valeur de chaque contrainte.

Cohérence : La cohérence, définie comme l'exigence qu'une série de

mesures du même projet réalisées par différents évaluateurs utilisant le
la même méthode devrait produire des résultats similaires, est l'une des plus importantes
aspects à prendre en compte dans les méthodes de mesure de la
Le logiciel. Les mesures fonctionnelles sont nécessaires à la gestion de projet,
qui comprend deux fonctions principales : la planification et le contrôle. Toutes deux
nécessite la capacité de mesurer le logiciel de manière précise et fiable.
La planification de la gestion de projet met l'accent sur l'estimation des budgets.
Le contrôle de développement nécessite de mesurer l'avancement du projet et
permet d'évaluer l'efficacité des outils utilisés dans le projet
développement afin d'améliorer la productivité.

• Être simple et facile à utiliser. Ils devraient être faciles à apprendre et leur
l'application ne devrait pas nécessiter un grand effort ni beaucoup de temps.

• Pour être convaincant. Les métriques doivent être en accord avec ce que notre
l'intuition suggère.

• Être fiable. En partant de la même information, plusieurs mètres

devrait obtenir des résultats vraiment similaires.

• Être d'accord avec les principes de la théorie de la mesure. Principalement, comme

concerns la performance des opérations mathématiques autorisées par le
type d'échelle correspondant.
Maintenabilité : La maintenabilité signifie réparer, mettre à jour, entretenir et
modifier le système ou mettre à jour le logiciel pour la performance
améliorations ou pour la correction des défauts”. La maintenabilité inclut également
l'ajout de nouvelles fonctionnalités ou l'adaptation de logiciels pour répondre à de nouveaux
exigences pour les besoins du client.

La maintenabilité des logiciels est le degré de la capacité d'une application à être réparée ou
amélioré. La maintenabilité augmente la fiabilité, l'efficacité ou la sécurité de
le logiciel. Il est également utilisé pour faciliter la maintenance future. Il est utilisé pour
augmenter la durée de vie du logiciel.

Maintenabilité réparer ou remplacer les composants défectueux et mettre le

logiciel encore meilleur par rapport à l'état précédent du
logiciel.
La maintenance des logiciels est nécessaire lorsque le client demande de nouvelles fonctionnalités.
fonctionnalités et nouvelles fonctions dans le logiciel. Parfois, la maintenance est
nécessaire lorsque le matériel du système est modifié alors le
une modification du logiciel est nécessaire.
Les conditions du marché et les changements organisationnels sont également les raisons de
modification de logiciel. Cela inclut également que lorsque le problème est détecté,
réparez-le immédiatement avant qu'il ne devienne un gros problème. Parfois, les virus et
des malwares sont détectés dans le logiciel, ce qui cause des problèmes pour l'utilisateur
que la maintenance logicielle est nécessaire pour le corriger ou l'améliorer
performance.

Avantages de la maintenabilité des logiciels

La maintenance logicielle comprend :

• Améliorations des performances

• Divers corrections de bogues
• À jour avec les tendances actuelles
• Pas besoin de dépenser des sous supplémentaires

• Contribue positivement à la réputation des entreprises

Inconvénient de la maintenabilité des logiciels

• Plus d'argent à l'avance

• Surentretien
• Plus de travailleurs

Codage :
Une fois la phase de conception du système terminée, la prochaine phase est le codage. Dans ce
phase, les développeurs commencent à construire l'ensemble du système en écrivant du code en utilisant le
langage de programmation choisi. Dans la phase de codage, les tâches sont divisées en
unités ou modules et assignés aux différents développeurs. C'est le plus long
phase du processus du cycle de vie du développement logiciel.

Dans cette phase, le développeur doit suivre certaines règles de codage préétablies.
directives. Ils doivent également utiliser des outils de programmation comme un compilateur,
interprètes, débogueur pour générer et mettre en œuvre le code.

Une fois le logiciel terminé et déployé dans les tests

environnement. L'équipe de test commence à tester la fonctionnalité de l'ensemble
système. Cela est fait pour vérifier que l'ensemble de l'application fonctionne conformément à
le besoin du client.
Au cours de cette phase, l'équipe d'assurance qualité et de test peut trouver des bogues/défauts qui
ils communiquent aux développeurs. L'équipe de développement corrige lebogue et
renvoyer à l'assurance qualité pour un nouveau test. Ce processus se poursuit jusqu'à ce que le logiciel soit

sans bogue, stable et fonctionnant selon les besoins de l'entreprise.

système.

Lorsque le logiciel est prêt, il est envoyé au département de test où le Test

l'équipe le teste soigneusement pour différents défauts. Ils testent soit le logiciel
manuellement ou en utilisant des outils de test automatisés dépend du processus défini
dans le STLC (Cycle de Vie des Tests Logiciels) et s'assurer que chacun et chacune
le composant du logiciel fonctionne bien. Une fois que l'assurance qualité s'assure que le
le logiciel est sans erreur, il passe à l'étape suivante, qui est l'Implémentation.
Le résultat de cette phase est le Produit de Qualité et les Artefacts de Test

4.5. TESTING :

Le but du test est de découvrir des erreurs. Le test est le processus d'essai.
pour découvrir tous les défauts ou faiblesses envisageables dans un produit de travail.
fournit un moyen de vérifier la fonctionnalité des composants, des sous-ensembles,
assemblées, et/ou un produit fini. C'est un processus d'exécution de logiciel
dans le but de s'assurer que le système logiciel répond à ses exigences
et les attentes des utilisateurs et ne faillit pas de manière inacceptable.

Les tests sont essentiels au succès de tout logiciel. Aucun design de système n'est parfait.
Les tests améliorent l'intégrité d'un système en détectant les écarts dans la conception.
et des erreurs dans le système.

Les tests sont un ensemble de techniques visant à déterminer l'exactitude de la

application sous le script prédéfini mais, les tests ne peuvent pas trouver tous les
défaut d'application. L'intention principale des tests est de détecter les échecs de la
application afin que les erreurs puissent être découvertes et corrigées. Elle ne
démontrer qu'un produit fonctionne correctement dans toutes les conditions mais
seulement que cela ne fonctionne pas dans certaines conditions spécifiques.

Le test fournit une comparaison qui compare le comportement et l'état de

logiciels contre les mécanismes car le problème peut être reconnu par
le mécanisme. Le mécanisme peut inclure des versions antérieures du même
produit spécifié, produits comparables et interfaces attendues
objectif, normes pertinentes, ou d'autres critères mais sans s'y limiter.

Les tests incluent un examen du code et également l'exécution du code dans

divers environnements, conditions ainsi que tous les aspects d'examen de la
code. Dans le scénario actuel du développement logiciel, une équipe de test peut
être séparé de l'équipe de développement afin que les informations dérivées de
Les tests peuvent être utilisés pour corriger le processus de développement logiciel.

Le succès d'un logiciel dépend de l'acceptation de son public cible.

interface graphique facile à utiliser, test de charge robuste, etc. Pour
par exemple, le public de la banque est totalement différent de celui d'un
jeu vidéo. Par conséquent, lorsqu'une organisation développe un produit logiciel,
il peut évaluer si le produit logiciel sera bénéfique pour ses
acheteurs et autre public.

Objectifs de test

1. Le test est le processus d'exécution du programme avec l'intention de trouver

erreurs.
2. Évaluer les produits de travail tels que les exigences, la conception, les histoires d'utilisateur,
et le code.

3. Vérifier le respect de toutes les exigences spécifiées.

4. Valider si l'objet de test est complet et fonctionne selon les attentes

des utilisateurs et des parties prenantes.

5. Construire la confiance dans le niveau de qualité de l'objet de test

6. Pour prévenir les défauts dans le produit logiciel.

7. Fournir suffisamment d'informations aux parties prenantes pour leur permettre de prendre des décisions
des décisions éclairées, en particulier concernant le niveau de qualité de l'objet de test.

8. Réduire le niveau de qualité logicielle insuffisante.

9. Pour se conformer aux exigences contractuelles, légales ou réglementaires, ou

normes, et à vérifier la conformité des objets de test avec cette exigence
ou standard.
10. Trouver des défauts dans le produit logiciel.

Approches de test

• Test de boîte noire

Il est réalisé pour tester la fonctionnalité du programme. On l'appelle aussi

Test de comportement. Le testeur, dans ce cas, dispose d'un ensemble de valeurs d'entrée et
résultats souhaités respectifs. En fournissant une entrée, si la sortie correspond à
les résultats souhaités, le programme est testé 'ok', et problématique sinon.

Dans cette méthode de test, la conception et la structure du code ne sont pas connues
au testeur, et les ingénieurs de test et les utilisateurs finaux effectuent ce test sur le
logiciel.

Techniques de test en boîte noire :

 • Classe d'équivalence : L'entrée est divisée en classes similaires. Si l'un
un élément d'une classe réussit le test, on suppose que toute la classe est
réussi.
• Valeurs limites : L'entrée est divisée en extrémités supérieures et inférieures
valeurs. Si ces valeurs passent le test, il est supposé que toutes les valeurs dans
entre mai passe aussi.
• Graphique de cause à effet : Dans les deux méthodes précédentes, il n'y a qu'une seule entrée.
La valeur à un moment donné est testée. Cause (entrée) – Effet (sortie) est un test.
technique où des combinaisons de valeurs d'entrée sont testées dans un
méthode systématique.

• Test de paires : Le comportement d'un logiciel dépend de plusieurs

paramètres. Dans les tests par paires, les multiples paramètres sont testés
paires pour leurs différentes valeurs.
• Tests basés sur l'état : Le système change d'état lors de la fourniture de
Ces systèmes sont testés en fonction de leurs états et de leurs entrées.

Test de boîte blanche

Il est réalisé pour tester le programme et son application, afin de l'améliorer.

l'efficacité du code ou sa structure. On l'appelle aussi test 'structurel'.
Dans cette méthode de test, la conception et la structure du code sont connues.
le testeur. Les programmeurs du code effectuent ce test sur le code.

Voici quelques techniques de test en boîte blanche :

• Test de flux de contrôle : L'objectif des tests de flux de contrôle

établir des cas de test qui couvrent toutes les instructions et les branches
conditions. Les conditions de branche sont testées pour les deux étant
vrai et faux, de sorte que toutes les affirmations puissent être couvertes.

• Tests de flux de données : Cette technique de test met l'accent sur la couverture
toutes les variables de données incluses dans le programme. Cela teste où
les variables ont été déclarées et définies et où elles étaient
utilisé ou changé.

Test Alpha

Les tests Alpha sont définis comme un type de test logiciel effectué pour
identifier les bogues avant de lancer le produit auprès des utilisateurs réels ou du public.
Les tests d'acceptation sont parfois appelés tests alpha.

Les tests alpha sont réalisés au sein de l'organisation et testés par un

groupe représentatif d'utilisateurs finaux du côté du développeur et parfois
par une équipe indépendante de testeurs.
Les tests alpha sont des tests opérationnels simulés ou réels sur un site interne. Il
vient après les tests unitaires, les tests d'intégration, etc. Les tests Alpha utilisés
après que tous les tests ont été exécutés.

Cela peut être un test en boîte blanche ou un test en boîte noire selon les exigences.
environnement de laboratoire particulier et simulation de l'environnement réel
nécessaire pour ce test.

Les tests alpha suivent le processus suivant :

1.Revue des exigences : Examinez la conception de la spécification et

exigence fonctionnelle
2.Développement de test : Le développement de tests est basé sur le résultat de la
examen des exigences. Développez les cas de test et le plan de test.
3.Conception des cas de test : Exécutez le plan de test et les cas de test.

4. Enregistrement des défauts : Enregistrement des bogues identifiés et détectés trouvés dans

l'application.
5. Correction de bugs : Lorsque tous les bugs sont identifiés et enregistrés, alors
il est nécessaire de corriger le bug.
6.Retest : Lorsque tous les problèmes sont résolus et corrigés, le retest est effectué.
Tests bêta
Les tests bêta, également connus sous le nom de tests utilisateurs, ont lieu sur le site de l'utilisateur final.
les utilisateurs finaux pour valider l'utilisabilité, la fonctionnalité, la compatibilité et
test de fiabilité.
Les tests bêta ajoutent de la valeur au cycle de vie du développement logiciel car ils permettent
le client "réel" une opportunité de fournir des contributions au design,
fonctionnalité et convivialité d'un produit. Ces retours ne sont pas seulement cruciaux
au succès du produit mais aussi un investissement dans les produits futurs
lorsque les données collectées sont gérées efficacement.
Niveaux de test :

• Tests unitaires
Les tests unitaires sont une technique de test logiciel par laquelle
unités individuelles de logiciel i. groupe de modules de programmes informatiques, utilisation
les procédures et les procédures opérationnelles sont testées pour déterminer si
ils sont adaptés à l'utilisation ou non. C'est une méthode de test grâce à laquelle chaque
des modules indépendants sont testés pour déterminer s'il y a des problèmes par
le développeur lui-même. Cela est corrélé avec la correction fonctionnelle de
modules indépendants.
Lors de la programmation, le programmeur effectue des tests sur cette unité de
programme pour savoir si c'est sans erreur. Les tests sont effectués sous le blanc-
approche de test boîte. Les tests unitaires aident les développeurs à décider que chaque individual
Les unités du programme fonctionnent conformément aux exigences et sont sans erreur.

Les tests unitaires sont définis comme un type de test logiciel où les éléments individuels
les composants d'un logiciel sont testés.

Les tests unitaires d'un produit logiciel sont effectués pendant le développement de
une application. Un composant individuel peut être soit un individu
fonction ou une procédure. Les tests unitaires sont généralement effectués par le
développeur

Objectif des tests unitaires :

L'objectif des tests unitaires est :
• Pour isoler une section de code.
• Pour vérifier l'exactitude du code.
• Tester chaque fonction et procédure.
• Pour corriger les bogues tôt dans le cycle de développement et réduire les coûts.
• Pour aider les développeurs à comprendre la base de code et à permettre
les amener à apporter des changements rapidement.

• Pour aider à la réutilisation du code.

Tests d'intégration
Les tests d'intégration sont le processus de test de l'interface entre deux
unités ou modules logiciels. Il se concentre sur la détermination de la justesse de la
interface. Le but des tests d'intégration est de révéler des défauts dans le
interaction entre unités intégrées. Une fois que tous les modules ont été unifiés
testé, des tests d'intégration sont effectués.

Même si les unités de logiciel fonctionnent bien individuellement, il y a un besoin

pour découvrir si les unités
s'il était intégré, cela fonctionnerait également sans erreurs. Par exemple, argument
passage et données
mise à jour, etc.
À l'issue des tests unitaires, les unités ou modules doivent être intégrés.
ce qui donne lieu aux tests d'intégration. Le but des tests d'intégration
est de vérifier la fonctionnalité, la performance et la fiabilité entre le
modules qui sont intégrés.
Les tests d'intégration sont le deuxième niveau du processus de test logiciel.
vient après les tests unitaires. Dans ce test, les unités ou les composants individuels de
les logiciels sont testés en groupe. L'accent est mis sur le test d'intégration
le niveau est d'exposer les défauts au moment de l'interaction entre intégrés
composants ou unités.

• Nous procédons aux tests d'intégration seulement après que les tests fonctionnels soient terminés.
complété sur chaque module de l'application.
• Nous faisons toujours des tests d'intégration en choisissant module par module donc
qu'une séquence appropriée est suivie, et aussi nous ne manquons rien
scénarios d'intégration.
• Tout d'abord, déterminez la stratégie de cas de test à travers laquelle un test exécutable
les cas peuvent être préparés en fonction des données de test.

• Examinez la structure et l'architecture de l'application et

identifiez les modules cruciaux à tester en premier et identifiez également tous
scénarios possibles.
 • Concevez des cas de test pour vérifier chaque interface en détail.
• Choisissez les données d'entrée pour l'exécution des cas de test. Les données d'entrée jouent un rôle
rôle significatif dans les tests.
• Si nous trouvons des bogues, communiquez les rapports de bogues aux développeurs
et corriger les défauts et retester.

• Réaliser des tests d'intégration positifs et négatifs.

Tests de système
Les tests système sont effectués sur un système complet et intégré. Cela permet
vérifier la conformité du système selon les exigences. Il teste le
interaction globale des composants. Cela implique la charge, les performances, la fiabilité,
et tests de sécurité.

Le test système (ST) est une technique de test boîte noire effectuée pour évaluer
le système complet la conformité du système par rapport aux spécifications
exigences. Dans les tests système, les fonctionnalités du système sont
testé d'un point de vue de bout en bout.

Les tests système sont généralement effectués par une équipe qui est indépendante de la
équipe de développement afin de mesurer la qualité du système de manière impartiale.
Cela inclut à la fois des tests fonctionnels et non fonctionnels.

Dans les tests système, les composants réussis aux tests d'intégration sont pris comme
L'objectif des tests d'intégration est de détecter toute irrégularité entre
les unités qui sont intégrées ensemble. Les tests système détectent les défauts
au sein des unités intégrées et du système entier. Le résultat de
les tests système sont le comportement observé d'un composant ou d'un système
lorsqu'il est testé.

Les tests système sont effectués sur l'ensemble du système dans le contexte de
soit spécifications des exigences système ou exigences fonctionnelles
les spécifications ou dans le contexte des deux. Les tests système vérifient la conception
et le comportement du système ainsi que les attentes du client. Cela
est effectué pour tester le système au-delà des limites mentionnées dans
lespécification des exigences logicielles (SEL).
 Les tests système sont effectués après les tests d'intégration et avant le
tests d'acceptation.

Processus de Test Système :

Le test système est effectué dans les étapes suivantes :

• Configuration de l'environnement de test :

Créer un environnement de test pour une meilleure qualité de test.

• Créer un cas de test :

Générez un cas de test pour le processus de test.

• Créer des données de test :

Générez les données à tester.

• Exécuter le cas de test :

Après la génération du cas de test et des données de test, les cas de test sont
exécuté.
• Rapport de défaut
Des défauts dans le système sont détectés.
• Tests de régression :
Il est effectué pour tester les effets secondaires du processus de test.
• Défauts de journal :

Les défauts sont corrigés à cette étape.

• Retest :
Tests d'acceptation

Les tests d'acceptation sont des tests effectués pour déterminer si les exigences d'un
les spécifications ou le contrat sont respectés conformément à sa livraison. Les tests d'acceptation sont
fondamentalement fait par l'utilisateur ou le client.

C'est un type de test effectué par des utilisateurs, des clients ou d'autres personnes autorisées.
entités pour déterminer les besoins en application/logiciel et les processus commerciaux.

Les tests d'acceptation sont la phase la plus importante des tests, car cela décide
que le client approuve ou non l'application/le logiciel. Cela peut impliquer
fonctionnalité, utilité, performance et interface utilisateur de l'application. C'est aussi
connu sous le nom de test d'acceptation utilisateur (TAU), test d'acceptation opérationnelle
(OAT) et tests utilisateurs.
C'est l'une des étapes finales du cycle de test du logiciel et se produit souvent
avant qu'un client ou un consommateur n'accepte la nouvelle application. Tests d'acceptation
sont des tests de système en boîte noire. Les utilisateurs du système effectuent des tests en fonction de

ce qui se passerait dans des scénarios en temps réel et vérifier si oui ou non le
le logiciel/l'application répond à toutes les spécifications.
Critères d'acceptation

Les critères d'acceptation sont définis sur la base des attributs suivants
• Correction fonctionnelle et exhaustivité
• Intégrité des données
• Conversion de données
• Utilisabilité
• Performance
• Ponctualité
• Confidentialité et Disponibilité
• Installabilité et Améliorabilité
• Scalabilité
• Documentation

Plan de Test d'Acceptation–Attributs

Les activités de test d'acceptation sont réalisées par phases. Tout d'abord, les bases
des tests sont exécutés, et si les résultats des tests sont satisfaisants alors le
l'exécution de scénarios plus complexes est réalisée.
Le plan de test d'acceptation a les attributs suivants :
• Introduction
• Catégorie de test d'acceptation
• opération Environnement
• ID de cas de test
• Titre du test
 • Objectif du test
• Procédure de test
• Horaire des tests
• Ressources

Les activités de test d'acceptation sont conçues pour atteindre l'un des
conclusions :
1. Accepter le système tel que livré
2. Accepter le système après que les modifications demandées ont été apportées
3. N'acceptez pas le système

Rapport de Test d'Acceptance – Attributs

Le rapport de test d'acceptation a les attributs suivants :

• Identifiant du rapport
• Résumé des résultats
• Variations
• Recommandations
• Résumé de la liste de tâches
• Décision d'approbation
TEST DE MANUEL :

Le test manuel est un type de test logiciel dans lequel des cas de test sont
exécuté manuellement par un testeur sans utiliser d'outils automatisés. Le
Le but des tests manuels est d'identifier les bogues, les problèmes et les défauts dans le
application logicielle. Les tests manuels de logiciels sont les plus primitifs
technique de tous les types de tests et elle aide à trouver des bogues critiques dans le
application logicielle.

Le test manuel est le processus de test du logiciel manuellement pour identifier

le bogue, les problèmes et les défauts dans le produit logiciel. L'objectif d'un logiciel
le testeur doit casser le système et comprendre la réponse du système à
divers scénarios.
Le comportement observé du système est toujours vérifié par rapport à
comportement système attendu ou souhaité. S'il y a une différence entre les deux, le
le testeur soulève le problème et le signale comme un bug. Un testeur peut utiliser plusieurs
techniques de test logiciel manuel pour tester chaque aspect du logiciel
c'est fonctionnel ou non fonctionnel.

Un processus de test logiciel comprend généralement une série d'étapes pour s'assurer que
que le produit a été soigneusement testé. La première étape consiste à obtenir
compréhension commerciale de l'application. La prochaine étape est de créer un test
plan qui peut être utilisé comme un guide pour le processus de test. Ce plan de test est
créé par le responsable des tests ou le responsable QA.

Après l'élaboration du plan de test, des scénarios de test et des cas de test sont créés
manuellement. Lorsque le produit est développé et arrive pour le QA, les testeurs
exécutez ces cas de test et consignez le statut des cas de test en tant que 'Réussite/Échec'. Quand
un cas de test échoue, un problème ou un bogue est signalé. Ce bogue est assigné à un
le développeur qui le corrige et le testeur le teste à nouveau. Le cycle continue jusqu'à ce que tout
les bogues sont résolus.

Toute nouvelle application doit être testée manuellement avant que ses tests puissent être
Les tests de logiciels manuels nécessitent plus d'efforts mais sont nécessaires.
vérifier la faisabilité de l'automatisation.
4.6 : Installation/Déploiement :

Une fois la phase de test logiciel terminée et qu'aucun bogue ou erreur ne reste dans le
système, puis le processus de déploiement final commence. En fonction des retours
donné par le chef de projet, le logiciel final est publié et vérifié pour
problèmes de déploiement s'il y en a.
Après des tests réussis, le produit est livré/déployé au client
pour leur utilisation. Le déploiement est effectué par le déploiement/la mise en œuvre
ingénieurs.
Une fois que les clients commencent à utiliser le système développé, alors l'actuel
Des problèmes surgiront et devront être résolus de temps à autre.
La correction des problèmes signalés par le client se fait lors de la phase de maintenance.
100% des tests ne sont pas possibles, car la façon dont les testeurs testent le produit est
différent de la façon dont les clients utilisent le produit. La maintenance devrait être
fait conformément au SLA (Contrat de Niveau de Service).

4.7 MAINTENANCE DU SYSTÈME :

La maintenance des logiciels fait partie du cycle de vie du développement logiciel. Son
Le but principal est de modifier et de mettre à jour les applications logicielles après leur livraison.

corriger les fautes et améliorer les performances.

Les résultats obtenus du processus d'évaluation aident l'organisation à

déterminer si ses systèmes d'information sont efficaces et efficients ou
sinon. Le processus de surveillance, d'évaluation et de modification de
systèmes d'information existants pour apporter des améliorations nécessaires ou souhaitables
peut être appelé Maintenance du Système.

Le logiciel est un modèle du monde réel. Lorsque le monde réel change, le

Le logiciel nécessite des modifications chaque fois que cela est possible.

La maintenance des logiciels est une activité inclusive qui comprend les erreurs
corrections, amélioration des capacités, suppression des capacités obsolètes
et optimisation.
La maintenance signifie restaurer quelque chose à ses conditions d'origine.
L'amélioration signifie ajouter ou modifier le code pour soutenir les changements dans
la spécification de l'utilisateur. La maintenance du système conforme le système à son
les exigences originales et les améliorations ajoutent des capacités au système par
incorporer de nouvelles exigences.

Ainsi, la maintenance modifie le système existant, l'amélioration ajoute

des fonctionnalités au système existant, et le développement remplace l'existant
système. C'est une partie importante du développement système qui inclut le
activités qui corrigent les erreurs dans la conception et l'implémentation du système,
met à jour les documents et teste les données.

5.CONCLUSION :

Une personne ayant plusieurs contacts appréciera le goût de cette application,

car les membres de leur liste peuvent déranger l'utilisateur avec des éléments similaires
nom pensé appartenant à différentes catégories, pour surmonter cette personne à
Une personne peut être classée selon ses catégories respectives.
6.CODE SOURCE
 main.py

fromtkinterimport*
importer datetime
de mes personnes importer MesPersonnes

fromaddpeopleimportAddPeople
deÀproposimporterÀpropos

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

classeApplication(object):
def__init__(self,root):
self.racine

#cadres

self.top = Cadre(root, hauteur=180, bg='blanc')

self.top.pack(remplir=X)

self.bottom = Frame(root, hauteur=600, bg='#34eb95')

self.bottom.pack(remplir=X)

#design de cadre supérieur

self.top_image = PhotoImage(file='icônes/contact.png')
self.top_image_label=Label(self.top,image=self.top_image,bg='blanc')
self.top_image_label.place(x=120,y=10)

self.heading = Label(self.top,text=' Mon application de carnet d'adresses ',font='arial 20

gras',bg='blanc',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)

Voir les personnes

self.viewButton = Button(self.bottom,text=" Mes contacts ",fg="#00
0000",bg='blanc',font='arial 20 gras',
commande=self.my_people
self.viewButton.place(x=200,y=70)

Ajouter des personnes

 self.addButton = Button(self.bottom,text=" Ajouter des contacts",fg="#00000
0",bg='blanc',font='arial 20 gras',
commande=self.ajouterfonctionpersonnes)
self.addButton.place(x=200,y=184)

À propos de nous
self.aboutButton = Button(self.bottom,text=" À propos de nous ",fg="#00
0000",bg='blanc',font='arial 20 gras',
self.about_us
self.aboutButton.place(x=200,y=300)

Sortie
self.ExitButton = Bouton(self.bas, texte= Sortie ,fg
#000000, bg='blanc',
font='arial 20 gras',command=self.root.destroy)
self.ExitButton.place(x=200,y=410)

defmy_people(self):
MonPeuple()

définir à propos de nous(self):

À propos()

defajouterfonctionpersonnes(self):
AjouterDesPersonnes()

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

defprincipal():
Tk()
app=Application(racine)
root.title("Application de carnet d'adresses")
root.geometry("600x750+350+200")
root.resizable(False, False)
root.mainloop()

si__nom__=='__principal__':
principale()
 moncontact.py

de tkinter import *
importer sqlite3
deajouterdesgensimporterAjouterDesGens
fromupdateimportUpdate
de l'affichage importation Affichage

de tkinter import messagebox

con = sqlite3.connect('database.db')
cur = con.cursor()

classMesPersonnes(Toplevel):
def__init__(self):
Toplevel.__init__(self)

self.geometry("600x750+350+200")
Mon Peuple
self.resizable(False,False)

self.top = Cadre(self, hauteur=180, bg='blanc')

self.top.pack(remplir=X)

self.bottom = Cadre(self, hauteur=600, bg='#18877c')

self.bottom.pack(fill=X)

#design de cadre supérieur

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

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

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

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

self.listbox = Listbox(self.bottom, largeur=60, hauteur=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)
personnes = cur.execute("select * from 'carnet d'adresses'").fetchall()
imprimer(personnes)
count =0
pourpersonnedanslespersonnes

self.listbox.insert(count, str(person[0]) + "." + person[1] + " " + person[

2])
compte +=1
self.scroll.grid(row=0, column=1, sticky=N+S)

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

Bouton(self.bottom,text="Mettre à jour",width=12,font='sans 1
2 audacieux', commande=self.update_function)
upcontact.grid(row=0,column=2,padx=25,pady=60,sticky=N)

bouton(self.bottom,text="Afficher",width=12,font='sans
12 gras', commande=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 gras', commande=self.delete_person)
delcontact.grille(ligne=0,colonne=2,espacement_x=25,espacement_y=140,collant=N)

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

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

supprimer de l'annuaire où person_id ={} .format(person_i

d)
êtes-vous sûr de vouloir supprimer
1],"?"
réponse = messagebox.demanderquestion("avertissement", "êtes-vous sûr de vouloir supprimer")
te?
si réponse =='oui':
essayer :
cur.execute(query)
con.commit()
messagebox.showinfo("success","Deleted")
 self.détruire()

exceptExceptionase:
messagebox.showinfo

defajouter_personnes(self):
AjouterDesPersonnes()
self.détruire()

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

mise à jour = Mise à jour(person_id)

defexit(self):
messagebox.askyesno("quitter","Voulez-vous vraiment quitter")
siask>0:
auto.détruire()

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

Afficher(page_id)
 ajoutercontact.py

fromtkinterimport*
importersqlite3
fromtkinterimportmessagebox
con = sqlite3.connect('base_de_données.db')
cur = con.cursor()

classAjouterDesPersonnes(Toplevel):

def__init__(self):
Toplevel.__init__(self)

self.geometry("600x700+350+200")
Ajouter de nouvelles personnes
self.resizable(False, False)

self.top = Cadre(self, hauteur=180, bg="blanc")

self.top.pack(remplir=X)

self.bas
self.bottom.pack(remplir=X)

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

self.heading = Label(self.top,text=' Ajouter de nouveaux contacts ',font='arial 23

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

id

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

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

self.entry_name.insert(0,"Entrez le nom")
self.entry_name.place(x=160,y=40)
#id
 self.label_sname = Label(self.bottom, text="Nom de famille", 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,"Entrez le nom de famille")
self.entry_sname.place(x=160,y=80)
#email
E-Mail
identifiant mail", police='sans 15 gras', bg='#d2a5e6', fg='blanc')
self.label_email.place(x=49,y=120)

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

self.entry_email.insert(0,"Entrez l'e-mail")
self.entry_email.place(x=160,y=120)
#mobile
self.label_mob = Label(self.bottom, text="Numéro de mobile.", font='sans 15 bol
d',bg='#d2a5e6',fg='white')
self.label_mob.place(x=49,y=160)

self.entry_mob = Entrée(self.bottom, largeur=30, bd=5)

self.entry_mob.insert(0, "Entrez le numéro")
self.entry_mob.place(x=160,y=160)

#adresse
self.label_add = Label(self.bottom, text="Adresse", font='sans 15 bold')
#d2a5e6
self.label_add.place(x=49,y=200)

self.entry_add = Texte(self.bottom, largeur=24, hauteur=8)

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

#bouton
bouton = Bouton(self.bottom, texte="Ajouter une personne", police='sans 15 gras', com
mand=self.add_people)
button.place(x=250,y=450)
defajouter_personnes(self):
self.entry_name.get()
sname = self.entry_sname.get()
self.entry_email.get()
mob = self.entry_mob.get()
ajouter =self.entry_add.get(1.0,'fin-1c')

ifnameandsnameandemailandmobandadd !="":
essayer
#ajoutez-le à la base de données
 #insérer dans 'carnet d'adresses' (nom_personne,email_personne,m
mobile, adresse, nom de famille) valeurs ()

requête = "insérer dans 'carnet d'adresses' (nom_personne, prenom_personne, p

person_email, person_mob1, adresse) valeurs (?,?,?,?,?)
cur.execute(query, (nom, prénom, email, portable, adresse))
con.commit()
messagebox.showinfo("success","contact added")

self.détruire()

saufEXCEPTIONase:
messagebox.showerror("Error",str(e))
sinon :
messagebox.showerror("Error","fill all the fields",icon='warning
')
 display.py

de tkinter importer *
importersqlite3
fromtkinterimportmessagebox
fromaddpeopleimportAddPeople

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

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

print("identifiant_personne =", identifiant_personne)

sélectionner * de carnet d'adresses où person_id = '{}' .format(pers

on_id)
resultat = cur.execute(query).fetchone()
imprimer(résultat)
self.person_id
result[1]
result[2]
result[3]
result[4]
result[5]

print("nom de la personne", person_name)

self.top = Cadre(self, hauteur=180, bg="blanc")

self.top.pack(remplir=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="blanc")
")
 self.top_image_label.place(x=100,y=10)

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

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

#id

nom
self.label_name = Label(self.bottom, text="Nom:", font='sans 15 bold', b
g='#17c2a8',fg='blanc')
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="désactivé")
self.entry_name.place(x=250,y=40)
#id
Étiquette(self.bottom, texte="Nom de famille:", police='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="désactivé")
self.entry_sname.place(x=250,y=90)
#email
E-
identifiant de mail :" , police='sans 15 gras', bg='#17c2a8', fg='blanc')

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="désactivé")
self.entry_email.place(x=250,y=140)
#mobile
self.label_mob =Label(self.bottom,text="Numéro de mobile :",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="désactivé")
self.entry_mob.place(x=250,y=190)

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

self.entry_add = Texte(self.bottom, largeur=24, hauteur=8)

self.entry_add.insert(1.0, adresse)
self.entry_add.config(state="disabled")
self.entry_add.place(x=250,y=240)
 mettre à jour.py

fromtkinterimport*
importer sqlite3
fromtkinterimportmessagebox
fromaddpeopleimportAddPeople

con = sqlite3.connect('database.db')
cur = con.cursor()
classMiseAJour(Toplevel):
def__init__(self,person_id):

Toplevel.__init__(self)
self.geometry("600x700+350+200")
self.title("Mettre à jour la personne")
self.resizable(False, False)

identifiant_personne =

sélectionner * de carnet d'adresses où person_id = '{}'

sur_id)
result = cur.execute(query).fetchone()
imprimer(résultat)
self.person_id
résultat[1]
result[2]
result[3]
result[4]
result[5]

imprimer("nom de la personne", nom_de_la_personne)

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

self.top.pack(remplir=X)

self.bas
self.bottom.pack(fill=X)

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

self.heading = Label(self.top,text=' Mettre à jour le contact ',font='arial 23 b

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

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

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

self.entry_name.insert(0, nom_personne)
self.entry_name.place(x=160,y=40)
#id
self.label_sname = Label(self.bottom, text="Nom de famille", font='sans 15 bold
',bg='#3287a8',fg='blanc')
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
E-mail
mail id
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="Numéro de mobile.", font='sans 15 bol
d',bg='#3287a8',fg='white')
self.label_mob.place(x=49,y=160)

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

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

#adresse
self.label_add = Label(self.bottom, text="Adresse", font='sans 15 bold',
#3287a8
self.label_add.place(x=49,y=200)

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

self.entry_add.insert(1.0, adresse)
self.entry_add.place(x=160,y=200)
 bouton
Bouton
,commande=self.update_people)
button.place(x=250,y=450)

def mettre à jour_personnes(self):

id=self.person_id
self.entry_name.get()
sname = self.entry_sname.get()
self.entry_email.get()
mob = self.entry_mob.get()
ajouter =self.entry_add.get(1.0,'fin-1c')
mettre à jour le carnet d'adresses set person_name = '{}', person_sname = '{}'
'{}'
, adresse = '{}' où person_id ={}
)

essayer :
cur.execute(requête)
con.commit()
messagebox.showinfo("success"," contact updated")

saufExceptionase:
imprimer(e)
 à propos de nous.py

de tkinter importer *

classeÀPropos(Toplevel):
def__init__(self):
Toplevel.__init__(self)

self.geometry("550x550+350+200")
À propos de nous
self.resizable(False,False)

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

self.top.pack(remplir=BOTH)

Hey, ceci est la page à propos de nous

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

Cette application est réalisée par le

Étudiants en MCA à des fins éducatives.

Cette application est le projet pour

Ingénierie logicielle.

vous pouvez nous contacter au

Facebook - https://facebook.com/MCA

Instagram -
MCA_GROUPE',police="monoscope 14",bg='#4c1663',fg="blanc")
self.text.place(x=100,y=130)
Résultats
8.FUTURESCOPE:

• Les développeurs Python construisent des carrières exceptionnelles grâce à

activité de développement. Demande de nouvelles applications et amélioration
l'application existante est en augmentation.

• Facilité de se connecter avec des personnes ainsi que des entreprises.

• Si quelqu'un veut un accès aux données plus facile, alors nous pouvons également utiliser

stockage cloud autre que serveur de données SQL.

• Nous pouvons également apporter des modifications à ce projet en fonction de

exigence d'utilisation/client.
10. RÉFÉRENCES

Références faites depuis :

Sites référencés :

Invalid input format. Please provide text to be translated.

Invalid input. Please provide text for translation.

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

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