Ce vei învăța astăzi?
După această lecție vei ști să descompui o problemă în subprobleme, vei recunoaște tipurile de erori și vei ști cum să testezi corect un program.
Proiectarea modulară
Definiție: Proiectarea modulară înseamnă descompunerea unei probleme mari în subprobleme mai mici, numite module (părți independente ale programului, fiecare cu o sarcină clară). Fiecare modul rezolvă o singură sarcină, clară.
Analogie
Este ca asamblarea unui dulap: nu îl construim dintr-o singură piesă uriașă, ci montăm separat ușile, rafturile și pereții, apoi le unim. Dacă un raft este greșit, îl înlocuim doar pe el.
Exemplu: „numărul de cifre ale lui n" pe module
MODULUL 1 - CITIREA DATELOR - n = int(input()) MODULUL 2 - PRELUCRAREA - cnt = 0 - cât timp n > 0: - cnt += 1 - n //= 10 MODULUL 3 - AFIȘAREA REZULTATULUI - print(cnt)
Observă: fiecare modul are o singură sarcină: citim, prelucrăm, afișăm. Așa gândim orice problemă!
n = int(input())
cnt = 0
while n > 0:
cnt += 1
n //= 10
print(cnt)
Avantajele modularității
| Avantaj | Ce înseamnă |
|---|---|
| Claritate | Programul este mai ușor de citit și de înțeles |
| Reutilizare | Un modul scris o dată poate fi folosit în mai multe programe |
| Testare independentă | Verificăm fiecare modul separat, găsim erorile mai repede |
| Întreținere | Modificăm un singur modul, fără să stricăm restul |
Tipurile de erori
| Tip de eroare | Când apare | Exemplu |
|---|---|---|
| Eroare de sintaxă (sintaxa este setul de reguli după care se scrie corect codul) | Am scris greșit regulile limbajului (paranteze, două puncte, indentare) | print("Salut" - lipsește paranteza închisă |
| Eroare de logică | Programul rulează, dar dă rezultat greșit | Am folosit * în loc de + |
| Eroare de executare | Programul se oprește pe loc, la rulare | x = 10 / 0 - împărțire la zero |
De reținut: erorile de sintaxă le găsește interpretorul imediat. Erorile de logică sunt cele mai periculoase, pentru că programul „merge", dar minte.
Criteriile de elaborare a testelor
Nu testăm programul cu orice date! Alegem date de test cu intenție, după trei criterii:
Date normale, obișnuite (ex: n = 5)
Date care nu respectă cerința (ex: n = 0 la împărțire)
Valori extreme: cel mai mic, cel mai mare (ex: n = 1)
Pentru programul „numărul de cifre" cu n = 273, urmărim valorile pas cu pas:
De reținut: urmărind valorile variabilelor pe hârtie, depistăm rapid erorile de logică. Aceasta este „execuția pas cu pas" făcută manual.
Exercițiu de completare
Așază modulele unei aplicații în ordinea corectă:
Modulul 1: ______
Modulul 2: ______
Modulul 3: ______
Bancă de cuvinte:
Test de înțelegere
Test rapid - erori și modularitate:
1. Un mesaj de eroare cauzat de scrierea greșită a sintaxei este o eroare de...
2. Programul rulează, dar dă un rezultat greșit. Aceasta este o eroare de...
3. Împărțirea la zero provoacă o eroare de...
Test de verificare
Test rapid - modularitate și erori:
1. Descompunerea unei probleme în subprobleme se numește...
2. O greșeală de scriere a regulilor limbajului este o eroare de...
3. Ce date de test alegem pentru a verifica valorile extreme ale programului?
except ar trebui să vizeze un tip clar de eroare, iar mesajele afișate trebuie să fie prietenoase și explicite.Aprofundare
De ce modularitatea face programele mai sigure? Atunci când un program este împărțit în module independente, o eroare rămâne izolată într-un singur modul: o găsim și o corectăm fără să afectăm restul programului. În echipele mari de programare, fiecare dezvoltator lucrează pe câte un modul, iar la final modulele se integrează (adică se combină într-un singur program funcțional). Aceasta este baza profesiei de inginer software (persoana care proiectează și construiește programe profesionale).
Erorile de executare - cele mai imprevizibile. Spre deosebire de erorile de sintaxă, care apar imediat, erorile de executare apar doar în anumite condiții: o împărțire la zero când utilizatorul introduce 0, conversia unui text greșit în număr, sau accesarea unei valori care nu există. De aceea, testarea cu date invalide și cazuri limită este singura metodă de a le descoperi înainte ca utilizatorul să le întâlnească.
Tratarea erorilor cu try/except. Python oferă o structură specială pentru a „prinde" erorile de executare: try: ... except:. Programul încearcă să execute instrucțiunile din try, iar dacă apare o eroare, intră în blocul except în loc să se oprească. Este instrumentul modern prin care programele devin prietenoase cu utilizatorul, afișând mesaje clare în loc de erori tehnice.
PbInfo - Maximul a trei numere
Enunț:
Cerință: Se citesc trei numere naturale a, b și c. Să se afișeze valoarea maximă dintre ele.
Date de intrare:
Programul citește de la tastatură numerele a, b și c.
Date de ieșire:
Programul va afișa valoarea maximă dintre cele trei numere.
Restricții și precizări:
Numerele citite sunt numere naturale, iar rezultatul este un număr întreg sau real.
Exemplu:
Intrare:
12 7 9
Ieșire:
12
Cum gândim soluția (pe module):
- Citirea: a, b, c cu
int(input()) - Prelucrarea: comparăm cu
if,elif,else - Afișarea: maximul cu
print()
Scrie soluția în Python:
Soluție corectă:
a = int(input())
b = int(input())
c = int(input())
if a > b and a > c:
print(a)
elif b > c:
print(b)
else:
print(c)
Ce învățăm: am combinat if, elif și else cu operatorul logic and pentru a acoperi toate cazurile.
PbInfo - Numărul de cifre al unui număr
Enunț:
Cerință: Se citește un număr natural n. Să se afișeze numărul de cifre ale lui n.
Date de intrare:
Programul citește de la tastatură numărul n.
Date de ieșire:
Programul va afișa numărul de cifre ale lui n.
Restricții și precizări:
Numerele citite sunt numere naturale, iar rezultatul este un număr întreg sau real.
Exemplu:
Intrare:
273
Ieșire:
3
Cum gândim soluția:
- Pornim un numărător
cnt = 0 - Cât timp
n > 0, creștem cnt și tăiem ultima cifră cun //= 10 - Afișăm cnt cu
print()
Scrie soluția în Python:
Soluție corectă:
n = int(input())
cnt = 0
while n > 0:
cnt += 1
n //= 10
print(cnt)
Ce învățăm: recapitulăm bucla while și numărătorul. Pentru n = 273, cnt devine 3, iar n devine 0.
Exercițiul Practic: Depanare și test final
Sarcini de lucru
Identifică erorile din cod și scrie programul final al modulului
Sarcina 1: Identifică tipul erorii
Cerință: Pentru fiecare fragment de mai jos, spune ce tip de eroare este (sintaxă, logică sau executare) și scrie varianta corectată.
print("Salut"
s = 5 + 3 print(s + 1) # intenționam să afișăm doar s
x = 10 print(x / 0)
Soluție pentru Sarcina 1:
Fragmentul 1: eroare de SINTAXĂ - lipsește paranteza
închisă. Corectat: print("Salut")
Fragmentul 2: eroare de LOGICĂ - afișăm s + 1, dar
intenționam să afișăm doar s. Corectat: print(s)
Fragmentul 3: eroare de EXECUTARE - împărțirea la zero
oprește programul. Corectat: x = 10; print(x / 2)
Verifică: sintaxa = scriere greșită, logica = gândire greșită, executare = programul se oprește pe loc.
Sarcina 2: TEST FINAL - Suma primelor n numere pare
Cerință: Scrie un program complet care citește n și afișează suma primelor n numere pare: 2 + 4 + 6 + ... + 2n. Folosește bucla for.
Soluție pentru Sarcina 2:
n = int(input())
s = 0
for i in range(1, n + 1):
s += 2 * i
print(s)
Verifică: pentru n = 3, programul calculează 2 + 4 + 6 = 12. Al i-lea număr par este 2 * i. Ai terminat modulul!
Scrie pe caiet - De reținut
Titlul lecției
Ora 9: Proiectarea modulară și tratarea erorilor
Definiția lecției
Proiectarea modulară înseamnă descompunerea unei probleme mari în subprobleme mai mici, numite module, fiecare rezolvând o singură sarcină clară. Un program bine structurat are module de citire, de prelucrare și de afișare, iar modulele pot fi testate independent și refolosite. Erorile care pot apărea sunt de trei tipuri: erori de sintaxă, când scriem greșit regulile limbajului, erori de logică, când programul rulează dar dă rezultate greșite, și erori de executare, care apar doar în anumite condiții, precum împărțirea la zero. Pentru a descoperi erorile, testăm programul cu date valide, date invalide și cazuri limită, iar urmărirea evoluției variabilelor pe hârtie ne ajută să depistăm rapid greșelile de logică. De exemplu, la numărarea cifrelor unui număr, testăm cu un număr obișnuit (273), cu valoarea minimă (1) și cu un caz care pune problema la încercare, verificând pas cu pas valorile lui n și cnt.
Definiții esențiale
- Proiectarea modulară - descompunerea problemei în subprobleme (module), fiecare cu o singură sarcină.
- Modulul - parte a programului care rezolvă o sarcină bine definită.
- Eroare de sintaxă - greșeala de scriere a codului, depistată imediat de interpretor.
- Eroare de logică - programul rulează, dar dă rezultate greșite.
- Eroare de executare - apare doar în anumite condiții (împărțire la zero, date greșite).
- try/except - structura care prinde erorile de executare și continuă programul.
Algoritmul cheie - pseudocod
Algoritmul cheie - cod Python
n = int(input())
cnt = 0
while n > 0:
cnt += 1
n //= 10
print(cnt)Greșeli comune de evitat
- Scrierea întregului program ca un bloc unic, fără a-l împărți în module logice.
- Confuzia tipurilor de erori: o eroare de logică nu produce mesaj - programul doar dă rezultat greșit.
- Uitarea faptului că
n // 10modifică n - fără el, bucla devine infinită. - Tratarea erorilor doar cu mesaje în engleză - utilizatorul trebuie să înțeleagă ce s-a întâmplat.
Sfaturi practice și trucuri
- Descompune orice problemă în trei module de bază: citire, prelucrare, afișare.
- Testează fiecare modul separat înainte de a-l integra în programul mare.
- Citește cu atenție mesajul de eroare: prima linie spune unde, ultima linie spune ce.
- Folosește
try/exceptpentru datele introduse de utilizator, ca programul să nu se oprească.
Exemplu practic
Un program de rezervare a biletelor de cinema este împărțit pe module: citirea numărului de bilete, verificarea locurilor disponibile și afișarea prețului final. Dacă utilizatorul introduce un număr greșit, programul nu trebuie să se oprească, ci să afișeze un mesaj prietenos, exact cu structura try/except:
try:
bilete = int(input("Câte bilete dorești? "))
print("Prețul total este", bilete * 25, "lei")
except:
print("Te rog introdu un număr valid de bilete.")