02. gyakorlat

Szerkesztés alatt!

Az oldal további része szerkesztés alatt áll, a tartalma minden további értesítés nélkül többször, gyakran, jelentősen megváltozhat!

Függvények

A függvény egy olyan programozási konstrukció, amely lehetővé teszi, hogy egy adott műveletet többször végrehajtsunk különböző bemeneti adatokkal anélkül, hogy újra és újra ugyanazt a kódot kellene megírnunk. A függvények segítenek a kódot rendszerezni, elkerülni a kód ismétlését.

Egy egyszerű függvényt így definiálhatunk:

def hello():
    print("Hello, világ!")

Mi történik itt?

• A def kulcsszóval létrehozunk egy új függvényt.
• A függvény neve hello.
• A függvény zárójelek között (itt üresen) kaphat paramétereket, amelyek a függvény belsejében használható bemeneti értékek lesznek.
• A függvény törzse behúzás alatt található, ahol a konkrét utasítások vannak, például a print függvény, amely kiír egy szöveget.

Hogyan használjuk a függvényt?

A függvény meghívásához egyszerűen írjuk le a nevét, majd tegyünk zárójeleket.

Például:

hello()

Függvények paraméterei

A függvények különböző bemeneti adatokat (paramétereket) is kaphatnak, amelyekkel rugalmasan tudnak működni. Például, ha azt szeretnénk, hogy a függvényünk ne mindig ugyanazt a szöveget írja ki, hanem változó szövegeket fogadjon el, használhatunk paramétereket:

def udvozol(nev):
    print(f"Szia, {nev}!")

Itt a nev egy paraméter, amely a függvény belsejében használható változóként. Meghívás esetén a zárójelbe írt érték lesz a paraméter értéke (több paraméter esetén vesszővel elválasztva).

Ha meghívjuk a függvényt, akkor a következő történik:

udvozol("Ádám")  # Szia, Ádám!
udvozol("Eszter")  # Szia, Eszter!

Több paraméteres függvények

Amikor egy függvény több paramétert vár, akkor ezeket mind meg kell adni a függvényhívás során. Például, ha szeretnénk egy olyan függvényt, amely két számot kap, és összeadja őket, így definiáljuk:

def osszead(a, b):
    print(a + b)

Itt az a és a b a két paraméter, amelyeket a függvényhíváskor meg kell adni. Így használhatjuk:

osszead(10, 5)  # 15

A Pythonban lehetőség van több paraméter használatára is, és ezeket sorrendben kell megadni a függvényhíváskor. Például egy három számot összeadó függvény:

def osszead_harom_szamot(a, b, c):
    print(a + b + c)

A függvényt így hívhatjuk meg:

osszead_harom_szamot(10, 5, 2)  # 17

Alapértelmezett paraméterek (default paraméterek)

A Pythonban függvényekben lehetőség van alapértelmezett értékeket is meghatározni a paraméterekhez. Ez azt jelenti, hogy ha a függvényt meghívjuk, és nem adunk meg egy bizonyos paramétert, akkor az automatikusan egy előre meghatározott értéket kap.

Példa:

Definiáljunk egy függvényt, amely két számot kap paraméterként, de ha a második paramétert nem adjuk meg, akkor az alapértelmezett értéke 1 legyen:

def osszead_alapertelmezett(a, b=1):
    print(a + b)

Itt a b paraméter alapértelmezett értéke 1. Ezért ha a függvényt csak egy paraméterrel hívjuk meg, akkor a második paraméter értéke automatikusan 1 lesz:

osszead_alapertelmezett(5) # 6

Ha mindkét paramétert megadjuk, akkor az alapértelmezett értéket felülírjuk:

osszead_alapertelmezett(5, 10) # 15

Több alapértelmezett paraméter

A függvények több alapértelmezett paramétert is kaphatnak, de fontos, hogy az alapértelmezett paramétereket mindig a nem alapértelmezett paraméterek után helyezzük el. Például:

def udvozol(nev, uzenet="Szia!", zarouzenet="Viszlát!"):
    print(f"{uzenet}, {nev}!")
    print(zarouzenet)

Ez a függvény egy nevet vár, valamint két alapértelmezett szöveget, amiket nem kötelező megadni. Ha csak a nevet adjuk meg, akkor az alapértelmezett üzenetek jelennek meg:

udvozol("Eszter")
# Eredmény:
# Szia, Eszter!
# Viszlát!

De ha szeretnénk, felülírhatjuk az alapértelmezett paramétereket:

udvozol("Eszter", "Üdv!", "Legközelebb találkozunk!")
# Eredmény:
# Üdv, Eszter!
# Legközelebb találkozunk!

Visszatérési értékek: return

A függvények nemcsak bemenetet kaphatnak, hanem eredményeket is visszaadhatnak. Ez a visszatérés a return kulcsszóval történik. Ha például egy olyan függvényt szeretnénk, ami két számot összead, és visszaadja az eredményt, így nézne ki:

def osszead(a, b):
    return a + b

Ebben az esetben a függvény a két paraméter, a és b összegét adja vissza, amit a függvény meghívásakor használhatunk fel:

eredmeny = osszead(5, 10)
print(eredmeny)  # 15

Itt a osszead(5, 10) függvényhívás visszatér a 15-tel, amit elmentünk a eredmeny változóba, és kiírtuk.

Függvények hívása más függvényekből

A függvények belsejében más függvényeket is meghívhatunk, ezáltal összetettebb működéseket is létrehozhatunk. Például, ha van egy függvényünk, ami megdupláz egy számot, azt egy másik függvényből is felhasználhatjuk:

def duplaz(szam):
    return szam * 2

def duplazast_hasznal():
    eredmeny = duplaz(5)
    print(eredmeny)

Ebben az esetben a duplazast_hasznal() függvény belül meghívja a duplaz() függvényt, és a visszatért értéket (10) kiírja.

Feltételes elágazások: if, else, elif

A programokban gyakran szükséges különböző műveleteket végrehajtani attól függően, hogy egy adott feltétel igaz vagy hamis. Ilyen esetekben használjuk a feltételes elágazásokat: az if, else és elif szerkezeteket.

Példa: if és else

Az if kulcsszó segítségével ellenőrizhetünk egy feltételt. Ha a feltétel igaz, a hozzá tartozó kódblokk végrehajtódik. Ha hamis, akkor a else ágban lévő kód fut le.

szam = 10

if szam > 5:
    print("A szám nagyobb, mint 5")
else:
    print("A szám kisebb vagy egyenlő 5-nél")

Ebben a példában az if megvizsgálja, hogy a szam nagyobb-e mint 5. Ha ez igaz, akkor az első üzenet kerül kiírásra, ha nem, akkor a második.

elif: több feltétel kezelése

Az elif (else if) akkor használható, ha több különböző feltételt szeretnénk ellenőrizni:

szam = 10

if szam > 10:
    print("A szám nagyobb, mint 10")
elif szam == 10:
    print("A szám pont 10")
else:
    print("A szám kisebb, mint 10")

Itt három különböző lehetőséget vizsgálunk: ha a szám nagyobb mint 10, akkor az első üzenet jelenik meg; ha pont 10, akkor a második; egyébként pedig a harmadik.

Logikai kifejezések: and, or, not

A logikai kifejezések lehetővé teszik több feltétel kombinálását. A három alapvető logikai operátor a and, or és not.

• Az and akkor igaz, ha mindkét feltétel igaz:

if szam > 5 and szam < 15:
    print("A szám 5 és 15 között van")

• Az or akkor igaz, ha legalább az egyik feltétel igaz:

if szam < 5 or szam > 15:
    print("A szám kívül esik az 5 és 15 közötti tartományon")

• A not megfordítja a feltétel igazságát:

if not szam > 5:
    print("A szám nem nagyobb, mint 5")

---

Példa feladatok megoldásokkal

01. feladat

Feladat: Írjunk függvényt, ami egy paramétert vár, és azt kiírja a képernyőre kétszer! Hívjuk meg a függvényt a "Hello, világ!" szöveggel, majd a nevünkkel, és végül a kedvenc egész számunkkal!

Megoldás:

def duplan_kiir(szoveg):
    print(szoveg)
    print(szoveg)

# Hívjuk meg a függvényt különböző paraméterekkel
duplan_kiir("Hello, világ!")
duplan_kiir("John Doe")
duplan_kiir(42)

02. feladat

Feladat: Írjunk függvényt, ami nem vár paramétert, bekér egy számot, és visszaadja azt! Hívjuk meg a függvényt és olvassuk be a kedvenc egész számunkat! A függvény eredményével hívjuk meg az előző feladatban megírt függvényt!

Megoldás:

def beker_szamot():
    szam = int(input("Kérlek, adj meg egy számot: "))
    return szam

# Hívjuk meg a függvényt és használjuk az első feladatot
szam = beker_szamot()
duplan_kiir(szam)

03. feladat

Feladat: Írjunk függvényt, ami két számot vár paraméterként, és vissza

adja a két szám összegét! Hívjuk meg a függvényt a saját és a padtársunk kedvenc számával, majd a függvény eredményével hívjuk meg az első feladatban megírt függvényt!

Megoldás:

def osszead(a, b):
    return a + b

# Hívjuk meg a függvényt két számmal
eredmeny = osszead(12, 30)
duplan_kiir(eredmeny)

04. feladat

Feladat: Írjunk függvényt, ami két számot vár paraméterként, és visszaadja a két számból a nagyobbat!

Megoldás:

def nagyobb_szam(a, b):
    if a > b:
        return a
    else:
        return b

# Példa függvényhívás
nagyobb = nagyobb_szam(15, 10)
print(nagyobb)

05. feladat

Feladat: Írjunk függvényt, ami egy számot vár paraméterként, és igazat ad vissza, ha a szám páros, egyébként hamisat!

Megoldás:

def paros_vagy_paratlan(szam):
    return szam % 2 == 0

# Példa függvényhívás
eredmeny = paros_vagy_paratlan(8)
print(eredmeny)  # True

06. feladat

Feladat: Micimackó akkor eszik mézet, ha van otthon, és ha éhes. Írjunk függvényt, ami két paramétert vár, az első egy logikai érték, ami azt jelzi, hogy van-e méz otthon, a második pedig egy logikai érték, ami azt jelzi, hogy éhes-e Micimackó. A függvény igazat ad vissza, ha Micimackó mézet eszik, egyébként hamisat.

Megoldás:

def eszik_mezet(van_mez, micimacko_ehes):
    return van_mez and micimacko_ehes

# Példa függvényhívás
mezes_eredmeny = eszik_mezet(True, False)
print(mezes_eredmeny)  # False

07. feladat

Feladat: Írjunk függvényt, ami két számot vár paraméterként, és igazat ad vissza, ha legalább az egyik szám osztható hárommal.

Megoldás:

def egyik_oszthato_harommal(a, b):
    return a % 3 == 0 or b % 3 == 0

# Példa függvényhívás
eredmeny = egyik_oszthato_harommal(9, 10)
print(eredmeny)  # True