Számonkérés
- Nagy ZH: október 14. hétfő, 18:00 - 19:30 HSZK (beosztás később)
- A portálon majd jelentkezni kell!
- Terembeosztás is majd ott lesz.
- ~90 perc, három feladat
NZH anyaga
- Ami a ZH-ig szerepelt előadáson és laboron.
- Gyakorolni kell! Sokat!
- Megajánlott jegy: az első megírt NZH számít!
Főprogram
def main():
db = 0
for sz in range(2, 1001):
if prim_e(sz):
db += 1
print(db, "db prímszám.")
main()Alprogram
def prim_e(szam):
vanoszto = False
for o in range(2, szam):
if szam % o == 0:
vanoszto = True
break
return not vanosztoElnevezések: fejléc, függvénytörzs, paraméter, visszatérési érték, hívás, visszatérés, lokális változó, láthatóság, élettartam.
A prim() függvény olyan, mint a teljes programunk: van bemenete és kimenete is. Csak ezek
nem a képernyő és a billentyűzet, hanem a főprogrammal történő kommunikáció által valósulnak meg:
Függvények definiálása: szintaktika
def függvénynév(paraméterlista): ... függvénytörzs ... return visszatérési_érték
A fejléc (header) meghatározza a függvény nevét, a paraméterei (parameter) számát. A függvénytörzs (function body) tartalmazza azt a programrészt, amely a függvény feladatát elvégzi.
Visszatérés a függvényből
A függvény törzsében elhelyezett return utasítással
visszatérhetünk (return) a függvény hívásának (call) helyére.
Ezzel egyben megadjuk a visszatérési értéket is, amelyet
egyébként a függvény értékének (function value) is nevezünk. Fontos, hogy a return
utasítás ezt a két szerepet elválaszthatatlanul összeköti! Ami a return
után van, az már nem hajtódik végre. (Viszont egy függvényben lehet több helyen
is return utasítás.)
Lokális változók
A függvényen belül is létrehozhatunk változókat. Ezek:
- Szintén értékadáskor jönnek létre
- A függvényből visszatérve megszűnnek → értékük elveszik
- Minden függvény csak a sajátjait látja! (láthatóság, scope)
Mi az előnyük? Például az, hogy minden függvénynek
lehetnek saját lokális változói, amelyekben olyan értékeket tárolnak, amelyekre
csak a futásuk idején van szükség. A fenti példában az osztó
változóra nincsen már szükség, amint meghatároztuk, hogy a szám prím-e.
(A van változó is lokális, és az is megszűnik, azonban az
értéke lemásolódik, és átadódik a hívónak.) Ezek a változók csak a függvényen
belül látszanak (a láthatóságuk (scope) csak a függvényen belülre terjed ki),
és így a nevük csak azon belül értelmezett. Másik függvényeknek
lehetnek ugyanolyan nevű lokális változóik, a nevek mégsem
fognak ütközni. További előny, hogy a változó nem foglal memóriát, csak akkor,
ha az azt definiáló függvény belsejében vagyunk. Vagyis a változó élettartama
(storage duration, lifetime és extent szavak is használatosak az angol
szakirodalomban) is csak arra az időre terjed ki, amíg a
függvény végrehajtása tart.
A függvényeknek értéke és mellékhatása lehet.
print(faktorialis(6))
print(faktorialis(6))
print(faktorialis(6))720 720 720
Érték: a kifejezés értéke.
print(random.randint(1,100));
print(random.randint(1,100));
print(random.randint(1,100));23 59 65
Mellékhatás: valahol változást okoz.
Az érték azt a számot, sztringet, listát... jelenti, amit a függvény a return utasítással
visszaadott. Ezért szoktuk a függvény hívását a függvény kiértékelésének is nevezni: a függvény lefut, és a hívás helyén
lévő kifejezésbe a visszatérési értéke behelyettesíthető.
Ezen felül a függvénynek lehet mellékhatása is, ami azt jelenti, hogy valahol valamit megváltoztatott. Például kiírt valamit a képernyőre, letörölt egy fájlt és így tovább.
Ha egy függvénynek nincs mellékhatása, akkor ugyanazokra a paraméterekre mindig ugyanazt az eredményt adja. Ha
van mellékhatása, ez nem biztos, hogy így lesz! Valahol valaminek történnie kell, hogy a random.randint(1, 100) mindig
más számot ad vissza. Ez a függvény kell rendelkezzen valamiféle belső állapottal. Láthatóan a kimenete nem csak a bemenő
paramétereitől függ.
Vannak olyan függvények, amiknek csak értékük van, mellékhatásuk nincs. Például a math.sqrt(2)
kiértékelésével megkapjuk az 1.414 értéket, de biztosak lehetünk abban, hogy semmilyen változás nem történt.
Vannak olyan függvények is, amelyeknek nincs értékük, csak mellékhatásuk. Ilyen a print(): ez kiír valamit
a képernyőre, de nem ad vissza semmit. Az ilyenek matematikai értelemben véve nem függvények már, de ennek ellenére programozásban
így hívjuk őket.
Fontos: ha a specifikáció nem kéri a kiírást, akkor kifejezetten hibának számít, ha a függvény mégis ilyet tesz! Például kiírja a képernyőre az eredményt ahelyett, hogy visszatérne vele. Hadd döntse el a hívó, mit szeretne csinálni az eredménnyel!
Általában igyekszünk olyan függvényeket írni, amelyeknek csak értéke, vagy csak mellékhatása van. Ennek az elvnek neve is van: command-query separation. Eszerint kétféle függvény van. Az egyik fajta a parancsfüggvény (command), amelyet azért használunk, hogy hatása legyen. A másik fajtának kérdéseket teszünk fel (query), amely kiszámol valamit, de mellékhatása nincs. Ha ez a kettő keveredik, az könnyen összevisszasághoz, átláthatatlan programfelépítéshez és nehezen megtalálható hibákhoz vezet.
Látszik persze, hogy a random modul randint() függvénye kilóg a sorból. De ez kivétel kell legyen:
kell legyen értéke is, a generált véletlenszám; és mellékhatása is, hogy a következő véletlenszám más lehessen. Különben
értelmetlen lenne.
A funkcionális dekompozíció (functional decomposition) egy tervezési elv. A másik neve a felülről lefelé (top-down) elv. Lényege, hogy a problémát részfeladatokra bontjuk. Az egész rendszert, programot úgy tervezzük meg, hogy közben a részfeladatokat megoldottnak tekintjük. Az egyes részfeladatok megoldása közben így nem kell a többi részleteivel bajlódni. A részfeladatok ugyanúgy specifikálhatóak, mintha egy teljes programról lenne szó.
– Gerald J. Sussman
A funkcionális dekompozíció céljai:
- Felülről lefelé tervezés (top-down design)
- Tervezés egyszerűsítése: „oszd meg és uralkodj”
- A programrészek közötti csatolások csökkentése
Érdekesség: Gerald Jay Sussman amerikai programozó, matematikus, aki legtöbbet a mesterséges intelligenciával foglalkozik. Az ő nevéhez is fűződik a Structure and Interpretation of Computer Programs című könyv megírása is, amelyhez egy programozás alapjait bemutató tárgy is tartozott az MIT egyetemen. A fenti idézet az egyik előadásáról származik. A tárgyat egyébként a saját maguk által kifejlesztett programozási nyelvvel tanították, amelynek a neve Scheme.
A top-down tervezést „wishful thinking” néven mutatta be (kb. ábrándozó gondolkodás). Hiszen éppen ez a lényege: „Bárcsak lenne egy olyan függvény, amelyik megmondja egy számról, hogy prímszám-e... Mert ha igen, akkor milyen egyszerű lenne a feladatunk!” Sokszor ezzel a gondolkodásmóddal tudjuk szétválasztani a részfeladatokat.
Ezek szerint tehát itt egy darab lista van és két darab változó. Emlékezzünk vissza a referenciákra, azok alapján rögtön meg tudjuk értni, mi itt a helyzet!
A listát, mint memóriában tárolt adatot, objektumnak (object) nevezzük. A lista objektumot a szögletes
zárójelekkel [] hoztuk létre, és itt az append() függvénnyel módosítjuk.
Az objektumra hivatkozhatunk, ahogy az ábra nyilai is mutatják. Az objektumokra hivatkozást referenciának (reference) neveztük. A létrehozott változók (variable) azok, amelyek ezeket a referenciákat tárolják, azaz hozzájuk kötöttünk egy objektumot (binding). Így lehetett több referenciánk ugyanarra az objektumra: több változó tárolja ugyanazt a referenciát, több változóhoz van hozzákötve egy objektum.
a = [1, 2, 3]
b = a
b.append(4)
def lista_bovit(b):
b.append(4)
a = [1, 2, 3]
lista_bovit(a)
Amikor egy változónak értéket adunk, akkor egy referenciát állítunk be egy meglévő
objektumra. Ugyanez játszódik le a függvényhívás esetében is (lásd a második kódrészletet). Kezdetben van egy listánk, az
[1, 2, 3] kifejezéssel létrehozott objektum. Azt hivatkozza (referálja) az a nevű változó. Ezek után
meghívjuk a függvényt, paraméterként adva neki az a változót. A függvény paramétere, azaz b is csak egy
ugyanolyan változó, mint a többi, és mivel azt a értékével inicializáltuk, ezért b is ugyanannak a
listának a referenciája lett. Ugyanaz a memóriakép állt elő, mint az első kódrészletben. Emiatt ha a b-n keresztül
látott lista végéhez fűzünk hozzá 4-et, az pont olyan, mintha a hívás helyén a.append(4)-et írtunk volna: az
a változón keresztül is elérhető lista egy elemmel hosszabb lesz.
A lista mutábilis típus
a = [1, 2, 3, 4, 5]
a[2] = -3
print(a)[1, 2, -3, 4, 5]
b = a
b = list(a) # nem mindegy!A lista objektumok értéke, tartalma változhat: az egyes elemeik módosíthatóak, kitörölhetőek, és így tovább. Az ilyen típusokat módosíthatónak, mutábilisnak (mutable) nevezzük.
Mivel maga az objektum változhat, nem mindegy, hogy csak a referenciáját másoljuk, vagy magát az objektumot is. Ha csak a referenciáját, akkor hiába van több nevünk, ugyanazzal az objektummal dolgozunk mindvégig. Persze sokszor éppen ez a célunk, de sosem tudhatjuk, ki látja még az objektumot, és ki módosíthatja azt – ezt tisztázni kell a programban, annak dokumentációjában.
A sztring immutábilis típus
a = "almafa"
a[0] = "A"TypeError: 'str' object does not support item assignment
b = a # sosem lehet gond
Vannak olyan objektumok, amelyek tartalma, értéke nem változhat. Ezeket immutábilisnak (immutable) hívjuk. A számok is ilyenek, de a sztringeknél még szembetűnőbb a dolog. A listákkal ellentétben ezeknek nem tudjuk módosítani az egyes karaktereit külön-külön, legfeljebb új sztringet tudunk létrehozni.
Ha egy objektum immutábilis, akkor mindegy, hogy hány referenciánk van rá. Nincs haszna annak sem, ha lemásoljuk (nem csak a referenciáját, hanem a tartalmát is). Ha több változó tárolja ugyanazt a szöveget, akkor is elég a karaktersorozatot egyszer eltárolni a memóriában, osztozhatnak rajta a változók. Mivel a tartalom nem változhat, nem lényeges, hogy egy vagy több példány van belőle, mert nem történhet olyan, hogy egyik változón keresztül beleírunk az objektumba, és közben egy másik változónk értéke „elromlik”.
A += operátor nem módosítja a sztringet?
Itt meg kell említeni egy látszólagos ellentmondást, a += operátort és társait. Bár úgy tűnhet, hogy ez módosítja
egy változó tartalmát, valójában viszont nem így történik! Az x += y csak az x = x + y rövidítése. Ami
azt jelenti, hogy kiértékelődik az x + y kifejezés, és létrejön egy új objektum; aztán az x változó
ennek az objektumnak a referenciáját fogja tárolni.
Lássuk ezt sztringekre! Lentebb a b = a értékadás hatására a b változó ugyanazt a referenciát
tartalmazza, mint az a. Ezek után b-hez hozzáfűztünk egy szót. De valójában b = b + "fa"
értékadásnak kezeli ezt a Python. Ekkor pedig új objektum keletkezik, és a b már nem mutat az a-val
közös szövegre, hanem az új objektum hivatkozása lesz.
a = "alma"
b = a
b += "fa"
Vizsgáljuk meg még egyszer a kódrészleteket, a változók, objektumok és referenciák működését szem előtt tartva!
def szamot_novel(b):
b += 1
print(b)
def main():
a = 3
print(a)
szamot_novel(a)
print(a)
3
4
3 !
def listat_bovit(b):
b.append(4)
print(b)
def main():
a = [1, 2, 3]
print(a)
listat_bovit(a)
print(a)
[1, 2, 3]
[1, 2, 3, 4]
[1, 2, 3, 4] !
Az első esetben tehát a függvényhívás pillanatában létrejön egy új referencia. Ez a b nevű
változó, a paraméter, amelyik ugyanarra az objektumra mutat, mint az a nevű: a 3-as egész számra. A b +=
1 értékadás valójában b = b + 1, amivel a nevű változót állítjuk át egy újonnan létrejött objektumra,
a 4-es egész számra. És ami a lényeg: itt a b nevű változót állítottuk át, és ez semmiféle hatással nincsen a
főprogram a nevű változójára. A függvényből visszatérve a b nevű változó meg is szűnik.
Nem így a listás példában. Kezdetben ott is létrejön egy referencia ugyanarra az objektumra (a listára). A
függvény belsejében viszont ne ma referenciát, hanem az általa hivatkozott objektumot módosítjuk a b.append()
függvényhívással. Mivel az objektum módosult, a főprogramban érzékelni fogjuk a változást – annak ellenére is, hogy mire
visszatértünk a függvényből, a b nevű változó már megszűnt.
Hogy írunk számot megnövelő függvényt?
def novel(szam):
szam += 1
x = 5
novel(x)
print(x) # 5def kovetkezo(szam):
return szam + 1
x = 5
x = kovetkezo(x) # !
print(x) # 6Megnöveli a változót?
Hogyan írjuk meg tehát azt a függvényt, amely megnöveli a neki paraméterként átadott változót?
Leginkább sehogy. Mivel a függvényhívásnál a paraméterátadás új változót hoz létre, az eredeti változóra
nem tudunk hatással lenni, az int típusú objektum pedig immutábilis. Legfeljebb olyan függvényt írhatunk,
amelyik visszatér egy másik objektummal, amivel felülírjuk az eredeti változót.
Megcseréli-e a függvény két lista tartalmát?
A listák mutábilis objektumok. Megcseréli-e ez a függvény két lista tartalmát?
def lista_csere(l1, l2):
temp = l1
l1 = l2
l2 = temp
a = [1, 2, 3]
b = [4, 5, 6]
lista_csere(a, b)
print(a, b, sep="\n") # mit ír ki?Megcseréli a listák tartalmát?
[1, 2, 3] [4, 5, 6]
Hiába mutábilisak a listák, az értékadással a változókat módosítjuk, nem pedig a listákat.
A függvényhíváskor létrejött két új változó, l1 és l2. Ezek a hívás helyén látott a
és b változók másolatai; ugyanazok a listák érhetők el rajtuk keresztül, de mint változók, függetlenek
az eredeti a-tól és b-től. Vagyis ha l1-nek és l2-nek adunk értéket,
akkor sem a, sem b nem fog módosulni; az értékadások nem módosították sem az eredeti változókat,
sem a listákat.
