NOM DE L'ÉCOLE

LOGO DE L'ÉCOLE

ANNÉE ACADÉMIQUE :

2019-20

RAPPORT DE PROJET SUR

"TIC-TAC-TOE GAME" (JEU

DE MORPION)
LOGO DE L'ÉCOLE 5
CERTIFICAT 5
ACCUSÉ DE RÉCEPTION
XI

L'INFORMATIQUE

083
6
INTRODUCTION 7

1
OBJECTIFS DU PROJET
7
SYSTÈME PROPOSÉ8
CYCLE DE VIE DU
DÉVELOPPEMENT DU
SYSTÈME (SDLC) 10
LES PHASES DU CYCLE DE
VIE DU DÉVELOPPEMENT
DU SYSTÈME11
PHASE D'INITIATION
11
L'objectif de la phase
d'initiation est le suivant :
11
PHASE DE
DÉVELOPPEMENT DU
CONCEPT DU SYSTÈME
12
PHASE DE PLANIFICATION
13
PHASE D'ANALYSE DES
BESOINS 14
Les objectifs de cette phase
sont les suivants14
PHASE DE CONCEPTION
14
PHASE DE
DÉVELOPPEMENT 16
PHASE D'INTÉGRATION ET
DE TEST 16
PHASE DE MISE EN
ŒUVRE 17
PHASE D'EXPLOITATION
ET DE MAINTENANCE

2
 17
SORTIE 30
»> 30
II 30
I I 41516 30
I I 71819 30
II 30
I I 41516 30
TEST 31
LES MÉTHODES D'ESSAI
31
TESTS DE LA BOÎTE NOIRE
31
LES TESTS BASÉS SUR LES
SPÉCIFICATIONS 32
AVANTAGES ET
INCONVÉNIENTS 32
TESTS EN BOÎTE
BLANCHE 32
ÉVALUATION DE
L'EXHAUSTIVITÉ DU
CODE 33
EXIGENCES EN MATIÈRE
DE MATÉRIEL ET DE
LOGICIEL 34

GUIDE DE PROJET:
PGT (CS)

3
 NOM DE L'ÉCOLE

LOGO DE L'ÉCOLE

CERTIFICAT

La présente atteste que le cadet __________________________________________

Rouleau n° : _______________________ a mené à bien le projet

Travail intitulé "TIC-TAC-TOE GAME." dans la matière Computer Science (083) définie

dans le règlement du CBSE pour les besoins de l'examen pratique de la classe XI qui

aura lieu en _______________________ sur_____________.

( )
PGT Comp Sci
Maître IC

L'examinateur :

Nom : ________________

Signature :

Date :

4
 TABLE DES MATIÈRES [ T O C ]

SER DESCRIPTION PAGE NO

01 ACCUSÉ DE RÉCEPTION 04

02 INTRODUCTION 05

03 OBJECTIFS DU PROJET 05

04 SYSTÈME PROPOSÉ 06

CYCLE DE VIE DU DÉVELOPPEMENT DU SYSTÈME

05 07
(SDLC)

LES PHASES DU CYCLE DE VIE DU DÉVELOPPEMENT DU

06 08
SYSTÈME

07 DIAGRAMME DE FLUX 15

08 CODE SOURCE 16

09 SORTIE 19

10 TEST 20

11 EXIGENCES EN MATIÈRE DE MATÉRIEL ET DE LOGICIEL 23

12 BIBLIOGRAPHIE 24

ACCUSÉ DE RÉCEPTION

Outre mes efforts, la réussite d'un projet dépend largement des encouragements
et des orientations de nombreuses autres personnes. Je saisis cette occasion pour
exprimer ma gratitude aux personnes qui ont contribué à la réussite de ce projet.

J'exprime ma profonde gratitude à Dieu tout-puissant qui m'a donné la force de

5
mener à bien ce projet.

J'exprime ma sincère gratitude à mes parents qui m'ont constamment encouragé

dans la réalisation de ce projet.

Je remercie les personnes qui ont contribué à l'avancement de ce projet et qui

continuent à s'occuper de moi malgré mes défauts,

J'exprime ma profonde gratitude à l'éminent Le Principal, qui n'a cessé de

nous motiver et de nous aider.

J'exprime mes sincères remerciements à l'académicien The Vice Principal,

________pour les encouragements constants et les conseils prodigués au cours de ce
projet

J'ai l'immense plaisir d'exprimer mes remerciements à ___ pour m'avoir fourni une
l'infrastructure et le soutien moral lors de la réalisation de ce projet dans l'école.

Mes sincères remerciements à __Un maître responsable, un guide, un mentor tout

au long de l'année
au-dessus d'un ami, qui a examiné mon projet d'un œil critique et m'a aidé à résoudre
tous les problèmes survenus au cours de la mise en œuvre du projet.

Les conseils et le soutien reçus de tous les membres qui ont contribué et qui
contribuent à ce projet ont été essentiels à sa réussite. Je leur suis reconnaissante pour
leur soutien et leur aide constants.

PROJET DE JEU DE MORPION

INTRODUCTION

Le tic-tac-toe (anglais américain), le noughts and crosses (anglais britannique) ou le

Xs and Os est un jeu de papier et de crayon pour deux joueurs, X et O, qui marquent à tour de

rôle les cases d'une grille de 3×3. Le joueur qui réussit à placer trois de ses marques dans une

rangée horizontale, verticale ou diagonale gagne la partie.

OBJECTIFS DU PROJET

L'objectif de ce projet est de permettre aux étudiants d'appliquer les

6
connaissances en programmation dans une situation/un problème du monde réel et de

leur montrer comment les compétences en programmation aident à développer un bon

logiciel.

1. Écrire des programmes à l'aide d'outils logiciels modernes.

2. Appliquer efficacement les principes de la programmation orientée objet lors du

développement de projets de petite ou moyenne taille.

3. Rédiger un code procédural efficace pour résoudre des problèmes de petite ou

moyenne envergure.

4. Les étudiants démontreront l'étendue de leurs connaissances en informatique,

notamment dans les domaines des systèmes, de la théorie et du développement

de logiciels.

5. Les étudiants démontreront leur capacité à mener un projet de recherche ou

d'informatique appliquée, nécessitant des compétences en matière de rédaction

et de présentation qui illustrent le style académique en informatique.

SYSTÈME PROPOSÉ

Aujourd'hui, on ne peut plus se permettre de s'en remettre aux êtres humains

faillibles de be really wants to stand against today's merciless competition where not to

wise saying "to err is human" no longer valid, it's outdated to rationalize your mistake.

Ainsi, pour suivre le rythme du temps, pour obtenir le meilleur résultat sans

dysfonctionnement et une plus grande efficacité, il convient de remplacer les piles de

mouches interminables par un disque dur d'ordinateur beaucoup plus sophistiqué.

Il faut utiliser le logiciel de gestion des données. Les logiciels ont joué un rôle de

plus en plus important dans l'atomisation de diverses organisations. Il existe aujourd'hui

sur les marchés de nombreux produits logiciels qui ont contribué à faciliter le travail des

organisations et à le rendre plus efficace. Au départ, la gestion des données nécessitait

7
la tenue d'un grand nombre de registres et la réalisation d'un grand nombre de travaux

sur papier, mais aujourd'hui, les logiciels de cette organisation ont rendu leur travail plus

rapide et plus facile. Il ne reste plus qu'à charger ce logiciel sur l'ordinateur et le travail

peut être effectué.

Cela permet d'économiser beaucoup de temps et d'argent. Le travail devient

entièrement automatisé et toute information concernant l'organisation peut être obtenue

en cliquant sur le bouton. De plus, nous sommes à l'ère de l'informatique et

l'automatisation d'une telle organisation donne une meilleure image.

8
CYCLE DE VIE DU DÉVELOPPEMENT DU SYSTÈME (SDLC)

Le cycle de vie du développement des systèmes est une technique de gestion de

projet qui divise les projets complexes en segments ou phases plus petits et plus faciles
à gérer. La segmentation des projets permet aux gestionnaires de vérifier que les
phases du projet ont été menées à bien avant d'allouer des ressources aux phases
suivantes.
Les projets de développement de logiciels comprennent généralement des
phases de lancement, de planification, de conception, de développement, de test, de
mise en œuvre et de maintenance. Toutefois, les phases peuvent être divisées
différemment selon l'organisation concernée.
Par exemple, les activités initiales du projet peuvent être désignées comme des
phases de demande, de définition des besoins et de planification, ou comme des phases
d'initiation, de développement de concepts et de planification. Les utilisateurs finaux du
système en cours de développement doivent être impliqués dans l'examen des résultats
de chaque phase afin de s'assurer que le système est construit pour fournir les
fonctionnalités nécessaires.

9
LES PHASES DU CYCLE DE VIE DU DÉVELOPPEMENT DU SYSTÈME

PHASE D'INITIATION

La phase d'initiation commence lorsqu'un sponsor de l'entreprise identifie un besoin ou

une opportunité.

L'objectif de la phase d'initiation est le suivant :

4- Identifier et valider une opportunité d'améliorer les réalisations de l'organisation ou

une déficience liée à un besoin de l'entreprise.
4- Identifier les hypothèses et les contraintes significatives des solutions à ce besoin.
4- Recommander l'exploration d'autres concepts et méthodes pour satisfaire le
besoin, y compris la remise en question de la nécessité de recourir à la
technologie, c'est-à-dire la question de savoir si un changement dans le
processus d'entreprise offrira une solution.
4- Assurer le parrainage technique et commercial de la direction. Le sponsor
désigne un chef de projet et le besoin de l'entreprise est documenté dans une
proposition de concept. La proposition de concept comprend des informations sur
le processus commercial et la relation avec l'agence/organisation.
4- L'infrastructure et le plan stratégique. Une proposition de concept réussie
débouche sur une charte de gestion de projet qui définit l'autorité du gestionnaire
de projet pour commencer à mettre en œuvre le projet.
le projet.

Une supervision attentive est nécessaire pour s'assurer que les projets
soutiennent les objectifs stratégiques de l'entreprise et que les ressources sont
effectivement mises en œuvre dans l'architecture d'entreprise d'une organisation. La
phase d'initiation commence lorsqu'une opportunité d'ajouter, d'améliorer ou de corriger
un système est identifiée et formellement demandée par la présentation d'une analyse
de rentabilité. L'analyse de rentabilité doit, au minimum, décrire l'objectif de la
proposition, identifier les avantages escomptés et expliquer comment le système
proposé soutient l'une des stratégies commerciales de l'organisation. L'analyse de
rentabilisation doit également identifier les solutions alternatives et détailler autant que
possible les exigences en matière d'information, de fonctionnement et de réseau.

1
0
PHASE DE DÉVELOPPEMENT DU CONCEPT DU SYSTÈME

La phase d'élaboration du concept du système commence après la validation d'un

besoin ou d'une opportunité par la direction du programme de l'agence/organisation et
par le DSI de l'agence/organisation.

L'objectif de la phase d'élaboration du concept de système est le suivant :

4- Déterminer la faisabilité et l'adéquation des alternatives.

4- Identifier les interfaces du système.
4- Identifier les exigences fonctionnelles de base et les exigences en matière de
données pour satisfaire les besoins de l'entreprise.
4- Établir les limites du système ; identifier les buts, les objectifs, les facteurs
critiques de succès et les mesures de performance.
4- Évaluer les coûts et les avantages des approches alternatives pour satisfaire les
exigences fonctionnelles de base.
4- Évaluer les risques du projet
4- Identifier et lancer des actions d'atténuation des risques, etDévelopper une
architecture technique de haut niveau, des modèles de processus, des modèles
de données et un concept d'opérations. Cette phase explore les solutions
techniques potentielles dans le contexte des besoins de l'entreprise.
4- Il peut inclure plusieurs décisions de compromis telles que la décision d'utiliser
des produits logiciels COTS plutôt que de développer des logiciels personnalisés
ou de réutiliser des composants logiciels, ou la décision d'utiliser une livraison
incrémentale plutôt qu'un déploiement complet en une seule fois.
4- La construction de prototypes exécutables est encouragée pour évaluer la
technologie destinée à soutenir le processus d'entreprise. Le document sur les
limites du système est un document de référence important pour soutenir le
processus de demande de projet de technologie de l'information (ITPR).
4- L'ITPR doit être approuvé par le CIO de l'État avant que le projet ne puisse aller
de l'avant.
REPRÉSENTATION PICTURALE DE LA SDLC :

1
1
PHASE DE PLANIFICATION

La phase de planification est l'étape la plus critique dans la réalisation des projets
de développement, d'acquisition et de maintenance. Une planification minutieuse, en
particulier dans les premières phases d'un projet, est nécessaire pour coordonner les
activités et gérer efficacement les risques du projet. La profondeur et la formalité des
plans de projet doivent être proportionnelles aux caractéristiques et aux risques d'un
projet donné. Les plans de projet affinent les informations recueillies au cours de la
phase de lancement en identifiant plus précisément les activités et les ressources
nécessaires à la réalisation d'un projet.
Une partie essentielle du travail du chef de projet consiste à coordonner les
discussions entre les utilisateurs, les auditeurs, les responsables de la sécurité, de la
conception, du développement et du réseau afin d'identifier et de documenter le plus
grand nombre possible d'exigences fonctionnelles, de sécurité et de réseau. Au cours de
cette phase, un plan est élaboré qui documente l'approche à utiliser et comprend une
discussion sur les méthodes, les outils, les tâches, les ressources, les calendriers de
projet et la contribution des utilisateurs. Les affectations de personnel, les coûts, le
calendrier du projet et les dates cibles sont établis.
Un plan de gestion de projet est créé avec des éléments liés à la planification de
l'acquisition, à la planification de la gestion de la configuration, à la planification de
l'assurance qualité, au concept d'opérations, à la sécurité du système, à la vérification et

1
2
à la validation, et à la planification de la gestion de l'ingénierie des systèmes.

PHASE D'ANALYSE DES BESOINS

Cette phase définit formellement les besoins fonctionnels détaillés des utilisateurs
en utilisant les besoins de haut niveau identifiés dans les phases de lancement, de
conception du système et de planification. Il définit également les exigences en termes
de données, de performances du système, de sécurité et de maintenabilité du système.
Les exigences sont définies au cours de cette phase à un niveau de détail suffisant pour
permettre la conception des systèmes. Ils doivent être mesurables, testables et se
rapporter au besoin ou à l'opportunité identifiés lors de la phase d'initiation. Les
exigences qui seront utilisées pour déterminer l'acceptation du système sont consignées
dans le plan directeur de test et d'évaluation.

Les objectifs de cette phase sont les suivants

4- Définir et affiner les exigences fonctionnelles et les exigences en matière de

données et les consigner dans le document d'exigences,
4- Réingénierie complète des processus opérationnels des fonctions à soutenir
(c'est-à-dire vérifier quelles informations alimentent le processus opérationnel,
quelles informations sont générées, qui les génère, où va l'information et qui la
traite),
4- Développer des modèles de données et de processus détaillés (entrées et sorties
du système, et processus).
4- Développer les exigences de test et d'évaluation qui seront utilisées pour
déterminer les performances acceptables du système.

PHASE DE CONCEPTION

La phase de conception consiste à convertir les exigences informationnelles,

fonctionnelles et de réseau identifiées au cours des phases d'initiation et de planification
en spécifications de conception unifiées que les développeurs utilisent pour écrire des
programmes au cours de la phase de développement. Les programmes sont conçus de
différentes manières. En utilisant une approche descendante, les concepteurs
commencent par identifier et relier les principaux composants et interfaces du
programme, puis développent les schémas de conception au fur et à mesure qu'ils

1
3
identifient et relient des sous-systèmes et des connexions plus petits. En utilisant une
approche ascendante, les concepteurs commencent par identifier et relier les
composants et interfaces mineurs du programme, puis développent les schémas de
conception à mesure qu'ils identifient et relient des systèmes et des connexions plus
importants. Les techniques de conception contemporaines utilisent souvent des outils de
prototypage qui construisent des maquettes d'éléments tels que des écrans
d'application, des dispositions de base de données et des architectures de système. Les
utilisateurs finaux, les concepteurs, les développeurs, les gestionnaires de bases de
données et les administrateurs de réseaux doivent revoir et affiner les prototypes dans le
cadre d'un processus itératif jusqu'à ce qu'ils s'accordent sur une conception acceptable.
Le personnel chargé de l'audit, de la sécurité et de l'assurance qualité doit être impliqué
dans le processus de révision et d'approbation. Au cours de cette phase, le système est
conçu pour répondre aux exigences fonctionnelles identifiées lors de la phase
précédente. Étant donné que les problèmes rencontrés lors de la phase de conception
peuvent s'avérer très coûteux à résoudre à un stade ultérieur du développement du
logiciel, divers éléments sont pris en compte dans la conception pour atténuer les
risques. Il s'agit notamment de

+ Identifier les risques potentiels et définir les caractéristiques de conception

permettant de les atténuer.
+ Effectuer une évaluation des risques de sécurité.
4- L'élaboration d'un plan de conversion pour migrer les données actuelles vers le
nouveau système.
4- Déterminer l'environnement d'exploitation.
4- Définir les principaux sous-systèmes et leurs entrées et sorties.
+ Attribution des processus aux ressources.
4- Préparation des spécifications logiques détaillées pour chaque module logiciel. Il
en résulte un projet de document de conception du système qui reprend la
conception préliminaire du système.
+ Tout ce qui nécessite l'intervention ou l'approbation de l'utilisateur est documenté
et revu par l'utilisateur. Une fois ces documents approuvés par le DSI de l'agence
et le commanditaire, le document final de conception du système est créé pour
servir de conception critique/détaillée du système.
+ Ce document fait l'objet d'un examen rigoureux par les représentants techniques et
fonctionnels de l'Agence afin de s'assurer qu'il répond aux exigences de

1
4
 l'entreprise. Parallèlement à l'élaboration de la conception du système, le
gestionnaire de projet de l'Agence commence à élaborer le plan de mise en
œuvre, le manuel d'exploitation et de maintenance et le plan de formation.

PHASE DE DÉVELOPPEMENT

La phase de développement consiste à convertir les spécifications de

conception en programmes exécutables. Des normes de développement efficaces
exigent que les programmeurs et les autres participants au projet discutent des
spécifications de conception avant le début de la programmation. Les procédures
permettent de s'assurer que les programmeurs comprennent clairement la
conception des programmes et les exigences fonctionnelles. Les programmeurs
utilisent différentes techniques pour développer des programmes informatiques. Les
grands programmes orientés vers les transactions associés aux institutions
financières ont traditionnellement été développés à l'aide de techniques de
programmation procédurales. La programmation procédurale implique l'écriture ligne
par ligne d'instructions logiques qui sont combinées pour former un programme.
L'achèvement efficace des étapes précédentes est un facteur clé de la réussite de la
phase de développement. La phase de développement consiste à

4- Traduire les exigences détaillées et la conception en composants du système.

4- Tester les éléments individuels (unités) pour la facilité d'utilisation.
4- Préparer l'intégration et les tests du système informatique.

PHASE D'INTÉGRATION ET DE TEST

4- L'intégration des sous-systèmes, les tests de système, de sécurité et d'acceptation

par l'utilisateur sont effectués pendant la phase d'intégration et de test.
L'utilisateur, avec les responsables de l'assurance qualité, valide que les
exigences fonctionnelles, telles que définies dans le document d'exigences
fonctionnelles, sont satisfaites par le système développé ou modifié. Le personnel
de sécurité de l'OIT évalue la sécurité du système et délivre une certification de
sécurité et une accréditation avant l'installation/la mise en œuvre.

Plusieurs niveaux de tests sont effectués, notamment

1
5
 4- Essais sur le site de développement par le contractant et éventuellement avec
l'aide des utilisateurs finaux.

4- Test en tant que système déployé avec les utilisateurs finaux travaillant en
collaboration avec le personnel contractuel

+ Test opérationnel par l'utilisateur final qui exécute seul toutes les fonctions.
Les exigences sont suivies tout au long des essais, une évaluation finale de
vérification et de validation indépendante est effectuée et toute la documentation
est examinée et acceptée avant la réception du système.

PHASE DE MISE EN ŒUVRE

Cette phase débute après que le système a été testé et accepté par l'utilisateur.
Au cours de cette phase, le système est installé pour prendre en charge les fonctions
commerciales prévues. La performance du système est comparée aux objectifs de
performance établis au cours de la phase de planification. La mise en œuvre comprend
la notification et la formation des utilisateurs, l'installation du matériel, l'installation des
logiciels sur les ordinateurs de production et l'intégration du système dans les processus
de travail quotidiens. Cette phase se poursuit jusqu'à ce que le système fonctionne en
production conformément aux exigences définies par l'utilisateur.

PHASE D'EXPLOITATION ET DE MAINTENANCE

Le fonctionnement du système est en cours. Le système est contrôlé pour

s'assurer qu'il continue à fonctionner conformément aux exigences de l'utilisateur et les
modifications nécessaires sont apportées au système. Les opérations se poursuivent
tant que le système peut être adapté efficacement pour répondre aux besoins de
l'organisation. Lorsque des modifications ou des changements sont identifiés, le système
peut revenir dans la phase de planification.

L'objectif de cette phase est de

4- Exploiter, maintenir et améliorer le système.

4- Certifier que le système peut traiter des informations sensibles.

1
6
4- Procéder à des évaluations périodiques du système pour s'assurer que les
exigences fonctionnelles continuent d'être satisfaites.
4- Déterminer quand le système doit être modernisé, remplacé ou mis hors service.

1
7
DIAGRAMME
DE FLUX

1
8
 CODE SOURCE

Créer un projet Python de TIC-TAC-TOE GAME

import random

square_values = ["1", "2", "3", "4", "5", "6", "7", "8", "9"]

nombre_de_tours = 0

no_wins = True

print("Jouons au Tic-Tac-Toe !")

player_1_pick = ""

player_2_pick = ""

player_1 = input("Entrez un nom pour le joueur 1 et appuyez sur enter, laissez

vide pour

partir en tant que joueur 1 : ")

player_2 = input("Enter a name for player 2 and press enter, leave blank to

leave as Player 2 : ")

#Définit le nom du joueur

si (joueur_1 == "" ou joueur_2 == "") :

si (joueur_1 == "") :

player_1 = "Joueur 1"

si (joueur_2 == "") :

player_2 = "Joueur 2"

d'autre part :

1
9
 passer

#Attribue des X ou des O aux joueurs

si (random.randint(1,2) == 1) :

player_1_pick = input(player_1 + ", choose X or O : ").upper()

si (player_1_pick == "X") :

player_2_pick = "O"

d'autre part :

player_2_pick = "X"

d'autre part :

player_2_pick = input(player_2 + ", choose X or O : ").upper()

si (player_2_pick == "X") :

player_1_pick = "O"

d'autre part :

player_1_pick = "X"

#makes a move

def make_a_move(player, player_pick) :

print("""

LOGO DE L'ÉCOLE................................................................................................................5
CERTIFICAT........................................................................................................................5
ACCUSÉ DE RÉCEPTION...........................................................................................6
INTRODUCTION..........................................................................................................7
OBJECTIFS DU PROJET.............................................................................................7
SYSTÈME PROPOSÉ...................................................................................................8
CYCLE DE VIE DU DÉVELOPPEMENT DU SYSTÈME (SDLC).........................10
LES PHASES DU CYCLE DE VIE DU DÉVELOPPEMENT DU SYSTÈME........11
PHASE D'INITIATION...............................................................................................11
L'objectif de la phase d'initiation est le suivant :.........................................................11
PHASE DE DÉVELOPPEMENT DU CONCEPT DU SYSTÈME............................12

2
0
 PHASE DE PLANIFICATION...................................................................................13
PHASE D'ANALYSE DES BESOINS........................................................................14
Les objectifs de cette phase sont les suivants...............................................................14
PHASE DE CONCEPTION........................................................................................14
PHASE DE DÉVELOPPEMENT................................................................................16
PHASE D'INTÉGRATION ET DE TEST...................................................................16
PHASE DE MISE EN ŒUVRE..................................................................................17
PHASE D'EXPLOITATION ET DE MAINTENANCE.............................................17
SORTIE........................................................................................................................30
»>.....................................................................................................................................30
I I......................................................................................................................................30
I I 41516...........................................................................................................................30
I I 71819...........................................................................................................................30
I I......................................................................................................................................30
I I 41516...........................................................................................................................30
TEST............................................................................................................................31
LES MÉTHODES D'ESSAI........................................................................................31
TESTS DE LA BOÎTE NOIRE...................................................................................31
LES TESTS BASÉS SUR LES SPÉCIFICATIONS...................................................32
AVANTAGES ET INCONVÉNIENTS......................................................................32
TESTS EN BOÎTE BLANCHE...................................................................................32
ÉVALUATION DE L'EXHAUSTIVITÉ DU CODE..................................................33
EXIGENCES EN MATIÈRE DE MATÉRIEL ET DE LOGICIEL...........................34

{} | {} | {}

| | Les valeurs de l'échantillon sont les suivantes :

""" .format(square_values[0], square_values[1], square_values[2],
square_values[3], square_values[4], square_values[5], square_values[6],
square_values[7], square_values[8])).

status = True

while (status == True) :

choice = input(player + " pick a square(" + player_pick + ") : ")

essayer :

int(choix)

si (1 <= int(choice) <= 9) :

2
1
 si (valeurs_carrées[int(choix)-1] != "X" et valeurs_carrées[int(choix)-1] !=

"O") :

square_values.remove(choice)

square_values.insert(int(choice)-1, player_pick)

statut = Faux

d'autre part :

print("Place déjà prise, choisissez une autre place")

d'autre part :

print("L'entrée n'est pas une option, choisissez à nouveau")

except ValueError :

print("L'entrée n'est pas une option, choisissez à nouveau")

status_main = True

def check_for_a_win(value1, value2, value3) :

global status_main

global no_wins

if (square_values[value1] == "X" and square_values[value2] == "X" and

square_values[value3] == "X") :

status_main = False

no_wins = False

if(player_1_pick == "X") :

print("Le joueur 1 a gagné !")

d'autre part :

print("Le joueur 2 a gagné !")

elif (square_values[value1] == "O" and square_values[value2] == "O" and

square_values[value3] == "O") :

2
2
 status_main = False

no_wins = False

if(player_1_pick == "O") :

print("Le joueur 1 a gagné !")

d'autre part :

print("Le joueur 2 a gagné !")

d'autre part :

passer

def func_1(player, pick) :

global number_of_turns

global status_main

si (no_wins == True) :

nombre_de_tours = nombre_de_tours + 1

make_a_move(player, pick)

check_for_a_win(0, 1, 2)

check_for_a_win(3, 4, 5)

check_for_a_win(6, 7, 8)

check_for_a_win(0, 3, 6)

check_for_a_win(1, 4, 7)

check_for_a_win(2, 5, 8)

check_for_a_win(0, 4, 8)

check_for_a_win(2, 4, 6)

if (number_of_turns == 9 and status_main == True) :

print("C'est un match nul :(")

status_main = False

2
3
while (status_main == True) :

func_1(player_1, player_1_pick)

func_1(player_2, player_2_pick) import random

square_values = ["1", "2", "3", "4", "5", "6", "7", "8", "9"]

nombre_de_tours = 0

no_wins = True

print("Jouons au Tic-Tac-Toe !")

player_1_pick = ""

player_2_pick = ""

player_1 = input("Entrez un nom pour le joueur 1 et appuyez sur enter, laissez

vide pour

partir en tant que joueur 1 : ")

player_2 = input("Entrez un nom pour le joueur 2 et appuyez sur enter, laissez

vide pour

partir en tant que joueur 2 : ")

#Définit le nom du joueur

si (joueur_1 == "" ou joueur_2 == "") :

si (joueur_1 == "") :

player_1 = "Joueur 1"

si (joueur_2 == "") :

player_2 = "Joueur 2"

d'autre part :

passer

#Attribue des X ou des O aux joueurs

2
4
si (random.randint(1,2) == 1) :

player_1_pick = input(player_1 + ", choose X or O : ").upper()

si (player_1_pick == "X") :

player_2_pick = "O"

d'autre part :

player_2_pick = "X"

d'autre part :

player_2_pick = input(player_2 + ", choose X or O : ").upper()

si (player_2_pick == "X") :

player_1_pick = "O"

d'autre part :

player_1_pick = "X"

#fait un mouvement def make_a_move(player, player_pick) :

print("""

LOGO DE L'ÉCOLE................................................................................................................5
CERTIFICAT........................................................................................................................5
ACCUSÉ DE RÉCEPTION...........................................................................................6
INTRODUCTION..........................................................................................................7
OBJECTIFS DU PROJET.............................................................................................7
SYSTÈME PROPOSÉ...................................................................................................8
CYCLE DE VIE DU DÉVELOPPEMENT DU SYSTÈME (SDLC).........................10
LES PHASES DU CYCLE DE VIE DU DÉVELOPPEMENT DU SYSTÈME........11
PHASE D'INITIATION...............................................................................................11
L'objectif de la phase d'initiation est le suivant :.........................................................11
PHASE DE DÉVELOPPEMENT DU CONCEPT DU SYSTÈME............................12
PHASE DE PLANIFICATION...................................................................................13
PHASE D'ANALYSE DES BESOINS........................................................................14
Les objectifs de cette phase sont les suivants...............................................................14
PHASE DE CONCEPTION........................................................................................14
PHASE DE DÉVELOPPEMENT................................................................................16
PHASE D'INTÉGRATION ET DE TEST...................................................................16
PHASE DE MISE EN ŒUVRE..................................................................................17
PHASE D'EXPLOITATION ET DE MAINTENANCE.............................................17

2
5
 SORTIE........................................................................................................................30
»>.....................................................................................................................................30
I I......................................................................................................................................30
I I 41516...........................................................................................................................30
I I 71819...........................................................................................................................30
I I......................................................................................................................................30
I I 41516...........................................................................................................................30
TEST............................................................................................................................31
LES MÉTHODES D'ESSAI........................................................................................31
TESTS DE LA BOÎTE NOIRE...................................................................................31
LES TESTS BASÉS SUR LES SPÉCIFICATIONS...................................................32
AVANTAGES ET INCONVÉNIENTS......................................................................32
TESTS EN BOÎTE BLANCHE...................................................................................32
ÉVALUATION DE L'EXHAUSTIVITÉ DU CODE..................................................33
EXIGENCES EN MATIÈRE DE MATÉRIEL ET DE LOGICIEL...........................34

""" .format(square_values[0], square_values[1], square_values[2],

valeurs_carrées[3], valeurs_carrées[4], valeurs_carrées[5], valeurs_carrées[6],

valeurs_carrées[7], valeurs_carrées[8]))

status = True

while (status == True) :

choice = input(player + " pick a square(" + player_pick + ") : ")

essayer :

int(choix)

si (1 <= int(choice) <= 9) :

si (valeurs_carrées[int(choix)-1] != "X" et valeurs_carrées[int(choix)-1] !=

"O") :

square_values.remove(choice)

square_values.insert(int(choice)-1, player_pick)

2
6
 statut = Faux

d'autre part :

print("Place déjà prise, choisissez une autre place")

d'autre part :

print("L'entrée n'est pas une option, choisissez à nouveau")

except ValueError :

print("L'entrée n'est pas une option, choisissez à nouveau")

status_main = True

def check_for_a_win(value1, value2, value3) :

global status_main

global no_wins

if (square_values[value1] == "X" and square_values[value2] == "X" and

square_values[value3] == "X") :

status_main = False

no_wins = False

if(player_1_pick == "X") :

print("Le joueur 1 a gagné !")

d'autre part :

print("Le joueur 2 a gagné !")

elif (square_values[value1] == "O" and square_values[value2] == "O" and

square_values[value3] == "O") :

status_main = False

no_wins = False

if(player_1_pick == "O") :

print("Le joueur 1 a gagné !")

d'autre part :

2
7
 print("Le joueur 2 a gagné !")

d'autre part :

passer

def func_1(player, pick) :

global nombre_de_tours

global status_main

si (no_wins == True) :

nombre_de_tours = nombre_de_tours + 1

make_a_move(player, pick)

check_for_a_win(0, 1, 2)

check_for_a_win(3, 4, 5)

check_for_a_win(6, 7, 8)

check_for_a_win(0, 3, 6)

check_for_a_win(1, 4, 7)

check_for_a_win(2, 5, 8)

check_for_a_win(0, 4, 8)

check_for_a_win(2, 4, 6)

if (number_of_turns == 9 and status_main == True) :

print("C'est un match nul :(")

status_main = False

while (status_main == True) :

func_1(player_1, player_1_pick)

func_1(joueur_2, joueur_2_pick)

2
8
 SORTIE

»>
Jouons au Tic-Tac-Toe !
Entrez un nom pour le joueur 1 et appuyez sur la touche Entrée, laissez un blanc pour
laisser le joueur 1 : xyz Entrez un nom pour le joueur 2 et appuyez sur la touche Entrée,
laissez un blanc pour laisser le joueur 2 : abc xyz, choisissez X ou O : 3

I I
1|2|3

I I 41516
I I 71819
I I
xyz pick a square(3) 1

II3| 2| 3II
I I 41516

2
9
 TEST

Le test de logiciel est une enquête empirique menée pour fournir aux parties
prenantes des informations sur la qualité du produit ou du service testé[1] , dans le
contexte dans lequel il est censé fonctionner. Les tests de logiciels fournissent
également une vision objective et indépendante du logiciel afin de permettre à
l'entreprise d'apprécier et de comprendre les risques liés à la mise en œuvre du
logiciel. Les techniques de test comprennent, entre autres, le processus d'exécution
d'un programme ou d'une application dans le but de trouver des bogues logiciels.
Elle peut également être décrite comme le processus de validation et de
vérification qu'un programme/application/produit logiciel répond aux exigences
commerciales et techniques qui ont guidé sa conception et son développement, de
sorte qu'il fonctionne comme prévu et puisse être mis en œuvre avec les mêmes
caractéristiques. Les tests de logiciels, en fonction de la méthode de test employée,
peuvent être mis en œuvre à tout moment du processus de développement, mais la
plupart des efforts de test sont déployés après que les exigences ont été définies et
que le processus de codage a été achevé.

LES MÉTHODES D'ESSAI

Les méthodes de test des logiciels sont traditionnellement divisées en deux
catégories : les tests "boîte noire" et les tests "boîte blanche". Ces deux approches
sont utilisées pour décrire le point de vue qu'adopte un ingénieur de test lors de la
conception des cas de test.

TESTS DE LA BOÎTE NOIRE

Les tests en boîte noire traitent le logiciel comme une "boîte noire", sans
aucune connaissance de l'implémentation interne. Les méthodes de test de la boîte
noire comprennent : le partitionnement de l'équivalence, l'analyse de la valeur limite,
le test de toutes les paires, le test fuzz, le test basé sur le modèle, la matrice de
traçabilité, le test exploratoire et le test basé sur les spécifications.

3
0
LES TESTS BASÉS SUR LES SPÉCIFICATIONS

Les tests basés sur les spécifications visent à tester la fonctionnalité du

logiciel conformément aux exigences applicables[16]. Ainsi, le testeur introduit des
données dans l'objet de test et n'en voit que la sortie. Ce niveau de test nécessite
généralement que des cas de test complets soient fournis au testeur, qui peut alors
simplement vérifier que pour une entrée donnée, la valeur de sortie (ou le
comportement) "est" ou "n'est pas" la même que la valeur attendue spécifiée dans le
cas de test. Les tests basés sur les spécifications sont nécessaires, mais ils sont
insuffisants pour se prémunir contre certains risques

AVANTAGES ET INCONVÉNIENTS

Le testeur de boîte noire n'a pas de "liens" avec le code, et la perception d'un
testeur est très simple : un code doit avoir des bogues. S'appuyant sur le principe
"Demandez et vous recevrez", les testeurs de boîtes noires trouvent des bogues là
où les programmeurs n'en trouvent pas. D'un autre côté, on a dit que les tests en
boîte noire étaient "comme une promenade dans un labyrinthe sombre sans lampe
de poche", parce que le testeur ne sait pas comment le logiciel testé a été réellement
construit.
C'est pourquoi il y a des situations où (1) un testeur de boîte noire écrit de
nombreux cas de test pour vérifier quelque chose qui ne peut être testé que par un
seul cas de test, et/ou (2) certaines parties du back-end ne sont pas testées du tout.
Par conséquent, les tests en boîte noire présentent l'avantage d'un "avis non affilié",
d'une part, et l'inconvénient d'une "exploration à l'aveugle", d'autre part.

TESTS EN BOÎTE BLANCHE

Les tests en boîte blanche, par opposition aux tests en boîte noire, sont
effectués lorsque le testeur a accès aux structures de données et aux algorithmes
internes (ainsi qu'au code qui les met en œuvre).

Types de tests en boîte blanche

Il existe plusieurs types de tests en boîte blanche :
4- tests d'api - Tests de l'application utilisant des API publiques et privées.

3
1
 4- Couverture du code - création de tests pour satisfaire certains critères
de couverture du code.
Par exemple, le concepteur de tests peut créer des tests pour que toutes les
instructions du programme soient exécutées au moins une fois.
4- les méthodes d'injection de fautes.

4- les méthodes de test de mutation.

4- tests statiques - Les tests en boîte blanche comprennent tous les tests
statiques.

ÉVALUATION DE L'EXHAUSTIVITÉ DU CODE

Les méthodes de test en boîte blanche peuvent également être utilisées pour
évaluer l'exhaustivité d'une suite de tests créée à l'aide de méthodes de test en boîte
noire. Cela permet à l'équipe chargée du logiciel d'examiner les parties d'un système
qui sont rarement testées et de s'assurer que les points de fonction les plus
importants ont été testés.

Les deux formes les plus courantes de couverture du code sont les suivantes :
4- Couverture des fonctions : qui rend compte des fonctions exécutées et
4- Couverture des instructions : Elle indique le nombre de lignes
exécutées pour mener à bien le test.
Ils ont tous les deux une mesure de couverture de retour, mesurée en
pourcentage

3
2
 EXIGENCES EN MATIÈRE DE MATÉRIEL ET DE LOGICIEL

I.SYSTÈME D'EXPLOITATION : WINDOWS 7 ET PLUS PENTIUM(ANY) OU

II. PROCESSEUR : AMD ATHALON(3800+- 4200+ DUAL

CORE) 1.845 OU 915,995 POUR PENTIUM

III. CARTE MÈRE 0R MSI K9MM-V VIA K8M800+8237R

:
PLUS CHIPSET POUR AMD ATHALON

512MB+

SATA 40 GB OU PLUS
IV. RAM
: (si une sauvegarde est nécessaire)

V. Disque dur : (si une sauvegarde est nécessaire)

VI. CD/DVD r/w multi drive

combo :

VII. LECTEUR DE DISQUETTES

1,44 MB : (si l'impression est requise - [Copie papier])
VIII. MONITEUR 14.1 ou 15 -17
pouces

IX. Clavier et souris

X. Imprimante :

LES EXIGENCES EN MATIÈRE

3
3
 BIBLIOGRAPHIE

1. Computer science With Python - Class XI Par : Sumita Arora

2. Rapport de projet sur le système de gestion de la banque de sang
(BBMS)
Par : Praveen M Jigajinni
3. Site web: https://www.w3resource.com
4. https://en.wikipedia.org/wiki/E_(constante_mathématique)

***

3
4