Python gyerekeknek - függvények

Kategória: Python gyerekeknek.

Elmélet

Ha egy kódrészletet több helyről szeretnénk használni, akkor érdemes azokat külön helyre szervezni, és csak hivatkozni rá. Ezt a "külön helyet" hívjuk függvénynek, a hivatkozást pedig függvényhívásnak.

Ha a program elér egy akkora méretet, amit mér nehéz átlátni, akkor is érdemes függvényekbe szervezni a kódot. Ez utóbbi esetben a logikailag jól elkülöníthető részeket érdemes egy függvénybe írni.

Már idáig is használtunk függvényeket, csak nem neveztük nevén. Pl. a print() utasítás egy függvényhívás volt. A függvénynek tehát van egy neve. Amikor meghívjuk, akkor nyitó és csukó zárójeleket kell írnunk. Vannak esetek, amikor agy, vagy akár több valamit be kell írni a zárójelbe. Ezeket a valamiket argumentumoknak hívjuk. Például ott, hogy print('Szia') az, hogy 'Szia', a függvény argumentuma.

Elképzelhető, hogy a függvény visszaad valamit. Ezt úgy hívjuk, hogy a függvény visszatérési értéke. Az input() függvény például ilyen: visszaadja azt, amit a felhasználó beírt.

A Scratch-nen a függvényekhez nagyon hasonló fogalom a blokk, amelyekből számos van, és mi magunk is tudunk létre hozni blokkot.

Lássuk most, hogy hogyan tudunk mi magunk készíteni függvényt, és azt hogyan tudjuk meghívni! A szabály a következő:

  • Függvény írását a def kulcsszóval kezdjük
  • Utána szóközzel elválasztva jön a függvény neve.
  • Utána zárójelet kell tenni. A zárójelben fel kell sorolni a függvény paramétereit. Ami a hívó oldalon az argumentum, az a függvény oldalán a paraméter. Erre majd látni fogunk példát. A zárójelet akkor is ki kell tenni, ha a függvénynek nincs paramétere.
  • A fejléc kettősponttal zárul.
  • A függvény törzsét ugyanolyan mélységben kell behúzni. Ha azon belül van elágazás agy ciklus, annak a törzsét tovább be kell húzni.
  • Ha van a függvénynek visszatérési értéke, akkor azt a return utasítással kell megadni.

Példák

Kezdjük egy egyszerű példával: a print_hello() függvény kiírja azt, hogy Helló, világ!.

def print_hello():
    print('Helló, világ!')
 
print_hello()

Ennek megfelelő Scratch kód az alábbi:

hello_vilag.png

Paramétert a következőképpen adhatunk hozzá:

def greet(name):
    print(f'Szia, {name}!')
 
greet('Csaba')

A paraméter és az argumentum rokon fogalmak, és sokszor felcserélik a kettőt. A jelentése:

  • A paraméter a hívott oldali megnevezése; a fenti példában ez a name.
  • Az argumentum az az érték, amit a hívó oldalon átadunk, a példában ez 'Csaba'.

A fenti kódrészletnek megfelelő Scratch program az alábbi:

szia.png

A következő példában van a függvénynek visszatérési értéke. Ez egy összeadó függvény, melynek már kettő paramétere is van, és a visszatérési értéke a kettő szám összege:

def add(a, b):
    result = a + b
    return result
 
c = add(3, 2)
print(c)

Láthatjuk, hogy a hívó oldalon egyenlőség jellel értékül adjuk a függvény eredményét a c változónak, majd kiíratjuk.

A Scratch-ben ennek megfelelő kód már nincs, viszont egy kis trükközéssel ezt még meg tudjuk oldani: felveszünk egy változót, beletesszük az eredményt, majd kiíratjuk a változó értékét:

osszead.png

A függvényekkel kapcsolatban még nagyon sok tudnivaló van; mindegyikre most nem térünk ki. Néhány fontosabb:

  • Megadhatjuk a paraméterek típusát, kettősponttal elválasztva.
  • Megadhatjuk a visszatérési érték típusát, nyíllal (->).
  • Híváskor megadhatjuk azt, hogy melyik paraméternek adunk értéket, a paraméter nevének megadásával és egy egyenlőségjellel.

Mindezekre példa:

def add(a: int, b: int) -> int:
    result = a + b
    return result
 
c = add(a=3, b=2)
print(c)

Van még egy probléma, amit megnézünk, mivel szükség lesz rá. A problémát az alábbi program segítségével illusztráljuk:

a = 1
 
def f():
    a = 2
 
f()
print(a)

Vajon mi lesz a futás eredménye: 1 vagy 2? Valójában 1, mert az első sorban levő a változóra azt mondjuk, hogy globális, az f() függvényen belülire pedig azt, hogy lokális. Ahhoz, hogy a globális változót tudjuk függvényen belülről módosítani, a global kulcsszót kell használnunk:

a = 1
 
def f():
    global a
    a = 2
 
f()
print(a)

Ez utóbbinak az eredménye 2 lesz.

Feladat

Írjuk át a kvíz szótár változatát úgy, hogy függvényt használunk. A függvénynek legyen két paramétere:

  • question: az aktuális kérdés,
  • correct_answer: a helyes válasz.

Kérje be a felhasználó válaszát, és a visszatérési értéke pedig legyen True vagy False attól függően, hogy a válasz helyes-e vagy helytelen. A kódot szervezzük át úgy, hogy ezt a függvényt hívja a fő ciklus.

def check_answer(question, correct_answer):
    answer = input(question)
    if answer == correct_answer:
        print('Helyes!')
        return True
    else:
        print(f'A válasz helytelen; a helyes válasz {correct_answer} lett volna.')
        return False
 
points = 0
question_answer_dict = {
    'Mi Magyarország fővárosa? ': 'Budapest',
    'Hány fokon forr a víz? ': '100',
    'Melyik az az állat, amelyiknek nagy füle és hosszú ormánya van? ': 'elefánt',
    'Hogy mondjuk angolul azt, hogy alma? ': 'apple',
    'Mi volt Petőfi vezetéknevű költőnk keresztneve? ': 'Sándor',
}
 
for question in question_answer_dict:
    correct_answer = question_answer_dict[question]
    result = check_answer(question, correct_answer)
    if result:
        points = points + 1
    print()
 
percentage = str(100 * points / len(question_answer_dict)) + '%'
print('Az eredmény: ' + percentage)

Önálló feladat lehetőségek

  • Fejlesszük tovább a programot úgy, hogy a teljes logika egy másik függvénybe kerül, pl. ask_quiz_questions, ami levezérli az egész kvízt, és a százalékos végeredményt adja vissza. Így a főprogram mindössze egyetlen sorból áll, ami kiírja az eredményt.
  • Készítsünk egy olyan kvíz motort, ami tartalmazhat kérdezz-felelek, számszerű és ABCD válasz lehetőségeket is.

Teszt

TODO

Unless otherwise stated, the content of this page is licensed under Creative Commons Attribution-ShareAlike 3.0 License