7. lecke
Függvények
A függvény egy újrahasznosítható kódrész: egyszer megírod, és bárhonnan meghívhatod. Ebben a leckében megtanulod, hogyan írj függvényt paraméterekkel és visszatérési értékkel (return), mi a különbség a print() és a return között, hogyan adj meg alapértelmezett paramétert, és egy gyakorlati példán listát dolgozol fel függvénnyel.
- Miért kell függvény?
- Függvény paraméterekkel
- Függvény visszatérési értékkel — return
- Különbség: print() vs return
- Alapértelmezett (default) paraméter
- Gyakorlati példa — függvény listával
- Olvasási idő: kb. 5 perc (a kódok kipróbálásával több)
- 6 rész · 16 kódpélda
- A végén gyakorló feladatok ellenőrzik a tudásodat

1. Miért kell függvény?
def koszontes():
print("Szia!")
print("Üdv a Python világában!")koszontes() # ez futtatja le a fenti kódot koszontes() # újra lefuttatja — akárhányszor hívhatjuk
Mi történik valójában, amikor definiálok egy függvényt, majd hívom? Ez két külön lépés, amit fontos megkülönböztetni. Amikor leírod a "def koszontes():" sort és alá a törzsét, a Python ekkor még nem futtatja le a benne lévő kódot — csak megjegyzi, "eltárolja" a memóriában, hogy "ha valaki majd meghívja a koszontes nevű dolgot, ezt kell csinálni." csak amikor később leírod: koszontes() (a zárójellel!), a Python ténylegesen végrehajtja a törzsben lévő utasításokat. Ez olyan, mintha egy receptet írnál le (a definíció), amit utána tetszőleges sokszor "meg lehet főzni" (a hívás) — maga a receptleírás nem süt meg semmit, csak akkor történik valami, amikor ténylegesen nekiállsz elkészíteni.
Igen, erre valók a docstringek: közvetlenül a def sor alá írt, hármas idézőjeles szöveg ("""Ez a függvény ezt csinálja."""), ami dokumentálja a függvény célját. Sok szerkesztő ezt automatikusan megmutatja, amikor a függvény nevére viszed az egeret, úgyhogy nem kell megnyitni a kódot ahhoz, hogy megtudd, mire való.
Miért éri meg egyáltalán ezt a 'kétlépéses' dolgot csinálni, ahelyett hogy egyszerűen kétszer leírnám a print()-eket? A gyakorlati előny akkor mutatkozik meg igazán, ha a kódrészlet hosszabb, vagy ha később módosítanod kell rajta. Ha 10 helyen hívnád meg ugyanazt a logikát (mint most a koszontes()), de külön-külön leírva mind a 10 helyen, és egyszer módosítanod kellene valamit rajta, mind a 10 helyen külön kellene javítanod — könnyű helyet téveszteni, hibázni. Függvénnyel egyetlen helyen kell módosítanod (a definícióban), és a változás automatikusan érvényesül minden olyan helyen, ahol meghívod.
2. Függvény paraméterekkel
def koszontes_nevvel(nev):
print("Szia,", nev, "!")koszontes_nevvel("Norbi")
koszontes_nevvel("Anna")Mi történik pontosan, amikor koszontes_nevvel('Norbi')-t hívok — hogyan 'kerül be' a 'Norbi' a nev változóba? Amikor definiálod a függvényt (def koszontes_nevvel(nev):), a "nev" itt egy üres helytartó (placeholder) — olyan, mint egy címke nélküli doboz, ami arra vár, hogy megtöltsék. Amikor hívod a függvényt (koszontes_nevvel("Norbi")), a Python veszi a zárójelben megadott értéket ("Norbi"), és beleteszi ezt az üres "nev" dobozba, mielőtt lefuttatná a függvény törzsét. Ez azt jelenti, hogy a "nev" minden egyes hívásnál újra megkaphat egy más értéket — ez az, ami lehetővé teszi, hogy ugyanazt a logikát (Szia, X, !) többféle bemenettel is le tudd futtatni, anélkül, hogy külön-külön meg kellene írnod minden névhez egy saját függvényt.
def bemutatkozas(nev, kor):
print(nev, "vagyok,", kor, "éves.")bemutatkozas("Norbi", 27)
bemutatkozas("Anna", 25)A Python alapértelmezés szerint a sorrend alapján párosít — az első megadott érték az első paraméterhez kerül, a második a másodikhoz, és így tovább. Ez azt jelenti, hogy ha felcserélnéd: bemutatkozas(27, "Norbi"), a Python ténylegesen megpróbálná ezt lefuttatni (nem adna hibát!), de a kimenet értelmetlen lenne: "27 vagyok, Norbi éves." — a Python nem "tudja", mi a logikus jelentés, csak vakon követi a pozíció szerinti párosítást. (Van egy fejlettebb módszer is, az ún. "kulcsszavas argumentumok" — bemutatkozas(kor=27, nev="Norbi") —, amivel a sorrend nem számítana, mert név szerint párosítanál, de ezt egyelőre nem kell megjegyezned, csak tudnod, hogy létezik.)
3. Függvény visszatérési értékkel — return
def osszead(a, b):
eredmeny = a + b
return eredmenyszumma = osszead(5, 3) print(szumma) print(osszead(10, 20))
Mit csinál pontosan a return, mi történik a 'eredmeny' változóval utána? A return két dolgot csinál egyszerre: (1) azonnal leállítja a függvény futását (minden, ami a return után következne a függvényben, már nem fut le), és (2) "kidobja" a megadott értéket a függvényből, odaadva annak a helynek, ahol a függvényt hívták. Ez azt jelenti, hogy amikor leírod: szumma = osszead(5, 3), a Python pontosan úgy kezeli ezt, mintha az osszead(5, 3) rész egyszerűen "átváltozna" a visszaadott értékre (8-ra) — tehát olyan, mintha azt írtad volna: szumma = 8. Az "eredmeny" nevű változó, ami a függvényen belül létezett, egyáltalán nem látható kívülről — ez egy ún. "lokális változó", ami csak addig él, amíg a függvény fut, utána "eltűnik" a memóriából.
Igen: return a, b — vesszővel elválasztva — egyszerre két (vagy több) értéket ad vissza, amit a hívó oldalon így vehetsz át: x, y = fuggveny(). A háttérben ez valójában egyetlen, rendezett pár (tuple) értékként adódik vissza, amit a Python automatikusan szétbont a két változóba.
4. Különbség: print() vs return
def csak_kiir(szam):
print(szam * 2)def visszaad(szam):
return szam * 2eredmeny1 = csak_kiir(5) print(eredmeny1) # None — mert a függvény nem adott vissza semmit!
eredmeny2 = visszaad(5) print(eredmeny2) # 10
Miért None, és mi az a None egyáltalán? A None a Python egyik különleges, beépített értéke, ami szó szerint azt jelenti: "itt nincs érték." Amikor a csak_kiir(5) függvényt hívod, az valóban kiírja a képernyőre a 10-et (a print() miatt) — de a függvény maga nem ad vissza semmit a return-nel, mert nincs benne return sor! Amikor a Python egy függvényt úgy fejez be, hogy nem találkozott return-nel, automatikusan None-t "ad vissza" (ez egy hallgatólagos alapértelmezés). Ez az egyik leggyakoribb kezdő hiba: összekeverni a "kiírást" (amit a felhasználó lát a képernyőn) a "visszaadással" (amit a program tud továbbhasználni egy változóban). A print() a felhasználónak szól, a return a programnak — a kettő teljesen független egymástól.
Igen, nagyon is: egy betanított neurális háló (13-14. lecke) valójában egy nagy függvény, aminek a bemenete az adat, a kimenete pedig a modell jóslata — a PyTorch-ban ezt is egyszerűen meghívod, mint egy függvényt (kimenet = model(bemenet)), a háttérben pedig pontosan az itt tanult elv fut le: bemenet be, számítás, kimenet vissza.
5. Alapértelmezett (default) paraméter
def koszontes_nyelven(nev, nyelv="magyar"):
if nyelv == "magyar":
print("Szia,", nev, "!")
elif nyelv == "angol":
print("Hello,", nev, "!")koszontes_nyelven("Norbi")
koszontes_nyelven("Norbi", "angol")Miért kell egyáltalán default érték, ha amúgy is meg tudom adni mindig a nyelvet? A default érték egy kényelmi funkció: lehetővé teszi, hogy a függvényt használó ember (aki lehet a jövőbeli te is, egy másik projektben) ne legyen köteles minden egyes paramétert mindig megadnia, ha a leggyakoribb esetben úgyis ugyanazt az értéket használná. Ez különösen hasznos, ha egy függvénynek sok paramétere van, de a legtöbb hívásnál ezek 90%-a ugyanaz az érték — ilyenkor csak azokat kell külön megadnod, amik eltérnek az alapértelmezettől, a többit a Python "magától kitölti."
6. Gyakorlati példa — függvény listával
def atlag_szamitas(szamok):
osszeg = sum(szamok) # a sum() beépített függvény összeadja a lista elemeit
darab = len(szamok) # a len() megadja a lista hosszát
return osszeg / darabjegyek = [5, 4, 5, 3, 4]
atlag = atlag_szamitas(jegyek)
print("Az átlag:", atlag)Miért jó, ha egy függvény egész listát kap paraméterként, ahelyett hogy külön paramétert adnék minden jegyre? Emlékezz a 7. leckében korábban tárgyalt problémára (fix paraméterek vs. lista): ha a függvény listát vár, tetszőleges számú jegyet tudsz átadni neki — 3-at, 5-öt, 20-at — anélkül, hogy módosítanod kellene a függvény definícióját. Ez sokkal rugalmasabb, mint pl. def atlag_szamitas(jegy1, jegy2, jegy3): írni, ami pontosan 3 jegyre lenne "beégetve", és sosem tudnál vele 4 vagy 5 jegyet kezelni módosítás nélkül.
- Írj egy függvényt, ami két számot szoroz össze, és return-nel visszaadja az eredményt.
- Írj egy függvényt "eldontoti_paros" néven, ami egy számot kap paraméterként, és True-t ad vissza, ha páros, False-t, ha páratlan.
- Írj egy függvényt, ami egy listát kap, és visszaadja a legnagyobb elemet.
- Új gyakorlat: írj egy függvényt, ami csak print()-et használ, nincs benne return, majd próbáld meg az eredményét egy másik számmal összeadni (pl. eredmeny = fuggvenyed(5); print(eredmeny + 10)) — nézd meg pontosan a hibaüzenetet, és gondold át, miért történik ez a fentebb olvasott None-magyarázat alapján.