CONTENU

CHAPITRE 1 : INTRODUCTION DU PROJET………………………………………1-3

1.1. Objectif……………………………………………………………….……..
….1
1.2. Introduction
…………2
1.3. Portée…………………………………………………………………….
………..3

CHAPITRE 2 : EXIGENCES MATÉRIELLES ET LOGICIELLES…………….…………..4

1.1. Exigences matérielles………………………………………..

…………..4
1.2. Exigences logicielles
…………...4

CHAPITRE 3 : DESCRIPTION TECHNIQUE………….……………………………..…5-6

1.1. Interface utilisateur

Description………………………………………………….................5

CHAPITRE 4 : ANALYSE ET CONCEPTION DE LOGICIEL………………........7-13

4.1. Analyse de logiciel……………………………………………………………...….7

4.1.1. Cycle de vie du développement logiciel…………………………………………7

4.1.2. Description du modèle utilisé……………... ………………………………..8

4.2. Conception logicielle…………………………………………………………………………10

4.2.1. Diagramme de flux de données………………………………………………………10

[Link]. Diagramme de Niveau Zéro (0)………….………………………..………. 10

[Link]. Un (1) Diagramme de Niveau………………………………………………….11
[Link]. Diagramme à Deux (2) Niveaux…………………………………….……….12

4.2.2. DIAGRAMME ER......……….…………………………………………………13

CHAPITRE 5 : DÉVELOPPEMENT DU PROJET……………………………..………14-67

5.1. Code source…………………………………………………………………….14

5.2. Instantanés de sortie…………………………………………………………….64

CHAPITRE 6 : TESTS…………………………………………………………...…...68-70
CHAPITRE 7 : AVANTAGES………………………………………………………………….71
CHAPITRE 8 : LIMITATIONS…………………………………………………………….72
CHAPITRE 9 : AMÉLIORATION FUTURE………………………………………...……73
CHAPITRE 10 : CONCLUSION……………………………………………………...……74
CHAPITRE 11 : RÉFÉRENCES………………………………………………………...…75

RÉSUMÉ

Notre projet de système de gestion des étudiants comprend l'inscription des étudiants, le stockage de leurs détails

dans le système c'est-à-dire informatisé le processus. Notre logiciel a la possibilité de donner un identifiant unique

pour chaque étudiant et stocke les détails de chaque étudiant. Il comprend également une fonctionnalité de recherche -

rechercher par nom, contact et numéro de rouleau. Les données peuvent être récupérées facilement. L'interface est très

Convivial. Les données sont bien protégées pour un usage personnel et rendent le traitement des données très

rapide.
CHAPITRE 1
INTRODUCTION
 1.1 OBJECTIF

Le système de gestion des étudiants est un logiciel utile pour les collèges ainsi que pour les écoles.
Les autorités. Dans le système actuel, toutes les activités sont effectuées manuellement. Cela prend beaucoup de temps.

et coûteux. Notre système de gestion des étudiants traite des différentes activités liées à
Gestion des dossiers étudiants. Notre objectif est de numériser le processus des dossiers étudiants.

gestion.
 1.2 INTRODUCTION

Ce projet vise à automatiser le système de gestion des étudiants. Ce projet est développé
principalement pour administrer les dossiers des étudiants.

Le but du projet intitulé SYSTÈME DE GESTION DES ÉTUDIANTS est de

informatiser la gestion du bureau d'accueil des dossiers étudiants dans les collèges, écoles et

coaching, pour développer des logiciels qui soient conviviaux, simples, rapides et rentables.
Traditionnellement, cela se faisait manuellement.

La fonction principale du système est d'enregistrer et de stocker les détails des étudiants, de récupérer ces détails en tant que

et lorsque cela est nécessaire, et aussi pour manipuler ces détails de manière significative.
 1.3 PORTÉE

Le produit logiciel proposé est le Système de Gestion des Étudiants. Le système sera utilisé dans
toute école, collège et institut de coaching pour obtenir des informations de l'élève et ensuite
stocker ces données pour une utilisation future

Le système actuel en usage est un système basé sur le papier. Il est trop lent et ne peut pas fournir des mises à jour.

listes d'étudiants dans un délai raisonnable. Les intentions du système sont de réduire le sur-
temps de paiement et augmenter la productivité. Les déclarations des exigences dans ce document sont à la fois

fonctionnel et non fonctionnel.

 CHAPITRE 2
MATÉRIEL & LOGICIEL
EXIGENCE
 EXIGENCES DU SYSTÈME

2.1 EXIGENCES MATÉRIELLES

Processeur Pentium IV ou supérieur

128 Mo de RAM (ou plus)
Disque dur de 40 Go ou plus

Souris/Clavier

2.2 EXIGENCE LOGICIELLE

Windows 7/8/10
Interpréteur Python
Pycharm IDE ou VS Code
Xampp (Pour Mysql) ou Mysql Workbench
 CHAPITRE 3
DESCRIPTION TECHNIQUE
 3.1 DESCRIPTION DE L'INTERFACE UTILISATEUR

Python

Python est un langage de programmation de haut niveau, largement utilisé et polyvalent. Il a été initialement

conçu par Guido van Rossum en 1991 et développé par la Python Software Foundation. Il a été
principalement développé pour mettre l'accent sur la lisibilité du code, et sa syntaxe permet aux programmeurs de

exprimer des concepts en moins de lignes de code.

Python est un langage de programmation qui vous permet de travailler rapidement et d'intégrer des systèmes plus facilement.

efficientement.

Python est dynamiquement typé et géré par un ramasse-miettes. Il prend en charge plusieurs langages de programmation.

paradigmes, y compris la programmation procédurale, orientée objet et fonctionnelle. Python est souvent
décrit comme un langage « batteries comprises » en raison de sa bibliothèque standard complète.

Tkinter

Tkinter est un lien Python vers la boîte à outils GUI Tk. C'est l'interface Python standard vers Tk
Boîte à outils GUI, et est le standard GUI de facto de Python. Tkinter est inclus avec

installations standard de Python sur Linux, Microsoft Windows et Mac OS X.

Le nom Tkinter vient de Tk interface. Tkinter a été écrit par Fredrik Lundh.
 CHAPITRE 4
ANALYSE ET CONCEPTION LOGICIELLE
 4.1 Analyse de logiciel

4.1.1 Cycle de vie du développement logiciel

Fig:- SDLC
 4.1.2 DESCRIPTION DU MODÈLE UTILISÉ

Le Modèle en Cascade

Le modèle en cascade est un processus de développement logiciel séquentiel, dans lequel les progrès sont vus comme

s'écoulant régulièrement vers le bas (comme une cascade) à travers les phases de Conception, Initiation,

Analyse, Conception (validation), Construction, Test et Maintenance.

Pour suivre le modèle en cascade, on passe d'une phase à l'autre de manière séquentielle.
Par exemple, on commence par rédiger la spécification des exigences, qui, après approbation, sont
considéré comme "gravé dans la pierre." Lorsque les exigences sont entièrement complètes, on passe à la conception.

Le logiciel en question est conçu et un plan est dessiné pour les mise en œuvre (codeurs) à
suivre — ce design devrait être un plan pour mettre en œuvre les exigences données. Quand le
la conception est entièrement terminée, une mise en œuvre de cette conception est réalisée par des codeurs. Vers le

les étapes ultérieures de cette phase d'implémentation, les composants logiciels séparés produits sont

combiné pour introduire de nouvelles fonctionnalités et réduire les risques grâce à la suppression des erreurs.

Ainsi, le modèle en cascade soutient qu'on ne devrait passer à une phase que lorsque sa précédente
la phase est complétée et perfectionnée. Cependant, il existe différents modèles de cascade modifiés.
(y compris le dernier modèle de Royce) qui peut inclure des variations mineures ou majeures par rapport à ce processus.

Le temps passé au début du cycle de production de logiciels peut conduire à une plus grande économie aux étapes ultérieures.

il a été démontré qu'un bogue trouvé dans les premières étapes (comme la spécification des exigences ou
la conception) est moins coûteuse en termes d'argent, d'efforts et de temps à corriger que le même bogue trouvé plus tard dans

le processus. Pour prendre un exemple extrême, si un design de programme s'avère impossible à

implémenter, il est plus facile de corriger la conception à l'étape de conception que de se rendre compte des mois plus tard, quand

les composants du programme sont en cours d'intégration, tout le travail effectué jusqu'à présent doit être abandonné

à cause d'un design défectueux.

C'est l'idée centrale derrière le modèle en cascade - le temps passé au début à s'assurer que
les exigences et la conception sont absolument correctes, ce qui vous fera gagner beaucoup de temps et d'efforts par la suite. Ainsi,

la pensée de ceux qui suivent le processus en cascade va, on devrait s'assurer que chaque
la phase est 100 % terminée et absolument correcte avant de passer à la phase suivante du programme
La création. Les exigences du programme doivent être gravées dans la pierre avant que la conception ne commence (sinon, le travail

mettre en place un design basé sur des exigences incorrectes est un gaspillage); le design du programme devrait être
parfait avant que les gens ne commencent à travailler sur la mise en œuvre du design (sinon ils sont

mettre en œuvre le mauvais design et leur travail est perdu), etc.

Un autre argument en faveur du modèle en cascade est qu'il met l'accent sur la documentation (comme par exemple

documents de spécifications et documents de conception) ainsi que le code source. Dans moins conçu et
les méthodologies documentées, si des membres de l'équipe partent, beaucoup de connaissances sont perdues et peuvent être

difficile pour un projet de s'en remettre. Un document de conception entièrement fonctionnel devrait être présent (comme c'est le cas

l'intention du Big Design Up Front et du modèle en cascade) de nouveaux membres d'équipe ou même complètement

Les nouvelles équipes devraient pouvoir se familiariser en lisant les documents.

Les principes de base du modèle en cascade sont :

Le projet est divisé en phases successives, avec un certain chevauchement et des retours acceptables entre les phases.

phases.

L'accent est mis sur la planification, les horaires, les dates cibles, les budgets et la mise en œuvre d'un entier

système à la fois.

Un contrôle strict est maintenu tout au long de la vie du projet grâce à l'utilisation d'une documentation exhaustive.

documentation, ainsi que par des examens formels et l'approbation/l'autorisation par l'utilisateur et
la gestion des technologies de l'information ayant lieu à la fin de la plupart des phases avant de commencer le

prochaine phase.
 4.2 CONCEPTION DE LOGICIEL

4.2.1 Diagramme de flux de données

Le DFD adopte une vue d'entrée-processus-sortie d'un système. Autrement dit, les objets de données circulent.
dans le logiciel, sont transformés par les éléments de traitement, et les données résultantes
Les objets sortent du logiciel. Les objets de données sont représentés par des flèches étiquetées.
et les transformations sont représentées par des cercles. Le DFD est représenté dans un
de manière hiérarchique. Le premier DFD représente le système dans son ensemble. Les suivants
Lesdiagrammesdefluxdedonnéesfournissentdesdétailsdeplusenplusprécisàchaqueniveausubséquent.

Le diagramme de flux de données permet à l'ingénieur logiciel de développer des modèles de

domaine d'information et domaine fonctionnel en même temps. Alors que le DFD est affiné
en niveaux de détail plus grands, les analystes effectuent une fonction implicite
décomposition du système. De plus, le raffinement du DFD entraîne un résultat correspondant
raffinement des données à mesure qu'elles progressent à travers les processus qui incarnent l'application.
Fig:- Niveau zéro (0)
DIAGRAMME ER

Fig: DIAGRAMME ER
DIAGRAMME DE CAS D'UTILISATION
CHAPITRE 5
DÉVELOPPEMENT
5.1 CODE SOURCE
 CODE SOURCE
de tkinter import *

de tkinter import tk

import pymysql

classe Étudiant :

def __init__(self, racine):

[Link] = racine

[Link]("Système de Gestion des Étudiants par Pankaj Panjwani")

[Link]("1350x700+0+0")

ttle = Étiquette([Link],text="Système de Gestion des Étudiants",bd=10,relief=

GROOVE

[Link](side=HAUT, remplir=X)

self.Roll_No_var = StringVar()

self.name_var = StringVar()

self.email_var = StringVar()

self.genre_var
 self.contact_var = StringVar()

self.dob_var = StringVar()

self.search_by = StringVar()

self.search_txt = StringVar()

Gérer_Cadre = Cadre([Link], bd=4, relief=RIDGE, bg="#F11C79")

Gérer_Cadre.place(x=20,y=100,largeur=450,hauteur=600)

Gérer les étudiants

, police=("tmes new roman", 30, "gras"))

m_ttle.grid(row=0,columnspan=2,pady=10)

lbl_rouleau= Étiquette(Gérer_Cadre, Rouler Non. #F11C79

blanc

lbl_roll.grid(row=1, column=0, pady=10,padx=20,stcky="w")

txt_Roll = Entrée(Manage_Frame, textvariable=self.Roll_No_var, police=("tmes new

roman", 10, "gras"), bd=5, relief=GROOVE)

txt_Roll.grid(row=1,column=1,pady=10,padx=20,stcky="w")

lbl_Nom = Étiquette(Gérer_Cadre, Nom #F11C79

blanc

lbl_Nom.grid(row=2, column=0, pady=10, padx=20, stcky="w")

 txt_Nom = Entry(Manage_Frame,textvariable=self.name_var, font=("tmes new
romain", 10, "gras"), bd=5, relief=GROOVE)

txt_Name.grid(row=2, column=1, pady=10, padx=20, stcky="w")

Email = Étiquette(Gérer_Cadre, Email #F11C79

blanc

lbl_Email.grid(row=3, column=0, pady=10, padx=20, stcky="w")

txt_Email = Entry(Manage_Frame, textvariable=self.email_var, font=("tmes new

roman", 10, "gras"), bd=5, soulagement=GROOVE)

txt_Email.grid(row=3, column=1, pady=10, padx=20, stcky="w")

Genre

("tmes new roman", 20, "gras")

lbl_Gender.grid(row=4, column=0, pady=10, padx=20, stcky="w")

combo_Sexe = [Link](Manage_Frame,textvariable=self.gender_var,
police=("times new roman", 10, "gras")

combo_Gender['values'] = ("Male","Female")

combo_Gender.grid(row=4, column=1, pady=10, padx=20, stcky="w")

Contact

font=("tmes new roman", 20, "gras")

lbl_Contact.grid(row=5, column=0, pady=10, padx=20, stcky="w")

 txt_Contact = Entry(Manage_Frame, textvariable=self.contact_var,font=("tmes new
roman", 10, "gras"), bd=5, relief=GROOVE)

txt_Contact.grid(row=5, column=1, pady=10, padx=20, stcky="w")

D.O.B

font=("tmes new roman", 20, "bold")

lbl_Dob.grid(row=6, column=0, pady=10, padx=20, stcky="w")

txt_Dob = Entry(Manage_Frame, textvariable=self.dob_var, police=("tmes nouvelle

roman", 10, "gras"), bd=5, relief=GROOVE)

txt_Dob.grille(ligne=6, colonne=1, pady=10, padx=20, stcky="w")

Adresse

font=("tmes new roman", 20, "bold")

lbl_Adresse

self.txt_Adresse
roman",10,"gras"),bd=5, relief=GROOVE)

self.txt_Address.grid(row=7, column=1, pady=10, padx=20, stcky="w")

btn_Frame = Cadre(Manage_Frame, bd=4, relief=RIDGE, bg="#F11C79")

btn_Frame.place(x=10,y=520,width=420)
 Ajouter un bouton =
Buton(btn_Frame,text="Ajouter",width=9,command=self.add_student).grid(row=0,column=0,padx=10,
pady=10)

mettre à jour le bouton= Bouton(btn_Cadre, Mise à jour

largeur=9, commande=self.update_data).grid(ligne=0, colonne=1, padx=10, pady=10)

bouton de suppression = Bouton(btn_Frame, Supprimer

largeur=9, commande=self.delete_data).grid(ligne=0, colonne=2, padx=10, pady=10)

BoutonEffacer = Bouton(btn_Frame, Clair

largeur=9, commande=[Link]).grid(ligne=0, colonne=3, padx=10, pady=10)

Cadre_Detail=Cadre([Link],bd=4,relief=RIDGE, bg="#F11C79")

Detail_Frame.place(x=500,y=100,width=830,height=600)

Rechercher par

police=("Times New Roman", 20, "gras")

lbl_search.grid(row=0, column=0, pady=10, padx=20, stcky="w")

combo_search=[Link](Detail_Frame,textvariable=self.search_by,width=10,font=("tmes new
roman",13,"bold"),état='readonly')

combo_search['values']=("Roll_no","Name","Contact")

combo_search.grid(row=0, column=1, pady=10, padx=20, stcky="w")

txt_Recherche = Entry(Detail_Frame, textvariable=self.search_txt, police=("tmes new

roman", 13, "gras"), bd=5, relief=GROOVE)

txt_Search.grid(row=0, column=2, pady=10, padx=20, stcky="w")

 bouton de recherche = Buton(Detail_Frame, Recherche
largeur=8,commande=self.search_data).grid(row=0, colonne=3, padx=10, pady=10)

Afficher tout = Buton(Detail_Frame, Montrer Tout

largeur=8,commande=self.fetch_data).grid(ligne=0, colonne=4, padx=10, pady=10)

Table_Frame = Frame(Detail_Frame,bd=4,relief=RIDGE,bg="#F11C79")

Table_Frame.place(x = 10 , y =70 , width=760,height=500)

scroll_x = Barre de défilement(Table_Frame, orient=HORIZONTAL)

scroll_y = Barre de défilement(Table_Frame, orient=VERTICAL)

self.Table_des_étudiants =
[Link](Table_Frame, colonnes=("Roll", "Nom", "Email", "Genre", "Contact", "DOB", "Adresse"),
xscrollcommand=scroll_x.set,yscrollcommand=scroll_y.set

scroll_x.pack(side=BOTTOM, fill=X)

scroll_y.pack(côté=DROITE, remplir=Y)

scroll_x.config(command=self.Student_table.xview)

scroll_y.config(command=self.Student_table.yview)

self.Student_table.heading("Roll", text="Numéro de rouleau.")

self.Student_table.heading("Nom", text="Nom")

self.Student_table.heading("Email", text="Email")

self.Student_table.heading("Genre", text="Genre")

self.Student_table.heading("Contact", text="Contact")
 self.Student_table.heading("DOB", text="Date de naissance")

self.Student_table.heading("Adresse", text="Adresse")

têtes

self.Student_table.colonne("Roll", largeur=100)

self.Student_table.colonne("Nom", largeur=100)

self.Student_table.column("Email", width=100)

self.Student_table.colonne("Genre", largeur=100)

self.Student_table.colonne("Contact", largeur=100)

self.Student_table.colonne("DOB", largeur=100)

self.Student_table.column("Adresse", width=100)

self.Student_table.pack(remplir=BOTH, étendre=1)

self.Student_table.bind("<ButonRelease-1>",self.get_cursor)

self.fetch_data()

def ajouter_étudiant(self):

con =
[Link](host="localhost",user="root",password="",database="stmgmtpython")

cur = [Link]()

[Link]("insérer dans étudiants valeurs(%s,%s,%s,%s,%s,%s,%s)

self.Roll_No_var.get()
[Link](),self.dob_var.get(),self.txt_Address.get('1.0',FIN)))

[Link]()

self.fetch_data()

[Link]()
 [Link]()

def fetch_data(self):

con = [Link](hôte="localhost", root password

stmgmtpython

cur = [Link]()

[Link]("select * from students")

lignes = [Link]()

si len(rows) != 0 :

self.Student_table.delete(*self.Student_table.get_children())

pour ligne dans lignes :

self.Student_table.insert('', END, values=row)

[Link]()

[Link]()

def rechercher_données(self):

con = [Link](hôte="localhost", root password

stmgmtpython

cur = [Link]()

[Link]("select * from students where " + str(self.search_by.get()) + " LIKE ")

'%"+str(self.search_txt.get())+"%'

les lignes = [Link]()

si len(rows)!=0 :

self.Student_table.delete(*self.Student_table.get_children())
 pour ligne dans lignes :

self.Student_table.insert('',END,values=row)

[Link]()

[Link]()

def effacer(self):

self.Roll_No_var.set("")

self.name_var.set("")

self.email_var.set("")

self.gender_var.set("")

self.contact_var.set("")

self.dob_var.set("")

self.txt_Address.delete("1.0", END)

def obtenir_curseur(self, ev):

cursor_row = self.Student_table.focus()

contenu = self.Student_table.item(cursor_row)

ligne = contenus['valeurs']

self.Roll_No_var.set(row[0])

self.name_var.set(row[1])

self.email_var.set(row[2])

self.gender_var.set(row[3])

self.contact_var.set(row[4])
 self.dob_var.set(row[5])

self.txt_Adresse.delete("1.0", FIN)

self.txt_Adresse.insert(END, row[6])

def mettre_à_jour_données(self):

con =
[Link](host="localhost",user="root",password="",database="stmgmtpython")

cur = [Link]()

[Link]("mettre à jour les étudiants set nom=%s,email=%s,genre=%s,contact=%s,dob=")

%s, adresse=%s où roll_no=%s

(self.name_var.get(),self.email_var.get(),self.gender_var.get(),self.contact_var.get(),self.dob_var.ge
t(),self.txt_Address.get('1.0',END),self.Roll_No_var.get()))

[Link]()

self.fetch_data()

[Link]()

[Link]()

def supprimer_données(self):

con = [Link](hôte="localhost", root password

stmgmtpython

cur = [Link]()

[Link]("supprimer de étudiants où roll_no=%s", self.Roll_No_var.get())

[Link]()

[Link]()
 self.fetch_data()

[Link]()

Tk()

ob = Étudiant(racine)

[Link]()

5.2 IMAGES
CHAPITRE 6
TEST
 6.1TESTING

Les tests sont plus qu'un simple débogage. L'objectif des tests peut être la qualité.
assurance, vérification et validation, ou estimation de fiabilité. Tests de correction et
Les tests de fiabilité sont deux domaines majeurs de l'évaluation. Les tests logiciels sont un compromis.
entre le budget, le temps et la qualité.

Tests de logiciels
Letestdelogicielestleprocessusd'exécutiond'unprogrammeoud'unsystèmedanslebutdetrouver
erreurs. Ou, cela implique toute activité visant à évaluer un attribut ou une capacité d'un
programme ou système et détermination qu'il atteint les résultats requis. Le logiciel n'est pas
contrairementàd'autresprocessusphysiquesoùdesentréessontreçuesetdessortiessontproduites.Où
la manière dont il échoue. Contrairement à la plupart des systèmes physiques, la plupart des
lesdéfautsdanslelogicielsontdeserreursdeconception,etnondesdéfautsdefabrication.

Pour améliorer la qualité

Alorsquelesordinateursetleslogicielssontutilisésdansdesapplicationscritiques,l'issued'unboguepeutêtre
sévère. Les bogues peuvent causer d'énormes pertes.

Pour la Vérification et la Validation (V&V)

Un autre objectif important des tests est la vérification et la validation (V&V).

utilisécommeunoutildansleprocessusdeV&[Link]éessurdesinterprétationsdela
résultats des tests, qui indiquent soit que le produit fonctionne dans certaines situations, soit qu'il ne fonctionne pas

travail.

Typesdetestslogiciels
Tests en boîte noire

L'approche boîte noire est une méthode de test dans laquelle les données de test sont dérivées de
exigences fonctionnelles spécifiées sans tenir compte de la structure finale du programme. C'est également
appelé testing basé sur les données, basé sur l'entrée/sortie ou basé sur les exigences. Une méthode de test
insisté sur l'exécution des fonctions et l'examen de leurs données d'entrée et de sortie.

Test de boîte blanche

Contrairementauxtestsenboîtenoire,lelogicielestconsidérécommeuneboîteblanche,ouboîteenverredanslaboîteblanche.

les tests, car la structure et le flux du logiciel en cours d'évaluation sont visibles pour le testeur. Ceci
lestestssontbaséssurlaconnaissancedelalogiqueinterneducoded'[Link]
sont réalisés selon les détails de la mise en œuvre du logiciel, tels que la programmation
langage, logique et styles. Les cas de test sont dérivés de la structure du programme. Boîte blanche
lestestssontégalementappeléstestsenboîtedeverre,testspilotésparlalogiqueoutestsbaséssurlaconception.

Tests unitaires

Cela implique le test des composants ou modules logiciels individuels. Typiquement réalisé par
le programmeur et non par les testeurs, car cela nécessite une connaissance détaillée de l'interne
conceptionetcodedeprogramme.

Tests du système
L'ensemble du système est testé conformément aux exigences. Tests de type boîte noire basés sur
les spécifications des exigences générales, couvrent toutes les parties combinées d'un système.

Tests de bout en bout

Tout comme les tests système, cela implique le test d'un environnement d'application complet dans un
situationquiimitel'utilisationdanslemonderéel,commeinteragiravecunebasededonnées,utiliserunréseau
communications, ou interagir avec d'autres matériels, applications ou systèmes si
approprié.
Test d'utilisabilité
Vérification de la convivialité. Le flux d'application est testé, Un nouvel utilisateur peut-il comprendre le
application facilement,Aide appropriée documentée chaque fois que l'utilisateur est bloqué à un moment donné. Fondamentalement

lanavigationdusystèmeestvérifiéedanscetest.

Tests d'installation/désinstallation

Testé pour des processus d'installation/désinstallation complets, partiels ou de mise à niveau sur différents systèmes d'exploitation.

systèmessousdifférentsenvironnementsmatérielsetlogiciels.

Test de récupération

Tester comment un système récupère des pannes, des défaillances matérielles ou d'autres catastrophes.
problèmes.

Tests de sécurité
Le système peut-il être pénétré par un quelconque moyen de piratage ? Tester à quel point le système se protège.
contre tout accès interne ou externe non autorisé.Vérifié si le système, la base de données est sûre contre
attaquesexternes.

Tests de compatibilité
Tester combien bien le logiciel fonctionne dans un matériel/un logiciel/un système d'exploitation particulier
environnementsystème/réseauetdifférentescombinaisonsdecequiprécède.

Tests de comparaison
Comparaison des forces et des faiblesses des produits par rapport aux versions précédentes ou à d'autres
produits similaires.
Tests alpha
Unenvironnementutilisateurvirtuelinternepeutêtrecréé[Link]ésà
lafindudé[Link]êtreapportéesàlasuitedetelstests.

Test de bêta
Testsgénéralementeffectuésparlesutilisateursfinauxoud'[Link]'applicationpour
but à des fins commerciales.
CHAPITRE 7
AVANTAGES
 7.1 AVANTAGES

Le logiciel permet une gestion facile des dossiers étudiants.

Le logiciel a une interface très conviviale qui est très facile à utiliser et
comprendre.
Le logiciel protège les données privées en les cachant.
Le logiciel utilise très peu de mémoire et démarre plus rapidement.
CHAPITRE 8
LIMITATIONS
 8.1LIMITATIONS

Le logiciel est limité uniquement au bureau.

Le système nécessite un interpréteur Python installé sur le système.

Toutes les options de gestion des étudiants ne sont pas incluses dans la version actuelle.

Les options de sécurité offrent uniquement un faible niveau de sécurité contre les attaquants débutants.

L'interface graphique est uniquement en anglais.

 CHAPITRE 9
AMÉLIORATION FUTURE
 9.1 AMÉLIORATION FUTURE

Ce logiciel peut être créé pour tous les systèmes d'exploitation

Des fonctionnalités de sécurité supérieures peuvent être incluses dans ce logiciel.

La planification des programmes peut également être incluse dans ce logiciel.

Ce logiciel peut être développé pour être utilisé comme tutoriel pour enseigner les concepts de base de
Système d'exploitation pour les nouveaux utilisateurs.

Ce système peut être mis en œuvre avec l'OS pour réduire les frais généraux d'installation.
et l'interface de fonctionnement de chaque outil à différents endroits.
L'arrêt automatique par le service SMS peut être mis en œuvre dans cela.
CHAPITRE 10
CONCLUSION
 10.1 CONCLUSION

Le projet intitulé « Système de gestion des étudiants » est développé en utilisant Python
Tkinter comme interface et base de données MYSQL en arrière-plan pour informatiser le
processus de gestion des dossiers des étudiants. Ce projet couvre uniquement les bases
fonctionnalités requises.
CHAPITRE 11
RÉFÉRENCES
 11.1 RÉFÉRENCES

Wikipédia
The provided text is a URL and cannot be [Link]-gui-tparentster/
Invalid URL [Link]/python-tparentéter
Invalid [Link]/