Ce vei învăța astăzi?
După această lecție vei construi o aplicație completă care generează o serie de numere aleatoare (valori generate la întâmplare, dintr-un interval stabilit) cu biblioteca random, o salvează într-un fișier text și apoi calculează statistici (valori rezumative: număr, sumă, minim, maxim, medie) din fișier.
Biblioteca random - numere aleatoare
Definiție: Biblioteca random este o colecție de funcții predefinite care generează numere aleatoare. O aducem cu import random și apelăm funcțiile cu punctul: random.randint(...).
Analogia din viața reală:
O aruncare de zaruri produce un rezultat diferit la fiecare aruncare, chiar dacă regulile sunt aceleași. Exact așa lucrează funcțiile din biblioteca random: la fiecare apel dau o valoare nouă, imprevizibilă, dar cuprinsă în intervalul cerut.
| Funcție | Ce întoarce | Exemplu |
|---|---|---|
| random() | Un număr real din intervalul [0, 1) | random.random() -> 0.374... |
| randint(a, b) | Un număr întreg din intervalul [a, b], inclusiv capetele | random.randint(1, 100) -> 42 |
| randrange(a, b) | Un număr întreg din [a, b), fără capătul b | random.randrange(1, 7) -> 1...6 |
| uniform(a, b) | Un număr real din [a, b] | random.uniform(1.5, 2.5) -> 2.1 |
| choice(lista) | Un element ales aleator din listă | random.choice(["a", "b", "c"]) |
| seed(n) | Fixează punctul de plecare al generatorului | random.seed(7) |
Reține: random.seed(n) face secvența reproductibilă: cu același seed, programul generează aceleași numere. Este util la testare, când vrem să repetăm exact o experiență.
Scrierea seriei într-un fișier text
O serie de numere generate nu trebuie să rămână doar în memorie: o salvăm pe disc. Deschidem fișierul cu open("serie.txt", "w"), scriem fiecare număr pe câte o linie cu write() și închidem cu close(). Numerele se convertesc în șir cu str(x) înainte de scriere.
De ce salvăm în fișier? Datele generate rămân păstrate după închiderea programului, pot fi analizate de alte programe și pot fi tipărite sau prelucrate în Excel.
f = open("serie.txt", "w")
for x in serie:
f.write(str(x) + "\n")
f.close()
Reține: fără str(x), funcția write() nu acceptă numere și programul se oprește cu TypeError. Fiecare valoare se scrie pe o linie proprie, ca la citire să fie ușor de separat.
Statistici din fișier
După salvarea seriei, o citim din fișier cu readlines(), transformăm fiecare linie în număr cu int(linie.strip()) și calculăm statistici cu funcțiile predefinite: len (numărul de valori), sum (suma), min și max (extremele) și media ca raport sum / len.
import random
def genereaza_serie(n, limita):
serie = []
for i in range(n):
serie.append(random.randint(1, limita))
return serie
def salveaza_fisier(fisier, serie):
f = open(fisier, "w")
for x in serie:
f.write(str(x) + "\n")
f.close()
def citeste_fisier(fisier):
f = open(fisier, "r")
linii = f.readlines()
f.close()
valori = []
for linie in linii:
valori.append(int(linie.strip()))
return valori
def statistici(serie):
print("Numar de valori:", len(serie))
print("Suma:", sum(serie))
print("Minimul:", min(serie))
print("Maximul:", max(serie))
print("Media:", round(sum(serie) / len(serie), 2))
n = int(input())
serie = genereaza_serie(n, 100)
salveaza_fisier("serie.txt", serie)
date = citeste_fisier("serie.txt")
statistici(date)
Observă: aplicația este modulară: fiecare funcție are un singur rol (generare, salvare, citire, statistici), iar programul principal are doar patru linii. Datele circulă între module prin valori returnate.
Aprofundare
Reproductibilitatea experiențelor: în fața clasei, profesorul poate demonstra că random.seed(7) urmat de aceeași secvență de apeluri produce de fiecare dată aceleași numere. În producție, seed-ul se omite pentru a obține valori într-adevăr imprevizibile, ca la extragerea loto.
- Alegeri aleatoare:
random.choice(lista)alege un element dintr-o listă, iarrandom.shuffle(lista)amestecă elementele în loc; ambele sunt folosite la jocuri și simulări. - Numere reale:
random.uniform(a, b)generează numere reale - util pentru mărimi fizice;random()dă valori în [0, 1), utile pentru probabilități. - Validarea la citire: o linie goală la sfârșitul fișierului ar produce
int("")- ValueError; filtrăm cuif linie.strip():înainte de conversie. - Extindere practică: numărarea valorilor pare, histograma cu caractere * sau media doar a valorilor peste un prag sunt completări naturale ale statisticilor de bază.
- Caz particular: cu modul "a" (append) putem adăuga o nouă serie la sfârșitul unui fișier existent, păstrând istoricul generărilor.
Exercițiu de completare
Completează enunțul cu cuvintele potrivite:
Pentru a genera numere aleatoare, importăm mai întâi biblioteca ______. Funcția ______(a, b) întoarce un număr întreg din intervalul [a, b]. Pentru a fixa punctul de plecare al generatorului folosim ______(n). Valorile generate se salvează într-un fișier cu ______().
Bancă de cuvinte:
Exercițiu de completare
Completează enunțul cu cuvintele potrivite:
Salvarea într-un fișier text începe cu funcția ______("serie.txt", ______). Fiecare număr se scrie convertit în șir cu ______(x), urmat de caracterul de linie nouă. La final, fișierul se închide cu ______().
Bancă de cuvinte:
Test de înțelegere
Test rapid - biblioteca random și fișiere:
1. Ce întoarce funcția random.randint(1, 10)?
2. Cu ce mod deschidem un fișier pentru a scrie peste conținutul vechi?
3. Ce calculează expresia sum(v) / len(v) pentru o listă de numere?
PbInfo - Generare și salvare în fișier
Enunț:
Cerință: Se citește numărul natural n. Să se genereze cu biblioteca random n numere întregi din intervalul [1, 100], să se scrie fiecare număr pe câte o linie în fișierul text "numere.txt" și să se afișeze numerele generate, separate prin spațiu.
Date de intrare:
Programul citește de la tastatură numărul natural n.
Date de ieșire:
Programul va afișa pe ecran cele n numere generate, separate prin spațiu, și va crea fișierul "numere.txt" cu câte un număr pe linie.
Restricții și precizări:
Valorile citite sunt numere întregi, iar n este un număr natural, cu 1 <= n <= 1000.
Exemplu:
Intrare:
5
Ieșire:
23 7 91 42 58
Cum gândim soluția:
- Importăm biblioteca random cu
import random - Generăm numerele cu
random.randint(1, 100)într-o buclă - Scriem fiecare număr în fișier cu
f.write(str(x) + "\n") - Afișăm lista generată și închidem fișierul cu close()
Scrie soluția în Python:
Soluție corectă:
import random
n = int(input())
v = []
f = open("numere.txt", "w")
for i in range(n):
x = random.randint(1, 100)
v.append(x)
f.write(str(x) + "\n")
f.close()
print(*v)
Ce învățăm: generarea cu randint, salvarea cu write și conversia str(x) formează lanțul complet al aplicației cu fișiere.
PbInfo - Statistici dintr-un fișier
Enunț:
Cerință: În fișierul text "numere.txt" se află, câte unul pe fiecare linie, numere naturale. Să se citească valorile din fișier și să se afișeze numărul de valori, minimul, maximul și media aritmetică cu două zecimale.
Date de intrare:
Programul citește datele din fișierul "numere.txt", fără a mai primi valori de la tastatură.
Date de ieșire:
Programul va afișa pe patru linii: numărul de valori, minimul, maximul și media aritmetică rotunjită la două zecimale.
Restricții și precizări:
Fișierul conține cel puțin un număr natural, iar numerele au cel mult 4 cifre.
Exemplu:
Intrare:
12 7 45 8 33
Ieșire:
4 7 45 24.0
Cum gândim soluția:
- Citim liniile fișierului cu
readlines() - Transformăm fiecare linie în număr cu
int(linie.strip()) - Aplicăm len, min, max și media cu sum / len
- Rotunjim media cu
round(media, 2)și afișăm rezultatele
Scrie soluția în Python:
Soluție corectă:
f = open("numere.txt", "r")
linii = f.readlines()
f.close()
v = []
for linie in linii:
v.append(int(linie.strip()))
print(len(v))
print(min(v))
print(max(v))
print(round(sum(v) / len(v), 2))
Ce învățăm: citirea linie cu linie și conversia cu int(linie.strip()) fac datele din fișier utilizabile în calcule.
Exercițiul Practic: Aplicația de generare a seriei
Sarcini de lucru
Completează cele două sarcini pentru a-ți consolida aplicația cu fișiere text și biblioteca random
Sarcina 1: Generare și afișare inversă
Cerință: Scrie un program care generează 20 de numere aleatoare din intervalul [1, 50], le salvează în fișierul "serie.txt" (câte unul pe linie), apoi le citește din fișier și le afișează în ordine inversă.
Soluție:
import random
f = open("serie.txt", "w")
for i in range(20):
f.write(str(random.randint(1, 50)) + "\n")
f.close()
f = open("serie.txt", "r")
v = f.readlines()
f.close()
for i in range(len(v) - 1, -1, -1):
print(int(v[i].strip()))
Verifică: salvarea se face cu open în modul "w" și write, iar citirea readlines permite parcurgerea inversă a liniilor cu un for descrescător.
Sarcina 2: Numărarea valorilor pare și peste medie
Cerință: Scrie un program care citește din fișierul "serie.txt" numerele salvate, calculează media lor și afișează câte valori sunt pare și câte valori sunt mai mari decât media.
Soluție:
f = open("serie.txt", "r")
v = [int(linie.strip()) for linie in f.readlines()]
f.close()
media = sum(v) / len(v)
pare = 0
peste_medie = 0
for x in v:
if x % 2 == 0:
pare = pare + 1
if x > media:
peste_medie = peste_medie + 1
print("Pare:", pare)
print("Peste medie:", peste_medie)
Verifică: list comprehension transformă liniile fișierului direct într-o listă de numere, apoi două contoare parcurg lista cu condiții.