Ce vei învăța astăzi?
După această lecție vei învăța să generezi sistematic secvențe de valori în Python, folosind reguli clare și bucle.
Generarea unei liste de valori după o regulă
Definiție: A genera o secvență de valori înseamnă a produce termenii unul câte unul, după o regulă clară, de obicei cu ajutorul unei bucle for.
Regula poate fi o formulă (de exemplu i * i pentru pătrate perfecte), o condiție (doar valorile pare) sau o recurență.
De ce ne folosim?
Este ca atunci când numerotezi rândurile unui caiet: fiecare număr se obține din cel anterior adăugând 1. Regula este simplă și se aplică de fiecare dată.
Execută regula mecanic, de mii de ori, fără greșeală
Obosește și poate greși la termenul 500
Termeni ai expresiilor matematice
Unele secvențe sunt formate din termeni ai expresiilor matematice. De exemplu, pătratele perfecte 1, 4, 9, 16, ... au termenul general (formula care calculează direct orice termen al șirului) i * i, iar suma 1 + 2 + ... + n se obține adunând pe rând fiecare i.
Exemplu: primele n pătrate perfecte
n = int(input())
patrate = []
for i in range(1, n + 1):
patrate.append(i * i)
print(patrate)
Observă: pentru n = 5 programul afișează [1, 4, 9, 16, 25]. Regula termenului general este i * i.
Discuție: factorialul 1 * 2 * ... * n
n = int(input())
fact = 1
for i in range(2, n + 1):
fact = fact * i
print(fact)
Observă: aici nu adunăm, ci înmulțim pe rând. Variabila fact este un acumulator (o variabilă în care înmulțim valorile pe rând) care reține produsul parțial.
Secvențe cu proprietăți date
Uneori vrem doar termenii care îndeplinesc o proprietate: doar numerele pare, doar numerele prime, doar multiplii lui 3. Regula conține atunci o condiție care selectează valorile.
| Proprietate | Regula în Python | Exemplu de ieșire |
|---|---|---|
| Numere pare | x % 2 == 0 |
2, 4, 6, 8, ... |
| Multipli ai lui k | x % k == 0 |
k, 2k, 3k, ... |
| Pătrate perfecte | x = i * i |
1, 4, 9, 16, ... |
Exemplu: doar numerele pare de la 2 la 2n
n = int(input())
for i in range(1, n + 1):
print(2 * i, end=" ")
Acumulatoare și liste
Un acumulator este o variabilă în care adunăm (sau înmulțim) valorile pe măsură ce le generăm. O listă reține toți termenii generați, ca un coș în care punem valorile unul câte unul.
Reține toate valorile, de exemplu lista notelor clasei
Reține doar o sumă sau un produs, de exemplu suma notelor
Listă și sumă împreună
n = int(input())
pare = []
s = 0
for i in range(1, n + 1):
pare.append(2 * i)
s = s + 2 * i
print(pare)
print("Suma:", s)
Exercițiu de completare
Completează programul care generează primele n pătrate perfecte:
Pentru a genera primele n pătrate perfecte folosim bucla ______(1, n+1) și adăugăm în listă valoarea ______. Valoarea o punem în listă cu ______. O variabilă în care adunăm valorile generate se numește ______.
Bancă de cuvinte:
Test de înțelegere
Test rapid - generarea secvențelor:
1. Care sunt primele 3 pătrate perfecte?
2. Pentru a calcula suma 1 + 2 + ... + n folosim în buclă:
3. O listă generată după o regulă:
Test suplimentar - verifică ce ai reținut
Test rapid suplimentar - generarea secvențelor:
1. Pentru a genera primele n pătrate perfecte folosim bucla:
2. Instrucțiunea care adaugă o valoare la o listă este:
3. Secvența 2, 4, 6, 8, ... se obține după regula:
range(1, n) generează doar valorile de la 1 la n-1, deci ultimul termen lipsește. Folosește range(1, n + 1) pentru a include și termenul n.Aprofundare
În Python există o formă compactă de a genera liste după o regulă, numită list comprehension (construirea unei liste într-o singură expresie): [i * i for i in range(1, n + 1)]. Ea construiește lista într-o singură expresie, fără a apela explicit append(). Rezultatul este identic cu bucla clasică, dar codul este mai scurt și se citește mai ușor.
- Generare deterministă: o secvență generată sistematic este complet determinată de regulă și de valorile de pornire; același program produce întotdeauna aceeași ieșire, ceea ce face testarea foarte ușoară.
- Memorie: lista reține toți termenii generați, deci pentru milioane de valori consumăm memorie proporțional cu numărul lor. Dacă avem nevoie doar de termenul curent, îl putem afișa direct în buclă, fără a construi lista.
- Cazul particular n = 0: pentru n = 0, bucla
range(1, 1)este goală, deci lista rămâne vidă, iar suma rămâne 0; un program corect nu trebuie să eșueze în acest caz. - Reguli cu pas:
range(1, n + 1, 2)generează doar indicii impari, util pentru secvențele de valori din 2 în 2. - Selecția după proprietate: dacă vrem doar numerele dintr-un interval care îndeplinesc o condiție (de exemplu pătrate perfecte), testăm condiția în buclă și adăugăm în listă doar valorile care o respectă.
- Lista ca parametru: o listă generată poate fi transmisă mai departe în program, spre deosebire de afișarea directă, care pierde valorile după ce bucla s-a terminat.
PbInfo - Pătratele perfecte
Enunț:
Cerință: Se citește numărul natural n. Să se afișeze pe o singură linie primele n pătrate perfecte, separate prin spații.
Date de intrare:
Programul citește de la tastatură numărul natural n.
Date de ieșire:
Programul va afișa pe o singură linie primele n pătrate perfecte, separate prin spații.
Restricții și precizări:
n este un număr natural, cu 1 <= n <= 1000, iar elementele sunt numere întregi.
Exemplu:
Intrare:
5
Ieșire:
1 4 9 16 25
Cum gândim soluția:
- Citim n cu
input()și îl transformăm cuint() - Parcurgem i de la 1 la n cu
range(1, n+1) - Afișăm valoarea i * i, cu
end=" "ca să rămână pe aceeași linie
Scrie soluția în Python:
Soluție corectă:
n = int(input())
for i in range(1, n + 1):
print(i * i, end=" ")
Ce învățăm: generăm termenii după regula i * i și îi afișăm unul câte unul, pe aceeași linie.
PbInfo - Suma 1+2+...+n
Enunț:
Cerință: Se citește numărul natural n. Să se calculeze și să se afișeze suma 1 + 2 + ... + n.
Date de intrare:
Programul citește de la tastatură numărul natural n.
Date de ieșire:
Programul va afișa pe ecran suma numerelor de la 1 la n.
Restricții și precizări:
n este un număr natural, cu 1 <= n <= 1000, iar elementele sunt numere întregi.
Exemplu:
Intrare:
5
Ieșire:
15
Cum gândim soluția:
- Citim n și inițializăm acumulatorul s = 0
- Parcurgem i de la 1 la n și adunăm: s = s + i
- Afișăm rezultatul cu
print()
Scrie soluția în Python:
Soluție corectă:
n = int(input())
s = 0
for i in range(1, n + 1):
s = s + i
print(s)
Ce învățăm: folosim un acumulator (variabila s) în care adunăm pe rând fiecare termen al sumei.
Exercițiul Practic: Generarea secvențelor de valori
Sarcini de lucru
Aplică regulile de generare a secvențelor în programe complete, cu citire de la tastatură.
Sarcina 1: Primele n numere pare
Cerință: Scrie un program care citește n și afișează primele n numere pare, adică 2, 4, 6, ...
Soluție:
n = int(input())
for i in range(1, n + 1):
print(2 * i, end=" ")
Verifică: pentru n = 3 se afișează 2 4 6. Termenul general al numerelor pare este 2 * i.
Sarcina 2: Șirul k, 2k, 3k, ...
Cerință: Scrie un program care citește k și n și generează o listă cu primii n termeni ai șirului k, 2k, 3k, ...
Soluție:
k = int(input())
n = int(input())
for i in range(1, n + 1):
print(i * k, end=" ")
Verifică: pentru k = 3 și n = 4 se afișează 3 6 9 12. Regula este i * k.