Ce vei învăța astăzi?
După această lecție vei parcurge o listă în două moduri: fără memorare (prelucrând elementele pe loc) și cu memorare (stocând lista), și vei rezolva probleme cu minim, maxim, sumă și numărare.
Parcurgerea liniară fără memorare
Definiție: Parcurgerea fără memorare înseamnă că prelucrăm fiecare valoare pe măsură ce o citim, fără să o stocăm într-o listă. Folosim variabile de lucru: sume, contoare (variabile care numără de câte ori se întâmplă o situație), minime sau maxime.
Este ca la contorizarea elevilor din curte: numări fiecare elev pe măsură ce trece pe lângă tine, fără să ții o listă cu toți.
Exemplu: suma și numărarea fără memorare
n = int(input())
valori = list(map(int, input().split()))
s = 0
cnt = 0
for x in valori:
s += x
if x > 10:
cnt += 1
print("Suma:", s)
print("Mai mari decat 10:", cnt)
Observă: elementele sunt prelucrate unul câte unul. Variabilele s (sumă) și cnt (contor) strâng informația pe măsură ce parcurgem lista.
Parcurgerea cu memorare
Definiție: Parcurgerea cu memorare înseamnă că stocăm mai întâi toate valorile într-o listă, apoi o parcurgem de câte ori este nevoie, la final.
Este ca la notele elevilor: profesorul le notează pe toate în catalog, apoi calculează media și vede cine este peste medie.
| Criteriu | Fără memorare | Cu memorare |
|---|---|---|
| Stocăm valorile? | Nu, le prelucrăm pe loc | Da, într-o listă |
| Când o folosim? | Sumă, numărare, min, max | Media, elemente peste medie, ordonare |
| De câte ori trecem prin valori? | O singură dată | De câte ori avem nevoie |
Exemplu: notele elevilor (cu memorare)
n = int(input())
note = list(map(int, input().split()))
media = sum(note) / len(note)
print("Media:", media)
for x in note:
if x > media:
print(x, end=" ")
Observă: lista a fost memorată. Abia după ce știm media, o parcurgem din nou ca să afișăm notele de peste medie.
Funcții utile pentru liste
Python are funcții gata făcute pentru prelucrarea listelor:
| Funcție | Ce face? | Exemplu |
|---|---|---|
len(v) |
Numărul de elemente | len([1, 2, 3]) dă 3 |
sum(v) |
Suma elementelor | sum([1, 2, 3]) dă 6 |
min(v) |
Cea mai mică valoare | min([4, 1, 7]) dă 1 |
max(v) |
Cea mai mare valoare | max([4, 1, 7]) dă 7 |
Exemplu: minim, maxim, sumă și medie
v = [15, 8, 22, 3, 9]
print("Minim:", min(v))
print("Maxim:", max(v))
print("Suma:", sum(v))
print("Media:", sum(v) / len(v))
Observă: media este suma împărțită la numărul de elemente: sum(v) / len(v).
Exercițiu de completare
Completează enunțul cu funcțiile potrivite:
Pentru a parcurge o listă folosim instrucțiunea ______: for x in v:. Funcția ______(v) calculează suma elementelor. Funcția ______(v) returnează numărul de elemente. Funcția ______(v) returnează cea mai mică valoare din listă.
Bancă de cuvinte:
Test de înțelegere
Test rapid - parcurgerea listelor:
1. Ce funcție returnează numărul de elemente dintr-o listă?
2. Media aritmetică a elementelor unei liste a se calculează cu:
3. Parcurgerea fără memorare înseamnă că:
s = 0, contorul de la cnt = 0, iar minimul se inițializează cu v[0] (nu cu 0), altfel rezultatele sunt greșite.Aprofundare
Parcurgerea cu index versus parcurgerea cu for x in v. Forma for x in v: este cea mai simplă, dar nu ne spune poziția elementului. Când avem nevoie și de poziție (de exemplu „luna în care vânzările sunt maxime"), folosim for i in range(len(v)): și accesăm v[i]. Python oferă și funcția enumerate(v), care produce perechi (poziție, valoare) la fiecare pas.
Calculul minimului și maximului manual. Funcțiile min() și max() sunt rapide, dar dacă vrem și poziția primei apariții, le combinăm cu v.index(). Pentru înțelegerea profundă a parcurgerii, este util să refacem manual algoritmul: inițializăm mini = v[0], apoi pentru fiecare x, dacă x < mini, actualizăm mini = x.
Când este obligatorie memorarea? Memorăm lista ori de câte ori o informație globală (media, maximul, totalul) este necesară pentru decizii ulterioare despre fiecare element. Fără listă nu putem spune „câte note sunt peste medie", pentru că media se cunoaște doar la finalul citirii. Memorarea are un cost: memoria ocupată crește cu numărul de elemente.
Eficiența parcurgerii. O parcurgere liniară cu for vizitează fiecare element o singură dată, deci timpul crește proporțional cu lungimea listei. Un program cu o singură parcurgere este eficient; fiecare parcurgere suplimentară adaugă o trecere completă prin date, deci să le evităm pe cele inutile.
Liste cu numere reale. Pentru note cu zecimale sau temperaturi, folosim map(float, ...) la citire, iar media poate avea multe zecimale; o rotunjim cu round(media, 2) pentru afișare clară.
Quiz de consolidare
Quiz de consolidare - parcurgerea listelor:
1. Pentru a afla cea mai mică valoare dintr-o listă v folosim:
2. Pentru a afla cea mai mare valoare dintr-o listă v folosim:
3. În structura for x in v, variabila x ia, pe rând:
PbInfo - Suma și produsul elementelor unei liste
Enunț:
Cerință: Se citește o listă de numere. Să se calculeze și să se afișeze suma elementelor, apoi produsul elementelor listei.
Date de intrare:
Programul citește de la tastatură numerele listei, separate prin spații.
Date de ieșire:
Programul va afișa suma și produsul elementelor, în această ordine.
Restricții și precizări:
n este un număr natural, cu 1 <= n <= 1000, iar elementele listei sunt numere întregi.
Exemplu:
Intrare:
1 2 3 4
Ieșire:
10 24
Cum gândim soluția:
- Citim numerele în lista v
- Calculăm suma cu
sum(v) - Parcurgem lista și înmulțim elementele într-o variabilă p, pornind de la 1
Scrie soluția în Python:
Soluție corectă:
v = list(map(int, input().split()))
p = 1
s = sum(v)
for x in v:
p *= x
print(s, p)
Ce învățăm: suma se ia direct cu sum(), iar produsul îl calculăm manual parcurgând lista și înmulțind.
PbInfo - Media aritmetică a elementelor
Enunț:
Cerință: Se citește o listă de numere. Să se calculeze media aritmetică a elementelor și să se numere câte elemente sunt mai mari decât media.
Date de intrare:
Programul citește de la tastatură numerele listei, separate prin spații.
Date de ieșire:
Programul va afișa numărul de elemente mai mari decât media aritmetică.
Restricții și precizări:
n este un număr natural, cu 1 <= n <= 1000, iar elementele listei sunt numere întregi.
Exemplu:
Intrare:
6 4 8 2
Ieșire:
1
Cum gândim soluția:
- Citim lista v
- Calculăm media:
med = sum(v) / len(v) - Parcurgem lista și numărăm elementele mai mari decât media
Scrie soluția în Python:
Soluție corectă:
v = list(map(int, input().split()))
med = sum(v) / len(v)
cnt = 0
for x in v:
if x > med:
cnt += 1
print(cnt)
Ce învățăm: media se află după ce memorăm lista, apoi facem o a doua parcurgere pentru numărare. Este parcurgere cu memorare!
Exercițiul Practic: Parcurgerea listelor în probleme
Sarcini de lucru
Completează următoarele sarcini pentru a exersa parcurgerea cu și fără memorare
Sarcina 1: Notele clasei
Cerință: Scrie un program care citește n, apoi n note. Calculează media notelor și afișează câte note sunt peste medie.
Soluție pentru Sarcina 1:
n = int(input())
note = list(map(int, input().split()))
media = sum(note) / len(note)
cnt = 0
for x in note:
if x > media:
cnt += 1
print("Media:", media)
print("Note peste medie:", cnt)
Verifică: lista este memorată, calculăm media, apoi numărăm notele de peste medie la o a doua parcurgere.
Sarcina 2: Temperaturile săptămânii
Cerință: Scrie un program care citește temperaturile unei săptămâni (7 valori) și afișează temperatura minimă și maximă, fără a folosi min() și max() (calculează-le manual cu for).
Soluție pentru Sarcina 2:
t = list(map(int, input().split()))
minim = t[0]
maxim = t[0]
for x in t:
if x < minim:
minim = x
if x > maxim:
maxim = x
print("Minim:", minim)
print("Maxim:", maxim)
Verifică: pornim cu primul element ca minim și maxim, apoi comparăm fiecare element în parte.