Új lapon nyílik meg

7. lecke

Függvények

6 rész16 kódpélda1 ábra
Miről szól ez a lecke?

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.

Amit ebben a leckében megtanulsz
  • 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
Tudnivalók
  • 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
Függvény mint gép: bemenet 5, kimenet 10
A függvény egy újrahasználható „gép": bemenetet kap, elvégez rajta egy műveletet, és visszaad egy kimenetet. Egyszer megírod, aztán bárhol meghívhatod.

1. Miért kell függvény?

PYTHON● ● ●
def koszontes():
    print("Szia!")
    print("Üdv a Python világában!")
PYTHON● ● ●
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.

SzéljegyzetÉrdemes leírni, mit csinál egy függvény, a kódon belül?

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

PYTHON● ● ●
def koszontes_nevvel(nev):
    print("Szia,", nev, "!")
PYTHON● ● ●
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.

PYTHON● ● ●
def bemutatkozas(nev, kor):
    print(nev, "vagyok,", kor, "éves.")
PYTHON● ● ●
bemutatkozas("Norbi", 27)
bemutatkozas("Anna", 25)
SzéljegyzetHonnan tudja a Python, hogy a 'Norbi' a nev-hez, a 27 pedig a kor-hoz tartozik — mi van, ha felcserélem a sorrendet híváskor?

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

PYTHON● ● ●
def osszead(a, b):
    eredmeny = a + b
    return eredmeny
PYTHON● ● ●
szumma = 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.

SzéljegyzetTud egy Python-függvény egyszerre több értéket is visszaadni?

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

PYTHON● ● ●
def csak_kiir(szam):
    print(szam * 2)
PYTHON● ● ●
def visszaad(szam):
    return szam * 2
PYTHON● ● ●
eredmeny1 = csak_kiir(5)
print(eredmeny1)   # None — mert a függvény nem adott vissza semmit!
PYTHON● ● ●
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.

SzéljegyzetElőfordul ez a 'függvényhívás' fogalom a valódi AI-rendszerekben is?

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

PYTHON● ● ●
def koszontes_nyelven(nev, nyelv="magyar"):
    if nyelv == "magyar":
        print("Szia,", nev, "!")
    elif nyelv == "angol":
        print("Hello,", nev, "!")
PYTHON● ● ●
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

PYTHON● ● ●
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 / darab
PYTHON● ● ●
jegyek = [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.

Gyakorlás
  1. Írj egy függvényt, ami két számot szoroz össze, és return-nel visszaadja az eredményt.
  2. Í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.
  3. Írj egy függvényt, ami egy listát kap, és visszaadja a legnagyobb elemet.
  4. Ú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.