Python-ban a kódban bárhol definiálható függvény, a def kulcsszóval.
def fv_neve(n):
pass
fv_neve(5)
Ez egy függvény definíció, itt csak azt írjuk le, hogy mit csináljon a negyzetel függvény, ha meghívjuk:
def negyzetel(l):
uj_l = []
for i in l:
uj_l.append(i*i)
return uj_l
A def kulcsszó után a függvény nevét írjuk, utána zárójelekben felsoroljuk a bemeneti paramétereket. A kettőspont után új blokk kezdődik, mint például egy for ciklusban, ez a blokk fut le amikor meghívjuk a függényt.
A blokkon belül új kulcsszó a return mely hatására a függvény futása leáll és az eredménye a return után írt kifejezéssel.
Egy függvényt a nevével tudunk meghívni, mely után zárójelekben a bemeneti argumentumokat kell felsorolni (itt csak egy lista a bemeneti argumentum):
negyzetel([4, 3, 5])
Természtesen egy változón is meg lehet hívni a függvényt:
szamok = [5, 1, 8]
negyzetelt_szamok = negyzetel(szamok)
print(szamok, negyzetelt_szamok)
Mivel "jól" volt megírva a függvényünk így semmi nem kívánt dolog nem történt, de nézzük meg mi lesz, ha ezt a megvalósítást használjuk:
def negyzetel2(l):
i = 0
while i < len(l):
l[i] = l[i] ** 2
i += 1
return l
szamok = [5, 1, 8]
negyzetelt_szamok = negyzetel2(szamok)
print(szamok, negyzetelt_szamok)
Tehát amilyen műveletet a függvényen belül végrehajtottunk a listán az a beadott argumentumon végrehajtódott, megváltozott a szamok lista. Erről egy későbbi előadáson még részletesen beszélünk, addig is tudjunk róla, hogy ilyen is lehetséges.
A paramétereket vesszővel választjuk el:
def skalaris_szorzat(v1, v2):
osszeg = 0
for i in range(len(v1)):
osszeg += v1[i] * v2[i]
return osszeg
skalaris_szorzat([2, 3, 5], [1, 5, 2])
A paraméterek bármilyen típusúak lehetnek. Akárhány paramétere lehet egy függvénynek, akár nulla is, a zárójelek ebben az esetben is kellenek:
def üzenet():
return "Jó reggelt!"
üzenet()
Első (felszínes) megközelítésben függvényről beszélünk, ha meghívásának módja: függvénynév, majd zárójelpárban az argumentumok felsorolása, metódusról, ha meghívásának módja: az objektum után pont, majd a metódus neve, majd zárójelben az argumentumok. Pl.:
l = [5, 2, 4]
l.sort()
print(l)
A sort a pythonban egy beépített metódusa a listáknak, mely rendezi az adott listát. Jó példa, mert létezik függvény formában is:
l = [5, 2, 4]
ujl = sorted(l)
print(l, ujl)
A sorted függvény nem rendezi az argumentumként adott listát, hanem visszaad egy rendezett listát.
Ez a legtöbbször igaz a beépített metódusokra és függvényekre, tehát a függvények nem módosítják a kapott változókat, míg a metódusok módosítják az objektumot (változót) amin meg vannak hívva (ami a pont bal oldalán áll). Ezt a konvenciót hasznos követni és csak olyan függvényeket írni, melyek nem módosítják a kapott változókat.
Metódus írásról később tanulunk.
return használata¶A return utasítás függvényből kilépését ki lehet használni, például:
def prim_e(n):
oszto = 2
while oszto ** 2 <= n:
if n % oszto == 0:
return False
oszto += 1
return True
print(prim_e(4))
print(prim_e(23))
Itt azt használtuk ki, hogy amint egy return parancshoz ér a függvény azonnal kilép és visszaadja ezt az eredményt. Tehát amint találunk egy osztót azonnal visszatérünk a hamis eredménnyel. Igazzal pedig csak akkor térünk vissza, ha végigért a ciklus, azaz nem találtunk megfelelő osztót.
Megjegyzés: a break egy ciklusból lép ki (csak ciklusból és csak egyből), míg a return függvényből (csak egy függvényből, de annak bárhány ciklusából).
return után állhat None, jelezvén, hogy "semmit" adott vissza a függvény.
Ha egy függvény nem találkozik futása során return paranccsal, akkor None-t ad ki eredményül.
Például ha elfelejtünk return-t írni vagy rossz helyre tesszük.
Megjegyzés: a .sort() metódus eredénye None, de mellékhatása, hogy közben rendezi a paraméterként kapott listát.
l = [3, 2, 1, 4]
l2 = l.sort()
print(l2, l)
Általunk írt függvényeket természetesen használhatunk más általunk írt függvényekben. Ez erősen ajánlott is.
Érdemes 4-5 sornál hosszabb függvényeket mellőzni, pontosabban azokat kisebb függvényekből összerakni. Így a függvényeink rövidek és egyértelműek lesznek. A működésük derüljön ki a változók és magának a függvénynek a nevéből.
Fealadat: Írjunk egy függvényt, melynek bemenete egy lista, melyben megkeresi a legkisebb és legnagyonbb elemet, kimenete pedig egy másik lista, melyben a legkisebb és legnagyobb elemek mind ki vannak nullázva!
Hogyan futunk neki egy ilyen feladatnak?
Itt a következő részfeladatokra bontható:
def minimum(l):
min_elem = float("inf")
for e in l:
if e < min_elem:
min_elem = e
return min_elem
def maximum(l):
max_elem = -float("inf")
for e in l:
if e > max_elem:
max_elem = e
return max_elem
def kinullaz(l, elem):
ujl = l[:] # Másolatot készítése (elejétől végéig részlista)
for i in range(len(ujl)):
if ujl[i] == elem:
ujl[i] = 0
return ujl
Most, hogy a részfeladatokat már megoldottuk nem maradt hátra más, mint hogy összerakjuk egybe a fő függvényt:
def min_max_nullaz(l):
minelem = minimum(l)
maxelem = maximum(l)
ujl = kinullaz(l, minelem)
ujl = kinullaz(ujl, maxelem)
return ujl
min_max_nullaz([2, 3, 1, 4, 6, 2, 9, 3, 1, 3, 1, 9, 3, 9])
min_max_nullaz([])
min_max_nullaz([1, 1, 1, 2])
Az utolsó három sor helyett írhattuk volna akár ezt is:
return kinullaz(kinullaz(l, minelem), maxelem)Természetesen meg lehetett volna oldani ezt a feladatot egy függvénnyel is, itt az eredmény:
def min_max_nullaz2(l):
min_elem = float("inf")
for e in l:
if e < min_elem:
min_elem = e
max_elem = -float("inf")
for e in l:
if e > max_elem:
max_elem = e
ujl = l[:] # Másolatot készítése (elejétől végéig részlista)
for i in range(len(ujl)):
if ujl[i] == min_elem:
ujl[i] = 0
for i in range(len(ujl)):
if ujl[i] == max_elem:
ujl[i] = 0
return ujl
min_max_nullaz2([2, 3, 1, 4, 6, 2, 9, 3, 1, 3, 1, 9, 3, 9])
Az első megoldás:
Bár a második megoldás is működik.
def buborek(l):
ujl = l[:]
for i in range(len(ujl) - 1):
for j in range(len(ujl) - i - 1):
if ujl[j] > ujl[j + 1]:
ujl[j], ujl[j + 1] = ujl[j+1], ujl[j]
# temp = ujl[j], ujl[j] = ujl[j + 1], ujl[j + 1] = temp
return ujl
buborek([2, 3, 1, 4, 6, 2, 9, 3, 1, 3, 1, 9, 3, 9])
buborek(list(range(10, 0, -1)))
Írjuk ki minden lépés után a rendezés aktuális állapotát:
def buborek_kiir(l):
ujl = l[:]
for i in range(len(ujl) - 1):
for j in range(len(ujl) - i - 1):
print(ujl) # Kiírás
if ujl[j] > ujl[j + 1]:
ujl[j], ujl[j + 1] = ujl[j+1], ujl[j]
return ujl
buborek_kiir(list(range(10, 0, -1)))
Ennél hatékonyabb algoritmusok léteznek a keresésre, ezekről részletesebben az Algoritmuselmélet című tárgyban lesz szó.
Feladat: Valósítsuk meg még azt az ötletet, hogy egyesével megkessük a legkisebb, a második legkisebb, stb. elemet és ezeket a megfelelő helyre tesszük.
def minimum_index(l):
min_index = 0
for i in range(len(l)):
if l[i] < l[min_index]:
min_index = i
return min_index
def min_rendez(l):
ujl = l[:]
for i in range(len(ujl) - 1):
minindex = i + minimum_index(ujl[i:])
ujl[i], ujl[minindex] = ujl[minindex], ujl[i]
return ujl
min_rendez([2, 3, 1, 4, 6, 2, 9, 3, 1, 3, 1, 9, 3, 9])
min_rendez(list(range(10, 0, -1)))
def min_rendez_kiir(l):
ujl = l[:]
for i in range(len(ujl) - 1):
print(ujl)
minindex = i + minimum_index(ujl[i:])
ujl[i], ujl[minindex] = ujl[minindex], ujl[i]
return ujl
min_rendez_kiir(list(range(10, 0, -1)))
min_rendez_kiir([4, 5, 2, 3, 6, 7, 1])
A kiírástól csalóka lehet, mert kevesebb kimenetet kaptunk, ez azért van, mert itt csak a külső for ciklusban van a kiírás, nem a belsőben. Itt a belső ciklus el van rejtve a minimum_index függvényben.