8. Eljárások és függvények

Ahogy egyre okosabb programokat írsz, a kódod elképesztően hosszúvá válhat. Ha egy bizonyos feladatot (például egy játékos életerejének kiszámítását) a program futása során többször is el kell végezni, nagyon rossz megoldás lenne a kódot újra és újra bemásolni.

A programozók egyik legfőbb szabálya a DRY elv (Don't Repeat Yourself - Ne ismételd önmagad!). Erre a problémára nyújtanak megoldást az eljárások és a függvények: segítségükkel a gyakran használt kódrészleteket "becsomagolhatjuk", adhatunk nekik egy nevet, és később egyetlen szóval bármikor újra előhívhatjuk őket.

8.1. Saját függvény létrehozása (A def kulcsszó)

A Pythonban egy függvényt a def (define = definiálás, meghatározás) kulcsszóval hozunk létre, amelyet a függvény neve, zárójelek, majd egy kettőspont követ. Az ehhez tartozó utasításokat itt is be kell húzni!

# 1. Lépés: A függvény létrehozása (definiálása)
def koszonto():
    print("Üdvözöllek a programban!")
    print("Jó munkát kívánok!")

# 2. Lépés: A függvény meghívása (használata)
koszonto()
print("...kis szünet...")
koszonto()  # Bármikor újra használhatjuk!

Fontos: Amikor megírod a def koszonto(): részt, a program még nem hajtja végre! Csak "megtanulja", hogy mit jelent ez a szó. A kód csak akkor fut le, amikor később a nevénél fogva meghívod!

8.2. Adatok átadása: A paraméterek

A függvényeink sokkal okosabbak lesznek, ha megengedjük, hogy a meghívásukkor adatokat adjunk át nekik. Ezeket a "fogadó" változókat a zárójelek között adjuk meg, és paramétereknek nevezzük.

# Ez a függvény vár egy "nev" paramétert
def szemelyes_koszonto(nev):
    print(f"Szia {nev}, örülök, hogy itt vagy!")

# Meghíváskor a zárójelben adjuk át a konkrét adatot (az argumentumot)
szemelyes_koszonto("Anna")
szemelyes_koszonto("Gergő")

8.3. Haladó paraméterezés (A "Pro" trükkök)

A Python nagyon rugalmas, ha a paraméterek megadásáról van szó. Számos kényelmi funkciót kínál:

1. Alapértelmezett értékek (Default argumentumok): Megadhatjuk, hogy mi legyen egy paraméter értéke, ha a felhasználó elfelejt (vagy nem akar) megadni semmit a meghíváskor.

def udvozles(nev="Ismeretlen", napszak="napot"):
    print(f"Jó {napszak} kívánok, {nev}!")

udvozles("Peti", "reggelt")  # Kimenet: Jó reggelt kívánok, Peti!
udvozles("Anna")             # Kimenet: Jó napot kívánok, Anna! (A napszak maradt az alapértelmezett)
udvozles()                   # Kimenet: Jó napot kívánok, Ismeretlen!

2. Kulcsszavas argumentumok (Keyword argumentumok): Ha egy függvénynek sok paramétere van, meghíváskor a nevük alapján is átadhatjuk az értékeket. Ilyenkor a sorrend egyáltalán nem számít!

udvozles(napszak="estét", nev="Gábor")  # Kimenet: Jó estét kívánok, Gábor!

3. Tetszőleges számú paraméter (*args): Mi van, ha nem tudjuk előre, hány számot akarunk összeadni? Ha egy paraméter neve elé csillagot teszünk (*), a Python az összes bedobott értéket egyetlen tuple-be (listába) csomagolja nekünk!

def sok_szam_kiirasa(*szamok):
    print(szamok)

sok_szam_kiirasa(1, 5, 8, 99, 2)  # Akármennyi számot bedobhatunk!

8.4. A visszatérési érték: A return kulcsszó

A valódi programozásban a függvények általában számolnak valamit, és az eredményt visszaadják a főprogramnak. Erre a return (visszatérés) kulcsszót használjuk.

def teglalap_terulet(a_oldal, b_oldal):
    terulet = a_oldal * b_oldal
    return terulet  # A függvény itt "kiköpi" magából az eredményt

# A függvény meghívása, és az eredmény elmentése egy változóba:
szoba_terulete = teglalap_terulet(4, 5)
print(f"A szoba területe: {szoba_terulete} négyzetméter.")

⚠️ A return megszakítja a függvényt! Amint a Python elér egy return utasításhoz, azonnal kilép a függvényből. Az alatta lévő kód már sosem fog lefutni!

8.5. Változók láthatósága (Lokális és Globális)

Ez az egyik leggyakoribb hibaforrás a kezdőknél! Nem mindegy, hogy egy változót hol hozunk létre a kódban. Kétféle láthatóságot (scope) különböztetünk meg:

• Lokális változók: Amelyeket a függvényen belül hozunk létre. Ezek csak és kizárólag a függvény belsejében léteznek. Amint a függvény lefut, ezek a változók azonnal megsemmisülnek! A főprogramból nem tudod elérni őket.
• Globális változók: Amelyeket a főprogramban, minden függvényen kívül (behúzás nélkül) hozunk létre. Ezeket a függvények "látják" és ki tudják olvasni, de alapértelmezetten nem tudják megváltoztatni az értéküket!

jelszo = "titok"  # Ez egy GLOBÁLIS változó

def teszt_fuggveny():
    titkos_szam = 42  # Ez egy LOKÁLIS változó
    print(f"A függvény látja a globális jelszót: {jelszo}")

teszt_fuggveny()
# print(titkos_szam)  <-- EZ HIBÁT OKOZNA! A titkos_szam itt már nem létezik.

A global kulcsszó: Ha egy függvényen belülről mindenképpen felül akarsz írni egy kinti (globális) változót, akkor a függvény elején ezt külön engedélyezned kell a global kulcsszóval:

pontszam = 0

def pontot_szerez():
    global pontszam  # Engedélyt kérünk a kinti változó módosítására!
    pontszam = pontszam + 1

pontot_szerez()
print(pontszam)  # Kimenet: 1

8.6. Dokumentációs stringek (Docstring)

Egy profi kódoló mindig dokumentálja, hogy mit csinál a függvénye. Ha a def sor alá közvetlenül egy többsoros stringet (""") írsz, azt a Python a függvény hivatalos dokumentációjának veszi. Ha később ráviszed az egeret a függvény nevére a VS Code-ban, ezt a szöveget fogja feldobni segítségként!

def atlag_szamitas(a, b):
    """
    Ez a függvény két számot vár paraméterként.
    Visszaadja a két szám matematikai átlagát lebegőpontos (float) értékként.
    """
    return (a + b) / 2

---

💻 Feladatok

1. Alapértelmezett paraméter: Írj egy kave_rendeles() nevű függvényt, amely két paramétert vár: fajta és meret. A meret alapértelmezett értéke legyen "Közepes". A függvény írja ki: "Egy {meret} {fajta} kávét kérek!". Hívd meg a függvényt egyszer úgy, hogy megadod a méretet (pl. "Nagy", "Espresso"), egyszer pedig úgy, hogy csak a fajtát (pl. "Latte")!
2. Láthatósági teszt (Scope):
   • Hozz létre egy globális változót: jatekos_elete = 100.
   • Készíts egy sebzodes() nevű függvényt, amely a global kulcsszó használatával csökkenti a jatekos_elete változó értékét 20-szal!
   • Hívd meg a függvényt kétszer, majd a főprogramban írasd ki a játékos maradék életét!
3. Valódi függvény return-nel és Docstringgel: Írj egy legnagyobb_kivalaszto(szam1, szam2, szam3) nevű függvényt!
   • Készíts hozzá egy rövid Docstringet, ami leírja, hogy a függvény a három szám közül a legnagyobbat adja vissza.
   • A függvény döntse el, melyik szám a legnagyobb, és adja vissza ezt az értéket a return kulcsszóval!
   • A főprogramban mentsd el a visszakapott értéket egy változóba, és ott írasd ki a képernyőre!