Saját függvények.

Eddig is sok függvényt használtál: print(), input(), len(), random.randint(). Ezeket mások írták meg, te csak meghívod őket – nem kell tudnod, hogyan működnek belül, elég tudnod, mit adsz nekik és mit kapsz vissza. Ugyanilyen egységeket magad is készíthetsz.

def fuggveny_neve(parameter1, parameter2):
    """Rövid leírás: mit csinál a függvény."""
    utasítások
    return eredmény

• defkulcsszó: „definiálok egy függvényt”
• fuggveny_nevea név (snake_case, mint a változóké)
• (…)a paraméterek listája – lehet üres is
• : + behúzása függvény törzse
• returnaz eredmény visszaadása (nem kötelező)

def koszont():
    print("Szia!")
    print("Üdv a függvények világában.")

print("A program eleje.")
koszont()
koszont()
print("A program vége.")

Kövesd Lépésenként, és figyeld a sorrendet. A def sorban a Python csak megjegyzi a függvényt (a Memóriában megjelenik egy ƒ koszont() bejegyzés), de a törzse ekkor nem fut le. A program a „A program eleje.” kiírásával folytatódik; a törzs csak a koszont() hívásakor fut – mindkét hívásnál újra. A hívás végén a program a hívás utáni sorral folytatódik.

A gyakorló feladatok kezdő kódjában a még üres függvénytörzsben pass áll: ez az üres utasítás, amely ott szerepel, ahol a nyelvtan utasítást követel, de még nincs mit írni.

A paraméter a függvény fejlécében álló név; az argumentum a hívásnál átadott konkrét érték. A hívás pillanatában minden paraméter megkapja a neki megfelelő argumentum értékét – a sorrend dönti el, melyik melyiket, nem a név.

def bemutat(nev, kor):
    print(f"{nev} {kor} éves.")

bemutat("Anna", 17)
bemutat("Bence", 16)
x = "Csilla"
bemutat(x, 15)
bemutat(18, "Dóra")

A lépésenkénti nézetben minden hívásnál új keret (frame) jelenik meg a Memóriában a függvény nevével: ebben vannak a paraméterek a kapott értékkel. Az utolsó hívásnál a sorrend fel van cserélve – a Python ezt nem veszi észre, csak furcsa mondat lesz belőle. A függvény nem tudja, mit „akartunk”, csak azt, amit kapott.

A return két dolgot tesz: kiszámolja a mögötte álló kifejezés értékét, és ezt az értéket visszaadja a hívás helyére, közben azonnal befejezi a függvényt (ami utána áll, már nem fut le). A hívás helyén a függvényhívás „helyére kerül” az eredmény, amit aztán változóba tehetünk, kiírhatunk, vagy egy nagyobb kifejezésben használhatunk.

def negyzet(x):
    return x * x

a = negyzet(5)
print(a)
print(negyzet(3) + negyzet(4))
if negyzet(7) > 40:
    print("49 nagyobb 40-nél.")

return vagy print?

A kezdők leggyakoribb tévedése, hogy a függvényben kiírják az eredményt ahelyett, hogy visszaadnák. A print csak megmutatja az értéket a képernyőn – a program többi része nem tud vele tovább számolni. Ha egy függvényben nincs return, az eredménye a None („nincs érték”).

def dupla_kiir(x):
    print(x * 2)

def dupla(x):
    return x * 2

eredmeny1 = dupla(5)
eredmeny2 = dupla_kiir(5)
print("return-nel:", eredmeny1)
print("print-tel:", eredmeny2)
print(eredmeny1 + 1)
print(eredmeny2 + 1)

Az utolsó sor TypeError-ral leáll: a None-hoz nem lehet hozzáadni. Szabály: a függvény számoljon és adjon vissza; a kiírás a hívó dolga. Így a függvény bárhol újra felhasználható – kiírásra, további számolásra, feltételben is.

def f(x):
    if x > 0:
        return "pozitív"
    return "nem pozitív"
    print("Ez sosem fut le.")

print(f(3), f(0))

Igaz-hamis eredmény

Ha a függvény egy kérdésre válaszol („osztható-e?”, „prím-e?”), logikai értéket adjon vissza. Mivel egy összehasonlítás eredménye már maga is True vagy False, gyakran közvetlenül visszaadható:

def oszthato(szam, oszto):
    return szam % oszto == 0

for ev in [2024, 2025, 1900, 2000]:
    szokoev = (oszthato(ev, 4) and not oszthato(ev, 100)) or oszthato(ev, 400)
    print(ev, "szökőév" if szokoev else "nem szökőév")

A "szökőév" if szokoev else "nem szökőév" egy feltételes kifejezés: ha a feltétel igaz, az első, különben a második érték lesz az eredménye. Például "páros" if 4 % 2 == 0 else "páratlan" értéke "páros".

Ha a return után vesszővel több értéket írunk, a függvény egy tuple-t ad vissza, amelyet a hívásnál kicsomagolhatunk (4. modul).

def statisztika(szamok):
    legkisebb = min(szamok)
    legnagyobb = max(szamok)
    atlag = sum(szamok) / len(szamok)
    return legkisebb, legnagyobb, atlag

jegyek = [4, 5, 3, 5, 2]
mini, maxi, atl = statisztika(jegyek)
print(f"Legrosszabb: {mini}, legjobb: {maxi}, átlag: {atl:.2f}")
print(statisztika([10, 20]))

A függvényen belül értéket kapó változó (és minden paraméter) helyi (lokális): csak a függvény adott hívásának keretében létezik, és a függvény végén megszűnik. A fő programban létrehozott változó globális: a függvények olvashatják.

afa = 0.27

def brutto(netto):
    ado = netto * afa
    return netto + ado

print(brutto(1000))
print(afa)
print(ado)

Kövesd lépésenként: az ado csak a brutto() keretében jelenik meg, és a visszatéréskor a kerettel együtt eltűnik. Ezért az utolsó sor NameError-t ad – a fő program nem látja a függvény helyi változóját.

Árnyékolás: két azonos nevű változó

Ha a függvényben értéket adunk egy olyan névnek, amely globálisan is létezik, az egy új, helyi változót hoz létre, amely a függvényen belül eltakarja (árnyékolja) a globálisat. A globális változó nem változik meg.

nev = "globális"

def pelda():
    nev = "helyi"
    print("A függvényben:", nev)

pelda()
print("A függvény után:", nev)

A global kulcsszó – és miért kerüljük

Ha a függvénynek tényleg a globális változót kell módosítania, a global nev sorral jelezhetjük. Működik, de a programot nehezen követhetővé teszi, mert egy függvényhívás „észrevétlenül” megváltoztatja a fő program adatait. Jobb megoldás, ha a függvény paraméterként kapja meg, amire szüksége van, és return-nel adja vissza az eredményt.

szamlalo = 0

def novel_global():
    global szamlalo
    szamlalo += 1

def novel(ertek):
    return ertek + 1

novel_global()
novel_global()
print(szamlalo)
szamlalo = novel(szamlalo)
print(szamlalo)

pont = 10

def bonusz():
    pont = pont + 5
    return pont

print(bonusz())

def bonusz_helyben(pontok):
    pontok.append(5)

def bonusz_uj_listaval(pontok):
    pontok = pontok + [5]
    return pontok

eredmenyek = [10, 20]
bonusz_helyben(eredmenyek)
print(eredmenyek)
uj = bonusz_uj_listaval(eredmenyek)
print(eredmenyek, uj)

x = 10

def f(x):
    x = x * 2
    return x

y = f(x)
print(x, y)

A függvény törzsének első sorában álló szöveg a docstring (dokumentációs szöveg). Leírja, mit csinál a függvény, mit vár és mit ad vissza. A help() függvény és a fejlesztőkörnyezetek ezt mutatják meg, amikor valaki a függvényedet használja.

def erdemjegy(pont, maximum=100):
    """Visszaadja a pontszámhoz tartozó érdemjegyet (1–5).

    pont: az elért pontszám (0 és maximum között)
    maximum: az elérhető pontszám, alapból 100
    """
    szazalek = pont / maximum * 100
    if szazalek >= 85:
        return 5
    if szazalek >= 70:
        return 4
    if szazalek >= 55:
        return 3
    if szazalek >= 40:
        return 2
    return 1

print(erdemjegy(78))
print(erdemjegy(30, 40))
help(erdemjegy)

A maximum=100 alapértelmezett érték: ha a hívó nem adja meg, 100 lesz. Részletesen a 9. modulban.

Nagyobb programot érdemes úgy felépíteni, hogy a részfeladatok külön függvényekbe kerülnek, a fő program pedig csak „vezényel”: beolvas, hív, kiír. A függvények is hívhatnak más függvényeket. Kövesd lépésenként, hogyan rakódnak egymásra a keretek, amikor a prim_e belülről hívja az oszthato-t.

def oszthato(szam, oszto):
    return szam % oszto == 0

def prim_e(szam):
    """True, ha a szám prím; az 1 és a 2-nél kisebb számok nem prímek."""
    if szam < 2:
        return False
    oszto = 2
    while oszto * oszto <= szam:
        if oszthato(szam, oszto):
            return False
        oszto += 1
    return True

hatar = int(input("Meddig keressek prímeket? "))
primek = []
for n in range(1, hatar + 1):
    if prim_e(n):
        primek.append(n)
print(primek)