Bevezetés a Python Függvényekhez

Mi az a függvény?

A függvény olyan újrafelhasználható kódblokk, amely egy specifikus feladatot hajt végre. A függvények segítségével:

Újrafelhasználható kód

Nem kell ugyanazt a kódot többször megírni

Modularitás

Komplex feladatok kisebb részekre bontása

Karbantarthatóság

Könnyebb módosítani és hibát keresni

Egy egyszerű függvény

Nézzük meg, hogyan néz ki egy alapvető Python függvény:

def koszont():
    """Ez egy egyszerű üdvözlő függvény"""
    print("Üdvözöllek a Python függvények világában!")

# A függvény meghívása
koszont()

A függvény részei:

def

A függvény definíció kulcsszava

koszont

A függvény neve

()

Paraméter lista (itt üres)

törzs

A függvény utasításai

Próbáld ki!

Függvények Alapjai

A függvények szintaxisa

A Python függvényeket a def kulcsszóval definiáljuk. Nézzük meg a függvények alapvető felépítését:

def függvény_neve(paraméter1, paraméter2):
    """Dokumentációs string (docstring) - a függvény leírása"""
    # A függvény törzse
    # Itt vannak a végrehajtandó utasítások
    eredmény = paraméter1 + paraméter2
    return eredmény  # Visszatérési érték

A függvény fő részei:

def

Kulcsszó, ami jelzi, hogy függvényt definálunk

függvény_neve

A függvény egyedi azonosítója, amivel később meghívhatjuk

(paraméterek)

A függvénynek átadott értékek, vesszővel elválasztva

:

A függvény fejlécének vége

docstring

A függvény működésének dokumentációja (opcionális)

törzs

A végrehajtandó utasítások (behúzással jelölve)

return

A függvény által visszaadott érték (opcionális)

Függvény használata

A függvényeket a nevük és zárójelek segítségével hívhatjuk meg. A zárójelekben adjuk át a szükséges paramétereket.

# Egyszerű függvény definíció
def osszeadas(a, b):
    return a + b

# Függvény használata (meghívása)
eredmeny = osszeadas(5, 3)
print(f"5 + 3 = {eredmeny}")  # Kiírja: 5 + 3 = 8

# Másik példa: szövegek kezelése
def koszont(nev):
    return f"Szia {nev}!"

# Függvény meghívása stringgel
udvozles = koszont("Anna")
print(udvozles)  # Kiírja: Szia Anna!

Próbáld ki!

Adj meg két számot az összeadáshoz:

+

Írd be a neved az üdvözléshez:

Függvények Definiálása

Paraméterek használata

A függvények paraméterekkel való definiálása lehetővé teszi, hogy különböző értékekkel használjuk ugyanazt a függvényt:

# Egyszerű paraméterek
def szoroz(a, b):
    return a * b

# Alapértelmezett értékek
def hatványoz(alap, kitevo=2):
    return alap ** kitevo

# Paraméterek név szerint
def szemely_info(nev, kor, varos="Budapest"):
    return f"{nev} ({kor} éves) - {varos}"

Próbáld ki a különböző paraméterezéseket:

Két szám szorzása:

×

Hatványozás:

^

Személy adatai:

Függvény dokumentálása

A jól dokumentált függvények könnyebben használhatók és karbantarthatók:

def korterfogat(sugar, magassag):
    """
    Kiszámolja egy kör alapú henger térfogatát.

    Paraméterek:
        sugar (float): A kör sugara
        magassag (float): A henger magassága

    Visszatérési érték:
        float: A henger térfogata
    """
    pi = 3.14159
    alapterulet = pi * sugar * sugar
    terfogat = alapterulet * magassag
    return terfogat

Henger térfogat számítása:

Sugár (cm):

Magasság (cm):

Visszatérési Értékek

A return utasítás

A return utasítás két fontos célt szolgál:

Értéket ad vissza a függvényből
Azonnal kilép a függvényből (akkor is, ha még lenne utána kód)

# Egyszerű visszatérési érték
def negyzet(szam):
    return szam * szam  # Visszaadja a szám négyzetét

# Több lehetséges visszatérési érték
def oszthato(szam, oszto):
    if szam % oszto == 0:
        return True
    return False

# Korai kilépés return-nel
def osztas(a, b):
    if b == 0:
        return "Nullával nem lehet osztani!"
    return a / b

Próbáld ki!

Szám négyzetre emelése:

Oszthatóság vizsgálata:

÷

Osztás biztonságos vizsgálata:

÷

Többszörös visszatérési érték

A Python lehetővé teszi több érték egyidejű visszaadását tuple formájában:

# Több érték visszaadása
def koordinatak(x, y):
    tavolsag = (x ** 2 + y ** 2) ** 0.5  # Távolság az origótól
    szog = math.atan2(y, x)              # Szög az x tengellyel
    return tavolsag, szog

# Értékek kibontása
tav, szog = koordinatak(3, 4)

# Lista visszaadása
def statisztika(szamok):
    minimum = min(szamok)
    maximum = max(szamok)
    atlag = sum(szamok) / len(szamok)
    return [minimum, maximum, atlag]

Többszörös visszatérés kipróbálása

Pont koordinátái:

X koordináta:

Y koordináta:

Add meg a számokat (vesszővel elválasztva):

Lokális és Globális Változók

Változók láthatósága

A Python függvényekben használt változók kétfélék lehetnek:

Lokális változók: Csak a függvényen belül érhetők el
Globális változók: A program bármely részéből elérhetők

# Globális változó
szamlalo = 0

def novel():
    global szamlalo  # Jelezzük, hogy a globális változót használjuk
    szamlalo += 1
    return szamlalo

def lokalis_pelda():
    # Ez egy lokális változó
    x = 10
    return x

# A lokális x itt már nem elérhető
# print(x)  # Ez hibát okozna!

print(novel())  # 1
print(novel())  # 2
print(szamlalo) # 2 - globális változó mindenhol elérhető

Számláló példa:

Globális számláló értéke: 0

Változók árnyékolása

Ha egy függvényben ugyanolyan nevű változót használunk, mint egy globális változó, akkor az a függvényen belül egy új, lokális változót hoz létre:

# Globális változó
nev = "Globális"

def pelda():
    nev = "Lokális"  # Új lokális változó, nem módosítja a globálist
    print(f"Függvényen belül: {nev}")

pelda()  # Kiírja: Függvényen belül: Lokális
print(f"Függvényen kívül: {nev}")  # Kiírja: Függvényen kívül: Globális

Próbáld ki a változó árnyékolást:

Globális változó értéke:

Lokális változó értéke:

Függvények Dokumentálása

A docstring használata

A docstring (documentation string) egy többsoros szöveges dokumentáció, amely leírja a függvény működését, paramétereit és visszatérési értékét.

def teglalap_terulet(szelesseg, magassag):
    """
    Kiszámolja egy téglalap területét.

    Paraméterek:
        szelesseg (float): A téglalap szélessége
        magassag (float): A téglalap magassága

    Visszatérési érték:
        float: A téglalap területe
    """
    return szelesseg * magassag

# A dokumentáció megtekintése
help(teglalap_terulet)
# vagy
print(teglalap_terulet.__doc__)

Dokumentáció generátor:

Függvény neve:

Paraméterek:

Visszatérési érték:

Dokumentáció példák

Nézzünk néhány gyakori esetet a függvények dokumentálására:

1. Egyszerű függvény

def koszont(nev):
    """Egyszerű üdvözlő üzenet generálása.

    Args:
        nev (str): A köszöntendő személy neve

    Returns:
        str: Az üdvözlő üzenet
    """
    return f"Szia {nev}!"

2. Összetett függvény

def osztalyzat_szamitas(pontszam, max_pont=100):
    """
    Kiszámolja az érdemjegyet a pontszám alapján.

    Args:
        pontszam (int): Elért pontszám
        max_pont (int, optional): Maximális pontszám. Alapértelmezett: 100

    Returns:
        int: Érdemjegy (1-5)

    Raises:
        ValueError: Ha a pontszám negatív vagy nagyobb, mint a maximum
    """
    if pontszam < 0 or pontszam > max_pont:
        raise ValueError("Érvénytelen pontszám!")

    szazalek = (pontszam / max_pont) * 100
    if szazalek < 50: return 1
    if szazalek < 60: return 2
    if szazalek < 70: return 3
    if szazalek < 85: return 4
    return 5

Próbáld ki a dokumentált függvényeket:

Név:

Pontszám és maximum:

Gyakorló Feladatok

Tudáspróba

Az alábbi feladatok segítenek a tanult függvénykezelési technikák gyakorlásában. Minden feladathoz tartozik egy leírás és egy interaktív felület a megoldás kipróbálásához.

1. Feladat: Egyszerű függvény írása

Írj egy függvényt, amely két számot kap paraméterként, és visszaadja a két szám közül a nagyobbat! Próbáld megoldani elsőként, majd hasonlítsd össze a megoldásoddal.

def nagyobb(a, b):
    """
    Visszaadja két szám közül a nagyobbat.

    Args:
        a (float): Első szám
        b (float): Második szám

    Returns:
        float: A nagyobb szám
    """
    return a if a > b else b

Próbáld ki!

2. Feladat: Alapértelmezett paraméter használata

Készíts egy függvényt, amely kiszámítja egy kör kerületét! A pi értéke legyen alapértelmezetten 3.14.

def kor_kerulet(sugar, pi=3.14):
    """
    Kiszámítja egy kör kerületét.

    Args:
        sugar (float): A kör sugara
        pi (float, optional): Pi értéke. Alapértelmezett: 3.14

    Returns:
        float: A kör kerülete
    """
    return 2 * pi * sugar

Próbáld ki!

3. Feladat: Dokumentált függvény return értékkel

Írj egy függvényt, amely megkapja egy számot és visszaadja, hogy a szám prím-e vagy sem! A függvény legyen megfelelően dokumentálva!

def prim_e(szam):
    """
    Ellenőrzi, hogy egy szám prím-e.

    Args:
        szam (int): A vizsgálandó szám

    Returns:
        bool: True ha a szám prím, False ha nem

    Raises:
        ValueError: Ha a szám kisebb mint 2
    """
    if szam < 2:
        raise ValueError("A szám nem lehet kisebb 2-nél!")

    for i in range(2, int(szam ** 0.5) + 1):
        if szam % i == 0:
            return False
    return True