Ce vei învăța astăzi?
După această lecție vei putea scrie programe care repetă operații: vei folosi bucla for și bucla while, precum și numărători și acumulatoare.
Bucla for cu range()
for repetă un bloc de cod de un număr cunoscut de ori. Ajutătorul range(start, stop, step) (o funcție care generează o succesiune de numere, de la start până înainte de stop, din step în step) generează numerele parcurse.
| Forma lui range() | Valorile generate |
|---|---|
range(5) |
0, 1, 2, 3, 4 (de la 0, stop exclus (adică valoarea stop nu este generată)) |
range(1, 6) |
1, 2, 3, 4, 5 (stop exclus) |
range(1, 10, 2) |
1, 3, 5, 7, 9 (pas de 2) |
for i in range(1, 6):
print(i)
De reținut: în range(start, stop, step), valoarea stop nu este inclusă! range(1, 6) înseamnă 1, 2, 3, 4, 5.
Bucla while
while repetă un bloc de cod cât timp o condiție este adevărată. Condiția se verifică înainte de fiecare execuție a blocului.
Analogie
Este ca o găleată care se umple: „cât timp găleata nu este plină, toarnă apă". Verificăm înainte de fiecare turnare dacă găleata este plină.
n = 5
while n > 0:
print(n)
n = n - 1
Atenție: dacă uităm să modificăm variabila din condiție, bucla nu se mai oprește niciodată. Se numește buclă infinită!
Numărătorii și acumulatoarele
De multe ori, în bucle, numărăm câte ceva (numărător (o variabilă care numără apariții, crescând cu 1 la fiecare repetare)) sau adunăm valori (acumulator (o variabilă care strânge suma valorilor întâlnite în buclă)).
cnt += 1 - crește cu 1, numără câte ceva
s += x - adună valoarea x, strânge suma
cnt = 0
for i in range(1, 11):
if i % 2 == 0:
cnt += 1
print(cnt)
De reținut: cnt += 1 este prescurtarea pentru cnt = cnt + 1. La fel, s += x înseamnă s = s + x.
for sau while? Când folosim fiecare
| Criteriu | for | while |
|---|---|---|
| Știm de câte ori repetăm | Da - număr cunoscut de pași | Nu neapărat |
| Ne oprim după o condiție | Nu | Da - cât timp condiția e adevărată |
| Exemplu tipic | for i in range(1, n + 1) |
while n > 0 (cu n //= 10) |
Regula simplă: știm de câte ori repetăm → for. Nu știm, depinde de condiție → while.
Buclele infinite
O buclă infinită este o buclă care nu se oprește niciodată, pentru că variabila din condiție nu se schimbă. Programul rămâne blocat.
n = 5
while n > 0:
print("Nu se oprește!")
# lipsește n = n - 1
Prevenire: asigură-te că în corpul buclei while modifici variabila din condiție. Dacă programul „îngheață", verifică bucla ta.
Exemple complete de bucle
Exemplul 1: suma 1 + 2 + ... + n cu for
n = int(input())
s = 0
for i in range(1, n + 1):
s += i
print(s)
Observă: s este un acumulator: pornește de la 0 și adună fiecare i.
Exemplul 2: suma cifrelor lui n cu while
n = int(input())
s = 0
while n > 0:
s += n % 10
n //= 10
print(s)
Observă: n % 10 ne dă ultima cifră, iar n //= 10 „taie" ultima cifră. Repetăm până când n devine 0.
Exercițiu de completare
Completează programul cu for pentru suma 1 + 2 + ... + n:
______ = 0
for i in range(1, ______):
s ______ i
______(s)
Bancă de cuvinte:
Test de înțelegere
Test rapid - structuri repetitive:
1. range(1, 5) generează valorile...
2. Bucla while verifică condiția...
3. range(1, 10, 2) generează valorile...
Test de verificare
Test rapid - bucle:
1. Ce buclă folosim când știm dinainte de câte ori repetăm?
2. Ce funcție generează o secvență de numere pentru bucla for?
3. Bucla while execută corpul...
while (de exemplu n //= 10), programul nu se mai oprește.Aprofundare
Când folosim for și când folosim while? Regula practică: dacă știm dinainte de câte ori se repetă bucla, folosim for; dacă repetarea depinde de o condiție care se poate schimba în timpul execuției, folosim while. De exemplu, parcurgerea primelor n numere este un caz de for, iar „cât timp n mai are cifre" este un caz de while, pentru că nu știm câte cifre are n înainte de a începe.
Bucla infinită - cel mai periculos caz particular. Dacă uităm să modificăm variabila din condiția unui while, condiția rămâne mereu adevărată și programul nu se termină niciodată. De exemplu, dacă în programul cu suma cifrelor uităm linia n //= 10, bucla rulează la nesfârșit. Înainte de a rula un while, verifică întotdeauna că există o instrucțiune care modifică variabila din condiție.
Acumulatorii și numărătorii. Acumulatorul adună valori (s = s + i), numărătorul numără apariții (cnt = cnt + 1). Ambele trebuie inițializate (adică li se dă o valoare de pornire) înainte de buclă - acumulatorul cu 0, numărătorul cu 0. O greșeală tipică este inițializarea lor în interiorul buclei, caz în care valoarea se resetează la fiecare pas și rezultatul final este greșit.
PbInfo - Suma numerelor de la 1 la n
Enunț:
Cerință: Se citește un număr natural n. Să se afișeze suma numerelor de la 1 la n (1 + 2 + 3 + ... + n).
Date de intrare:
Programul citește de la tastatură numărul n.
Date de ieșire:
Programul va afișa suma cerută.
Restricții și precizări:
Numerele citite sunt numere naturale, iar rezultatul este un număr întreg sau real.
Exemplu:
Intrare:
5
Ieșire:
15
Cum gândim soluția:
- Citim n cu
int(input()) - Pornim un acumulator
s = 0 - Parcurgem cu
for i in range(1, n + 1)și adunăm:s += i - Afișăm cu
print()
Scrie soluția în Python:
Soluție corectă:
n = int(input())
s = 0
for i in range(1, n + 1):
s += i
print(s)
Ce învățăm: pentru n = 5, programul calculează 1 + 2 + 3 + 4 + 5 = 15. Am folosit bucla for și un acumulator.
PbInfo - Suma cifrelor unui număr
Enunț:
Cerință: Se citește un număr natural n. Să se afișeze suma cifrelor sale.
Date de intrare:
Programul citește de la tastatură numărul n.
Date de ieșire:
Programul va afișa suma cifrelor 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:
12
Cum gândim soluția:
- Citim n cu
int(input()) - Luăm ultima cifră cu
n % 10și o adunăm la s - „Tăiem" ultima cifră cu
n //= 10 - Repetăm
while n > 0, apoi afișăm
Scrie soluția în Python:
Soluție corectă:
n = int(input())
s = 0
while n > 0:
s += n % 10
n //= 10
print(s)
Ce învățăm: pentru n = 273, programul calculează 3 + 7 + 2 = 12. Am folosit while pentru că nu știm de câte ori repetăm.
Exercițiul Practic: Bucle în acțiune
Sarcini de lucru
Scrie programe cu bucle for și while pentru probleme concrete
Sarcina 1: Factorialul unui număr
Cerință: Scrie un program care citește n și afișează n! (factorialul), adică produsul 1 * 2 * 3 * ... * n. Folosește bucla for.
Soluție pentru Sarcina 1:
n = int(input())
f = 1
for i in range(1, n + 1):
f *= i
print(f)
Verifică: pentru n = 5, programul calculează 1 * 2 * 3 * 4 * 5 = 120. Acumulatorul f pornește de la 1 și înmulțește fiecare i.
Sarcina 2: Divizorii unui număr
Cerință: Scrie un program care citește n și afișează, fiecare pe câte o linie, toți divizorii lui n. Parcurge cu for i in range(1, n + 1) și verifică cu if n % i == 0.
Soluție pentru Sarcina 2:
n = int(input())
for i in range(1, n + 1):
if n % i == 0:
print(i)
Verifică: pentru n = 6, programul afișează 1, 2, 3, 6. Am combinat bucla for cu structura de decizie if.
Scrie pe caiet - De reținut
Titlul lecției
Ora 8: Structuri repetitive în Python
Definiția lecției
Structura repetitivă permite programului să execute un grup de instrucțiuni de mai multe ori, fără să le scriem de fiecare dată. Bucla for repetă de un număr cunoscut de ori și folosește funcția range(start, stop, step) pentru a genera numerele parcurse, iar bucla while repetă cât timp o condiție rămâne adevărată, verificând condiția înainte de fiecare execuție. În bucle folosim des numărătorii, variabile care numără apariții crescând cu 1, și acumulatoarele, variabile care strâng suma valorilor. Un pericol important este bucla infinită, care apare când uităm să modificăm variabila din condiție, programul rămânând blocat. De exemplu, pentru a calcula suma cifrelor unui număr, folosim o buclă while care adună ultima cifră (n % 10) și o elimină (n //= 10) până când numărul devine 0.
Definiții esențiale
- Structura repetitivă - instrucțiunea care execută un grup de pași de mai multe ori.
- for - repetă de un număr cunoscut de ori:
for i in range(1, n + 1):. - while - repetă cât timp condiția este adevărată:
while n > 0:. - Acumulatorul - variabilă care adună valori (inițializat cu 0).
- Numărătorul - variabilă care numără apariții (inițializat cu 0).
- Bucla infinită - bucla a cărei condiție nu devine niciodată falsă.
Algoritmul cheie - pseudocod
Algoritmul cheie - cod Python
n = int(input())
s = 0
while n > 0:
s += n % 10
n //= 10
print(s)Greșeli comune de evitat
- Uitarea inițializării acumulatorului:
strebuie pornit cu 0 înainte de buclă. - Buclă infinită: uitarea instrucțiunii care modifică variabila din condiția
while. - Scrierea
range(1, n)când vrem 1 ... n: al doilea argument este exclusiv, deci scriemn + 1. - Inițializarea acumulatorului în interiorul buclei - se resetează la fiecare pas.
Sfaturi practice și trucuri
- Alege
forcând știi numărul de repetări șiwhilecând depinde de o condiție. - Pentru cifrele unui număr:
n % 10dă ultima cifră,n // 10o elimină. - Urmărește fiecare buclă pe hârtie pentru o valoare mică, înainte de a rula programul.
- Dacă programul „nu se termină", verifică imediat condiția buclei
while.
Exemplu practic
Când aduni pe hârtie valorile unor cumpărături, faci de fapt o buclă: aduni fiecare preț la suma totală, exact ca un acumulator. La fel, un program poate număra câte note de 10 ai într-un semestru, parcurgând notele cu o buclă for și crescând un numărător de fiecare dată când întâlnește un 10:
cnt = 0
for i in range(1, 11):
if i % 3 == 0:
cnt += 1
print(cnt)