A függvény egy **kódrészlet**, amely **csak akkor fut le**, amikor meghívjuk.
A függvény **adatot is visszaadhat** eredményként. Az olyan függvényt, amely nem ad vissza adatot **eljárás**nak nevezzük.
A függvények segítenek **elkerülni a kódismétlést**.
## Függvény létrehozása
Python-ban egy függvény létrehozásához a ``def`` kulcsszót használjuk, majd megadjuk a függvény nevét és zárójeleket:
>[!example] Függvény létrehozása
>```python
>def fuggvenyem():
> print("Üdvözlet egy függvényből!")
>```
Ez egy ``fuggvenyem`` nevű függvényt hoz létre, amely kiírja: ``Üdvözlet egy függvényből!``, amikor meghívjuk.
A függvényen belüli kódot **be kell húzni**.
Python-ban a behúzás határozza meg a kódtömböt.
## Függvény meghívása
Egy függvény meghívásához írd le a nevét, majd tedd mögé a zárójeleket:
>[!example] Függvény meghívása
>```python
>def fuggvenyem():
> print("Üdvözlet egy függvényből!")
>
>fuggvenyem()
>```
Ugyanazt a függvényt többször is meghívhatjuk:
>[!example] Függvény többszöri meghívása
>```python
>def fuggvenyem():
> print("Üdvözlet egy függvényből!")
>
>fuggvenyem()
>fuggvenyem()
>fuggvenyem()
>```
## Függvénynevek
A függvénynevek ugyanazokat a szabályokat követik, mint a változónevek:
- betűvel vagy aláhúzással (\_) kell kezdődniük
- csak betűket, számokat és aláhúzást tartalmazhatnak
- a kis- és nagybetűk különböznek (``azEnFuggvenyem`` ≠ ``azenfuggvenyem``)
>[!example] Érvényes függvénynevek
>```python
>calculate_sum()
>_private_function()
>myFunction2()
>```
Jó gyakorlat olyan neveket adni, amelyek leírják, mit csinál a függvény.
## Miért használjunk függvényeket?
Képzeljük el, hogy többször is át kell váltanunk Fahrenheit hőmérsékletet Celsius-ra.
Függvény nélkül ugyanazt a számítást újra és újra le kell írnunk:
>[!example] Függvények nélkül (ismétlődő kód)
>```python
>temp1 = 77
>celsius1 = (temp1 - 32) * 5 / 9
>print(celsius1)
>
>temp2 = 95
>celsius2 = (temp2 - 32) * 5 / 9
>print(celsius2)
>
>temp3 = 50
>celsius3 = (temp3 - 32) * 5 / 9
>print(celsius3)
>```
Függvénnyel azonban csak egyszer írjuk meg a kódot, és újra felhasználhatjuk:
>[!example] Függvénnyel (újrahasznosítható kód)
>```python
>def fahrenheit_to_celsius(fahrenheit):
> return (fahrenheit - 32) * 5 / 9
>
>print(fahrenheit_to_celsius(77))
>print(fahrenheit_to_celsius(95))
>print(fahrenheit_to_celsius(50))
>```
## Visszatérési értékek
A függvény a ``return`` utasítással küldhet vissza értéket annak a résznek, amely meghívta.
Amikor a Python eléri a ``return`` sort, a függvény leáll, és visszaadja az eredményt.
>[!example] Függvény, amely visszatérési értéket ad
>```python
>def koszones():
> return "Üdvözlet egy függvényből!"
>
>uzenet = koszones()
>print(uzenet)
>```
A visszatérési értéket közvetlenül is felhasználhatjuk:
>[!example] A visszatérési érték azonnali használata
>```python
>def koszones():
> return "Üdvözlet egy függvényből!"
>
>print(koszones())
>```
Ha egy függvény nem tartalmaz ``return`` utasítást, akkor automatikusan ``None``-t ad vissza.
## A ``pass`` utasítás
A függvénydefiníció **nem lehet üres**.
Ha szeretnénk létrehozni egy függvényt, de még nincs kész a belseje, használhatjuk a ``pass`` utasítást:
>[!example] ``pass`` utasítás használata
>```python
>def fuggvenyem():
> pass
>```
A ``pass`` gyakran hasznos fejlesztés közben: így előre megírhatjuk a program szerkezetét, majd később tölthetjük ki a részleteket.
## Argumentumok
Információt **argumentumok** formájában adhatunk át a függvényeknek.
Az argumentumok a függvény neve után, a zárójelek között szerepelnek.
Annyi argumentumot adhatunk meg, amennyit szeretnénk – vesszővel kell őket elválasztani.
A következő példában a függvénynek **egy argumentuma** van (``keresztnev``).
Amikor meghívjuk, egy keresztnevet adunk át, amit a függvény felhasznál, hogy kiírja a teljes nevet:
>[!example] Függvény egy argumentummal
>```python
>def teljes_nev(keresztnev):
> print("Kovács " + keresztnev)
>
>teljes_nev("Emil")
>teljes_nev("Réka")
>teljes_nev("Richárd")
>```
## Paraméterek és argumentumok
A _paraméter_ és az _argumentum_ gyakran ugyanazt jelenti: a függvénybe átadott információt.
Egy függvény nézőpontjából:
- **paraméter:** a függvény definíciójában szereplő változó a zárójelben.
- **argumentum:** a tényleges érték, amit a függvény meghívásakor átadunk.
>[!example] Paraméter és argumentum közötti különbség
>```python
>def koszontes(nev): # a nev egy paraméter
> print("Szia", nev)
>
>koszontes("Emil") # "Emil" egy argumentum
>```
## Az argumentumok száma
Alapértelmezés szerint a függvényt **pontosan annyi argumentummal** kell meghívni, amennyit elvár.
Ha a függvény 2 argumentumot vár, akkor 2-t kell megadni.
>[!example] 2 paraméter, 2 argumentum
>```python
>def teljes_nev(vezeteknev, keresztnev):
> print(vezeteknev + " " + keresztnev)
>
>teljes_nev("Tóth", "Géza")
>```
Ha rossz számú argumentumot adunk meg, akkor hibát kapunk:
>[!error] Hibás, mert csak 1 argumentumot kap
>```python
>def teljes_nev(vezeteknev, keresztnev):
> print(vezeteknev + " " + keresztnev)
>
>teljes_nev("Tóth")
>```
# Alapértelmezett paraméterértékek
Paraméterekhez **alapértelmezett értéket** is rendelhetünk.
Ha a függvényt argumentum nélkül hívjuk meg, akkor ezt az alapértéket használja.
>[!example] Alapértelmezett paraméteérték
>```python
>def koszones(nev = "barátom"):
> print(f"Szia {nev}!")
>
>koszones("Lukács")
>koszones("Flóra")
>koszones()
>koszones("Zoli")
>```
# Kulcsszavas argumentumok (keyword arguments)
Argumentumokat megadhatunk **kulcs = érték** formában is.
>[!example] Alapértelmezett paraméterérték
>```python
>def my_function(animal, name):
> print("I have a", animal)
> print("My", animal + "'s name is", name)
>
>my_function(animal = "dog", name = "Buddy")
>```
Ilyenkor **nem számít az argumentumok sorrendje**.
>[!example] Más sorrend, ugyanaz az eredmény
>```python
>def my_function(animal, name):
> print("I have a", animal)
> print("My", animal + "'s name is", name)
>
>my_function(name = "Buddy", animal = "dog")
>```
A dokumentációban ezt gyakran ``kwargs`` néven rövidítik.
## Pozicionális argumentumok
Ha kulcs nélkül adjuk meg az argumentumokat, akkor ezek **pozicionális argumentumok**.
A sorrendjük **számít**.
>[!example] Pozicionális argumentumok
>```python
>def my_function(animal, name):
> print("I have a", animal)
> print("My", animal + "'s name is", name)
>
>my_function("dog", "Buddy")
>```
>[!example] Felcserélt sorrend, megváltozik az eredmény
>```python
>def my_function(animal, name):
> print("I have a", animal)
> print("My", animal + "'s name is", name)
>
>my_function("Buddy", "dog")
>```
## Pozicionális és kulcsszavas argumentumok keverése
A pozicionális argumentumoknak **mindig elől kell lenniük**, a kulcsszavasak utánuk jöhetnek.
>[!example] Felcserélt sorrend, az eredmény megváltozik
>```python
>def my_function(animal, name, age):
> print("I have a", age, "year old", animal, "named", name)
>
>my_function("dog", name = "Buddy", age = 5)
>```
## Különböző adattípusok átadása
Bármilyen adattípust átadhatsz egy függvénynek: sztringet, számot, listát, szótárat stb.
Az adattípus a függvényen belül megmarad.
>[!example] Lista átadása
>```python
>def my_function(fruits):
> for fruit in fruits:
> print(fruit)
>
>my_fruits = ["apple", "banana", "cherry"]
>my_function(my_fruits)
>```
>[!example] Szótár átadása
>```python
>def my_function(person):
> print("Name:", person["name"])
> print("Age:", person["age"])
>
>my_person = {"name": "Emil", "age": 25}
>my_function(my_person)
>```
## Visszatérési értékek
A függvények a ``return`` utasítással térnek vissza egy értékkel.
>[!example] Visszatérési érték
>```python
>def my_function(x, y):
> return x + y
>
>result = my_function(5, 3)
>print(result)
>```
## Különböző adattípusok visszaadása
A függvény bármilyen adattípust visszaadhat: listát, tuple-t, szótárat stb.
>[!example] Lista visszaadása
>```python
>def my_function():
> return ["apple", "banana", "cherry"]
>
> fruits = my_function()
> print(fruits[0])
> print(fruits[1])
> print(fruits[2])
>```
>[!example] Tuple visszaadása
>```python
>def my_function():
> return (10, 20)
>
>x, y = my_function()
>print("x:", x)
>print("y:", y)
>```
## Globális hatókör (Global Scope)
A Python-kódban **a főprogramban létrehozott változó globális változó**, és a globális hatókörhöz tartozik.
A globális változók **bármilyen hatókörből elérhetők** – globálisból és lokálisból is.
Egy függvényen kívül létrehozott változó globális, és bárki használhatja:
>[!example] Globális változó
>```python
>x = 300
>
>def myfunc():
> print(x)
>
>myfunc()
>
>print(x)
>```
>
## Változónevek ütközése
Ha ugyanazt a változónevet használjuk egy függvényen **belül** és **kívül**, a Python két külön változóként kezeli őket:
- a függvényen **kívüli** változó → **globális**
- a függvényen **belüli** változó → **lokális**
>[!example] A függvény a lokális `x` értékét írja ki, majd a kód a globális `x` értékét
>```python
>x = 300
>
>def myfunc():
> x = 200
> print(x)
>
>myfunc()
>
>print(x)
>```
>
## ``global`` kulcsszó
Ha egy függvényen belül szeretnél **globális változót létrehozni**, vagy módosítani, akkor a **global** kulcsszót kell használnod.
A ``global`` kulcsszó globálissá teszi a változót.
>[!example] Globális változó létrehozása függvényen belül
>```python
>def myfunc():
> global x
> x = 300
>
>myfunc()
>
>print(x)
>```
A ``global`` kulcsszót akkor is használjuk, ha egy **már létező globális változót** akarsz módosítani függvényből.
>[!example] Globális változó értékének megváltoztatása függvényen belül
>```python
>x = 300
>
>def myfunc():
> global x
> x = 200
>
>myfunc()
>
>print(x)
>```
## ``nonlocal`` kulcsszó
A ``nonlocal`` kulcsszót egymásba ágyazott függvényekben használjuk.
A ``nonlocal`` a változót **a külső függvény lokális változójához** köti.
>[!example] A változó a külső függvényhez fog tartozni
>```python
>def myfunc1():
> x = "Jane"
> def myfunc2():
> nonlocal x
> x = "hello"
> myfunc2()
> return x
>
>print(myfunc1())
>```
A Python a változóneveket az alábbiak szerint keresi meg, ebben a sorrendben:
1. **Lokális** – az aktuális függvényen belül
2. **Befoglaló** – a külső (befoglaló) függvényekben, belülről kifelé
3. **Globális** – a modul legfelső szintjén
4. **Beépített** – a Python beépített névtérben
>[!example] Változónevek keresése
>```python
>x = "globális"
>
>def kulso():
> x = "befoglaló"
> def belso():
> x = "lokális"
> print("Belső:", x)
> belso()
> print("Külső:", x)
>
>kulso()
>print("Globális:", x)
>```
## Feladatok
>[!task] **1. Egyszerű köszönés**
>Írj egy `greet()` nevű függvényt, amely **nem kap argumentumot**, és csak ezt írja ki: `"Hello, Python!"` Hívd meg a függvényt **kétszer egymás után**.
>[!task] **2. Névre szóló köszönés**
>Írj egy `hello(nev)` nevű függvényt, amely: **egy paramétert** kap (`nev`), majd kiírja: `"Hello, {nev}!"`! Például: `Hello, Anna!`
>
>Hívd meg a függvényt legalább háromszor különböző nevekkel, pl.:
>`hello("Anna")`
>`hello("Bence")`
>`hello("Lili")`
>[!task] **3. Összegző függvény**
>Írj egy `add(a, b)` nevű függvényt, amely két számot kap paraméterként (`a` és `b`), **visszaadja** (`return`) a két szám összegét, **nem csak kiírja**!
>
>A főprogramban hívd meg a függvényt néhány különböző párral, pl. `(3, 5)`, `(10, 20)`, az eredményt mentsd el változóba, pl. `eredmeny = add(3, 5)` és írd ki formázottan (`A két szám összege: {eredmeny}`)!
>[!task] **4. Alapértelmezett paraméter**
>Írj egy `bemutatkozas(nev, kor=18)` nevű függvényt, amely két paraméterrel dolgozik: `nev` (kötelező) és `kor` (opcionális, alapértelmezett értéke 18), és így ír ki egy mondatot: `A nevem {nev} és {kor} éves vagyok.`
>
>Teszteld a függvényt így:
>`bemutatkozas("Anna", 15)`
>`bemutatkozas("Bence")`
>`bemutatkozas("Csilla", 22)`
>[!task] **5. Lista feldolgozása függvénnyel**
>Írj egy `hosszu_szavak(szavak, min_hossz)` nevű függvényt, amely kap egy **lista** paramétert,`szavak` (szavak listája, pl. `["alma", "banán", "szilva", "körte"]`), és egy szám paramétert, `min_hossz`, majd végigmegy a listán, és **megszámolja**, hány szó **legalább** `mon_hossz` hosszú; a függvény **visszatérési értéke** legyen ez a darabszám (ne kiírd, hanem add vissza)!
>>[!example] Példa a használatra
>>```python
>>gyumolcsok = ["alma", "banán", "szilva", "körte", "dinnye"]
>>db = hosszu_szavak(gyumolcsok, 5)
>>print(f"Legalább 5 betűs szavak száma: {db}.")
>>```
## Források
- https://www.w3schools.com/python/python_functions.asp (utolsó hozzáférés dátuma: 2025. 11. 27.)
- https://www.w3schools.com/python/python_arguments.asp (utolsó hozzáférés dátuma: 2025. 11. 28.)
- https://www.w3schools.com/python/python_scope.asp (utolsó hozzáférés dátuma: 2025. 11. 28.)