NUMELE ȘCOLII

SIGLA ȘCOLII

AN UNIVERSITAR : 2019-20

RAPORT DE PROIECT

PRIVIND "

TIC-TAC-TOE GAME"
SIGLA ȘCOLII 5
CERTIFICAT 5
CONFIRMARE 6
XI

INFORMATICĂ

083
INTRODUCERE7
OBIECTIVELE
PROIECTULUI 7

1
 SISTEMUL PROPUS 8
CICLUL DE VIAȚĂ AL
DEZVOLTĂRII
SISTEMULUI (SDLC)
10
FAZELE CICLULUI DE
VIAȚĂ AL DEZVOLTĂRII
SISTEMULUI 10
FAZA DE INIȚIERE 10
Scopul Fazei de Inițiere este:
11
FAZA DE DEZVOLTARE A
CONCEPTULUI DE SISTEM
11
FAZA DE PLANIFICARE
13
ETAPA DE ANALIZĂ A
CERINȚELOR 14
Scopurile acestei faze sunt:
14
FAZA DE PROIECTARE
14
FAZA DE DEZVOLTARE
15
INTEGRAREA ȘI FAZA DE
TESTARE 16
FAZA DE IMPLEMENTARE
17
FAZA DE OPERARE ȘI
ÎNTREȚINERE17
IEŞIRE 29
»> 29
II 29

2
 I I 41516 29
I I 71819 29
II 29
I I 41516 29
TESTARE 30
METODE DE TESTARE
30
TESTAREA CUTIEI NEGRE
30
TESTAREA BAZATĂ PE
SPECIFICAȚII30
PUNCTELE TARI ȘI
PUNCTELE SLABE 31
TESTAREA WHITE BOX
31
EVALUAREA
INTEGRALITĂȚII
CODULUI 32
CERINȚE HARDWARE ȘI
SOFTWARE 33

GHIDUL PROIECTULUI:
PGT (CS)

3
 NUMELE ȘCOLII

SIGLA ȘCOLII

CERTIFICAT

Aceasta este pentru a certifica faptul că Cadet _______________________________

Nr. rolă: __________________________ a finalizat cu succes proiectul

Lucrare intitulată "TIC-TAC-TOE GAME." LA DISCIPLINA Informatică (083) prevăzută în

regulamentul CBSE în scopul examenului practic [ Examenul în clasa a XI-a va avea loc

în _______________________________ pe______________.

( )
PGT Comp Sci
Master IC

Examinator:

Nume: _______________

Semnătură:

Dată:

4
 CUPRINS [ t o c ]

SER DESCRIERE PAGINA NR.

01 CONFIRMARE 04

02 INTRODUCERE 05

03 OBIECTIVELE PROIECTULUI 05

04 SISTEMUL PROPUS 06

05 CICLUL DE VIAȚĂ AL DEZVOLTĂRII SISTEMULUI (SDLC) 07

FAZELE CICLULUI DE VIAȚĂ AL DEZVOLTĂRII

06 08
SISTEMULUI

07 DIAGRAMĂ 15

08 CODUL SURSĂ 16

09 IEŞIRE 19

10 TESTARE 20

11 CERINȚE HARDWARE ȘI SOFTWARE 23

12 BIBLIOGRAFIE 24

CONFIRMARE

În afară de eforturile mele, succesul oricărui proiect depinde în mare măsură de

încurajarea și îndrumarea multor altora. Profit de această ocazie pentru a-mi exprima
recunoștința față de oamenii care au contribuit la finalizarea cu succes a acestui proiect.

Îmi exprim profunda recunoștință față de atotputernicul Dumnezeu pentru că mi-a

5
dat putere pentru finalizarea cu succes a proiectului.

Îmi exprim recunoștința sinceră față de părinții mei pentru încurajarea constantă
în realizarea acestui proiect.

Recunosc cu recunoștință contribuția persoanelor care au contribuit la aducerea

acestui proiect la acest nivel, care continuă să aibă grijă de mine în ciuda defectelor
mele,

Îmi exprim profundul sentiment de recunoștință față de luminătorul Director,

care ne-au motivat continuu și ne-au întins mâna lor de ajutor.

Exprim sincerele mele mulțumiri academicianului Vicedirector, , pentru

încurajarea constantă și îndrumarea oferită în timpul acestui proiect

Sunt copleșit să-mi exprim mulțumirile față de _________ pentru a-mi oferi un
infrastructură și sprijin moral în timpul desfășurării acestui proiect în școală.

Sincerele mele mulțumiri _______, Master In-charge, Un ghid, Mentor toate

Un prieten, care mi-a revizuit critic proiectul și a ajutat la rezolvarea fiecărei probleme, a
apărut în timpul implementării proiectului

Îndrumarea și sprijinul primit de la toți membrii care au contribuit și care contribuie

la acest proiect, au fost vitale pentru succesul proiectului. Sunt recunoscător pentru
sprijinul și ajutorul lor constant.

PROIECT PE TIC-TAC-TOE JOC

INTRODUCERE

Tic-tac-toe (engleză americană), noughts and crosses (engleză britanică) sau Xs and

Os este un joc de hârtie și creion pentru doi jucători, X și O, care marchează pe rând spațiile într-

o grilă 3×3. Jucătorul care reușește să plaseze trei dintre semnele lor într-un rând orizontal,

vertical sau diagonal câștigă jocul.

OBIECTIVELE PROIECTULUI

Obiectivul acestui proiect este de a permite elevilor să aplice cunoștințele de

programare într-o situație / problemă din lumea reală și să expună elevilor modul în care

6
abilitățile de programare ajută la dezvoltarea unui software bun.

1. Scrieți programe utilizând instrumente software moderne.

2. Aplicați în mod eficient principiile de programare orientate pe obiecte atunci când

dezvoltați proiecte mici și mijlocii.

3. Scrieți un cod de procedură eficient pentru a rezolva probleme mici și mijlocii.

4. Elevii vor demonstra o gamă largă de cunoștințe în informatică, așa cum este

exemplificat în domeniile sistemelor, teoriei și dezvoltării de software.

5. Elevii vor demonstra capacitatea de a efectua un proiect de cercetare sau

informatică aplicată, necesitând abilități de scriere și prezentare care exemplifică

stilul științific în informatică.

SISTEMUL PROPUS

Astăzi nu-ți poți permite să te bazezi pe ființele umane supuse greșelii de a fi vrea

cu adevărat să se opună concurenței nemiloase de astăzi, unde a nu spune înțelept " a

greși este uman" nu mai este valabil, este depășit să-ți raționalizezi greșeala. Deci,

pentru a ține pasul cu timpul, pentru a obține cel mai bun rezultat fără defecțiuni și o

eficiență mai mare, astfel încât să înlocuiți grămezile nesfârșite de muște cu un hard disk

mult mai sofisticat al computerului.

Trebuie să utilizați software-ul de gestionare a datelor. Software-ul a fost o

ascensiune în atomizarea diferitelor organizații. Multe produse software care

funcționează sunt acum pe piețe, ceea ce a ajutat organizațiile să funcționeze mai ușor

și eficient. Gestionarea datelor a trebuit inițial să mențină o mulțime de registre și trebuie

făcută o mulțime de lucrări pe hârtie, dar acum produsul software al acestei organizații

le-a făcut munca mai rapidă și mai ușoară. Acum doar acest software trebuie încărcat pe

computer și se poate lucra.

7
 Acest lucru împiedică o mulțime de timp și bani. Activitatea devine complet

automatizată și orice informație referitoare la organizație poate fi obținută făcând clic pe

buton. Mai mult decât atât, acum este o epocă a computerelor și automatizarea unei

astfel de organizații oferă un aspect mai bun.

8
CICLUL DE VIAȚĂ AL DEZVOLTĂRII SISTEMULUI (SDLC )

Ciclul de viață al dezvoltării sistemelor este o tehnică de management de proiect

care împarte proiectele complexe în segmente sau faze mai mici, mai ușor de gestionat.
Segmentarea proiectelor permite managerilor să verifice finalizarea cu succes a fazelor
proiectului înainte de alocarea resurselor către fazele ulterioare.
Proiectele de dezvoltare software includ de obicei fazele de inițiere, planificare,
proiectare, dezvoltare, testare, implementare și întreținere. Cu toate acestea, fazele pot fi
împărțite diferit în funcție de organizația implicată.
De exemplu, activitățile inițiale ale proiectului ar putea fi desemnate ca faze de
solicitare, definire a cerințelor și planificare sau faze de inițiere, dezvoltare a conceptului
și planificare. Utilizatorii finali ai sistemului în curs de dezvoltare ar trebui să fie implicați
în revizuirea rezultatelor fiecărei faze pentru a se asigura că sistemul este construit
pentru a furniza funcționalitatea necesară.
FAZELE CICLULUI DE VIAȚĂ AL DEZVOLTĂRII SISTEMULUI

FAZA DE INIȚIERE

Faza de inițiere începe atunci când un sponsor de afaceri identifică o nevoie sau o
oportunitate.

9
Scopul Fazei de Inițiere este:

4- Identificați și validați o oportunitate de îmbunătățire a realizărilor de afaceri ale

organizației sau o deficiență legată de o nevoie de afaceri.
4- Identificați ipotezele și constrângerile semnificative privind soluțiile la această
nevoie.
4- Recomandați explorarea conceptelor și metodelor alternative pentru a satisface
nevoia, inclusiv punerea sub semnul întrebării a nevoii de tehnologie, adică o
schimbare în procesul de afaceri va oferi o soluție?
4- Asigurați sponsorizarea executivă a afacerilor și a tehnicii executive. Sponsorul
desemnează un manager de proiect, iar nevoia de afaceri este documentată într-
o propunere de concept. Propunerea de concept include informații despre
procesul de afaceri și relația cu agenția / organizația.
4- Infrastructura și planul strategic. O propunere de concept de succes are ca
rezultat o Cartă a managementului de proiect care subliniază autoritatea
managerului de proiect pentru a începe
proiectul.

Este necesară o supraveghere atentă pentru a se asigura că proiectele susțin

obiectivele strategice de afaceri și că resursele sunt implementate eficient în arhitectura
întreprinderii unei organizații. Faza de inițiere începe atunci când o oportunitate de a
adăuga, îmbunătăți sau corecta un sistem este identificată și solicitată în mod oficial prin
prezentarea unui caz de afaceri. Business case-ul ar trebui, cel puțin, să descrie scopul
unei propuneri, să identifice beneficiile așteptate și să explice modul în care sistemul
propus sprijină una dintre strategiile de afaceri ale organizației. Business case-ul ar
trebui, de asemenea, să identifice soluții alternative și să detalieze cât mai multe cerințe
informaționale, funcționale și de rețea.

FAZA DE DEZVOLTARE A CONCEPTULUI DE SISTEM

Faza de dezvoltare a conceptului de sistem începe după ce o nevoie sau o oportunitate

de afaceri este validată de conducerea programului agenției / organizației și de CIO al
agenției / organizației.

Scopul fazei de dezvoltare a conceptului de sistem este:

1
0
 4- Determinați fezabilitatea și adecvarea alternativelor.
4- Identificați interfețele sistemului.
4- Identificați cerințele funcționale și de date de bază pentru a satisface nevoile de
afaceri.
4- Stabilirea limitelor sistemului; Identificați scopurile, obiectivele, factorii critici de
succes și măsurile de performanță.
4- Evaluarea costurilor și beneficiilor abordărilor alternative pentru a satisface
cerințele funcționale de bază
4- Evaluarea riscurilor proiectului
4- Identificați și inițiați acțiuni de atenuare a riscurilor și dezvoltați arhitectură tehnică
la nivel înalt, modele de proces, modele de date și un concept de operațiuni.
Această fază explorează soluții tehnice potențiale în contextul nevoii de afaceri.
4- Aceasta poate include mai multe decizii de compromis, cum ar fi decizia de a
utiliza produse software COTS, spre deosebire de dezvoltarea de software
personalizat sau reutilizarea componentelor software sau decizia de a utiliza o
livrare incrementală față de o implementare completă, unică.
4- Construcția prototipurilor executabile este încurajată să evalueze tehnologia
pentru a sprijini procesul de afaceri. Documentul de delimitare a sistemului
servește ca un document de referință important pentru a sprijini procesul de
solicitare a proiectelor pentru tehnologia informației (ITPR).
4- ITPR trebuie să fie aprobat de CIO de stat înainte ca proiectul să poată avansa.
REPREZENTARE PICTURALĂ A SDLC:

1
1
FAZA DE PLANIFICARE

Faza de planificare este cel mai important pas în finalizarea proiectelor de

dezvoltare, achiziție și întreținere. Planificarea atentă, în special în primele etape ale unui
proiect, este necesară pentru coordonarea activităților și gestionarea eficientă a riscurilor
proiectului. Profunzimea și formalitatea planurilor de proiect ar trebui să fie proporționale
cu caracteristicile și riscurile unui anumit proiect. Planurile de proiect rafinează
informațiile colectate în timpul fazei de inițiere prin identificarea suplimentară a
activităților și resurselor specifice necesare pentru finalizarea unui proiect.
O parte critică a activității unui manager de proiect este de a coordona discuțiile
dintre utilizator, audit, securitate, proiectare, dezvoltare și personalul rețelei pentru a
identifica și documenta cât mai multe cerințe funcționale, de securitate și de rețea. În
această fază, se dezvoltă un plan care documentează abordarea care urmează să fie
utilizată și include o discuție despre metode, instrumente, sarcini, resurse, planificări de
proiect și contribuții ale utilizatorilor. Sunt stabilite sarcinile de personal, costurile,
programul proiectului și datele țintă.
Este creat un plan de management al proiectului cu componente legate de
planificarea achizițiilor, planificarea managementului configurației, planificarea asigurării
calității, conceptul de operațiuni, securitatea sistemului, verificarea și validarea și
planificarea managementului ingineriei sistemelor.

1
2
ETAPA DE ANALIZĂ A CERINȚELOR

Această fază definește în mod oficial cerințele funcționale detaliate ale

utilizatorilor utilizând cerințele la nivel înalt identificate în fazele de inițiere, concept de
sistem și planificare. De asemenea, delimitează cerințele în ceea ce privește datele,
performanța sistemului, securitatea și cerințele de mentenanță pentru sistem. Cerințele
sunt definite în această fază la un nivel de detaliere suficient pentru ca proiectarea
sistemelor să poată continua. Acestea trebuie să fie măsurabile, testabile și să se refere
la nevoia sau oportunitatea de afaceri identificată în faza de inițiere. Cerințele care vor fi
utilizate pentru a determina acceptarea sistemului sunt cuprinse în Master Planul de
testare și evaluare.

Scopurile acestei faze sunt:

4- să definească și să perfecționeze în continuare cerințele funcționale și cerințele

privind datele și să le documenteze în documentul de cerințe;
4- Reproiectarea completă a proceselor de afaceri a funcțiilor care urmează să fie
suportate (adică verificați ce informații conduc procesul de afaceri, ce informații
sunt generate, cine le generează, unde merg informațiile și cine le procesează),
4- Dezvoltați date detaliate și modele de proces (intrări de sistem, ieșiri și proces.
4- Dezvoltați cerințele de testare și evaluare care vor fi utilizate pentru a determina
performanța acceptabilă a sistemului.

FAZA DE PROIECTARE

Faza de proiectare implică conversia cerințelor informaționale, funcționale și de

rețea identificate în timpul fazelor de inițiere și planificare în specificații de proiectare
unificate pe care dezvoltatorii le utilizează pentru programele script în timpul fazei de
dezvoltare. Proiectele de programe sunt structurate în diferite moduri. Folosind o
abordare de sus în jos, designerii identifică și leagă mai întâi componentele și interfețele
majore ale programului, apoi extind aspectele de proiectare pe măsură ce identifică și
leagă subsistemele și conexiunile mai mici. Folosind o abordare de jos în sus,
proiectanții identifică și leagă mai întâi componentele și interfețele minore ale
programului, apoi extind aspectele de proiectare pe măsură ce identifică și leagă sisteme
și conexiuni mai mari. Tehnicile contemporane de proiectare folosesc adesea
instrumente de prototipare care construiesc modele machete de elemente, cum ar fi

1
3
ecrane de aplicații, machete de baze de date și arhitecturi de sistem. Utilizatorii finali,
proiectanții, dezvoltatorii, managerii de baze de date și administratorii de rețea ar trebui
să revizuiască și să perfecționeze proiectele prototipate într-un proces iterativ până când
convin asupra unui design acceptabil. Personalul de audit, securitate și asigurare a
calității ar trebui să fie implicat în procesul de revizuire și aprobare. În această fază,
sistemul este proiectat pentru a satisface cerințele funcționale identificate în faza
anterioară. Deoarece problemele din faza de proiectare ar putea fi foarte costisitoare de
rezolvat în etapa ulterioară a dezvoltării software-ului, o varietate de elemente sunt luate
în considerare în proiectare pentru a atenua riscul. Acestea includ:

+ Identificarea riscurilor potențiale și definirea caracteristicilor de atenuare a

proiectării.
+ Efectuarea unei evaluări a riscurilor de securitate.
4- Dezvoltarea unui plan de conversie pentru migrarea datelor curente către noul
sistem.
4- Determinarea mediului de operare.
4- Definirea subsistemelor majore și a intrărilor și ieșirilor acestora.
+ Alocarea proceselor către resurse.
4- Pregătirea specificațiilor logice detaliate pentru fiecare modul software. Rezultatul
este un proiect de document de proiectare a sistemului care surprinde proiectarea
preliminară a sistemului.
+ Tot ceea ce necesită contribuția sau aprobarea utilizatorului este documentat și
revizuit de utilizator. Odată ce aceste documente au fost aprobate de CIO și
sponsorul de afaceri al agenției, documentul final de proiectare a sistemului este
creat pentru a servi drept proiectare critică / detaliată pentru sistem.
+ Acest document este revizuit riguros de către reprezentanții tehnici și funcționali ai
Agenției pentru a se asigura că satisface cerințele de afaceri. Concomitent cu
dezvoltarea designului sistemului, managerul de proiect al agenției începe
elaborarea planului de implementare, a manualului de operațiuni și întreținere și a
planului de instruire.

FAZA DE DEZVOLTARE

Faza de dezvoltare implică conversia specificațiilor de proiectare în programe

executabile. Standardele eficiente de dezvoltare includ cerințe ca programatorii și alți

1
4
 participanți la proiect să discute specificațiile de proiectare înainte de începerea
programării. Procedurile ajută programatorii să înțeleagă în mod clar proiectele de
programe și cerințele funcționale. Programatorii folosesc diverse tehnici pentru a
dezvolta programe de calculator. Programele mari orientate spre tranzacții asociate
instituțiilor financiare au fost dezvoltate în mod tradițional folosind tehnici de
programare procedurală. Programarea procedurală implică scriptarea linie cu linie a
instrucțiunilor logice care sunt combinate pentru a forma un program. Finalizarea
efectivă a etapelor anterioare este un factor cheie în succesul fazei de dezvoltare.
Faza de dezvoltare constă în:

4- Traducerea cerințelor detaliate și a designului în componentele sistemului.

4- Testarea elementelor individuale (unități) pentru utilizare.
4- Pregătirea pentru integrarea și testarea sistemului informatic.

INTEGRAREA ȘI FAZA DE TESTARE

4- Integrarea subsistemului, testarea sistemului, securității și acceptării utilizatorilor

se efectuează în timpul fazei de integrare și testare. Utilizatorul, împreună cu cei
responsabili pentru asigurarea calității, validează faptul că cerințele funcționale,
așa cum sunt definite în documentul cerințelor funcționale, sunt îndeplinite de
sistemul dezvoltat sau modificat. Personalul OIT Security evaluează securitatea
sistemului și emite o certificare și acreditare de securitate înainte de
instalare/implementare.

Sunt efectuate mai multe niveluri de testare, inclusiv:

4- Testarea la instalația de dezvoltare de către contractant și, eventual, susținută de

utilizatorii finali

4- Testarea ca sistem implementat cu utilizatorii finali care lucrează împreună cu

personalul contractual

+ Testarea operațională numai de către utilizatorul final care îndeplinește toate

funcțiile.
Cerințele sunt urmărite pe tot parcursul testării, se efectuează o evaluare finală

1
5
 independentă de verificare și validare și toată documentația este revizuită și
acceptată înainte de acceptarea sistemului.

FAZA DE IMPLEMENTARE

Această fază este inițiată după ce sistemul a fost testat și acceptat de utilizator. În
această fază, sistemul este instalat pentru a sprijini funcțiile de afaceri intenționate.
Performanța sistemului este comparată cu obiectivele de performanță stabilite în timpul
fazei de planificare. Implementarea include notificarea utilizatorilor, instruirea
utilizatorilor, instalarea hardware-ului, instalarea software-ului pe computerele de
producție și integrarea sistemului în procesele zilnice de lucru. Această fază continuă
până când sistemul funcționează în producție în conformitate cu cerințele definite ale
utilizatorilor.

FAZA DE OPERARE ȘI ÎNTREȚINERE

Funcționarea sistemului este în curs de desfășurare. Sistemul este monitorizat

pentru performanță continuă în conformitate cu cerințele utilizatorului și sunt încorporate
modificările necesare ale sistemului. Operațiunile continuă atâta timp cât sistemul poate
fi adaptat eficient pentru a răspunde nevoilor organizației. Atunci când sunt identificate
modificări sau modificări, sistemul poate reintra în faza de planificare.

Scopul acestei etape este:

4- Operați, întrețineți și îmbunătățiți sistemul.

4- Certificați că sistemul poate procesa informații sensibile.
4- Efectuați evaluări periodice ale sistemului pentru a vă asigura că cerințele
funcționale continuă să fie îndeplinite.
4- Determinați când sistemul trebuie modernizat, înlocuit sau retras.

1
6
DIAGRAMĂ

1
7
 CODUL SURSĂ

Creați un proiect Python de joc TIC-TAC-TOE

Importați aleatoriu

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

number_of_turns = 0

no_wins = Adevărat

print("Să jucăm Tic-Tac-Toe!")

player_1_pick = ""

player_2_pick = ""

player_1 = input("Introduceți un nume pentru jucătorul 1 și apăsați enter,

lăsați necompletat la

pleacă ca Jucător 1:")

player_2 = intrare("Introduceți un nume pentru jucătorul 2 și apăsați enter,

lăsați necompletat pentru a pleca ca jucător 2: ")

#sets numele jucătorilor

dacă (player_1 == "" sau player_2 == ""):

dacă (player_1 == ""):

player_1 = "Jucătorul 1"

dacă (player_2 == ""):

player_2 = "Jucător 2"

altfel:

1
8
 trece

#assigns X sau O jucătorilor

dacă (random.randint(1,2) == 1):

player_1_pick = input(player_1 + ", alegeți X sau O: ").upper()

dacă (player_1_pick == "X"):

player_2_pick = "O"

altfel:

player_2_pick = "X"

altfel:

player_2_pick = input(player_2 + ", alegeți X sau O: ").upper()

dacă (player_2_pick == "X"):

player_1_pick = "O"

altfel:

player_1_pick = "X"

#makes o mișcare

def make_a_move(jucător, player_pick):

imprimare("""

SIGLA ȘCOLII.........................................................................................................................5
CERTIFICAT........................................................................................................................5
CONFIRMARE..............................................................................................................6
INTRODUCERE............................................................................................................7
OBIECTIVELE PROIECTULUI...................................................................................7
SISTEMUL PROPUS....................................................................................................8
CICLUL DE VIAȚĂ AL DEZVOLTĂRII SISTEMULUI (SDLC)...........................10
FAZELE CICLULUI DE VIAȚĂ AL DEZVOLTĂRII SISTEMULUI.....................10
FAZA DE INIȚIERE...................................................................................................10
Scopul Fazei de Inițiere este:.......................................................................................11
FAZA DE DEZVOLTARE A CONCEPTULUI DE SISTEM...................................11

1
9
 FAZA DE PLANIFICARE..........................................................................................13
ETAPA DE ANALIZĂ A CERINȚELOR..................................................................14
Scopurile acestei faze sunt:..........................................................................................14
FAZA DE PROIECTARE...........................................................................................14
FAZA DE DEZVOLTARE..........................................................................................15
INTEGRAREA ȘI FAZA DE TESTARE...................................................................16
FAZA DE IMPLEMENTARE.....................................................................................17
FAZA DE OPERARE ȘI ÎNTREȚINERE..................................................................17
IEŞIRE.........................................................................................................................29
»>.....................................................................................................................................29
I I......................................................................................................................................29
I I 41516...........................................................................................................................29
I I 71819...........................................................................................................................29
I I......................................................................................................................................29
I I 41516...........................................................................................................................29
TESTARE....................................................................................................................30
METODE DE TESTARE............................................................................................30
TESTAREA CUTIEI NEGRE.....................................................................................30
TESTAREA BAZATĂ PE SPECIFICAȚII................................................................30
PUNCTELE TARI ȘI PUNCTELE SLABE...............................................................31
TESTAREA WHITE BOX..........................................................................................31
EVALUAREA INTEGRALITĂȚII CODULUI..........................................................32
CERINȚE HARDWARE ȘI SOFTWARE..................................................................33

{} | {} | {}

| | """ .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 = Adevărat

în timp ce (stare == Adevărat):

alegere = intrare(jucător + " alege un pătrat(" + player_pick + "): ")

încerca:

int(alegere)

dacă (1 <= int(alegere) <= 9):

2
0
 dacă (square_values[int(choice)-1] != "X" și square_values[int(choice)-

1] != "O"):

square_values.Remove(alegere)

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

status = Fals

altfel:

print("Pătrat deja luat, selectați alt pătrat.")

altfel:

imprimare("Introducerea nu este o opțiune, alegeți din nou.")

cu excepția ValueError:

imprimare("Introducerea nu este o opțiune, alegeți din nou.")

status_main = Adevărat

def check_for_a_win(valoare1, valoare2, valoare3):

status_main globală

no_wins globală

dacă (square_values[valoare1] == "X" și square_values[valoare2] == "X" și

square_values[valoare3] == "X"):

status_main = Fals

no_wins = Fals

dacă(player_1_pick == "X"):

print("Jucătorul 1 a câștigat!")

altfel:

print("Jucătorul 2 a câștigat!")

elif (square_values[valoare1] == "O" și square_values[valoare2] == "O" și

square_values[valoare3] == "O"):

2
1
 status_main = Fals

no_wins = Fals

dacă(player_1_pick == "O"):

print("Jucătorul 1 a câștigat!")

altfel:

print("Jucătorul 2 a câștigat!")

altfel:

trece

def func_1(jucător, alegere):

number_of_turns globală

status_main globală

dacă (no_wins == Adevărat):

number_of_turns = number_of_turns + 1

make_a_move(jucător, alegere)

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)

dacă (number_of_turns == 9 și status_main == Adevărat):

print("Este o cravată :(")

status_main = Fals

2
2
în timp ce (status_main == Adevărat):

func_1(player_1, player_1_pick)

func_1(player_2, player_2_pick) import aleatoriu

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

number_of_turns = 0

no_wins = Adevărat

print("Să jucăm Tic-Tac-Toe!")

player_1_pick = ""

player_2_pick = ""

player_1 = input("Introduceți un nume pentru jucătorul 1 și apăsați enter,

lăsați necompletat la

pleacă ca Jucător 1:")

player_2 = intrare("Introduceți un nume pentru jucătorul 2 și apăsați enter,

lăsați necompletat la

pleacă ca Jucător 2: ")

#sets numele jucătorilor

dacă (player_1 == "" sau player_2 == ""):

dacă (player_1 == ""):

player_1 = "Jucătorul 1"

dacă (player_2 == ""):

player_2 = "Jucător 2"

altfel:

trece

#assigns X sau O jucătorilor

2
3
dacă (random.randint(1,2) == 1):

player_1_pick = input(player_1 + ", alegeți X sau O: ").upper()

dacă (player_1_pick == "X"):

player_2_pick = "O"

altfel:

player_2_pick = "X"

altfel:

player_2_pick = input(player_2 + ", alegeți X sau O: ").upper()

dacă (player_2_pick == "X"):

player_1_pick = "O"

altfel:

player_1_pick = "X"

#makes o mișcare def make_a_move(jucător, player_pick):

imprimare("""

SIGLA ȘCOLII.........................................................................................................................5
CERTIFICAT........................................................................................................................5
CONFIRMARE..............................................................................................................6
INTRODUCERE............................................................................................................7
OBIECTIVELE PROIECTULUI...................................................................................7
SISTEMUL PROPUS....................................................................................................8
CICLUL DE VIAȚĂ AL DEZVOLTĂRII SISTEMULUI (SDLC)...........................10
FAZELE CICLULUI DE VIAȚĂ AL DEZVOLTĂRII SISTEMULUI.....................10
FAZA DE INIȚIERE...................................................................................................10
Scopul Fazei de Inițiere este:.......................................................................................11
FAZA DE DEZVOLTARE A CONCEPTULUI DE SISTEM...................................11
FAZA DE PLANIFICARE..........................................................................................13
ETAPA DE ANALIZĂ A CERINȚELOR..................................................................14
Scopurile acestei faze sunt:..........................................................................................14
FAZA DE PROIECTARE...........................................................................................14
FAZA DE DEZVOLTARE..........................................................................................15
INTEGRAREA ȘI FAZA DE TESTARE...................................................................16
FAZA DE IMPLEMENTARE.....................................................................................17
FAZA DE OPERARE ȘI ÎNTREȚINERE..................................................................17

2
4
 IEŞIRE.........................................................................................................................29
»>.....................................................................................................................................29
I I......................................................................................................................................29
I I 41516...........................................................................................................................29
I I 71819...........................................................................................................................29
I I......................................................................................................................................29
I I 41516...........................................................................................................................29
TESTARE....................................................................................................................30
METODE DE TESTARE............................................................................................30
TESTAREA CUTIEI NEGRE.....................................................................................30
TESTAREA BAZATĂ PE SPECIFICAȚII................................................................30
PUNCTELE TARI ȘI PUNCTELE SLABE...............................................................31
TESTAREA WHITE BOX..........................................................................................31
EVALUAREA INTEGRALITĂȚII CODULUI..........................................................32
CERINȚE HARDWARE ȘI SOFTWARE..................................................................33

""" .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 = Adevărat

în timp ce (stare == Adevărat):

alegere = intrare(jucător + " alege un pătrat(" + player_pick + "): ")

încerca:

int(alegere)

dacă (1 <= int(alegere) <= 9):

dacă (square_values[int(choice)-1] != "X" și square_values[int(choice)-

1] != "O"):

square_values.Remove(alegere)

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

2
5
 status = Fals

altfel:

print("Pătrat deja luat, selectați alt pătrat.")

altfel:

imprimare("Introducerea nu este o opțiune, alegeți din nou.")

cu excepția ValueError:

imprimare("Introducerea nu este o opțiune, alegeți din nou.")

status_main = Adevărat

def check_for_a_win(valoare1, valoare2, valoare3):

status_main globală

no_wins globală

dacă (square_values[valoare1] == "X" și square_values[valoare2] == "X" și

square_values[valoare3] == "X"):

status_main = Fals

no_wins = Fals

dacă(player_1_pick == "X"):

print("Jucătorul 1 a câștigat!")

altfel:

print("Jucătorul 2 a câștigat!")

elif (square_values[valoare1] == "O" și square_values[valoare2] == "O" și

square_values[valoare3] == "O"):

status_main = Fals

no_wins = Fals

dacă(player_1_pick == "O"):

print("Jucătorul 1 a câștigat!")

altfel:

2
6
 print("Jucătorul 2 a câștigat!")

altfel:

trece

def func_1(jucător, alegere):

number_of_turns globală

status_main globală

dacă (no_wins == Adevărat):

number_of_turns = number_of_turns + 1

make_a_move(jucător, alegere)

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)

dacă (number_of_turns == 9 și status_main == Adevărat):

print("Este o cravată :(")

status_main = Fals

în timp ce (status_main == Adevărat):

func_1(player_1, player_1_pick)

func_1(player_2, player_2_pick)

2
7
 IEŞIRE

»>
Să jucăm Tic-Tac-Toe!
Introduceți un nume pentru jucătorul 1 și apăsați enter, lăsați necompletat pentru a pleca ca
Jucător 1: xyz Introduceți un nume pentru jucătorul 2 și apăsați enter, lăsați necompletat
pentru a pleca ca Jucător 2: abc xyz, alegeți X sau O: 3

I I
1|2|3

I I 41516
I I 71819
I I
xyz alege un pătrat(3) 1

II3|2|3II
I I 41516

2
8
 TESTARE

Testarea software este o investigație empirică efectuată pentru a oferi părților

interesate informații despre calitatea produsului sau serviciului testat[1], în ceea ce
privește contextul în care este destinat să funcționeze. Testarea software oferă, de
asemenea, o viziune obiectivă și independentă a software-ului pentru a permite
afacerii să aprecieze și să înțeleagă riscurile la implementarea software-ului.
Tehnicile de testare includ, dar nu se limitează la, procesul de executare a unui
program sau a unei aplicații cu intenția de a găsi erori software.
De asemenea, poate fi declarat ca procesul de validare și verificare a faptului
că un program software / aplicație / produs îndeplinește cerințele de afaceri și tehnice
care au ghidat proiectarea și dezvoltarea acestuia, astfel încât să funcționeze
conform așteptărilor și să poată fi implementat cu aceleași caracteristici. Testarea
software, în funcție de metoda de testare utilizată, poate fi implementată în orice
moment al procesului de dezvoltare, însă cel mai mare efort de testare este utilizat
după ce cerințele au fost definite și procesul de codificare a fost finalizat.

METODE DE TESTARE
Metodele de testare software sunt în mod tradițional împărțite în testarea cutiei
negre și testarea cutiei albe. Aceste două abordări sunt utilizate pentru a descrie
punctul de vedere pe care un inginer de testare îl ia atunci când proiectează cazuri
de testare.

TESTAREA CUTIEI NEGRE

Testarea cutiei negre tratează software-ul ca o "cutie neagră", fără cunoștințe
despre implementarea internă. Metodele de testare Black box includ: partiționarea
echivalenței, analiza valorii limită, testarea tuturor perechilor, testarea fuzz, testarea
bazată pe model, matricea de trasabilitate, testarea exploratorie și testarea bazată pe
specificații.

TESTAREA BAZATĂ PE SPECIFICAȚII

Testarea bazată pe specificații are ca scop testarea funcționalității software-

2
9
ului în conformitate cu cerințele aplicabile. [16] Astfel, testerul introduce date și vede
doar ieșirea de la obiectul de testare. Acest nivel de testare necesită, de obicei,
furnizarea de cazuri de testare amănunțite testerului, care apoi poate verifica pur și
simplu că, pentru o anumită intrare, valoarea de ieșire (sau comportamentul), fie
"este", fie "nu este" aceeași cu valoarea așteptată specificată în cazul de testare.
Testarea bazată pe specificații este necesară, dar este insuficientă pentru a proteja
împotriva anumitor riscuri

PUNCTELE TARI ȘI PUNCTELE SLABE

Testerul cutiei negre nu are "legături" cu codul, iar percepția unui tester este
foarte simplă: un cod trebuie să aibă bug-uri. Folosind principiul "Cereți și veți primi",
testerii cutiei negre găsesc bug-uri acolo unde programatorii nu o fac. Dar, pe de altă
parte, testarea cutiei negre a fost considerată a fi "ca o plimbare într-un labirint
întunecat fără lanternă", deoarece testerul nu știe cum a fost construit software-ul
testat.
De aceea, există situații în care (1) un tester de cutie neagră scrie multe cazuri
de testare pentru a verifica ceva care poate fi testat de un singur caz de testare și /
sau (2) unele părți ale back-end-ului nu sunt testate deloc. Prin urmare, testarea
cutiei negre are avantajul "unei opinii neafiliate", pe de o parte, și dezavantajul
"explorării oarbe", pe de altă parte.

TESTAREA WHITE BOX

Testarea cutiei albe, spre deosebire de testarea cutiei negre, este atunci când
testerul are acces la structurile interne de date și algoritmi (și codul care le
implementează)

Tipuri de testare a cutiei albe: -

Există următoarele tipuri de testare a cutiei albe:
4 - testarea api - Testarea aplicației folosind API-uri publice și private.
4- Acoperirea codului - crearea de teste pentru a satisface anumite criterii
de acoperire a codului.
De exemplu, proiectantul de teste poate crea teste pentru ca toate declarațiile
din program să fie executate cel puțin o dată.

3
0
 4- metode de injectare a defectelor.

4- Metode de testare a mutației.

4 - testare statică - Testarea cutiei albe include toate testele statice.

EVALUAREA INTEGRALITĂȚII CODULUI

Metodele de testare a cutiei albe pot fi, de asemenea, utilizate pentru a evalua
completitudinea unei suite de testare care a fost creată cu metode de testare a cutiei
negre. Acest lucru permite echipei de software să examineze părți ale unui sistem
care sunt rareori testate și asigură testarea celor mai importante puncte funcționale.

Două forme comune de acoperire a codului sunt:

4- Acoperirea funcțiilor: care raportează funcțiile executate și
4- Acoperirea declarației: Care raportează numărul de linii executate
pentru a finaliza testul.
Ambele returnează metrica de acoperire, măsurată ca procent

3
1
 CERINȚE HARDWARE ȘI SOFTWARE

I. SISTEM DE OPERARE : WINDOWS 7 ȘI VERSIUNI ULTERIOARE

II. PROCESOR : PENTIUM(ORICE) SAU AMD ATHALON

(3800+- 4200+ DUAL CORE) 1.845 SAU

III. PLACA 915.995 PENTRU PENTIUM 0R MSI

:
K9MM-V PRIN K8M800+8237R PLUS

CHIPSET PENTRU AMD ATHALON

512MB+
IV. BERBEC
: SATA 40 GB SAU MAI MULT

V. Disc dur : (Dacă este necesară copierea de rezervă)

VI. Combo CD/DVD r/w multi (Dacă este necesară copierea de rezervă)
drive:

VII. UNITATE DE DISCHETĂ 1.44

MB :

VIII. MONITOR 14.1 sau 15 -17 (dacă este necesară imprimarea – [Copie
inch
fizică])
IX. Tabla de taste și mouse-ul

X. Imprimantă :

CERINȚE SOFTWARE:

3
2
 BIBLIOGRAFIE

1. Informatică cu Python - Clasa XI De: Sumita Arora

2. Un raport de proiect privind sistemul de gestionare a băncilor de sânge
(BBMS)
De: Praveen M Jigajinni
3. Site-ul: https://www.w3resource.com
4. https://en.wikipedia.org/wiki/E_(mathematical_constant)

***

3
3