Ce vei învăța astăzi?
În această lecție vei construi o aplicație modulară completă (aplicație împărțită în funcții cu roluri separate) de gestionare a notelor: vei descompune problema în module (părți ale aplicației, fiecare cu un singur rol), vei defini funcții proprii cu def și return și vei salva datele într-un fișier text.
Proiectarea modulară a unei aplicații
Definiție: Proiectarea modulară înseamnă descompunerea unei aplicații în module independente, fiecare cu un rol bine definit. Fiecare modul este implementat printr-un subprogram (funcție).
Analogia din viața reală:
Gândește-te la o echipă care construiește un proiect: un membru colectează datele, altul verifică validitatea lor, altul calculează rezultatele, altul scrie raportul. Fiecare membru face un singur modul, dar împreună produc aplicația finală.
Modulele aplicației noastre: citire date (introducerea notelor), validare (verificarea intervalului), prelucrare (media, min, max), raport (afișarea rezultatelor) și salvare (scrierea în fișier text).
Observă: fiecare modul se testează separat, iar modificarea unuia nu afectează celelalte. Asta înseamnă cod curat, ușor de citit și de întreținut.
Modulele aplicației de gestionare a notelor
Aplicația folosește funcții proprii definite cu def și return: citire_note() citește notele, media(lista) calculează media, maxim(lista) și minim(lista) găsesc extremul, iar raport(lista) afișează toate rezultatele.
def citire_note():
n = int(input())
v = list(map(int, input().split()))
return v
def media(lista):
return sum(lista) / len(lista)
def minim(lista):
m = lista[0]
for x in lista:
if x < m:
m = x
return m
def maxim(lista):
m = lista[0]
for x in lista:
if x > m:
m = x
return m
def raport(lista):
print("Media:", round(media(lista), 2))
print("Minimul:", minim(lista))
print("Maximul:", maxim(lista))
note = citire_note()
raport(note)
Reține: programul principal este doar două linii: citirea notelor și apelul raportului. Toată logica este ascunsă în funcții, care pot fi refolosite în orice alt program.
Integrarea cu fișiere: salvarea și citirea notelor
Pentru a salva notele, deschidem un fișier cu open() în modul de scriere "w" și scriem cu write(). Pentru a le citi, deschidem în modul "r" și folosim read(). Fișierele se închid întotdeauna cu close().
n = int(input())
v = list(map(int, input().split()))
f = open("note.txt", "w")
for x in v:
f.write(str(x) + "\n")
f.close()
f = open("note.txt", "r")
continut = f.read()
f.close()
print(continut)
Observă: scriem o notă pe fiecare linie, iar la citire read() întoarce tot conținutul ca text. Închiderea fișierului cu close() este obligatorie după fiecare operație.
Exercițiu de completare
Completează enunțul cu cuvintele potrivite:
O aplicație modulară se descompune în părți independente numite ______. Fiecare modul este implementat printr-un ______, definit cu cuvântul cheie ______. Valorile se trimit înapoi locului de apel cu instrucțiunea ______.
Bancă de cuvinte:
Exercițiu de completare
Completează enunțul cu cuvintele potrivite:
Pentru a salva notele într-un fișier text, deschidem fișierul cu funcția ______, în modul de scriere ______. Scriem o notă pe fiecare linie cu metoda ______. La final închidem fișierul cu ______(), iar pentru citire folosim modulul ______.
Bancă de cuvinte:
Test de înțelegere
Test rapid - aplicația modulară:
1. Ce calculează funcția media(lista)?
2. Cu ce mod deschidem un fișier pentru scriere?
3. Pentru ca o funcție să trimită o valoare înapoi locului de apel folosim:
Aprofundare
Validarea datelor de intrare: o aplicație robustă nu acceptă valori greșite. Definim o funcție validare(x) care întoarce adevărat doar dacă 1 <= x <= 10 (intervalul notelor) și repetăm citirea cu o buclă while până când valoarea este validă.
- Raportul în fișier: în loc de print, deschidem
open("raport.txt", "w")și scriem rezultatele cu write; astfel raportul poate fi păstrat și tipărit. - Statistici suplimentare: numărarea notelor peste medie, histograma cu caractere * (o stea pentru fiecare notă) sau sortarea notelor.
- Modul principal: structura
if __name__ == "__main__":permite rularea programului direct, dar și importarea funcțiilor din alt program fără a le executa. - Testarea modulelor: fiecare funcție se testează separat, cu valori cunoscute, înainte de asamblarea aplicației.
- Caz particular: o funcție care primește o listă goală trebuie să fie pregătită: media ar produce împărțire la zero.
PbInfo - Raportul notelor
Enunț:
Cerință: Se citesc n și n note. Folosind funcții proprii media(v), minim(v) și maxim(v), definite cu def și return, să se afișeze media notelor (cu două zecimale), nota minimă și nota maximă.
Date de intrare:
Programul citește de la tastatură numărul n, apoi n note pe o singură linie.
Date de ieșire:
Programul va afișa pe ecran, pe linii separate: media notelor (cu două zecimale), minimul și maximul.
Restricții și precizări:
Valorile citite sunt numere întregi, iar n este un număr natural, cu 1 <= n <= 1000.
Exemplu:
Intrare:
5 7 8 9 6 10
Ieșire:
8.0 6 10
Cum gândim soluția:
- Definim funcția media(v) care întoarce sum(v) / len(v)
- Definim funcțiile minim(v) și maxim(v) cu parcurgerea listei și return
- Citim n și notele, apelăm funcțiile și afișăm rezultatele
Scrie soluția în Python:
Soluție corectă:
def media(v):
return sum(v) / len(v)
def minim(v):
m = v[0]
for x in v:
if x < m:
m = x
return m
def maxim(v):
m = v[0]
for x in v:
if x > m:
m = x
return m
n = int(input())
v = list(map(int, input().split()))
print(round(media(v), 2))
print(minim(v))
print(maxim(v))
Ce învățăm: fiecare modul este o funcție cu un singur rol: media, minimul și maximul se calculează separat, apoi programul principal le apelează.
PbInfo - Notele în fișier
Enunț:
Cerință: Se citesc n și n note. Să se scrie notele în fișierul text "note.txt", câte una pe linie, apoi să se citească fișierul și să se afișeze suma notelor.
Date de intrare:
Programul citește de la tastatură numărul n, apoi n note pe o singură linie.
Date de ieșire:
Programul va crea fișierul "note.txt" și va afișa pe ecran suma notelor citite din fișier.
Restricții și precizări:
Valorile citite sunt numere întregi, iar n este un număr natural, cu 1 <= n <= 1000.
Exemplu:
Intrare:
4 7 8 6 9
Ieșire:
30
Conținutul fișierului note.txt:
7 8 6 9
Cum gândim soluția:
- Citim n și notele
- Deschidem "note.txt" în modul "w" și scriem fiecare notă pe o linie cu write()
- Închidem fișierul, îl redeschidem în modul "r" și adunăm liniile citite
- Afișăm suma
Scrie soluția în Python:
Soluție corectă:
n = int(input())
v = list(map(int, input().split()))
f = open("note.txt", "w")
for x in v:
f.write(str(x) + "\n")
f.close()
f = open("note.txt", "r")
s = 0
for linie in f:
s = s + int(linie)
f.close()
print(s)
Ce învățăm: datele se pot salva într-un fișier text cu open/write/close și se pot reciti linie cu linie, transformându-le înapoi în numere cu int().
Exercițiul Practic: Aplicația modulară de gestionare a notelor
Sarcini de lucru
Completează aplicația modulară cu funcții noi: validarea notelor și raportul final
Sarcina 1: Funcția de validare a notelor
Cerință: Completează aplicația cu o funcție validare(note) care întoarce True dacă toate notele sunt în intervalul 1-10 și False dacă există cel puțin o notă în afara intervalului. Programul principal citește notele și afișează un mesaj corespunzător.
Soluție:
def validare(note):
for x in note:
if x < 1 or x > 10:
return False
return True
def citire_note():
n = int(input())
v = list(map(int, input().split()))
return v
v = citire_note()
if validare(v):
print("Toate notele sunt in intervalul 1-10")
else:
print("Exista note in afara intervalului 1-10")
Verifică: funcția validează fiecare notă cu if x < 1 or x > 10 și întoarce False la prima notă nevalidă, altfel True.
Sarcina 2: Funcția raport()
Cerință: Adaugă o funcție raport() care afișează media notelor, minimul, maximul și numărul de note mai mari decât media. Programul principal citește notele și apelează raport().
Soluție:
def media(v):
return sum(v) / len(v)
def minim(v):
m = v[0]
for x in v:
if x < m:
m = x
return m
def maxim(v):
m = v[0]
for x in v:
if x > m:
m = x
return m
def raport(v):
medie = media(v)
peste = 0
for x in v:
if x > medie:
peste = peste + 1
print("Media:", round(medie, 2))
print("Minimul:", minim(v))
print("Maximul:", maxim(v))
print("Note peste medie:", peste)
v = [int(x) for x in input().split()]
raport(v)
Verifică: raportul reutilizează funcțiile media, minim și maxim, iar numărul notelor peste medie se numără cu o buclă for.