BEVEZETÉS A PROGRAMOZÁSBA

(GI BSc)

Szeghalmy Szilvia, Fazekas Attila

Debreceni Egyetem, Informatikai Kar
Tartalom

• Alprogramok
– void függvények (eljárások)
– nem void függvények
• Gyakorlás
Alprogram

• Névvel ellátott utasítássorozat

• Jól körülhatárolható feladata van (jó esetben)
– Pár példa:
• print: adatok megjelenítése
• input: adatbekérés
• float, int, str függvények: értékek konvertálása
• ceil, round, floor, sin, cos, ...: matematikai függvények

• Újrahasznosítás eszköze
• Kódszervezés eszköze
Kódrészlet

• Olvassunk be három számot, és határozzuk meg az abszolút

értékük összegét. Jelenítsük is meg az eredményt.
x = float(input("x:"))
if x < 0: #abszolútérték
x = -x

y = float(input("y:"))
if y < 0: #abszolútérték
y = -y

z = float(input("z:"))
if z < 0: #abszolútérték
z = -z

osszeg = x + y + z
print(osszeg)
Kódrészlet

• A Pythonban van beépített abs függvény:

x = float(input("x:"))
x = abs(x) # x-et írd felül az abszolútértékével

y = float(input("y:"))
y = abs(y)

z = float(input("z:"))
z = abs(z)

osszeg = x + y + z
print(osszeg)

• A pirossal kiemelve az abs függvénynek átadott argumentum

Kódrészlet

• Csak az összeget kell meghatároznunk

• Az x, y és z abszolútértéke nem lényeges önmagában
=> használhatjuk a függvényt rögtön az összegzésnél is:
#beolvasások
x = float(input("x:"))
y = float(input("y:"))
z = float(input("z:"))

osszeg = abs(x) + abs(y) + abs(z)

print(osszeg)
Függvények létrehozása

• Szintaktika:
def függvény_neve([paraméter_lista]): # fejléc
[dokumentációs_sztring] # """leírás"""
utasítások # törzs

• (Formális) paraméterlista: lehetővé teszi, hogy értékeket adhassunk át a függvényeknek

• Egy abszolútérték függvény egy (szám)értéket vár

def abszolut_ertek(x): # más neveket is adhatunk
"""Az x paraméterben kapott szám abszolútértékét adja vissza"""
utasitasok

• Egy téglalap területét számító függvény pl. az oldalhosszúságokat várja

def teglalap_terulete(a, b): # más neveket is adhatunk
utasitasok
Függvények létrehozása

• A fejléc megléte fél siker, de szükségünk van a törzsre is:

def abszolut_ertek(x):
"""Az x paraméter abszolútértékével tér vissza"""
if x >= 0:
return x
return -x

• return kifejezés
• a kifejezés értékét visszaadja a hívónak
• a függvény végrehajtását azonnal befejezteti

• Ha futtatjuk a szkriptet, a def utasítás létrehozza a függvényeket de nem

hajtja végre a bennük álló utasításokat
Függvényhívás

• A függvény hívása fogja végrehajtatni a függvényen belüli utasításokat!

• Menete:
• Leírjuk a függvény nevét
• Mögé az argumentumlistát kerek zárójelben

print() #a zárójel kötelező!

abs(-3) #3
pow(2, 4) #2 a negyediken

• A hívásnál megadott argumentumok hozzárendelődnek a megfelelő

paraméterekhez
def teglalap_terulete(a, b):
• Sorrendi kötés: #a értéke 10
#b értéke 20
teglalap_terulete(10, 20)

• Név szerinti kötés: def teglalap_terulete(a, b):

#a értéke 9
teglalap_terulete(b=1, a=9) #b értéke 1
Feladat

• Írjuk egy függvényt, mely egy téglalap oldalainak hosszát kapja

paraméterként és visszaadja a téglalap területét:

def terulet(a, b):

_______________

• és egy másik függvényt, mely visszaadja a téglalap kerületét:

def kerulet(a, b):

________________

• Kérjük be a téglalap oldalhosszát a felhasználótól, és a függvények

segítségével írjuk ki a területet és a kerületet.
Láthatóság és élettartam

• Az alábbi példa
• létrehoz egy terulet függvényt
• létrehoz egy b változót 2-es kezdőértékkel
• meghívja a függvényt, és a visszatérési értékét hozzárendeli a T változóhoz
• kiírja a változók értékét

def terulet(a, b):

return a*b # mennyi itt a b értéke?

b = 2
T = terulet(10, 8)
print(T)
print(b) # mennyi itt a b értéke?
Láthatóság és élettartam

• Élettartam:
• A függvény paraméterei és a bennük létrehozott változók
– a függvény meghívásakor jönnek létre (életük elkezdődik)
– a függvény végetértekor megsemmisülnek (élettartamuk lejár)

• Láthatóság:
• A függvény paraméterei és a bennük létrehozott változók csak a
függvényen belül láthatóak

(Egy kicsit leegyszerűsítettük most a helyzetet. Részletek Prog1 előadáson.)

Feladat

• Készíts egy függvényt, mely paraméterként vár két számot

és visszaadja annak összegét.
• Teszteld a függvényt egész számokra és valós számokra.
• Figyeld meg, hogy mi történik, ha sztringekre hívod meg a
függvényt.
Feladat

• Készíts függvényt, amely egy valós számot vár paraméterként és

megjeleníti a képernyőn két tizedesjegy pontossággal.
def print_float(x):
____________________________

• Teszteld le a függvényt:
print_float(2.4)

• Miért nincs return kifejezés? Miért nem kezdtünk semmit a visszatérési

értékkel?
Függvények csoportosítása

• void függvények (visszatérési érték nélküli függvények)

• Más programnyelvek szóhasználatával: eljárások
• Céljuk: környezetük megváltoztatása
– Pl: kiíratás, argumentumok értékének megváltoztatása, függvényen kívül álló, de
azon belül látható változók értékének megváltoztatása
• Pythonban igazából van visszatérési értékük, a speciális None érték
• return utasítás kifejezés nélkül szerepelhet, a függvény befejeztetésére

• nem void függvények (visszatérési értékkel rendelkező függvények)

• Más programnyelvek szóhasználatával: függvények
• Céljuk: egy érték előállítása az esetleges paraméterek alapján
• return kifejezés mindig szerepeljen, minden végrehajtási ágban
• Ne legyen mellékhatása:
– ne csevegjen a felhasználóval, ne módosítsa a paramétereit, csak csinálja meg amit
kell
void és nem void függvények felhasználása

• Ha nincs visszatérési érték nincs mit felhasználni:

print("Ez elég logikus.")

• Ha van visszatérési érték, azt

• elmenthetjük
• kifejezésben szerepeltethetjük

szoveg = input("adj egy számot: ")

x = float(szoveg)
osszeg = abs(x)+abs(-3)

• egymásba is ágyazhatjuk a függvényhívásokat

x = float(input("adj egy számot: "))

Feladat

• Készíts egy ÁFA számító függvényt. A függvény

paraméterként várja egy termék nettó árat és az ÁFA-
kulcsot, és visszaadja az ÁFA-t.

• Készíts egy (void) függvényt, mely megjeleníti az 1, 3, 5 ...,

2*n+1 számokat, ahol n a függvény paramétere.

• Teszteld is a függvényeket.
Feladat

• Készíts egy függvényt, mely megjeleníti a f(x)=x3 függvény értékét 0.2

lépésközzel a x[0; 2] valós számok felett értelmezett tartományon, 2
tizedes pontossággal.
A kiírás formája legyen:
f(<x_erteke>)=<f_x_erteke>
pl: f(0) = 0.00
• Vigyázz, a for ciklus csak egész értékeket képes kezelni.

def kob_kiiro():

• Teszteld is a függvényt.
Feladat

• Készíts egy függvényt, mely a hónap sorszáma alapján visszaadja az

évszakot!
• tél: 12, 1, 2
• tavasz: 3, 4, 5
• nyár: 6, 7, 8
• ősz: 9, 10, 11

• Egy for ciklus segítségével teszteld le a függvényt az összes hónapra.

Függvények hívása függvényből

• A beépített és az általunk definiált függvények is hívhatók függvényekből

• Itt egy példa, mely két 2 dimenziós pont Manhattan távolságát adja meg.
• (x1, y1) és (x2, y2) pontokra a távolság: |x1 - x2| + |y1 - y2|.

def abszolut_ertek(x):
if x >= 0:
return x
return -x

def manhattan_tavolsag(x, y, x2, y2):

return abszolut_ertek(x-x2) + abszolut_ertek(y-y2)

mt = manhattan_tavolsag(0, 0, 10, 4)
print(mt)
Feladat
• Készíts egy függvényt, mely visszaadja két paraméterben kapott érték
maximumát.
def maximum( a, b ):

• Készíts egy függvényt, mely visszaadja két paraméterben kapott érték

minimumát.
def minimum( a, b ):

• Egészíts ki a függvényt, mely megjeleníti az összes egész számot két

paraméterben kapott érték között (bármelyik paraméter is a nagyobb).
def megjelenit(a, b):
also_hatar = __________
felso_hatar = ___________
for i in range(also_hatar+1, felso_hatar):
print(i, end=" ")
• Teszteld le a függvényed!
Feladat

• Készíts függvényt, mely egy neptunkódot vár paraméterként és visszaadja

a megfelelő hallgató nevét. Ha a paraméterben kapott neptunkód nem
szerepel a táblázatban, akkor az "ismeretlen" szót adjon vissza a függvény.
Neptunkód Hallgató
AAAAAA Fel Elek
BBBBBB Nemfel Elek
CCCCCC Feles Elek

• Egészítsd ki a függvényt, mely megjeleníti a hallgatók listáját:

def hallgato_lista():
for i in ["AAAAAA", "BBBBBB", "CCCCCC", "DDDDDD"]:
print(____________________)

• Hívd meg a hallgatók nevét listázó függvényt.

Feladat
• Készíts függvényt, amely egy egész számot vár paraméterként és True
értékkel tér vissza, ha a szám prím, különben False értékkel.
def prim_e(n): Mert az utolsó érték
if n < 2: nincs benne a
__________________ sorozatban.
for i in range(2, int(n**0.5 + 1)):
__________________
____________________ Mert a range
____________________ egész számot vár

• Készíts egy (void) függvényt, mely egy n egész számot vár paraméterként,
és kiírja az összes prímszámot n-nel bezárólag.
def prim_kiiro(n):

• Kérj be egy egész számot a felhasználótól és hívd meg az előző void

függvényt.
Feladat
• Készíts egy függvényt, mely visszaadja, hogy mennyit kell fizetni egy
ételrendelés házhozszállításáért. A függvény 1. paramétere egy irányítószám, a
2. paramétere a rendelés értéke:
• 5000Ft-ot elérő rendelés esetén nincs kiszállítási díj
• Egyébként 4028-as irányítószám esetén 100Ft, más irányítószám esetében 200Ft a
szállítási díj.

def kiszallitasi_dij( irszam, rendeles_ertek ):

• Az online tökfőzelékbárból 600Ft/adag áron rendelhetünk. A rendelésnél a

fejlécben látott paramétereket kell megadnunk. Készítsd el a függvény törzsét,
mely visszaadja a fizetendő összeget a kiszállítási díjjal együtt.

def rendeles( irszam, cim, adag ):

rend_ertek = ______________________
szall_dij = ________________________
return ________________________
Teknőcök elérése

import turtle # teknőc modul eléréséhez

IDE JÖNNEK A FÜGGVÉNYDEFINÍCIÓK

ablak = turtle.Screen() # itt fog(nak) mászkálni a teknőcök

teki = turtle.Turtle() # egy teki létrehozása

teki.shape("turtle")
teki.pencolor("blue") # kékkel rajzol

IDE JÖNNEK A FÜGGVÉNYHÍVÁSOK (DOLGOZTASD MEG A TEKNŐCÖKET)

ablak.mainloop() # Ablakbezárásra vár

https://docs.python.org/3.6/library/turtle.html
Teknőcök

• Készíts egy téglalaprajzoló függvényt. Az oldalak hosszát paraméterként lehessen

megadni.

• Készíts egy négyzet rajzoló függvényt. Az oldal hosszát paraméterként lehessen

megadni. A függvény használja fel (hívja meg) a téglalaprajzoló függvényt.

• Ciklus segítéségével rajzolj ki 10 négyzetet egy sorba. Az oldalhossza legyen 20

egység.
Teknőcök

• Az alábbi függvényt az (x, y) koordinátára viszi a teknőcöt rajzolás nélkül:

def mozgat(teki, x, y):
teki.penup()
teki.goto(x, y)
teki.pendown()

• Készíts egy rácsrajzoló függvényt a segítségével. A függvény a sorok (n) és az

oszlopok (m) számát és az oldalhosszúságot (meret) paraméterben várja.
def racs(teki, n, m, meret):
ismételd n-szer:
ismételd m-szer:
mozdíts a tekit egy megfelelő koordinátára
rajzolj négyzetet
Teknőcök

• Kis átalakítás után sakktábla mintát is rajzolhatsz:

def racs(teki, n, m, meret):

teki.fillcolor("blue")
for i in range(0,n):
for j in range(0,m):
mozgat(teki, j*meret, i*meret)
if (i+j)%2:
teki.begin_fill()
negyzet(teki, meret)
if (i+j)%2:
teki.end_fill()
Teknőcök

• Készíts egy sziromrajzoló függvényt:

def szirom(teki, meret, szin):
teki.fillcolor(szin)
teki.begin_fill()

lépj előre meret-nyit

fordulj balra 30 fokot
lépj előre meret-nyit
fordulj balra 150 fokot
ismételd meg a folyamatot még egyszer

teki.end_fill()
Teknőcök

• Készíts egy virágrajzoló függvényt.

def virag(teki, szirom_meret, szirom_szin, szirmok_szama):

""" Egy virág rajzolása
teki: a rajzoló teknős
szirom_meret: a szirom egy oldalának hossza
szirom_szin: a virág színe
szirmok_szama: hány sziromból álljon a virág
"""
Ismételd meg szirom_szama-szor:
Hívd meg a szirom függvényt a megfeleő paraméterekkel
Fordulj balra 360//szirmok_szama fokot
Teknőcök

• Írj egy réteges virágrajzoló programot a korábbi függvényed

segítségével:
• Hívd meg a virágrajzoló függvényt újra és újra, úgy, hogy a
– a szirom_meret: 100, 90, 80, ..., 20 legyen
– a szirom_szin váltakozzon
– a szirmok_szama 10 legyen