\n",
" "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"%pylab inline"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# If (elágázás, feltétel vizsgálat)\n",
"\n",
"\n",
"\n",
"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.\n",
"\n",
"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. \n",
"\n",
"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."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"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.\n",
"\n",
"Szerkezete:\n",
"\n",
"```python\n",
"if (feltétel vizsgálat):\n",
" utasítás1\n",
"else:\n",
" utasítás2\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"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. \n",
"\n",
">Tehát a következő parancs is értelmes:\n",
"\n",
">```python\n",
"if \"élet értelme\" == 42:\n",
" print(\"Naná\") # És itt nem adunk meg else ágat\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Példák"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"var1 = 100\n",
"if var1:\n",
" print(\"A változónak van értéke\")\n",
" print(var1)\n",
"else:\n",
" print(\"A változónak nincs értéke\")\n",
" print(var1)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"var1 = \"cica\"\n",
"if var1:\n",
" print(\"A változónak van értéke\")\n",
" print(var1)\n",
"else:\n",
" print(\"A változónak nincs értéke\")\n",
" print(var1)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"var1 = \"\"\n",
"if var1:\n",
" print(\"A változónak van értéke\")\n",
" print(var1)\n",
"else:\n",
" print(\"A változónak nincs értéke\")\n",
" print(var1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Adjunk magyarázatot a kovetkezőre:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"var1 = 0\n",
"if var1:\n",
" print(\"A változónak van értéke\")\n",
" print(var1)\n",
"else:\n",
" print(\"A változónak nincs értéke\")\n",
" print(var1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Többszörös elágazások (`if-elif-else`)\n",
"\n",
"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:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"szam=1 #Ide írj be egy számot\n",
"\n",
"if szam > 0:\n",
" if szam%2 == 0:\n",
" print(\"A megadott szám páros pozitív\")\n",
" else: \n",
" print(\"A megadott szám páratlan pozitív\")\n",
"else: \n",
" if szam%2 == 0:\n",
" print(\"A megadott szám páros negatív\")\n",
" else: \n",
" print(\"A megadott szám páratlan negatív\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"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:\n",
"\n",
""
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"szam=1 #Ide írj be egy számot\n",
"\n",
"if szam == 0:\n",
" print(\"nulla\")\n",
"elif szam > 0:\n",
" print(\"pozitív\")\n",
"else:\n",
" print(\"negatív\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**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`.**"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Diákok napja (feladat)\n",
"\n",
"Í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:\n",
"- A fiúk is és a lányok is hétköznap délelőtt tanulnak.\n",
"- 12-től fociznak.\n",
"- Hétvégén mindenki kirándul.\n",
"- Mindennap mindenki 8-kor megy aludni, és reggel 8 kor kel."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"# Megoldás helye"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# For-loop (ciklus)\n",
"\n",
"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. \n",
"\n",
"\n",
"\n",
"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):\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"days_of_the_week = [\"Sunday\",\"Monday\",\"Tuesday\",\"Wednesday\",\"Thursday\",\"Friday\",\"Saturday\"]"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"for day in days_of_the_week:\n",
" print(day)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"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.\n",
"\n",
"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: \n",
"\n",
"`for (i=1..10) {print i}` \n",
"\n",
"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](http://django.arek.uni-obuda.hu/python3-doc/html/tutorial/controlflow.html#intermezzo-kodolasi-stilus) minden behúzást 4 szóköznek javasol.) \n",
"\n",
"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:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"for macska in days_of_the_week:\n",
" print(macska)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"A ciklus utasításblokkja állhat több utasításból is:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"for day in days_of_the_week:\n",
" statement = \"Today is \" + day\n",
" print(statement)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"A **range()** parancs remekül használható ha a **for** ciklusban adott számú műveletet szeretnénk elvégezni:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"for i in range(20):\n",
" print(\"The square of \",i,\" is \",i*i)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Akkor válik mindez még érdekesebbé, ha az eddig tanult iterációt és feltétel vizsgálatot kombináljuk:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"for day in days_of_the_week:\n",
" statement = \"Today is \" + day\n",
" print(statement)\n",
" if day == \"Sunday\":\n",
" print (\" Sleep in\")\n",
" elif day == \"Saturday\":\n",
" print (\" Do chores\")\n",
" else:\n",
" print (\" Go to work\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Figyeljük meg a fenti példában hogy ágyazódik egymás alá a **for** és az **if**! "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Példa a négyzetszámok előállítására:\n",
"\n",
"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."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"dat=[];\n",
"for i in range(10):\n",
" dat.append(i**2)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"dat"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Fibonacci sorozat (feladat)\n",
"\n",
"A [Fibonacci](http://en.wikipedia.org/wiki/Fibonacci_number) sorozat első két eleme 0 és 1, majd a következő elemet mindig az előző kettő összegéből számoljuk ki: 0,1,1,2,3,5,8,13,21,34,55,89,...\n",
"\n",
"Ha nagyobb **n** értékekre is ki akarjuk számolni a sorozatot, ez kiváló feladat lehet egy fáradhatatlan és gyors számítógépnek!"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Egy kis segítségképpen \n",
"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ó.\n",
"\n",
"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. \n",
"\n",
"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."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"# Megoldás helye"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# WhileLoop (Elöltesztelő ciklus)\n",
"\n",
"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.\n",
"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).\n",
"\n",
"Kiugrási lehetőségek a ciklusból (a feltétel teljesülése esetén):\n",
"\n",
"- `break` - rögtön a ciklus utáni utasításra kerül a vezérlés\n",
"- `continue` - a ciklusfeltétel tesztelésére ugrik a vezérlés\n",
"\n",
"Ezek a parancsok mindig 1 ciklusban hajtódnak végre, azaz nincs lehetőség egyszerre több ciklusból való kiugrásra.\n",
"\n",
"Szerkezete:\n",
"\n",
"```python\n",
"while :\n",
" utasítások\n",
"else:\n",
" \"végül\" utasítások\n",
"```"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Erőnk\n",
"power = 5\n",
"\n",
"# Addig dolgozunk amíg el nem fáradunk (az erőnk nagyobb, mint nulla)\n",
"while(power > 0):\n",
" print(\"Még dolgozol, mert az erőd: \"+str(power))\n",
" # Minden körben fogy az erőnk:\n",
" power = power - 1\n",
"else:\n",
" print (\"\\nOh nem, az erőd 0-ra esett, elfáradtál.\")\n",
"# \"\\n\" string az új sor jele, azaz most létrehoz egy üres sort."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Függvények (function)\n",
"\n",
"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."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Függvények és eljárások használatnak előnyei\n",
"\n",
"- csökkenthető a kódismétlődés\n",
"- ugyanaz a függvény más programban is használható\n",
"- ö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\n",
"- javítható a program olvashatósága\n",
"- elrejthetők és szabályozhatók a program egyes részei"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"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. "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"A következőkben bemutatjuk, hogyan lehet egyszerűen a függvények használni. \n",
"\n",
"A függvények szintaktikájára jellemző, hogy 3 fő része van.\n",
"* Beolvasott adatok, paraméterek\n",
"* Műveletvégzés\n",
"* A kész eredmény visszaadása a fő programnak (oda ahol megvolt hívva a függvény): **`return`** rész\n",
"\n",
"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."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"############################\n",
"\n",
"def func(x): # A fügvényünk megkapja az \"x\" adatokat\n",
" return 1/x # A visszadás és a művelevégézés ez esetben egybe van olvasztva\n",
"\n",
"############################\n",
"\n",
"\n",
"x=arange(1,2,0.01) # Geneáljuk az x adatokat"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Lehet több függvényünk is: (f1 és f2 nevű)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"########################################################\n",
"def f1(t): # Egy \"sima\" koszinusz függvény\n",
" y=cos(2*pi*t)\n",
" return y\n",
"########################################################\n",
"########################################################\n",
"def f2(t):\n",
" y=f1(t) * exp(-t) # Adjunk hozzá \"exp(-t)\" csillapítást\n",
" return y\n",
"########################################################\n",
"\n",
"t1 = arange(0.0, 5.0, 0.05)\n",
"\n",
"print(f2(f1(t1))) # Egymásba is ágyazhatóak"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Egy másik példa függvények használatára: \n",
"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: \n",
">`func(x, *(a,b))`"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def func(x,a,b):\n",
" return (x**a)+b\n",
"\n",
"x=arange(1,2,0.01)\n",
"zz=(2.5,100)\n",
"print(zz)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"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:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print(func(x, *(zz)))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Háromszögszámokat előállító függvényt (feladat)\n",
"\n",
"A [Háromszögszámok](https://hu.wikipedia.org/wiki/H%C3%A1romsz%C3%B6gsz%C3%A1mok) 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.\n",
"\n",
"Analitikus formában: \n",
"\n",
"$$\n",
"x=\\frac{n \\cdot (n+1)}{2}\n",
"$$"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"# Megoldás helye"
]
}
],
"metadata": {
"hide_input": false,
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.5.2"
},
"latex_envs": {
"bibliofile": "biblio.bib",
"cite_by": "apalike",
"current_citInitial": 1,
"eqLabelWithNumbers": true,
"eqNumInitial": 0
},
"nav_menu": {},
"toc": {
"navigate_menu": true,
"number_sections": false,
"sideBar": true,
"threshold": 6,
"toc_cell": false,
"toc_section_display": "block",
"toc_window_display": false
}
},
"nbformat": 4,
"nbformat_minor": 1
}