Ce vei învăța astăzi?
Aceasta este lecția de recapitulare generală: parcurgem toată materia clasei a IX-a, modul cu modul, printr-un tabel rezumativ, și rezolvăm o problemă integrată (problemă care combină mai multe module) care unește funcții proprii, liste și fișiere text.
Tabelul rezumativ al clasei a IX-a
| Modul | Teme principale | Elemente cheie |
|---|---|---|
| Modulul 1 | Gândirea computațională | algoritmi, pseudocod, organigrame, date de intrare/ieșire |
| Modulul 2 | Elemente de bază Python | variabile, tipuri de date, operatori, input(), print() |
| Modulul 3 | Structuri de decizie și repetitive | if/elif/else, for, while, contoare (variabile care numără) și acumulatori (variabile care adună valori) |
| Modulul 4 | Liste | creare, parcurgere, sortare, min/max/sum, metode |
| Modulul 5 | Subprograme și aplicații modulare | def, return, parametri, fișiere text, Tkinter, OOP |
Reține: evaluarea finală verifică integrarea acestor module: un program complet pleacă de la citirea datelor, prelucrează cu structuri de decizie, bucle și funcții, și termină cu afișarea sau salvarea rezultatelor.
Recapitularea subprogramelor și a funcțiilor predefinite
Un subprogram (funcție, bloc de cod cu un nume, rulat de mai multe ori) se definește cu def, primește date prin parametri, întoarce rezultatul cu return și folosește variabile locale (în interior) sau globale (în afara funcțiilor).
| Funcție | Rol | Exemplu | Rezultat |
|---|---|---|---|
| abs(x) | Valoarea absolută | abs(-7) | 7 |
| int(x) | Taie partea zecimală / convertește | int(3.9) | 3 |
| round(x) | Rotunjește la cel mai apropiat întreg | round(3.6) | 4 |
| sqrt(x) | Rădăcina pătrată (din math) | math.sqrt(16) | 4.0 |
| len(v) | Numărul de elemente | len([2, 4, 6]) | 3 |
| min(v) / max(v) | Extremele unei colecții | max([3, 9, 5]) | 9 |
| sum(v) | Suma elementelor | sum([1, 2, 3]) | 6 |
Analogia din viața reală:
Un program modular este ca o echipă de muncitori: fiecare membru (funcție) are o sarcină clară (citire, verificare, calcul, raport) și predă rezultatul mai departe. Echipa întreagă produce aplicația, dar fiecare piesa poate fi verificată separat.
Problema integrată - funcții, liste și fișiere
O problemă integrată combină toate modulele: citim o listă (Modulul 4), verificăm numerele prime cu o funcție proprie (Modulul 5), numărăm și calculăm statistici, apoi salvăm raportul în fișier text (Modulul 5).
def citeste_lista():
n = int(input())
v = list(map(int, input().split()))
return v
def prim(n):
if n < 2:
return False
for i in range(2, n):
if n % i == 0:
return False
return True
def prelucreaza(v):
contor_prime = 0
for x in v:
if prim(x):
contor_prime = contor_prime + 1
f = open("rezultat.txt", "w")
f.write("Numar de elemente: " + str(len(v)) + "\n")
f.write("Suma: " + str(sum(v)) + "\n")
f.write("Media: " + str(round(sum(v) / len(v), 2)) + "\n")
f.write("Numere prime: " + str(contor_prime) + "\n")
f.close()
v = citeste_lista()
prelucreaza(v)
print("Raportul a fost salvat in rezultat.txt")
Observă: programul principal are doar două linii. Toată logica este în funcții refolosibile, iar rezultatul final rămâne salvat în fișier pentru raportare. Aceasta este arhitectura cerută la evaluarea finală.
Aprofundare
Optimizarea verificării numerelor prime: pentru valori mari, parcurgerea tuturor divizorilor până la n este lentă. Este suficient să verificăm până la int(n ** 0.5) (radicalul lui n): dacă n are un divizor mai mare decât radicalul, are și unul mai mic.
- Tehnica tabelului de urmărire: la recapitulare, rulează manual programele pe valori mici și notează valorile pas cu pas într-un tabel; vei descoperi singur orice eroare de logică.
- Cazuri limită de verificat: n = 0, n = 1 (nu sunt prime), listă goală (len = 0, media nu există), numere egale, valori negative.
- Fișiere cu diacritice: dacă raportul conține caractere românești, deschidem cu
encoding="utf-8"pentru a le salva corect. - Tipuri de probleme frecvente: prelucrări de cifre (oglindit, palindrom, suma cifrelor), divizori și numere prime, extreme și medii pe liste, salvarea rezultatelor în fișiere.
- Caz particular: media se calculează doar dacă lista nu este goală; altfel raportul ar conține împărțire la zero.
Exercițiu de completare
Completează enunțul cu cuvintele potrivite:
O funcție se definește cu cuvântul cheie ______. Datele de intrare ale funcției se numesc ______, iar rezultatul se trimite înapoi cu ______. O variabilă definită în interiorul funcției este variabilă ______.
Bancă de cuvinte:
Exercițiu de completare
Completează enunțul cu cuvintele potrivite:
Un fișier se deschide cu funcția ______(); pentru citire folosim modul ______. Într-o aplicație grafică, fereastra principală se creează cu ______(), iar o casetă de text este un obiect ______. Un obiect este o instanță a unei ______.
Bancă de cuvinte:
Test de înțelegere
Test rapid de recapitulare finală:
1. Ce afișează print(round(4.5))?
2. Cu ce mod deschidem un fișier pentru a adăuga la sfârșit?
3. Ce este un obiect în programarea orientată pe obiecte?
4. Ce întoarce len([10, 20, 30])?
PbInfo - Recapitulare: media elementelor pare
Enunț:
Cerință: Se citește o listă de numere. Să se scrie funcția media_pare(v) care întoarce media aritmetică a elementelor pare din listă și să se afișeze rezultatul cu două zecimale.
Date de intrare:
Programul citește de la tastatură elementele listei, pe o singură linie.
Date de ieșire:
Programul va afișa media aritmetică a elementelor pare, rotunjită la două zecimale.
Restricții și precizări:
Lista conține cel puțin un element par, iar valorile sunt numere naturale cu cel mult 4 cifre.
Exemplu:
Intrare:
4 7 8 10 3
Ieșire:
7.33
Cum gândim soluția:
- Definim funcția
media_pare(v)care adună doar elementele pare - Numărăm câte elemente pare există
- Întoarcem raportul sumă / număr de elemente pare
- Afișăm rezultatul cu
round(media, 2)
Scrie soluția în Python:
Soluție corectă:
def media_pare(v):
suma = 0
contor = 0
for x in v:
if x % 2 == 0:
suma = suma + x
contor = contor + 1
return suma / contor
v = list(map(int, input().split()))
print(round(media_pare(v), 2))
Ce învățăm: o funcție cu filtru (doar elementele pare) și contor întoarce media cerută, iar programul principal doar citește și afișează.
PbInfo - Recapitulare: numerele prime în fișier
Enunț:
Cerință: Se citește o listă de numere. Folosind o funcție prim(n), să se scrie în fișierul text "prime.txt" numerele prime din listă, câte unul pe linie, și să se afișeze câte au fost scrise.
Date de intrare:
Programul citește de la tastatură elementele listei, pe o singură linie.
Date de ieșire:
Programul va crea fișierul "prime.txt" cu numerele prime și va afișa pe ecran numărul lor.
Restricții și precizări:
Valorile citite sunt numere naturale cu cel mult 4 cifre, iar lista are cel puțin un element.
Exemplu:
Intrare:
2 4 7 9 11
Ieșire:
3
Cum gândim soluția:
- Definim funcția
prim(n)cu return True/False - Parcurgem lista și pentru fiecare valoare verificăm primalitatea
- Scriem valorile prime în fișier cu write
- Afișăm contorul de valori scrise
Scrie soluția în Python:
Soluție corectă:
def prim(n):
if n < 2:
return False
for i in range(2, n):
if n % i == 0:
return False
return True
v = list(map(int, input().split()))
f = open("prime.txt", "w")
contor = 0
for x in v:
if prim(x):
f.write(str(x) + "\n")
contor = contor + 1
f.close()
print(contor)
Ce învățăm: combinația funcție proprie + listă + fișier este exact modelul cerut la evaluarea finală.
Exercițiul Practic: Recapitulare integrată
Sarcini de lucru
Rezolvă cele două sarcini de recapitulare, folosind funcții, liste și fișiere text
Sarcina 1: Numerele cu exact trei divizori
Cerință: Scrie o funcție numar_divizori(n) care întoarce numărul de divizori ai lui n, apoi un program care citește o listă și afișează câte elemente au exact 3 divizori (pătratele perfecte ale numerelor prime).
Soluție:
def numar_divizori(n):
contor = 0
for d in range(1, n + 1):
if n % d == 0:
contor = contor + 1
return contor
v = list(map(int, input().split()))
rezultat = 0
for x in v:
if numar_divizori(x) == 3:
rezultat = rezultat + 1
print(rezultat)
Verifică: funcția numără divizorii cu o buclă și un rest zero, iar programul contorizează valorile cu exact trei divizori.
Sarcina 2: Sortare cu metoda bulelor și salvare
Cerință: Scrie un program care citește n și n numere, le sortează crescător cu metoda bulelor și scrie lista sortată în fișierul "sortate.txt", câte un număr pe linie.
Soluție:
n = int(input())
v = list(map(int, input().split()))
for i in range(n - 1):
for j in range(0, n - i - 1):
if v[j] > v[j + 1]:
v[j], v[j + 1] = v[j + 1], v[j]
f = open("sortate.txt", "w")
for x in v:
f.write(str(x) + "\n")
f.close()
print("Lista sortata a fost salvata")
Verifică: metoda bulelor compară elementele vecine și le interschimbă cu o atribuire simultană, apoi rezultatul se salvează în fișier.