Ce cuprinde sinteza?
Această pagină este breviarul complet al Modulului 5: definițiile cheie, algoritmii principali în pseudocod și în Python, tabelele recapitulative, regulile de aur și greșelile frecvente - tot ce trebuie recapitulat înaintea evaluării finale.
Subprograme - definiții cheie
Definiție: Un subprogram (funcție) este un bloc de cod cu un nume, rulabil de mai multe ori dintr-un singur loc. Se definește cu def, are antet (linia cu def, nume și paranteze), corp (instrucțiunile indentate) și se folosește prin apel (numele urmat de paranteze).
| Noțiune | Definiție | Exemplu |
|---|---|---|
| def | Cuvântul cheie care definește o funcție | def arie(L, l): |
| Parametru | Datele de intrare ale funcției | L, l din antet |
| Argument | Valoarea concretă transmisă la apel | arie(5, 3) |
| return | Trimite valoarea înapoi locului de apel | return L * l |
| Variabilă locală | Definită în interiorul funcției, vizibilă doar acolo | total din corp |
| Variabilă globală | Definită în afara funcțiilor, vizibilă peste tot | x = 10 în program |
Reține: după return, funcția se oprește. O funcție fără return întoarce implicit None. Print doar afișează, return trimite valoarea înapoi.
def dublu(x):
rezultat = 2 * x # rezultat este variabilă locală
return rezultat # valoarea pleacă înapoi către apel
a = 5 # a este variabilă globală
print(dublu(a)) # afișează 10
# print(rezultat) # EROARE! rezultat nu există în afara funcției
| Variabilă locală | Variabilă globală |
|---|---|
| Definită în interiorul funcției | Definită în afara funcțiilor |
| Vizibilă doar în interiorul funcției | Vizibilă în tot programul |
| Nu poate fi citită din afara funcției | Poate fi citită din orice funcție |
| Se creează la fiecare apel și dispare la ieșire | Există pe tot parcursul programului |
Funcțiile predefinite - tabel recapitulativ
| Funcție | Rol | Exemplu | Rezultat |
|---|---|---|---|
| abs(x) | Valoarea absolută (elimină semnul) | abs(-7) | 7 |
| int(x) | Taie partea zecimală / convertește în întreg | int(3.9) | 3 |
| round(x) | Rotunjește la cel mai apropiat întreg | round(3.6) | 4 |
| round(x, n) | Rotunjește la n zecimale | round(3.14159, 2) | 3.14 |
| math.sqrt(x) | Rădăcina pătrată (cu import math) | math.sqrt(16) | 4.0 |
| len(v) | Numărul de elemente dintr-o colecție | len([2, 4, 6]) | 3 |
| min(v) | Cel mai mic element | min([3, 9, 5]) | 3 |
| max(v) | Cel mai mare element | max([3, 9, 5]) | 9 |
| sum(v) | Suma elementelor | sum([1, 2, 3]) | 6 |
Atenție la diferențe: int taie, round rotunjește. sqrt necesită import math și apel math.sqrt(x). min/max/sum pe o listă goală dau ValueError.
import math print(int(3.9)) # 3 - taie partea zecimală print(round(3.9)) # 4 - rotunjește la cel mai apropiat întreg print(abs(-7)) # 7 - elimină semnul print(round(3.14159, 2)) # 3.14 - rotunjire la 2 zecimale print(math.sqrt(16)) # 4.0 - rădăcină pătrată (din modulul math)
Fișiere text - reguli și funcții
| Funcție | Rol | Exemplu |
|---|---|---|
| open(fisier, mod) | Deschide fișierul pentru lucru | f = open("date.in", "r") |
| read() | Citește tot conținutul ca un singur șir | continut = f.read() |
| readline() | Citește o singură linie | n = int(f.readline()) |
| readlines() | Citește toate liniile într-o listă | linii = f.readlines() |
| write() | Scrie un șir în fișier (cu str() pentru numere) | f.write(str(x) + " ") |
| close() | Închide fișierul - obligatoriu la final | f.close() |
Modurile de deschidere: "r" (citire), "w" (scriere - șterge conținutul vechi), "a" (adăugare la sfârșit). La citire, o buclă for peste fișier parcurge liniile până la EOF (sfârșitul fișierului).
f = open("date.in", "r")
v = [int(x) for x in f.read().split()]
f.close()
rezultat = sum(v)
g = open("date.out", "w")
g.write(str(rezultat) + "
")
g.close()
| Consolă (tastatură / ecran) | Fișier text |
|---|---|
| Citire cu input() | Citire cu read(), readline(), readlines() |
| Afișare cu print() | Scriere cu write() |
| Datele dispar la închiderea programului | Datele rămân pe disc după rulare |
| Potrivit pentru programe mici, interactive | Potrivit pentru volume mari de date, reutilizabile |
f = open("numere.txt", "r")
s = 0
for linie in f: # parcurge fișierul până la sfârșit (EOF)
s = s + int(linie) # int() ignoră caracterul \n de la finalul liniei
f.close()
print(s)
Tkinter și programarea orientată pe obiecte
| Element | Rol | Exemplu |
|---|---|---|
| Tk() | Fereastra principală a aplicației | fereastra = Tk() |
| Label | Etichetă de text | Label(fereastra, text="Salut") |
| Entry | Casetă de text; conținutul cu get() | caseta = Entry(fereastra) |
| Button | Buton cu acțiune (command) | Button(f, text="Apasa", command=salut) |
| messagebox | Casete de dialog: showinfo, showwarning, showerror | messagebox.showinfo("Titlu", "Mesaj") |
| mainloop() | Bucla de evenimente care ține fereastra deschisă | fereastra.mainloop() |
| Clasă | Tip de date care descrie o structură | list, str, Tk, Label |
| Obiect | Instanță a unei clase, creată prin apelarea ei | v = [1, 2, 3] |
| Metodă | Acțiune a obiectului, apelată cu punctul | v.append(4), v.sort() |
Reține: command=salut fără paranteze (funcția rulează la clic); command=salut() ar rula-o imediat. Obiectele grafice se așază cu pack() sau grid().
Explicație clară: Clasa este tipul (planul), obiectul este instanța creată prin apelarea clasei, iar metoda este o acțiune a obiectului, apelată cu punctul. În Tkinter, Tk() creează obiectul fereastră, iar Label(), Entry() și Button() creează obiecte plasate în ea cu pack() sau grid(). Fără mainloop(), fereastra se deschide și se închide imediat.
Algoritmii principali - pseudocod și cod
def maxim(a, b):
if a > b:
return a
return b
def prim(n):
if n < 2:
return False
for i in range(2, n):
if n % i == 0:
return False
return True
def palindrom(n):
oglindit = 0
copie = n
while n > 0:
oglindit = oglindit * 10 + n % 10
n = n // 10
return copie == oglindit
n = int(input())
v = list(map(int, input().split()))
f = open("date.out", "w")
for x in v:
if prim(x):
f.write(str(x) + "
")
f.close()
Comparații esențiale pentru test
| Parametru | return |
|---|---|
| Datele de intrare ale funcției | Valoarea de ieșire a funcției |
| Se declară în antet, între paranteze | Se scrie în corp, urmat de valoare |
| Primește valoare la fiecare apel (argument) | Trimite o singură valoare înapoi |
| Fără parametri, funcția lucrează cu date fixe | Fără return, funcția întoarce None |
Diferența cheie: print arată valoarea pe ecran, dar nu o pune la dispoziția programului; return o trimite efectiv înapoi, ca să poată fi folosită în calcule.
Ce trebuie să știi pentru test
Parcurge această listă înainte de test:
- Scrii o funcție corect: def, parametri, corp indentat, return.
- Deosebești parametrul de argument și variabila locală de variabila globală.
- Aplici funcțiile predefinite: abs, int, round, math.sqrt, len, min, max, sum.
- Distingi int (taie) de round (rotunjește) și știi când ai nevoie de import math.
- Deschizi, citești, scrii și închizi un fișier: open, read/readline/readlines, write, close.
- Recunoști modurile "r", "w", "a" și efectul fiecăruia asupra fișierului.
- Construiești o fereastră Tkinter: Tk, Label, Entry, Button, pack/grid, mainloop.
- Identifici clasa, obiectul, instanțierea și accesul la membri cu punctul.
- Rezolvi o problemă integrată (funcții + liste + fișiere) în ordinea citire - prelucrare - afișare sau salvare.
- Verifici un program cu un tabel de urmărire pe valori mici.
Mini-provocări de recapitulare (cu rezolvare)
Provocarea 1: media cu funcție
Cerință: Scrie o funcție media(v) care întoarce media aritmetică a elementelor unei liste, apoi afișează media listei [8, 9, 10] rotunjită la 2 zecimale.
def media(v):
return sum(v) / len(v)
print(round(media([8, 9, 10]), 2)) # 9.0
Provocarea 2: numerele prime în fișier
Cerință: Scrie un program care citește din fișierul "date.in" o listă de numere, iar în "date.out" scrie numerele prime dintre ele, câte unul pe linie.
def prim(n):
if n < 2:
return False
for i in range(2, n):
if n % i == 0:
return False
return True
f = open("date.in", "r")
v = [int(x) for x in f.read().split()]
f.close()
g = open("date.out", "w")
for x in v:
if prim(x):
g.write(str(x) + "\n")
g.close()
Provocarea 3: găsește eroarea
Cerință: Găsește și corectează eroarea din programul de mai jos: el ar trebui să afișeze dublul lui 7, dar afișează None.
def dublu(x):
print(2 * x)
rezultat = dublu(7)
print(rezultat) # afișează None, nu 14
Răspuns: funcția folosește print în loc de return. Corect: return 2 * x, iar afișarea se face în programul principal cu print(dublu(7)).
Greșeli frecvente la test
Aceste erori costă puncte în plus față de cele obișnuite:
- Lipsa int() la citire - valoarea rămâne șir și calculul eșuează.
- Print în loc de return în funcții - funcția întoarce None.
- Modul "w" în loc de "r" - fișierul de intrare se golește.
- Scrierea fără str() - f.write(x) dă TypeError.
- Uitarea close() - datele nu ajung complet în fișier.
- Contoare neinițializate - valoarea de pornire trebuie setată.
- Condiții inversate la min/max - folosim < pentru minim și > pentru maxim.
- command=salut() cu paranteze - funcția rulează la definire, nu la clic.
- Uitarea mainloop() - fereastra se închide imediat.
- Lista goală la min/max/sum - se verifică întâi lungimea.
Reguli de aur și greșeli frecvente
Reguli de aur:
- Suma se inițializează cu 0, produsul cu 1.
- Fiecare open() are un close() la final.
- O funcție face un singur lucru, bine definit.
- La verificarea numerelor prime, n < 2 nu este prim; 2 este singurul prim par.
- La descompunerea în cifre, n % 10 extrage ultima cifră, n // 10 o elimină.
Greșeli frecvente:
- Lipsa int(input()) - valorile citite rămân șiruri de caractere.
- Print în loc de return în funcții.
- Modul "w" în loc de "r" - fișierul existent este șters.
- Scrierea numerelor fără str() - TypeError la write.
- command=salut() cu paranteze - funcția rulează prematur.
- Uitarea mainloop() - fereastra se închide imediat.