NAME DER SCHULE

SCHULLOGO

STUDIENJAHR : 2019-20

PROJEKTBERICHT ZUM

THEMA „TIC-TAC-TOE-

SPIEL“
SCHULLOGO 5
ZEUGNIS 5
DANKSAGUNG6
XI

INFORMATIK

083
EINLEITUNG 7
ZIELE DES PROJEKTS
8

1
 VORGESCHLAGENES
SYSTEM 8
SYSTEMENTWICKLUNGSL
EBENSZYKLUS (SDLC)
10
PHASEN DES
SYSTEMENTWICKLUNGSL
EBENSZYKLUS10
INITIIERUNGSPHASE
10
Der Zweck der
Initiierungsphase besteht darin:
11
SYSTEMKONZEPT 11
PLANUNGSPHASE 13
ANFORDERUNGSANALYS
EPHASE 14
Die Zwecke dieser Phase sind:
14
DESIGNPHASE14
ENTWICKLUNGSPHASE
16
INTEGRATIONS- UND
TESTPHASE 16
IMPLEMENTIERUNGSPHA
SE 17
BETRIEBS- UND
WARTUNGSPHASE 17
AUSGABE 30
»> 30
II 30
I I 41516 30

2
 I I 71819 30
II 30
I I 41516 30
PRÜFUNG 31
PRÜFVERFAHREN 31
BLACK-BOX-TESTS 31
SPEZIFIKATIONSBASIERT
E PRÜFUNG 32
VOR- UND NACHTEILE
32
WHITE-BOX-TESTS 32
BEWERTUNG DER CODE-
VOLLSTÄNDIGKEIT
33
HARDWARE- UND
SOFTWAREANFORDERUN
GEN 34

PROJEKTLEITFADEN:
PGT (CS)

3
 NAME DER SCHULE

SCHULLOGO

ZEUGNIS

Hiermit wird bescheinigt, dass Kadett ______________________________________

Rollen-Nr.: ________________________ hat das Projekt erfolgreich abgeschlossen

Arbeit mit dem Titel "TIC-TAC-TOE-SPIEL." im Fach Informatik (083), festgelegt in den

Vorschriften des CBSE zum Zwecke der praktischen [ Prüfung in Klasse XI, abzulegen in

_________________________________ am_____________.

( )
PGT Comp Sci
Master-IC

Prüfer:

Name: _______________

Unterschrift:

Datum:

4
 INHALTSVERZEICHNIS [ T O C ]

SER BESCHREIBUNG SEITE NR.

01 DANKSAGUNG 04

02 EINLEITUNG 05

03 ZIELE DES PROJEKTS 05

04 VORGESCHLAGENES SYSTEM 06

05 SYSTEMENTWICKLUNGSLEBENSZYKLUS (SDLC) 07

06 PHASEN DES SYSTEMENTWICKLUNGSLEBENSZYKLUS 08

07 ABLAUFDIAGRAMM 15

08 QUELLCODE 16

09 AUSGABE 19

10 PRÜFUNG 20

11 HARDWARE- UND SOFTWAREANFORDERUNGEN 23

12 LITERATURVERZEICHNIS 24

DANKSAGUNG

Abgesehen von den Bemühungen von mir hängt der Erfolg eines jeden Projekts
weitgehend von der Ermutigung und den Richtlinien vieler anderer ab. Ich nutze diese
Gelegenheit, um mich bei den Menschen zu bedanken, die zum erfolgreichen Abschluss
dieses Projekts beigetragen haben.

5
 Ich drücke dem allmächtigen Gott meine tiefe Dankbarkeit dafür aus, dass er mir
Kraft für den erfolgreichen Abschluss des Projekts gegeben hat.

Ich bedanke mich herzlich bei meinen Eltern für die ständige Ermutigung bei der
Durchführung dieses Projekts.

Ich anerkenne dankbar den Beitrag der Personen, die dazu beigetragen haben,
dieses Projekt auf dieses Niveau zu bringen, die sich trotz meiner Mängel weiterhin um
mich kümmern.

Ich drücke dem Koryphäen The Principal meine tiefe Dankbarkeit aus, die
uns immer wieder motiviert und die helfende Hand gereicht hat.

Ich bedanke mich aufrichtig bei dem Akademiker The Vice Principal, , für
ständige Ermutigung und die Anleitung während dieses Projekts

Ich bin überwältigt, meinen Dank auszusprechen an ____ für die Bereitstellung
eines
infrastruktur und moralische Unterstützung bei der Durchführung dieses Projekts in der
Schule.

Herzlichen Dank an ___________, verantwortlich für den Master, ein Führer,

Mentor für alle
über einem Freund, der mein Projekt kritisch überprüft und bei der Lösung jedes
Problems geholfen hat, trat während der Umsetzung des Projekts auf

Die Anleitung und Unterstützung durch alle Mitglieder, die zu diesem Projekt
beigetragen haben und beitragen, war entscheidend für den Erfolg des Projekts. Ich bin
dankbar für ihre ständige Unterstützung und Hilfe.

PROJEKT AUF TIC-TAC-TOE-SPIEL

EINLEITUNG

Tic-Tac-Toe (amerikanisches Englisch), Nullen und Kreuze (britisches Englisch) oder

Xs und Os ist ein Papier- und Bleistiftspiel für zwei Spieler, X und O, die abwechselnd die

Felder in einem 3×3-Raster markieren. Der Spieler, dem es gelingt, drei seiner Markierungen in

einer horizontalen, vertikalen oder diagonalen Reihe zu platzieren, gewinnt das Spiel.

6
ZIELE DES PROJEKTS

Das Ziel dieses Projekts ist es, die Schüler das Programmierwissen in eine reale

Situation/ein Problem anwenden zu lassen und den Schülern zu zeigen, wie

Programmierkenntnisse bei der Entwicklung einer guten Software helfen.

1. Schreiben Sie Programme mit modernen Software-Tools.

2. Wenden Sie objektorientierte Programmierprinzipien effektiv an, wenn Sie kleine

bis mittelgroße Projekte entwickeln.

3. Schreiben Sie effektiven Verfahrenscode, um kleine bis mittelgroße Probleme zu

lösen.

4. Die Studierenden demonstrieren ein breites Wissen in der Informatik, beispielhaft

in den Bereichen System-, Theorie- und Softwareentwicklung.

5. Die Studierenden zeigen die Fähigkeit, ein Forschungs- oder angewandtes

Informatikprojekt durchzuführen, das Schreib- und Präsentationsfähigkeiten

erfordert, die den wissenschaftlichen Stil in der Informatik veranschaulichen.

VORGESCHLAGENES SYSTEM

Heute kann man es sich nicht leisten, sich auf die fehlbaren Menschen zu

verlassen, die sich wirklich gegen die heutige gnadenlose Konkurrenz stellen wollen, bei

der es nicht mehr gültig ist, weise zu sagen: "Irren ist menschlich", sondern veraltet

ist, um Ihren Fehler zu rationalisieren. Also, um mit der Zeit Schritt zu halten, um das

beste Ergebnis ohne Fehlfunktionen und eine größere Effizienz zu erzielen, um die

endlosen Fliegenhaufen durch eine sehr ausgeklügelte Festplatte des Computers zu

ersetzen.

Man muss die Datenverwaltungssoftware verwenden. Software war ein Aufstieg

in der Atomisierung verschiedener Organisationen. Viele Softwareprodukte arbeiten jetzt

7
in Märkten, die dazu beigetragen haben, dass die Organisationen einfacher und

effizienter arbeiten können. Das Datenmanagement musste anfangs viele Bücher führen

und es muss viel Papierarbeit geleistet werden, aber jetzt hat das Softwareprodukt in

dieser Organisation ihre Arbeit schneller und einfacher gemacht. Jetzt muss nur noch

diese Software auf den Computer geladen werden und die Arbeit kann erledigt werden.

Das spart viel Zeit und Geld. Die Arbeit wird vollständig automatisiert und alle

Informationen über die Organisation können durch Klicken auf die Schaltfläche

abgerufen werden. Darüber hinaus ist es jetzt ein Zeitalter der Computer und die

Automatisierung einer solchen Organisation gibt das bessere Aussehen.

8
SYSTEMENTWICKLUNGSLEBENSZYKLUS (SDLC)

Der Lebenszyklus der Systementwicklung ist eine Projektmanagement-Technik,

die komplexe Projekte in kleinere, leichter zu verwaltende Segmente oder Phasen
unterteilt. Durch die Segmentierung von Projekten können Manager den erfolgreichen
Abschluss von Projektphasen überprüfen, bevor sie Ressourcen für nachfolgende
Phasen zuweisen.
Softwareentwicklungsprojekte umfassen typischerweise Initiierungs-, Planungs-,
Design-, Entwicklungs-, Test-, Implementierungs- und Wartungsphasen. Die Phasen
können jedoch je nach beteiligter Organisation unterschiedlich aufgeteilt werden.
Beispielsweise können anfängliche Projektaktivitäten als Anfrage-,
Anforderungsdefinitions- und Planungsphasen oder Initiierungs-, Konzeptentwicklungs-
und Planungsphasen bezeichnet werden. Die Endbenutzer des in der Entwicklung
befindlichen Systems sollten in die Überprüfung der Ergebnisse jeder Phase einbezogen
werden, um sicherzustellen, dass das System so gebaut wird, dass es die erforderliche
Funktionalität bietet.
PHASEN DES SYSTEMENTWICKLUNGSLEBENSZYKLUS

INITIIERUNGSPHASE

Die Initiierungsphase beginnt, wenn ein Unternehmenssponsor einen Bedarf oder eine

9
Chance identifiziert.

Der Zweck der Initiierungsphase besteht darin:

4- Identifizieren und validieren Sie eine Gelegenheit zur Verbesserung der

Geschäftsleistungen der Organisation oder einen Mangel im Zusammenhang mit
einem Geschäftsbedarf.
4- Identifizieren Sie wichtige Annahmen und Einschränkungen für Lösungen für
diesen Bedarf.
4- Empfehlen Sie die Erforschung alternativer Konzepte und Methoden, um den
Bedarf zu befriedigen, einschließlich der Infragestellung des Bedarfs an
Technologie, d. h. bietet eine Änderung des Geschäftsprozesses eine Lösung?
4- Sicherstellung des geschäftlichen und technischen Sponsorings für
Führungskräfte. Der Sponsor benennt einen Projektmanager und der
Geschäftsbedarf wird in einem Konzeptvorschlag dokumentiert. Der
Konzeptvorschlag enthält Informationen über den Geschäftsprozess und die
Beziehung zur Agentur/Organisation.
4- Infrastruktur und der Strategieplan. Ein erfolgreicher Konzeptvorschlag führt zu
einer Projektmanagement-Charta, die die Befugnis des Projektmanagers umreißt,
das Projekt.

Eine sorgfältige Aufsicht ist erforderlich, um sicherzustellen, dass Projekte

strategische Geschäftsziele unterstützen und Ressourcen effektiv in die
Unternehmensarchitektur eines Unternehmens implementiert werden. Die
Initiierungsphase beginnt, wenn eine Gelegenheit zum Hinzufügen, Verbessern oder
Korrigieren eines Systems identifiziert und durch die Präsentation eines Business Case
formell angefordert wird. Der Business Case sollte mindestens den Zweck eines
Vorschlags beschreiben, den erwarteten Nutzen ermitteln und erklären, wie das
vorgeschlagene System eine der Geschäftsstrategien des Unternehmens unterstützt.
Der Business Case sollte auch alternative Lösungen identifizieren und so viele
Informations-, Funktions- und Netzwerkanforderungen wie möglich detaillieren.

SYSTEMKONZEPT

Die Entwicklungsphase des Systemkonzepts beginnt, nachdem ein Geschäftsbedarf

1
0
oder eine Geschäftsgelegenheit von der Führung des Agentur-/Organisationsprogramms
und dem CIO der Agentur/Organisation validiert wurde.

Der Zweck der Systemkonzeptentwicklungsphase besteht darin:

4- Bestimmen Sie die Durchführbarkeit und Angemessenheit der Alternativen.

4- Identifizieren Sie Systemschnittstellen.
4- Identifizieren Sie grundlegende Funktions- und Datenanforderungen, um die
Geschäftsanforderungen zu erfüllen.
4- Legen Sie Systemgrenzen fest; identifizieren Sie Ziele, kritische Erfolgsfaktoren
und Leistungskennzahlen.
4- Bewertung von Kosten und Nutzen alternativer Ansätze zur Erfüllung der
grundlegenden funktionalen Anforderungen
4- Projektrisiken bewerten
4- Identifizieren und initiieren Sie Maßnahmen zur Risikominderung und entwickeln
Sie eine übergeordnete technische Architektur, Prozessmodelle, Datenmodelle
und ein Betriebskonzept. In dieser Phase werden mögliche technische Lösungen
im Kontext des Geschäftsbedarfs untersucht.
4- Es kann mehrere Kompromissentscheidungen beinhalten, wie die Entscheidung,
COTS-Softwareprodukte im Gegensatz zur Entwicklung benutzerdefinierter
Software oder zur Wiederverwendung von Softwarekomponenten zu verwenden,
oder die Entscheidung, eine inkrementelle Lieferung im Vergleich zu einer
vollständigen, einmaligen Bereitstellung zu verwenden.
4- Der Aufbau von ausführbaren Prototypen wird ermutigt, die Technologie zur
Unterstützung des Geschäftsprozesses zu bewerten. Das System Boundary
Document dient als wichtiges Referenzdokument zur Unterstützung des ITPR-
Prozesses (Information Technology Project Request).
4- Der ITPR muss vom staatlichen CIO genehmigt werden, bevor das Projekt
voranschreiten kann.
BILDLICHE DARSTELLUNG VON SDLC:

1
1
PLANUNGSPHASE

Die Planungsphase ist der kritischste Schritt beim Abschluss von Entwicklungs-,
Akquisitions- und Instandhaltungsprojekten. Eine sorgfältige Planung, insbesondere in
der Anfangsphase eines Projekts, ist notwendig, um Aktivitäten zu koordinieren und
Projektrisiken effektiv zu managen. Die Tiefe und Formalität der Projektpläne sollte den
Merkmalen und Risiken eines bestimmten Projekts entsprechen. Projektpläne verfeinern
die während der Initiierungsphase gesammelten Informationen, indem sie die
spezifischen Aktivitäten und Ressourcen, die für den Abschluss eines Projekts
erforderlich sind, weiter identifizieren.
Ein wichtiger Teil der Arbeit eines Projektmanagers besteht darin, Diskussionen
zwischen Benutzer-, Audit-, Sicherheits-, Design-, Entwicklungs- und Netzwerkpersonal
zu koordinieren, um so viele Funktions-, Sicherheits- und Netzwerkanforderungen wie
möglich zu identifizieren und zu dokumentieren. In dieser Phase wird ein Plan entwickelt,
der den zu verwendenden Ansatz dokumentiert und eine Diskussion von Methoden,
Tools, Aufgaben, Ressourcen, Projektzeitplänen und Benutzereingaben beinhaltet.
Personaleinsätze, Kosten, Projektzeitplan und Zieltermine werden festgelegt.
Ein Projektmanagementplan wird mit Komponenten erstellt, die sich auf die
Akquisitionsplanung, die Planung des Konfigurationsmanagements, die
Qualitätssicherungsplanung, das Betriebskonzept, die Systemsicherheit, die
Verifizierung und Validierung sowie die Managementplanung des Systems Engineering

1
2
beziehen.

ANFORDERUNGSANALYSEPHASE

In dieser Phase werden die detaillierten funktionalen Benutzeranforderungen

anhand der in der Initiierungs-, Systemkonzept- und Planungsphase identifizierten
übergeordneten Anforderungen formal definiert. Es beschreibt auch die Anforderungen
in Bezug auf Daten, Systemleistung, Sicherheit und Wartbarkeitsanforderungen für das
System. Die Anforderungen werden in dieser Phase so detailliert definiert, dass das
Systemdesign fortgesetzt werden kann. Sie müssen messbar und testbar sein und sich
auf die in der Initiierungsphase identifizierten Geschäftsanforderungen oder -chancen
beziehen. Die Anforderungen, die zur Festlegung der Abnahme des Systems verwendet
werden, sind im Test- und Bewertungs-Masterplan erfasst.

Die Zwecke dieser Phase sind:

4- Die Funktions- und Datenanforderungen weiter zu definieren und zu verfeinern

und im Anforderungsdokument zu dokumentieren,
4- Vollständiges Reengineering der Geschäftsprozesse der zu unterstützenden
Funktionen (d. h. Überprüfung, welche Informationen den Geschäftsprozess
antreiben, welche Informationen generiert werden, wer sie generiert, wohin die
Informationen gehen und wer sie verarbeitet),
4- Entwickeln Sie detaillierte Daten- und Prozessmodelle (Systemeingänge, -
ausgänge und der Prozess.
4- Entwickeln der Test- und Bewertungsanforderungen, die zur Bestimmung der
akzeptablen Systemleistung verwendet werden.

DESIGNPHASE

In der Designphase werden die in der Initiierungs- und Planungsphase

identifizierten Informations-, Funktions- und Netzwerkanforderungen in einheitliche
Designspezifikationen umgewandelt, die Entwickler in der Entwicklungsphase für
Skriptprogramme verwenden. Programmdesigns werden auf verschiedene Weise
aufgebaut. Mit einem Top-Down-Ansatz identifizieren und verknüpfen Designer zunächst
Hauptprogrammkomponenten und Schnittstellen und erweitern dann die
Entwurfslayouts, wenn sie kleinere Subsysteme und Verbindungen identifizieren und

1
3
verknüpfen. Mithilfe eines Bottom-up-Ansatzes identifizieren und verknüpfen Designer
zunächst kleinere Programmkomponenten und Schnittstellen und erweitern dann die
Entwurfslayouts, wenn sie größere Systeme und Verbindungen identifizieren und
verknüpfen. Moderne Designtechniken verwenden häufig Prototyping-Tools, die
Modelldesigns von Elementen wie Anwendungsbildschirmen, Datenbanklayouts und
Systemarchitekturen erstellen. Endbenutzer, Designer, Entwickler, Datenbankmanager
und Netzwerkadministratoren sollten die prototypisierten Designs in einem iterativen
Prozess überprüfen und verfeinern, bis sie sich auf ein akzeptables Design einigen. Das
Audit-, Sicherheits- und Qualitätssicherungspersonal sollte in den Überprüfungs- und
Genehmigungsprozess einbezogen werden. Während dieser Phase ist das System so
ausgelegt, dass es die in der vorherigen Phase identifizierten funktionalen
Anforderungen erfüllt. Da Probleme in der Designphase in der späteren Phase der
Softwareentwicklung sehr teuer zu lösen sein könnten, werden im Design eine Vielzahl
von Elementen berücksichtigt, um das Risiko zu mindern. Dazu gehören:

+ Identifizierung potenzieller Risiken und Definition von mitigierenden

Designmerkmalen.
+ Durchführung einer Sicherheitsrisikobewertung.
4- Entwicklung eines Umstellungsplans zur Migration aktueller Daten auf das neue
System.
4- Bestimmung der Betriebsumgebung.
4- Definition der wichtigsten Subsysteme und ihrer Ein- und Ausgänge.
+ Zuordnung von Prozessen zu Ressourcen.
4- Erstellung detaillierter Logikspezifikationen für jedes Softwaremodul. Das
Ergebnis ist ein Entwurf des Systemdesign-Dokuments, das den vorläufigen
Entwurf für das System erfasst.
+ Alles, was eine Benutzereingabe oder Genehmigung erfordert, wird vom Benutzer
dokumentiert und überprüft. Sobald diese Dokumente vom CIO der Agentur und
dem Business-Sponsor genehmigt wurden, wird das endgültige Systemdesign-
Dokument erstellt, das als kritisches/detailliertes Design für das System dient.
+ Dieses Dokument wird von den technischen und funktionalen Vertretern der
Agentur gründlich überprüft, um sicherzustellen, dass es den
Geschäftsanforderungen entspricht. Parallel zur Entwicklung des Systemdesigns
beginnt der Projektleiter der Agentur mit der Entwicklung des
Implementierungsplans, des Betriebs- und Wartungshandbuchs und des

1
4
 Schulungsplans.

ENTWICKLUNGSPHASE

In der Entwicklungsphase geht es darum, Designvorgaben in ausführbare

Programme umzuwandeln. Effektive Entwicklungsstandards umfassen
Anforderungen, die Programmierer und andere Projektteilnehmer vor Beginn der
Programmierung mit den Designspezifikationen besprechen. Die Verfahren helfen
sicherzustellen, dass Programmierer die Programmdesigns und funktionalen
Anforderungen klar verstehen. Programmierer verwenden verschiedene Techniken,
um Computerprogramme zu entwickeln. Die großen transaktionsorientierten
Programme, die mit Finanzinstituten verbunden sind, wurden traditionell unter
Verwendung von prozeduralen Programmiertechniken entwickelt. Die prozedurale
Programmierung umfasst das zeilenweise Skripten von logischen Anweisungen, die
zu einem Programm kombiniert werden. Der effektive Abschluss der vorherigen
Phasen ist ein Schlüsselfaktor für den Erfolg der Entwicklungsphase. Die
Entwicklungsphase besteht aus:

4- Übersetzung der detaillierten Anforderungen und des Designs in

Systemkomponenten.
4- Testen einzelner Elemente (Einheiten) auf Verwendbarkeit.
4- Vorbereitung auf die Integration und das Testen des IT-Systems.

INTEGRATIONS- UND TESTPHASE

4- Subsystemintegrations-, System-, Sicherheits- und Benutzerakzeptanztests

werden während der Integrations- und Testphase durchgeführt. Der Anwender
validiert mit den für die Qualitätssicherung Verantwortlichen, dass die funktionalen
Anforderungen, wie im Dokument der funktionalen Anforderungen definiert, durch
das entwickelte oder geänderte System erfüllt werden. OIT Security-Mitarbeiter
bewerten die Systemsicherheit und stellen vor der Installation/Implementierung
eine Sicherheitszertifizierung und Akkreditierung aus.

Es werden mehrere Teststufen durchgeführt, darunter:

1
5
 4- Erprobung in der Entwicklungseinrichtung durch den Auftragnehmer und ggf.
unterstützt durch Endanwender

4- Testen als eingesetztes System mit Endbenutzern in Zusammenarbeit mit

Vertragspersonal

+ Betriebsprüfung durch den Endbenutzer allein, der alle Funktionen ausführt.

Die Anforderungen werden während des gesamten Tests verfolgt,eine
abschließende unabhängige Verifizierungs- und Validierungsbewertung wird
durchgeführt und alle Dokumentationen werden vor der Abnahme des Systems
überprüft und akzeptiert.

IMPLEMENTIERUNGSPHASE

Diese Phase wird eingeleitet, nachdem das System vom Benutzer getestet und
akzeptiert wurde. In dieser Phase wird das System installiert, um die vorgesehenen
Geschäftsfunktionen zu unterstützen. Die Systemleistung wird mit den in der
Planungsphase festgelegten Leistungszielen verglichen. Die Implementierung umfasst
die Benachrichtigung der Benutzer, die Schulung der Benutzer, die Installation der
Hardware, die Installation der Software auf Produktionscomputern und die Integration
des Systems in die täglichen Arbeitsprozesse. Diese Phase wird fortgesetzt, bis das
System gemäß den definierten Benutzeranforderungen in der Produktion arbeitet.

BETRIEBS- UND WARTUNGSPHASE

Der Systembetrieb ist im Gange. Das System wird auf kontinuierliche Leistung in
Übereinstimmung mit den Benutzeranforderungen überwacht und erforderliche
Systemänderungen werden einbezogen. Der Betrieb wird fortgesetzt, solange das
System effektiv an die Bedürfnisse der Organisation angepasst werden kann. Wenn
Änderungen oder Änderungen festgestellt werden, kann das System erneut in die
Planungsphase eintreten.

Ziel dieser Phase ist es:

4- Betreiben, warten und verbessern Sie das System.

1
6
 4- Bestätigen Sie, dass das System sensible Informationen verarbeiten kann.
4- Führen Sie regelmäßige Bewertungen des Systems durch, um sicherzustellen,
dass die funktionalen Anforderungen weiterhin erfüllt werden.
4- Bestimmen Sie, wann das System modernisiert, ersetzt oder außer Betrieb
genommen werden muss.

1
7
ABLAUFDIAG
RAMM

1
8
 QUELLCODE

Erstellen Sie ein Python-Projekt mit TIC-TAC-TOE-SPIEL

zufällig importieren

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

number_of_turns = 0

no_wins = True

print("Lass uns Tic-Tac-Toe spielen!")

player_1_pick = ""

player_2_pick = ""

player_1 = input("Geben Sie einen Namen für Player 1 ein und drücken Sie die

Eingabetaste, lassen Sie das Feld leer, um

als Spieler 1 verlassen: ")

player_2 = input("Geben Sie einen Namen für Spieler 2 ein und drücken Sie

die Eingabetaste, lassen Sie das Feld leer, um Spieler 2 zu verlassen: ")

#legt den Spielernamen fest

wenn (player_1 == "" oder player_2 == ""):

if (player_1 == ""):

player_1 = "Spieler 1"

if (player_2 == ""):

player_2 = "Spieler 2"

else:

1
9
 bestanden

#weist Spielern X oder O zu

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

player_1_pick = input(player_1 + ", wählen Sie X oder O: ").upper()

if (player_1_pick == "X"):

player_2_pick = "O"

else:

player_2_pick = "X"

else:

player_2_pick = input(player_2 + ", wählen Sie X oder O: ").upper()

if (player_2_pick == "X"):

player_1_pick = "O"

else:

player_1_pick = "X"

#bewegt sich

def make_a_move(player, player_pick):

print("""

SCHULLOGO...........................................................................................................................5
ZEUGNIS..............................................................................................................................5
DANKSAGUNG............................................................................................................6
EINLEITUNG................................................................................................................7
ZIELE DES PROJEKTS................................................................................................8
VORGESCHLAGENES SYSTEM...............................................................................8
SYSTEMENTWICKLUNGSLEBENSZYKLUS (SDLC).........................................10
PHASEN DES SYSTEMENTWICKLUNGSLEBENSZYKLUS..............................10
INITIIERUNGSPHASE..............................................................................................10
Der Zweck der Initiierungsphase besteht darin:...........................................................11
SYSTEMKONZEPT....................................................................................................11

2
0
 PLANUNGSPHASE....................................................................................................13
ANFORDERUNGSANALYSEPHASE......................................................................14
Die Zwecke dieser Phase sind:.....................................................................................14
DESIGNPHASE..........................................................................................................14
ENTWICKLUNGSPHASE.........................................................................................16
INTEGRATIONS- UND TESTPHASE......................................................................16
IMPLEMENTIERUNGSPHASE................................................................................17
BETRIEBS- UND WARTUNGSPHASE....................................................................17
AUSGABE...................................................................................................................30
»>.....................................................................................................................................30
I I......................................................................................................................................30
I I 41516...........................................................................................................................30
I I 71819...........................................................................................................................30
I I......................................................................................................................................30
I I 41516...........................................................................................................................30
PRÜFUNG...................................................................................................................31
PRÜFVERFAHREN....................................................................................................31
BLACK-BOX-TESTS.................................................................................................31
SPEZIFIKATIONSBASIERTE PRÜFUNG...............................................................32
VOR- UND NACHTEILE...........................................................................................32
WHITE-BOX-TESTS..................................................................................................32
BEWERTUNG DER CODE-VOLLSTÄNDIGKEIT.................................................33
HARDWARE- UND SOFTWAREANFORDERUNGEN..........................................34

{} | {} | {}

| | """ .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 + "ein Feld auswählen (" + player_pick + "): ")

try:

int(choice)

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

2
1
 if (square_values[int(choice)-1] != "X" und square_values[int(choice)-1] !=

"O"):

square_values.remove(Auswahl)

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

status = False

else:

print("Quadrat bereits vergeben, wählen Sie ein anderes Quadrat aus.")

else:

print("Eingabe keine Option, erneut wählen.")

außer ValueError:

print("Eingabe keine Option, erneut wählen.")

status_main = Wahr

def check_for_a_win(Wert1, Wert2, Wert3):

global status_main

global no_wins

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

square_values[value3] == "X"):

status_main = Falsch

no_wins = False

if(player_1_pick == "X"):

print("Spieler 1 hat gewonnen!")

else:

print("Spieler 2 hat gewonnen!")

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

square_values[value3] == "O"):

2
2
 status_main = Falsch

no_wins = False

if(player_1_pick == "O"):

print("Spieler 1 hat gewonnen!")

else:

print("Spieler 2 hat gewonnen!")

else:

bestanden

def func_1(Spieler, Auswahl):

global number_of_turns

global status_main

if (no_wins == True):

number_of_turns = number_of_turns + 1

make_a_move(Spieler, Auswahl)

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("Es ist eine Krawatte :(")

status_main = Falsch

2
3
while (status_main == Wahr):

func_1(player_1, player_1_Pick)

func_1(player_2, player_2_Pick) Import zufällig

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

number_of_turns = 0

no_wins = True

print("Lass uns Tic-Tac-Toe spielen!")

player_1_pick = ""

player_2_pick = ""

player_1 = input("Geben Sie einen Namen für Player 1 ein und drücken Sie die
Eingabetaste, lassen Sie das Feld leer, um

als Spieler 1 verlassen: ")

player_2 = input("Geben Sie einen Namen für Player 2 ein und drücken Sie die
Eingabetaste, lassen Sie das Feld leer, um

als Spieler 2 verlassen: ")

#legt den Spielernamen fest

wenn (player_1 == "" oder player_2 == ""):

if (player_1 == ""):

player_1 = "Spieler 1"

if (player_2 == ""):

player_2 = "Spieler 2"

else:

bestanden

#weist Spielern X oder O zu

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

player_1_pick = input(player_1 + ", wählen Sie X oder O: ").upper()

if (player_1_pick == "X"):

player_2_pick = "O"

else:

player_2_pick = "X"

else:

player_2_pick = input(player_2 + ", wählen Sie X oder O: ").upper()

if (player_2_pick == "X"):

player_1_pick = "O"

else:

player_1_pick = "X"

#macht einen Zug def make_a_move(player, player_pick):

print("""

SCHULLOGO...........................................................................................................................5
ZEUGNIS..............................................................................................................................5
DANKSAGUNG............................................................................................................6
EINLEITUNG................................................................................................................7
ZIELE DES PROJEKTS................................................................................................8
VORGESCHLAGENES SYSTEM...............................................................................8
SYSTEMENTWICKLUNGSLEBENSZYKLUS (SDLC).........................................10
PHASEN DES SYSTEMENTWICKLUNGSLEBENSZYKLUS..............................10
INITIIERUNGSPHASE..............................................................................................10
Der Zweck der Initiierungsphase besteht darin:...........................................................11
SYSTEMKONZEPT....................................................................................................11
PLANUNGSPHASE....................................................................................................13
ANFORDERUNGSANALYSEPHASE......................................................................14
Die Zwecke dieser Phase sind:.....................................................................................14
DESIGNPHASE..........................................................................................................14
ENTWICKLUNGSPHASE.........................................................................................16
INTEGRATIONS- UND TESTPHASE......................................................................16
IMPLEMENTIERUNGSPHASE................................................................................17
BETRIEBS- UND WARTUNGSPHASE....................................................................17

2
5
 AUSGABE...................................................................................................................30
»>.....................................................................................................................................30
I I......................................................................................................................................30
I I 41516...........................................................................................................................30
I I 71819...........................................................................................................................30
I I......................................................................................................................................30
I I 41516...........................................................................................................................30
PRÜFUNG...................................................................................................................31
PRÜFVERFAHREN....................................................................................................31
BLACK-BOX-TESTS.................................................................................................31
SPEZIFIKATIONSBASIERTE PRÜFUNG...............................................................32
VOR- UND NACHTEILE...........................................................................................32
WHITE-BOX-TESTS..................................................................................................32
BEWERTUNG DER CODE-VOLLSTÄNDIGKEIT.................................................33
HARDWARE- UND SOFTWAREANFORDERUNGEN..........................................34

""" .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 + "ein Feld auswählen (" + player_pick + "): ")

try:

int(choice)

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

if (square_values[int(choice)-1] != "X" und square_values[int(choice)-1] !=

"O"):

square_values.remove(Auswahl)

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

2
6
 status = False

else:

print("Quadrat bereits vergeben, wählen Sie ein anderes Quadrat aus.")

else:

print("Eingabe keine Option, erneut wählen.")

außer ValueError:

print("Eingabe keine Option, erneut wählen.")

status_main = Wahr

def check_for_a_win(Wert1, Wert2, Wert3):

global status_main

global no_wins

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

square_values[value3] == "X"):

status_main = Falsch

no_wins = False

if(player_1_pick == "X"):

print("Spieler 1 hat gewonnen!")

else:

print("Spieler 2 hat gewonnen!")

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

square_values[value3] == "O"):

status_main = Falsch

no_wins = False

if(player_1_pick == "O"):

print("Spieler 1 hat gewonnen!")

else:

2
7
 print("Spieler 2 hat gewonnen!")

else:

bestanden

def func_1(Spieler, Auswahl):

global number_of_turns

global status_main

if (no_wins == True):

number_of_turns = number_of_turns + 1

make_a_move(Spieler, Auswahl)

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("Es ist eine Krawatte :(")

status_main = Falsch

while (status_main == Wahr):

func_1(player_1, player_1_Pick)

func_1(player_2, player_2_Pick)

2
8
 AUSGABE

»>
Lass uns Tic-Tac-Toe spielen!
Geben Sie einen Namen für Spieler 1 ein und drücken Sie die Eingabetaste, lassen Sie das
Feld leer, um als Spieler 1 zu bleiben: xyz Geben Sie einen Namen für Spieler 2 ein und
drücken Sie die Eingabetaste, lassen Sie das Feld leer, um als Spieler 2 zu bleiben: abc xyz,
wählen Sie X oder O: 3

I I
1|2|3

I I 41516
I I 71819
I I
xyz wähle ein Quadrat(3) 1

II3|2|3II
I I 41516

2
9
 PRÜFUNG

Softwaretest ist eine empirische Untersuchung, die durchgeführt wird, um

Stakeholdern Informationen über die Qualität des zu testenden Produkts oder der zu
testenden Dienstleistung [1] in Bezug auf den Kontext zu liefern, in dem es betrieben
werden soll. Softwaretests bieten auch eine objektive, unabhängige Sicht auf die
Software, damit das Unternehmen die Risiken bei der Implementierung der Software
einschätzen und verstehen kann. Testtechniken beinhalten, sind aber nicht
beschränkt auf, den Prozess der Ausführung eines Programms oder einer
Anwendung mit der Absicht, Softwarefehler zu finden.
Es kann auch als der Prozess der Validierung und Verifizierung angegeben
werden, dass ein Softwareprogramm/eine Anwendung/ein Produkt die geschäftlichen
und technischen Anforderungen erfüllt, die sein Design und seine Entwicklung
geleitet haben, so dass es wie erwartet funktioniert und mit den gleichen
Eigenschaften implementiert werden kann. Softwaretests können, abhängig von der
verwendeten Testmethode, jederzeit im Entwicklungsprozess implementiert werden,
jedoch wird der größte Testaufwand betrieben, nachdem die Anforderungen definiert
und der Codierungsprozess abgeschlossen wurde.

PRÜFVERFAHREN
Software-Testmethoden werden traditionell in Black-Box-Tests und White-
Box-Tests unterteilt. Diese beiden Ansätze werden verwendet, um den Standpunkt
zu beschreiben, den ein Testingenieur beim Entwerfen von Testfällen einnimmt.

BLACK-BOX-TESTS
Black-Box-Tests behandeln die Software als "Black-Box", ohne Kenntnis der
internen Implementierung. Zu den Black-Box-Testmethoden gehören:
Äquivalenzpartitionierung, Grenzwertanalyse, All-Pair-Tests, Fuzz-Tests,
modellbasierte Tests, Rückverfolgbarkeitsmatrix, explorative Tests und
spezifikationsbasierte Tests.

3
0
SPEZIFIKATIONSBASIERTE PRÜFUNG

Spezifikationsbasiertes Testen zielt darauf ab, die Funktionalität der Software

gemäß den geltenden Anforderungen zu testen.[16] Somit gibt der Tester Daten in
das Testobjekt ein und sieht nur die Ausgabe von diesem. Diese Teststufe erfordert
in der Regel gründliche Testfälle, die dem Tester zur Verfügung gestellt werden
müssen, der dann einfach überprüfen kann, ob der Ausgabewert (oder das
Verhalten) für eine bestimmte Eingabe entweder „ist“ oder „ist nicht“ mit dem im
Testfall angegebenen Erwartungswert übereinstimmt. Spezifikationsbasierte Tests
sind notwendig, reichen jedoch nicht aus, um bestimmte Risiken abzuwehren

VOR- UND NACHTEILE

Der Black-Box-Tester hat keine „Bindungen“ an den Code, und die

Wahrnehmung eines Testers ist sehr einfach: Ein Code muss Fehler haben. Black-
Box-Tester finden nach dem Prinzip "Ask and you shall receive" Fehler, die
Programmierer nicht finden. Auf der anderen Seite gilt Black-Box-Tests als „wie ein
Spaziergang in einem dunklen Labyrinth ohne Taschenlampe“, weil der Tester nicht
weiß, wie die getestete Software tatsächlich aufgebaut ist.
Deshalb gibt es Situationen, in denen (1) ein Black-Box-Tester viele Testfälle
schreibt, um etwas zu überprüfen, das nur von einem Testfall getestet werden kann,
und/oder (2) einige Teile des Backends überhaupt nicht getestet werden. Black-Box-
Tests haben daher einerseits den Vorteil einer „unverbundenen Meinung“ und
andererseits den Nachteil einer „blinden Erkundung“.

WHITE-BOX-TESTS

White-Box-Tests sind im Gegensatz zu Black-Box-Tests, wenn der Tester

Zugriff auf die internen Datenstrukturen und Algorithmen (und den Code, der diese
implementiert) hat

Arten von White-Box-Tests:-

Es gibt die folgenden Arten von White-Box-Tests:
4- api testing - Testen der Anwendung mit öffentlichen und privaten APIs.
4- Codeabdeckung - Erstellen von Tests, um einige Kriterien der

3
1
 Codeabdeckung zu erfüllen.
Beispielsweise kann der Testdesigner Tests erstellen, um zu veranlassen,
dass alle Anweisungen im Programm mindestens einmal ausgeführt werden.
4- FEHLERINJEKTIONSMETHODEN

4- Mutationstestmethoden.
4- statische Tests - White-Box-Tests umfassen alle statischen Tests.

BEWERTUNG DER CODE-VOLLSTÄNDIGKEIT

White-Box-Testmethoden können auch verwendet werden, um die

Vollständigkeit einer Testsuite zu bewerten, die mit Black-Box-Testmethoden erstellt
wurde. Dies ermöglicht es dem Softwareteam, selten getestete Teile eines Systems
zu untersuchen und stellt sicher, dass die wichtigsten Funktionspunkte getestet
wurden.

Zwei gängige Formen der Codeabdeckung sind:

4- Funktionsabdeckung: Welche Berichte über ausgeführte Funktionen
und
4- Statement Coverage: Der Bericht über die Anzahl der ausgeführten
Zeilen, um den Test abzuschließen.
Beide geben die Deckungsmetrik zurück, gemessen als Prozentsatz

3
2
 HARDWARE- UND SOFTWAREANFORDERUNGEN

I.BETRIEBSSYSTEM : WINDOWS 7 UND HÖHER

II. PROZESSOR : PENTIUM(BELIEBIG) ODER AMD

ATHALON(3800+- 4200+ DUAL CORE)

III. HAUPTPLATINE 1.845 ODER 915.995 FÜR PENTIUM 0R

:
MSI K9MM-V ÜBER K8M800 +8237R PLUS

CHIPSATZ FÜR AMD ATHALON 512 MB+

SATA 40 GB ODER HÖHER

IV. RAM
: (Wenn Sicherung erforderlich)

V. Festplatte : (Wenn Sicherung erforderlich)

VI. CD/DVD r/w Multi-Laufwerk-

Kombination:

VII. DISKETTENLAUFWERK 1,44

MB : (wenn Druck erforderlich – [Hardcopy])
VIII. MONITOR 14,1 oder 15 -17
Zoll

IX. Tastatur und Maus

X. Drucker :

SOFTWAREANFORDERUNGEN:

3
3
 LITERATURVERZEICHNIS

1. Informatik mit Python - Klasse XI Von : Sumita Arora

2. Ein Projektbericht über das Blutbankmanagementsystem (BBMS)
Von : Praveen M Jigajinni
3. Website: https://www.w3resource.com
4. https://de.wikipedia.org/wiki/E_(mathematische_Konstante)

***

3
4