clasa a IX-a · Python · Subprograme · lecția 8
Subprograme (1): definire, parametri, apel
100 minmate-info · Python
Înainte de lecția asta: IX.2 De la pseudocod (sau C++) la Python, IX.6 cmmdc și algoritmul lui Euclid
Ce vei ști după lecție
- Explici rolul unui subprogram și identifici antetul, corpul, parametrii și valoarea returnată.
- Definești funcții cu def, le apelezi cu argumente potrivite și folosești return, inclusiv pentru mai multe valori.
- Urmărești mecanismul de executare al apelurilor, inclusiv când o funcție apelează altă funcție.
- Descompui o problemă simplă în subprograme și testezi fiecare subprogram separat.
Lecția are și o fișă de lucru, de rezolvat după ce o citești. Mergi la fișă ↓
Clasa a IX-aLecția 8 din 21 · mai sunt 13Urmează: IX.9 · Subprograme (2): variabile locale și globale, funcții predefiniteVezi toate lecțiile
Fișiere PDF și de lucru
- Lecția în PDF
versiunea de printat
- Fișa de lucru: Subprograme (1): definire, parametri, apel
6 pagini · 100 min
1. De ce avem nevoie de subprograme
În lecția py9-06, la operațiile cu fracții, bucla lui Euclid apărea identic de mai multe ori. Dacă găseai o greșeală în ea, trebuia s-o corectezi peste tot. Un subprogram (în Python: funcție) este o secvență de instrucțiuni cu un nume, scrisă o singură dată și apelată de câte ori ai nevoie.
Câștigi reutilizare (scrii cmmdc o dată, îl folosești în zece programe), claritate ( if este_prim(x): se citește ca o propoziție), testare separată (verifici fiecare funcție pe cazurile ei) și lucru în echipă (fiecare scrie un modul, apoi modulele se asamblează). Ai folosit deja subprograme predefinite: print, input, int, abs. Acum le scrii pe ale tale.
2. Definirea: antet și corp
def arie(lungime, latime): # ANTETUL: def, numele, parametrii, două puncte
s = lungime * latime # CORPUL: instrucțiunile indentate
return s # rezultatul trimis înapoi
print(arie(20, 15)) # apel → 300
print(arie(12.5, 8)) # alt apel → 100.0
total = arie(20, 15) + arie(10, 10)
print(total) # 400| C++ | Python | |
|---|---|---|
| antet | int arie(int lungime, int latime) |
def arie(lungime, latime): |
| corpul | între { } |
blocul indentat |
| tipuri | declarate pentru parametri și rezultat | nu se declară |
| fără rezultat | void f() |
o funcție fără return (întoarce None) |
Definiția doar „învață” programul ce înseamnă arie ; nu execută nimic. Corpul rulează abia la apel. De aceea, funcția trebuie definită înainte de primul apel care se execută.
3. Parametri și argumente
- Parametrii sunt numele din antet (
lungime,latime). Sunt ca niște variabile ale funcției, care primesc valori la fiecare apel. - Argumentele sunt valorile date la apel (
20,15, sauL, sau2 * x + 1). Ele se potrivesc cu parametrii în ordine: primul argument merge în primul parametru și așa mai departe.
def pret_final(pret, reducere): # reducere în procente
return pret - pret * reducere / 100
print(pret_final(200, 15)) # 170.0
print(pret_final(15, 200)) # -15.0: ordinea contează!
print(pret_final(reducere=15, pret=200)) # 170.0: argumente cu numeNumărul argumentelor trebuie să fie egal cu numărul parametrilor: pret_final(200) dă TypeError: pret_final() missing 1 required positional argument: 'reducere'. O funcție poate avea și zero parametri: def meniu(): se apelează cu meniu(). Parantezele sunt obligatorii.
4. return: rezultatul și ieșirea din funcție
return valoare face două lucruri: trimite valoarea în locul apelului și oprește imediat funcția. Poți avea mai multe return-uri, pe ramuri diferite:
def este_prim(n):
if n < 2:
return False # ieșire rapidă pentru 0 și 1
d = 2
while d * d <= n:
if n % d == 0:
return False # am găsit un divizor: nu mai căutăm
d += 1
return True # ajungem aici doar dacă nu am găsit niciunul
print(este_prim(1), este_prim(2), este_prim(91), este_prim(97)) # False True False TrueMai multe valori deodată. Scrii valorile separate prin virgulă și le primești în tot atâtea variabile:
def ore_minute(m):
return m // 60, m % 60
h, mn = ore_minute(135)
print(h, mn) # 2 15Atenție — greșeli frecvente
print nu este return. O funcție care doar afișează rezultatul nu îl dă înapoi: r = f(5) primește None, iar f(5) + 1 dă eroare. Regula: funcțiile care calculează returnează; afișarea o face programul principal.
5. Mecanismul de executare
La fiecare apel, Python:
- calculează argumentele;
- creează un cadru de apel (un „spațiu de lucru” nou) în care parametrii primesc valorile argumentelor;
- execută corpul funcției;
- la
return(sau la sfârșitul corpului) șterge cadrul și se întoarce exact în locul apelului, cu valoarea returnată.
Când o funcție apelează altă funcție, cadrele se pun unul peste altul, ca o stivă: ultimul apelat este primul care se termină. Am pus print-uri ca să vedem ordinea:
def cmmdc(a, b):
print(" intru în cmmdc cu", a, b)
while b != 0:
a, b = b, a % b
print(" ies din cmmdc cu", a)
return a
def cmmmc(a, b):
print(" intru în cmmmc cu", a, b)
r = a // cmmdc(a, b) * b
print(" ies din cmmmc cu", r)
return r
print("încep")
print(cmmmc(60, 90))
print("gata")încep
intru în cmmmc cu 60 90
intru în cmmdc cu 60 90
ies din cmmdc cu 30
ies din cmmmc cu 180
180
gataÎn interiorul lui cmmdc, stiva este: cmmdc(a=60, b=90) deasupra lui cmmmc(a=60, b=90), deasupra programului principal. După return 30, cadrul lui cmmdc dispare, iar cmmmc continuă: r = 60 // 30 * 90 = 180. Observă că cmmdc își modifică propriii a și b (ajung 30 și 0), dar a și b din cmmmc rămân 60 și 90. Fiecare cadru are variabilele lui. Despre asta vorbim pe larg în lecția py9-09.
6. Proiectare modulară: o problemă, trei subprograme
Problema (din programă): câte numere dintr-un șir citit au suma cifrelor un număr prim?
Analiză. Cerința se sparge în bucăți independente: (1) suma cifrelor unui număr; (2) testul de primalitate; (3) parcurgerea șirului și numărarea. Fiecare devine un modul.
def suma_cifrelor(n):
s = 0
while n > 0:
s += n % 10
n //= 10
return s
def este_prim(n):
... # exact ca în secțiunea 4
# programul principal
c = 0
for x in map(int, input().split()):
if este_prim(suma_cifrelor(x)):
c += 1
print(c)Pentru intrarea 12 29 47 100 55 afișează 3 (sumele sunt 3, 11, 11, 1, 10).
Testare pe module. Înainte să rulezi tot programul, testezi fiecare funcție separat:
| apel | așteptat | de ce acest test |
|---|---|---|
suma_cifrelor(9081) |
18 |
caz obișnuit, cu un 0 în mijloc |
suma_cifrelor(0) |
0 |
bucla nu se execută |
este_prim(1) |
False |
1 nu este prim |
este_prim(2) |
True |
cel mai mic prim |
este_prim(91) |
False |
7 · 13: „pare” prim |
Testele se pot automatiza cu assert suma_cifrelor(9081) == 18: dacă trece, nu se întâmplă nimic; dacă nu, programul se oprește cu AssertionError și știi exact ce modul să repari.
La BAC
La Bac, subprogramele se cer de obicei cu antet precizat („Scrieți definiția completă a subprogramului f, cu parametrii…”). Respectă exact numele, ordinea parametrilor și ce se returnează. Nu citi și nu afișa în funcție decât dacă ți se cere.
7. Verifică-te
- Care este antetul, care este corpul și care sunt parametrii în
def medie(a, b, c): return (a + b + c) / 3? - Ce afișează
def dublu(x): return 2 * xurmat deprint(dublu(dublu(3)) + dublu(1))? - Ce afișează programul următor și de ce?
def f(n):
if n % 2 == 0:
return "par"
print("impar")
print(f(4), f(7))- Scrie o funcție
min_max(a, b)care returnează mai întâi minimul, apoi maximul. - În ce ordine se afișează mesajele?
def a():
print("A")
def b():
print("B1")
a()
print("B2")
b()
a()Fișa de lucru
Ai citit lecția? Printează fișa sau deschide-o pe ecran și rezolvă exercițiile în ordine.
Fișă de lucru · 6 pagini · 100 min
Subprograme (1): definire, parametri, apel
- Prezici rezultatul apelurilor, inclusiv al celor imbricate și al funcțiilor fără return.
- Repari greșelile tipice: print în loc de return, return prea devreme, apel înainte de definiție, antet „ca în C++”.
- Scrii funcții cu antetul cerut, le testezi separat și le combini într-un program modular.
Te-ai blocat la un exercițiu?
Probleme de lucru
Începe cu acestea, în ordine. Problemele se deschid pe pbinfo.ro, unde trimiți soluția și primești punctajul.
- ușoară
nrpal#368
https://www.pbinfo.ro/probleme/368/nrpal
numarperfect#64
https://www.pbinfo.ro/probleme/64/numarperfect
Temă
Rezolvă-le singur și bifează ce ai terminat. Bifele rămân salvate în acest browser.
- ușoară
prietene#1574
https://www.pbinfo.ro/probleme/1574/prietene
urmatorul-prim#375
https://www.pbinfo.ro/probleme/375/urmatorul-prim
Te-ai blocat la lecția asta?
Scrie-mi ce nu iese și vedem împreună de unde se blochează.
Răspunsuri
- Antetul:
def medie(a, b, c):; corpul:return (a + b + c) / 3; parametrii:a,b,c. 14:dublu(dublu(3)) = dublu(6) = 12, plusdublu(1) = 2.- Întâi
impar(afișat în timpul apeluluif(7)), apoipar None.f(7)nu ajunge la niciunreturn, deci întoarceNone. Argumentele luiprintse calculează înainte de afișare. def min_max(a, b):·if a < b: return a, b·return b, a.B1,A,B2,A.