{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "

Alapvető vezérlési utasítások a programozásban

\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 }