Alapvető vezérlési utasítások a programozásban
%pylab inline
If (elágázás, feltétel vizsgálat)¶
Ha azt szeretnénk, hogy valami akkor történjen, ha megfelel vagy épp nem felel meg valamilyen feltételnek (valami egyenlő-e valamivel, nagyobb-e, ...) akkor feltétel vizsgálatot kell végezni és az eredmény szerinti feladatot elvégezni.
Például, ha gyököt akarunk vonni egy beadott számból szükséges lehet ilyen vizsgálat. Ugyanis ha pozitív a szám semmi gond, ha viszont negatív, akkor ezt kezelni kell, mondjuk szorozzuk meg -1-el.
Ez a kérdés magyarul hogy is szól: Ha a szám nagyobb (vagy egyenlő) mint 0 akkor vonjunk gyököt, ha pedig nem akkor szorozzuk meg mínusz eggyel és utána vonjunk gyököt belőle. Lehet érzeni a mondatban, mit mikor kell elvégezni.
Ennek a műveleteknek az elvégzésére több paranccsal is alkalmas, de a leggyakoribb az if-else parancs. Ez lényegében egy elágazás, ami azt teszik, hogy ha igaz az állítás, akkor megcsinál valamit, ha meg hamis, akkor mást.
Szerkezete:
if (feltétel vizsgálat):
utasítás1
else:
utasítás2
Megjegyzés: Nem kötelező mindkét ágban utasítást adni, ilyenkor csakis a feltétel teljesülésekor hajtódik végre utasítás.
Tehát a következő parancs is értelmes:
if "élet értelme" == 42: print("Naná") # És itt nem adunk meg else ágat
Példák¶
var1 = 100
if var1:
print("A változónak van értéke")
print(var1)
else:
print("A változónak nincs értéke")
print(var1)
var1 = "cica"
if var1:
print("A változónak van értéke")
print(var1)
else:
print("A változónak nincs értéke")
print(var1)
var1 = ""
if var1:
print("A változónak van értéke")
print(var1)
else:
print("A változónak nincs értéke")
print(var1)
Adjunk magyarázatot a kovetkezőre:
var1 = 0
if var1:
print("A változónak van értéke")
print(var1)
else:
print("A változónak nincs értéke")
print(var1)
Többszörös elágazások (if-elif-else)¶
Az elágazások egymásba fűzhetőek két módon. Vagy egy már nyitott elágazásban helyezünk el újabb elágazást, vagy többszörös feltételvizsgálatot végzünk az elágazásunkon. Lássuk most az első esetet:
szam=1 #Ide írj be egy számot
if szam > 0:
if szam%2 == 0:
print("A megadott szám páros pozitív")
else:
print("A megadott szám páratlan pozitív")
else:
if szam%2 == 0:
print("A megadott szám páros negatív")
else:
print("A megadott szám páratlan negatív")
Ha nem egymásba akarunk teljesen eltérő feltételeket vizsgálni, hanem összefüggően, több feltételt külön-külön vizsgálni (több elágazásunk van), akkor használjuk az if-elif-else szerkezetet:
szam=1 #Ide írj be egy számot
if szam == 0:
print("nulla")
elif szam > 0:
print("pozitív")
else:
print("negatív")
Megjegyzés: Törekedjünk a lehető legkevesebb új elágazás használatára. Mivel a sok elágazás átláthatatlanná teszi a program működését. Azaz szerencsésebb az if-elif-else használata, mint sok önálló if-else.
Diákok napja (feladat)¶
Írjunk egy if tömböt amely a nap és az óra változók megadott értékei alapján eldönti, hogy épp az adott időben a diák mit csinál. Az if tömb válasza az alábbiak szerint osztandó ki:
- A fiúk is és a lányok is hétköznap délelőtt tanulnak.
- 12-től fociznak.
- Hétvégén mindenki kirándul.
- Mindennap mindenki 8-kor megy aludni, és reggel 8 kor kel.
# Megoldás helye
For-loop (ciklus)¶
A számítógépek legfontosabb tulajdonságai közt szerepel az, hogy nagyon gyorsak és "fáradhatatlanok". Olyan feladatok megoldásában a leghatékonyabbak, amikor a feladatot kevés munkával meg lehet fogalmazni ("az alkotó pihen") de végrehajtása nagyon sok ismétlést, iterációt igényel ("a gép forog"). Az iteráció (angol: iterate) azt jelenti, hogy például egy lista elemein egyesével végigmegy a program, és műveleteket végez el rajtuk.
A Python-ban, az egyik erre használható utasítás a for parancs (magyarul kb. a ...-ra, azaz pl. a hét minden napjára, a lista minden elemére):
days_of_the_week = ["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"]
for day in days_of_the_week:
print(day)
Ez a kódrészlet a days_of_the_week listán megy végig és a meglátogatott elemet hozzárendeli a day változóhoz, amit ciklusváltozónak is neveznek. Ezek után mindent végrehajt amit a beljebb tabulált (angolul: indented) parancsblokkban írtunk (most csak egy print utasítás), amihez felhasználhatja a ciklusváltozót is. Miután vége a beljebb tabulált régiónak, kilép a ciklusból.
Szinte minden programnyelv használ hasonló ciklusokat. A C, C++, Java nyelvekben kapcsos zárójeleket {} használnak a ciklusok elkülönítésére, kb. így:
for (i=1..10) {print i}
A FORTRAN nyelvben az END szócska kiírása jelzi a ciklus végét. A pythonban a kettőspont (":"), majd szóközökkel beljebb írt sorok szolgálnak erre. Ha más programokból másolunk át részleteket figyeljünk arra hogy a behúzás helyett nem TAB-ot használ. (A TAB néhol megengedett de kerülendő. A modern python kódolási stílusirányzat minden behúzást 4 szóköznek javasol.)
Annak semmi jelentősége nincs, hogy a példában a day nevet adtunk az iterációban szereplő ciklusváltozónak. A program semmit se tud az emberi időszámításról, például, hogy a hétben napok vannak és nem kiscicák:
for macska in days_of_the_week:
print(macska)
A ciklus utasításblokkja állhat több utasításból is:
for day in days_of_the_week:
statement = "Today is " + day
print(statement)
A range() parancs remekül használható ha a for ciklusban adott számú műveletet szeretnénk elvégezni:
for i in range(20):
print("The square of ",i," is ",i*i)
Akkor válik mindez még érdekesebbé, ha az eddig tanult iterációt és feltétel vizsgálatot kombináljuk:
for day in days_of_the_week:
statement = "Today is " + day
print(statement)
if day == "Sunday":
print (" Sleep in")
elif day == "Saturday":
print (" Do chores")
else:
print (" Go to work")
Figyeljük meg a fenti példában hogy ágyazódik egymás alá a for és az if!
Példa a négyzetszámok előállítására:¶
A program 0-tól 9-ig kiszámolja a számok négyzetét, majd egy listában sorban egymás mögé fűzi.
dat=[];
for i in range(10):
dat.append(i**2)
dat
Egy kis segítségképpen Nézzük végig lépésről lépésre! Először n értékét, azaz a kiszámolandó sorozat hosszát állítjuk be 10-re. A sorozatot majdan tároló listát sequence-nek neveztük el, és inicializáltuk az első két értékkel. A "kézi munka" után következhet a gép automatikus munkája, az iteráció.
Az iterációt 2-vel kezdjük (ez ugye a 0-s indexelés miatt a 3. elem lesz, hisz az első kettőt már mi megadtuk) és n-ig, a megadott lista méretig számolunk.
A ciklus törzsében az addig kiszámolt lista végére hozzátűzzük (append) az előző két tag összegét. A ciklus vége után kiíratjuk az eredményt.
# Megoldás helye
WhileLoop (Elöltesztelő ciklus)¶
A while a hagyományos elöltesztelős ciklus (a for és az if ötvözete). A ciklus addig fut, amíg valamilyen általunk definiált feltétel teljesül.
Lehetőség van kilépési ág megadására is, és ez az else-ága akkor fut le, ha a ciklusfeltétel nem teljesül (tehát a ciklus elhagyása után mindig, kivéve ha break utasítással hagyjuk el a ciklust).
Kiugrási lehetőségek a ciklusból (a feltétel teljesülése esetén):
break- rögtön a ciklus utáni utasításra kerül a vezérléscontinue- a ciklusfeltétel tesztelésére ugrik a vezérlés
Ezek a parancsok mindig 1 ciklusban hajtódnak végre, azaz nincs lehetőség egyszerre több ciklusból való kiugrásra.
Szerkezete:
while <feltétel>:
utasítások
else:
"végül" utasítások
# Erőnk
power = 5
# Addig dolgozunk amíg el nem fáradunk (az erőnk nagyobb, mint nulla)
while(power > 0):
print("Még dolgozol, mert az erőd: "+str(power))
# Minden körben fogy az erőnk:
power = power - 1
else:
print ("\nOh nem, az erőd 0-ra esett, elfáradtál.")
# "\n" string az új sor jele, azaz most létrehoz egy üres sort.
Függvények (function)¶
A számítógép-programozásban a függvény (function) egy nagyobb program forráskódjának egy viszonylag jól felismerhető része, amely egy adott feladatot hajt végre. A kód többi részétől viszonylag független egység, és többször felhasználható anélkül, hogy a program kódjának több példányban is tartalmaznia kellene, azaz többször, több helyen is hivatkozhatunk ugyanarra a függvényre. Hasonló fogalmat jelölnek a eljárás, szubrutin, metódus, procedúra vagy alprogram nevek is.
Függvények és eljárások használatnak előnyei¶
- csökkenthető a kódismétlődés
- ugyanaz a függvény más programban is használható
- összetett problémák egyszerűbb részekre bonthatók, ami könnyebbé teszi a kód frissítését és bővítését
- javítható a program olvashatósága
- elrejthetők és szabályozhatók a program egyes részei
Az eddig megismert parancsokat felfoghatjuk már előre definiált függvényként. Például a exp parancs, olyan függvény, ami kiszámolja az e hatványait. Vagy a következő órán bemutatott plot egy olyan eljárás, ami ábrázolja az adatokat. Néhány programozási nyelvben szokás különbséget tenni eljárás és függvény között. A függvény egy csoportja az eljárások halmazának. Olyan speciális eljárások, melyeknek van valamilyen visszatérési értéke (csinál valami, és az eredményt visszaadja a programnak). Tehát a plot inkább csak szimpla eljárás, míg az exp, vagy sqrt igazi függvények. A C-ben és a pythonban a két fogalmat szinonimaként használhatjuk.
A következőkben bemutatjuk, hogyan lehet egyszerűen a függvények használni.
A függvények szintaktikájára jellemző, hogy 3 fő része van.
- Beolvasott adatok, paraméterek
- Műveletvégzés
- A kész eredmény visszaadása a fő programnak (oda ahol megvolt hívva a függvény):
returnrész
A következő példában a func függvény kiszámolja a beadott szám reciprokát, majd az eredményt visszaadja meghívás helyének, ez esetben a plot parancs y adatsorának.
############################
def func(x): # A fügvényünk megkapja az "x" adatokat
return 1/x # A visszadás és a művelevégézés ez esetben egybe van olvasztva
############################
x=arange(1,2,0.01) # Geneáljuk az x adatokat
Lehet több függvényünk is: (f1 és f2 nevű)
########################################################
def f1(t): # Egy "sima" koszinusz függvény
y=cos(2*pi*t)
return y
########################################################
########################################################
def f2(t):
y=f1(t) * exp(-t) # Adjunk hozzá "exp(-t)" csillapítást
return y
########################################################
t1 = arange(0.0, 5.0, 0.05)
print(f2(f1(t1))) # Egymásba is ágyazhatóak
Egy másik példa függvények használatára:
Figyeljük meg, hogy a függvény hívásakor több paramétert is meg kell adni! (x,a,b-t is, ahol x egy vektor, míg a és b konstansok). A konstansok átadása a következő módon történik:
func(x, *(a,b))
def func(x,a,b):
return (x**a)+b
x=arange(1,2,0.01)
zz=(2.5,100)
print(zz)
A zz változó most egy speciális lista, úgynevezett tuple típusú változó. Ezeket a "listákat" nem lehet elemként kezelni, kivéve, ha kibontjuk őket. (Úgy szokták hívni a tuple-t, hogy nem módosítható lista.) Most bontsuk ki a paramétereket a függvény számára a `*()' használatával:
print(func(x, *(zz)))
Háromszögszámokat előállító függvényt (feladat)¶
A Háromszögszámok azok a számok, amelyek előállnak az első valahány egymást követő természetes szám összegeként. A feladat, hogy legeneráljuk az első néhány ilyen számot függvényt használva.
Analitikus formában:
$$ x=\frac{n \cdot (n+1)}{2} $$# Megoldás helye