Python: függvények

Az eljárások és függvények utasítások sorozatából állnak, melyeket többször is fel tudunk használni. Segítségükkel átláthatóbb lehet a program, és nem kell ugyanazt a kódrészletet többször is megírni. Az eljárások és a függvények csak akkor kerülnek végrehajtásra, ha lefuttatjuk őket. Ezt a nevükkel tudjuk megtenni. Például a print() függvényt már elég sokszor használtuk. A Pythonban technikailag nincs külön „eljárás”, minden def kulcsszóval létrehozott blokk függvény, függetlenül attól, hogy van-e return utasítás. Pedagógiai szempontból célszerű volt külön választani őket.

Eljárások

Az eljárások olyan blokkok, amelyek végrehajtják a bennük található utasításokat, de nem térnek vissza semmilyen értékkel. Például kiírnak valamit, vagy adatot kérnek be. Az eljárásokat a def kulcsszóval lehet definiálni, majd a nevük segítségével hívhatók meg. Első példa: csinálunk egy udv nevű eljárást, ami kírja, hogy Helló! Ez egy paraméter nélküli eljárás, nem kap semmilyen adatot, egyszerűen csak végrehajtja a benne található utasítást.
A függvény nevének betűvel, vagy alulvonással kell kezdődnie, és betúket, számokat, alulvonást tartalmazhat. Figyeljünk a kis és nagybetűkre az elnevezéseknél!

def udv():
    print("Helló!")
# eljárás futtatása:
udv()

def udv():

print("Helló!")

# eljárás futtatása:

udv()

Paraméterek

Paraméter: adhatunk adatokat is egy eljárásnak, amivel tud „dolgozni”. Alapvetően annyi paramétert várunk, amennyit megadunk a függvény létrehozásakor. Paraméter bármilyen típusú adat lehet: string, number, list, dictionary… ) Adjunk az üdvözlő eljárásunknak egy nevet paraméterként! Paramétereket a zárójelbe tudunk megadni. Lehet többet is!

# eljárás 1 paraméterrel
def udv_nevvel(nev):
    print("Helló ",nev)
# futtatás:
udv_nevvel("Elek")

# eljárás több paraméterrel
def udv_teljesnevvel(vezeteknev, keresztnev):
    print("Helló: ", vezeteknev,keresztnev,sep=" ")
udv_teljesnevvel("Teszt","Elek")

def osszead(x,y):
print("Összeg: ",x+y)
osszead(20,30)

# eljárás 1 paraméterrel

def udv_nevvel(nev):

print("Helló ",nev)

# futtatás:

udv_nevvel("Elek")

# eljárás több paraméterrel

def udv_teljesnevvel(vezeteknev, keresztnev):

print("Helló: ", vezeteknev,keresztnev,sep=" ")

udv_teljesnevvel("Teszt","Elek")

def osszead(x,y):

print("Összeg: ",x+y)

osszead(20,30)

A paramétereknél meg lehet adni kulcsszavakat (keywords) is, amivel biztosítjuk, hogy melyik érték melyik paraméterhez tartozik! Ilyenkor nem muszáj sorrendben írni, hiszen a ‘kulcs’ egyértelműen azonosítja, melyik érték tartozik hozzá.

def my_function(allat, nev):
  print("Háziállat: ", allat)
  print("A háziállat", allat + "'meve:", nev)

my_function(allat = "kutya", nev = "Bodri")

def my_function(allat, nev):

print("Háziállat: ", allat)

print("A háziállat", allat + "'meve:", nev)

my_function(allat = "kutya", nev = "Bodri")

Meg lehet hívni vegyesen is a paramétereket, kulcsszavakkal és sorrend használatával.

Meg lehet adni típust is:

def osszead(x: int, y: int) -> int:
    return x + y

1 2	def osszead(x: int, y: int) -> int: return x + y

Megadhatunk akár listát is paraméternek. Összegezzük egy lista elemeit!

def osszegezd(lista):
    osszesen = 0
    for szam in lista:
        osszesen = osszesen + szam
    print("A számok összege: ", osszesen)
szamok = [3, 33, 99, 100]
osszegezd(szamok)

def osszegezd(lista):

osszesen = 0

for szam in lista:

osszesen = osszesen + szam

print("A számok összege: ", osszesen)

szamok = [3, 33, 99, 100]

osszegezd(szamok)

A paramétereknek lehet megadni alapértelmezett értéket is. Pl: adott falfelületet mennyiért burkolnak? Alapértelmezett érték 7800Ft/nm. Ha nem adjuk meg a 3. paramétert, akkor ezzel számol.

def kalkulator(szelesseg,magassag,nm_ar=7800):
    ar = szelesseg * magassag *nm_ar
    print("Burkolás költsége: ",ar)
kalkulator(3 , 2.75)
kalkulator(3 , 2.75, 12000)

def kalkulator(szelesseg,magassag,nm_ar=7800):

ar = szelesseg * magassag *nm_ar

print("Burkolás költsége: ",ar)

kalkulator(3 , 2.75)

kalkulator(3 , 2.75, 12000)

Dokstring használata: komment a függvényben:

def udv_nevvel(nev: str) -> None:
    """Kiírja a Helló üzenetet a megadott névvel."""
    print("Helló", nev)

def udv_nevvel(nev: str) -> None:

"""Kiírja a Helló üzenetet a megadott névvel."""

print("Helló", nev)

Args és kwargs avagy a csillagok

Pythonban az *args és a **kwargs két olyan speciális kifejezés, amivel a függvényeinket rendkívül rugalmassá tehetjük. Lehetővé teszik, hogy változó számú argumentumot adjunk át egy függvénynek. Nem kell előre tudni, hogy 2, 5 vagy 100 adatot fogunk felhasználni, ezek az eszközök „összecsomagolják” azokat. A * iterálható adattípusba (tuple) kicsomagolást a ** szótárba (dictionary) kicsomagolást végez.

*args: akkor használjuk, ha sima (név nélküli) listát akarsz átadni. A függvényen belül az értékeket egy tuple (módosíthatatlan lista) formájában kapjuk meg.

def osszegzes(*args):
    return sum(args)

print(osszegzes(1, 2, 3, 4)) # Eredmény: 10

def osszegzes(*args):

return sum(args)

print(osszegzes(1, 2, 3, 4)) # Eredmény: 10

**kwargs: ezzel kulcsszavakat rendelünk az értékekhez, szótárként (dictionary) kezeli az adatokat.

def koszones(**kwargs):
    for kulcs, ertek in kwargs.items():
        print(f"{kulcs}: {ertek}")

koszones(nev="Béla", koszones="Szia", varos="Budapest")

def koszones(**kwargs):

for kulcs, ertek in kwargs.items():

print(f"{kulcs}: {ertek}")

koszones(nev="Béla", koszones="Szia", varos="Budapest")

Természetesen bármelyiket használhatjuk akár egyszerre is, tehát lehet sima paraméterünk, args és kwargs is egy függvényben.

def rendeles_felvetel(asztal_szam, *etelek, **extrak):
    print(f"--- Rendelés az asztalhoz: {asztal_szam} ---")
    
    # args: egy tuple, amin végigmehetünk
    if etelek:
        print("Ételek:")
        for etel in etelek:
            print(f"  - {etel}")
            
    # kwargs: egy szótár (dict), ahol kulcs-érték párok vannak
    if extrak:
        print("Extrák/Módosítások:")
        for kulcs, ertek in extrak.items():
            print(f"  - {kulcs}: {ertek}")

# Meghívás:
rendeles_felvetel(5, "Gulyásleves", "Rántott hús", "Somlói galuska", 
                  ital="Mentes víz", 
                  fizetes="Bankkártya", 
                  ablak_melle=True)

def rendeles_felvetel(asztal_szam, *etelek, **extrak):

print(f"--- Rendelés az asztalhoz: {asztal_szam} ---")

# args: egy tuple, amin végigmehetünk

if etelek:

print("Ételek:")

for etel in etelek:

print(f" - {etel}")

# kwargs: egy szótár (dict), ahol kulcs-érték párok vannak

if extrak:

print("Extrák/Módosítások:")

for kulcs, ertek in extrak.items():

print(f" - {kulcs}: {ertek}")

# Meghívás:

rendeles_felvetel(5, "Gulyásleves", "Rántott hús", "Somlói galuska",

ital="Mentes víz",

fizetes="Bankkártya",

ablak_melle=True)

Globális és lokális változók

Az eljárásokban és függvényekben használt változók olyan változók, amik csak az adott blokkban léteznek. Tehát csak ott láthatóak, elérhetők. Pl. az ar változó csak a kalkulator eljáráson belül elérhető. A globális változók az adott programon belül bárhonnan elérhetőek.

Függvények

A függvények hasonlóan működnek, mint az eljárások, de a fő különbség az, hogy a függvények visszaadnak valamilyen értéket. A return utasításról lehet könnyen felismerni egy függvényt. A függvény visszatérési értékét el lehet menteni példul egy változóba. Nézzünk egy példa függvényt, ami a téglalap kerületét számolja ki.

# függvény létrehozása
def kerulet(a,b):
    return (a+b)*2
k = kerulet(10,10)
print("Kerület: ",kerulet(10,30))
print("Kerület: ",k)

# függvény létrehozása

def kerulet(a,b):

return (a+b)*2

k = kerulet(10,10)

print("Kerület: ",kerulet(10,30))

print("Kerület: ",k)

Számoljuk ki egy számsorozat maximumát függvény segítségével! Ha nem tudjuk, hogy mennyi paramétert (argumentumot) fogunk használni, akkor használjuk a *-ot!

def osszeg(x , *args):
    max = x
    for szam in args:
            if szam > max:
                max = szam
    return max
print("Maximum: ",osszeg(2,33,55,44,77,66,88,100))

def osszeg(x , *args):

max = x

for szam in args:

if szam > max:

max = szam

return max

print("Maximum: ",osszeg(2,33,55,44,77,66,88,100))

Egy függvénynek lehet több visszatérési értéke, tuple típusként. Ezekre az indexükkel lehet hivatkozni. Például keressük meg egy lista első és utolsó elemét függvény segítségével!

def szelek(lista):
    eleje = lista[0]
    vege = lista[-1]
    return (eleje, vege)
szamok = [2,4,6,8,10,13]
print(szelek(szamok)) #ebben az esetben a kimenet (2,13)
e,v = szelek(szamok) # az e változóban lesz az eleje, a v változóban a lista vege
print("Lista első eleme: ", e, "lista utolsó eleme: ",v) # kimenet: 2 13

def szelek(lista):

eleje = lista[0]

vege = lista[-1]

return (eleje, vege)

szamok = [2,4,6,8,10,13]

print(szelek(szamok)) #ebben az esetben a kimenet (2,13)

e,v = szelek(szamok) # az e változóban lesz az eleje, a v változóban a lista vege

print("Lista első eleme: ", e, "lista utolsó eleme: ",v) # kimenet: 2 13

Beágyazott függvények és Python‑bezárások (closures)

Beágyazott függvénynek nevezzük azt a függvényt, amely egy másik függvényen belül van definiálva. A beágyazott függvény csak a külső függvényen belül érhető el, így segít elrejteni logikát (enkapszuláció),
szervezettebb, moduláris kódot írni.

def kulso():
    def belso():
        print("Ez egy belső függvény.")
    belso()
kulso()

def kulso():

def belso():

print("Ez egy belső függvény.")

belso()

kulso()

Mi az a bezárás (closure)? Egy olyan függvény, amely hozzáfér a külső (nem globális) függvény lokális változóihoz még akkor is, ha a külső függvény már befejezte a futását. A closure tulajdonképpen „bezárja” (megjegyzi) azt a környezetet, amelyben létrejött. A nonlocal segítségével a belső függvény módosíthatja a külső függvény változóit.

n értéke: 2 (a szorzo(2) hívásból)
x értéke: 5 (a dupla(5) hívásból)
dupla egy olyan függvény, ami szoroz 2-vel

def szorzo(n):
    def belso(x):
        return x * n
    return belso

dupla = szorzo(2)
print(dupla(5))   # 10

# másik példa: számláló értéke minden hivásnál nő
def szamlalo():
    szam = 0
    def novel():
        nonlocal szam
        szam += 1
        return szam
    return novel

sz = szamlalo()
print(sz())  # 1
print(sz())  # 2

def szorzo(n):

def belso(x):

return x * n

return belso

dupla = szorzo(2)

print(dupla(5)) # 10

# másik példa: számláló értéke minden hivásnál nő

def szamlalo():

szam = 0

def novel():

nonlocal szam

szam += 1

return szam

return novel

sz = szamlalo()

print(sz()) # 1

print(sz()) # 2

Bankszámla: Készíts egy bank_szamla(kezdo_osszeg) függvényt, amely visszaad két függvényt:
betesz(x), kivesz(x)
Ezek módosítsák a zárt változóban tárolt egyenleget! A belső változóhoz kívülről ne lehessen hozzáférni!

Tehát az egyenleg nem érhető el, mert nem globális, csak a closure-ön belül él. Az adat el van zárva, csak engedélyezett műveleteken keresztül férsz hozzá!

def bank_szamla(kezdo_osszeg):
    egyenleg = kezdo_osszeg

    def betesz(x):
        nonlocal egyenleg
        egyenleg += x
        return egyenleg

    def kivesz(x):
        nonlocal egyenleg
        egyenleg -= x
        return egyenleg

    return betesz, kivesz

betesz, kivesz = bank_szamla(1000)
betesz(500)
print(kivesz(300))  # 1200

def bank_szamla(kezdo_osszeg):

egyenleg = kezdo_osszeg

def betesz(x):

nonlocal egyenleg

egyenleg += x

return egyenleg

def kivesz(x):

nonlocal egyenleg

egyenleg -= x

return egyenleg

return betesz, kivesz

betesz, kivesz = bank_szamla(1000)

betesz(500)

print(kivesz(300)) # 1200

Ha le akarjuk kérni az egyenleget, akkor kell egy lekerdez() függvény, és ezt a 3. paramétert is használni kell a számla létrehozásánál! Utána már simán lekerdez() és megvan az aktuális egyenleg.

Rekurzió

A rekurzió azt jelenti, hogy egy függvény önmagát hívja meg. Ebben az esetben általában valamilyen feltétel vizsgálatot is használni kell, hogy ne írjunk végtelen ciklust. A rekurzió hatékony megoldást jelenthet olyan problémákra, amelyek természetükből adódóan ismétlődőek és strukturáltak.

Általában a faktoriális számítással szokták szemléltetni.

# Rekurzió:  faktoriális számítás
# n! n=0    1
# n>0        n*(n-1)!
def fakt(n):
    if n == 0:
        return 1
    else:
        return n * fakt(n - 1)
print(fakt(5)) # kimenet: 120
# kicsit formázzuk meg a kiírást, nézzük meg hogyan számol
def ertek():
    for i in range(0, 5):
        print(f"{i}! = {fakt(i)}")
ertek()

# Rekurzió: faktoriális számítás

# n! n=0 1

# n>0 n*(n-1)!

def fakt(n):

if n == 0:

return 1

else:

return n * fakt(n - 1)

print(fakt(5)) # kimenet: 120

# kicsit formázzuk meg a kiírást, nézzük meg hogyan számol

def ertek():

for i in range(0, 5):

print(f"{i}! = {fakt(i)}")

ertek()

Lambda

A Python lambda egy egysoros névtelen (anonim) függvény, általában rövid kódrészletekhez használjuk. A lambda kulcsszóval definiáljuk. A következő példában a paraméterként kapott számhoz hozzáad 10-et.

x = lambda a : a + 10
print(x(10)) # eremény: 20

Adjunk össze 3 számot lambda segítségével:

x = lambda a, b, c : a + b + c
print(x(5, 6, 2))

A lambda erőssége az, hogy felhasználhatjuk függvényekben. Duplázzuk, triplázzuk meg a megadott számot!

def fuggveny(n):
  return lambda a : a * n
duplazz = fuggveny(2)
triplazz = fuggveny(3)
print(duplazz(10))
print(triplazz(10))

Számoljuk ki egy lista minden elemének a négyzetét lambda segítségével!

szamok = [1, 2, 3, 4, 5]
# A map() függvény az összes elemre alkalmazza a lambda függvényt
szamok_negyzete = list(map(lambda x: x**2, szamok))
# Kiírjuk a lista elemeit
print(szamok_negyzete) # eredmény: [1, 4, 9, 16, 25]

Python beépített függvények, modulok

Egy részükkel már találkoztunk, pl. print(), input(), random()
Megnézünk még néhány hasznosat, amit sűrűn használunk.

math modul

math.sqrt(x)Négyzetgyök (Square Root)
math.pi A pi konstans értéke.
math.sin(x) Szinusz (Sine) számítása x radiánra
math.ceil(x) Felső egész (Ceiling): A legkisebb egész szám, ami nagyobb vagy egyenlő x-szel
math.floor(x) Alsó egész (Floor): A legnagyobb egész szám, ami kisebb vagy egyenlő x-szel.
math.factorial(x) Faktoriális számítása x-re (x!)
math.log(x, base) Logaritmus számítása x-re a megadott base alapon. Alapértelmezett alap az e (természetes logaritmus).

import math

# Négyzetgyök és PI
gyok = math.sqrt(25)
kerulet = 2 * math.pi * 5
print(f"25 négyzetgyöke: {gyok}") # 5.0
print(f"Egy 5 egység sugarú kör kerülete: {kerulet:.2f}") # kb. 31.42

# Felső és alsó egész
fuggveny_ceil = math.ceil(4.2)
fuggveny_floor = math.floor(4.8)
print(f"4.2 felső egésze: {fuggveny_ceil}") # 5
print(f"4.8 alsó egésze: {fuggveny_floor}") # 4

import math

# Négyzetgyök és PI

gyok = math.sqrt(25)

kerulet = 2 * math.pi * 5

print(f"25 négyzetgyöke: {gyok}") # 5.0

print(f"Egy 5 egység sugarú kör kerülete: {kerulet:.2f}") # kb. 31.42

# Felső és alsó egész

fuggveny_ceil = math.ceil(4.2)

fuggveny_floor = math.floor(4.8)

print(f"4.2 felső egésze: {fuggveny_ceil}") # 5

print(f"4.8 alsó egésze: {fuggveny_floor}") # 4

Datetime modul: Dátum és idő kezelése

datetime.datetime.now() Az aktuális helyi dátumot és időpontot adja vissza.
datetime.date.today() Az aktuális helyi dátumot adja vissza.
datetime.datetime(y, m, d, h, min, s) Egy specifikus dátum/idő objektum létrehozása.
datetime.timedelta(days=x, seconds=y, …) Két időpont közötti különbséget vagy időtartamot jelöli.
datetime_obj.strftime(format) Egy datetime objektum formázása stringgé (pl. „%Y-%m-%d”).
datetime.datetime.strptime(string, format) Egy string átalakítása datetime objektummá

from datetime import datetime, timedelta

# Aktuális dátum és idő
most = datetime.now()
print(f"Aktuális dátum és idő: {most}") # pl. 2025-11-10 13:29:54.123456

# Formázás
formazott_datum = most.strftime("%Y. %m. %d. - %H:%M")
print(f"Formázott dátum: {formazott_datum}") # pl. 2025. 11. 10. - 13:29

# Időpontok közötti aritmetika (timedelta)
harom_nap = timedelta(days=3)
harom_nap_mulva = most + harom_nap
print(f"3 nap múlva: {harom_nap_mulva.strftime('%Y-%m-%d')}")

# Különbség számítása
szuletesnap = datetime(2026, 3, 15)
hatralevo_ido = szuletesnap - most
print(f"A születésnapig hátralévő napok: {hatralevo_ido.days}") # pl. 125

from datetime import datetime, timedelta

# Aktuális dátum és idő

most = datetime.now()

print(f"Aktuális dátum és idő: {most}") # pl. 2025-11-10 13:29:54.123456

# Formázás

formazott_datum = most.strftime("%Y. %m. %d. - %H:%M")

print(f"Formázott dátum: {formazott_datum}") # pl. 2025. 11. 10. - 13:29

# Időpontok közötti aritmetika (timedelta)

harom_nap = timedelta(days=3)

harom_nap_mulva = most + harom_nap

print(f"3 nap múlva: {harom_nap_mulva.strftime('%Y-%m-%d')}")

# Különbség számítása

szuletesnap = datetime(2026, 3, 15)

hatralevo_ido = szuletesnap - most

print(f"A születésnapig hátralévő napok: {hatralevo_ido.days}") # pl. 125

Példa: prímszám ellenőrzés. Döntse el a függvény, hogy a megadott szám prím szám-e?

import math

def is_prime(number):
    """
    Eldönti, hogy a megadott szám prímszám-e.
    Egy szám akkor prímszám, ha nagyobb, mint 1, és csak 1-gyel és önmagával osztható.
    """
    # 1. Feltétel: 1-nél kisebb vagy egyenlő számok nem prímek
    if number <= 1:
        return False

    # 2. Feltétel: A 2 az egyetlen páros prímszám
    if number == 2:
        return True

    # 3. Feltétel: Minden más páros szám nem prím
    if number % 2 == 0:
        return False

    # 4. Feltétel: Csak páratlan osztókat kell ellenőrizni 3-tól 
    #              a szám négyzetgyökéig (beleértve)
    # Csak azokat a számokat kell ellenőrizni, amelyek a szám négyzetgyökéig 
    # bezárólag fekszenek, mivel ha van egy x * y = number osztópár, 
    # akkor legalább az egyik (x vagy y) kisebb vagy egyenlő, mint a négyzetgyök.
    limit = int(math.sqrt(number))
    
    # 3-tól kezdve minden második (páratlan) számmal osztunk
    for i in range(3, limit + 1, 2):
        if number % i == 0:
            return False

    # Ha a fenti ellenőrzések nem találtak osztót, a szám prím
    return True

# --- Példák a függvény használatára ---

print(f"7 prímszám? {is_prime(7)}")          # Eredmény: True
print(f"1 prímszám? {is_prime(1)}")          # Eredmény: False
print(f"10 prímszám? {is_prime(10)}")        # Eredmény: False
print(f"91 prímszám? {is_prime(91)}")        # Eredmény: False (91 = 7 * 13)

print("\n--- Prímszámok listázása 50-ig ---")
for num in range(1, 51):
    if is_prime(num):
        print(f"{num} egy prímszám.")

import math

def is_prime(number):

"""

Eldönti, hogy a megadott szám prímszám-e.

Egy szám akkor prímszám, ha nagyobb, mint 1, és csak 1-gyel és önmagával osztható.

"""

# 1. Feltétel: 1-nél kisebb vagy egyenlő számok nem prímek

if number <= 1:

return False

# 2. Feltétel: A 2 az egyetlen páros prímszám

if number == 2:

return True

# 3. Feltétel: Minden más páros szám nem prím

if number % 2 == 0:

return False

# 4. Feltétel: Csak páratlan osztókat kell ellenőrizni 3-tól

# a szám négyzetgyökéig (beleértve)

# Csak azokat a számokat kell ellenőrizni, amelyek a szám négyzetgyökéig

# bezárólag fekszenek, mivel ha van egy x * y = number osztópár,

# akkor legalább az egyik (x vagy y) kisebb vagy egyenlő, mint a négyzetgyök.

limit = int(math.sqrt(number))

# 3-tól kezdve minden második (páratlan) számmal osztunk

for i in range(3, limit + 1, 2):

if number % i == 0:

return False

# Ha a fenti ellenőrzések nem találtak osztót, a szám prím

return True

# --- Példák a függvény használatára ---

print(f"7 prímszám? {is_prime(7)}") # Eredmény: True

print(f"1 prímszám? {is_prime(1)}") # Eredmény: False

print(f"10 prímszám? {is_prime(10)}") # Eredmény: False

print(f"91 prímszám? {is_prime(91)}") # Eredmény: False (91 = 7 * 13)

print("\n--- Prímszámok listázása 50-ig ---")

for num in range(1, 51):

if is_prime(num):

print(f"{num} egy prímszám.")

Frissítve: 2026.02.03.

Eljárások

Paraméterek

Args és kwargs avagy a csillagok

Globális és lokális változók

Függvények

Beágyazott függvények és Python‑bezárások (closures)

Rekurzió

Lambda

Python beépített függvények, modulok

Kategóriák

Friss bejegyzések

WS2022 – WDS

Playwright teszt