{ "nbformat": 4, "nbformat_minor": 0, "metadata": { "colab": { "name": "kl_py_vezerlok.ipynb", "provenance": [], "collapsed_sections": [ "WDnLMxbVb51p", "OqAphANBb52K", "_EWRCGLAb52e", "d8McYu2-b525", "6V0p5crxb53D" ], "include_colab_link": true }, "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.7.4" }, "latex_envs": { "bibliofile": "biblio.bib", "cite_by": "apalike", "current_citInitial": 1, "eqLabelWithNumbers": true, "eqNumInitial": 0 }, "name": "python-bevezeto.ipynb", "toc": { "toc_cell": false, "toc_number_sections": true, "toc_threshold": 6, "toc_window_display": false } }, "cells": [ { "cell_type": "markdown", "metadata": { "id": "view-in-github", "colab_type": "text" }, "source": [ "\"Open" ] }, { "cell_type": "markdown", "metadata": { "id": "lJHspPrNY9go", "colab_type": "text" }, "source": [ "

\n", " \n", " \n", "

\n", "\n", "\n", "

\n", "\n", "\n", "\n", "# Python alapok változók\n", "\n", "\n", "\n", "\n", "---" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "BDoUZlrxb51O" }, "source": [ "# Alapvető vezérlőutasítások\n", "\n", "Bonyolultabb programok sok egymás után következő utasítás végrehajtásából állnak. \n", "\n", "Azt, hogy melyik utasítás mikor kerül végrehajtásra, a vezérlőutasítások határozzák meg. \n", "\n", "\n", "Minden program nyelvben két alapvető vezérlő utasítás mindenképpen megtalálható, a feltételválasztó és a ciklusszervező.\n", "\n", "A ciklusok végrehajtását a continue és break utasításokkal befolyásolhatjuk. \n", "\n", "Egy speciális utasítás a pass, mely nem csinál semmit, helykitöltésre használható. \n", "\n", "A döntéseknél az if elif else utasítást használhatjuk\n", "\n", "---\n" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "O8nkkP8Tb51P" }, "source": [ "## Az `if` utasítás\n", "Az **`if`** utasítás tölti be a legtöbb nyelvben a feltételválsztó utasítás szerepét. Segítségével határozhatjuk meg, hogy bizonyos körülmények teljesülésekor a program a megfelelő utasításokat hajtsa végre. \n", "Lássunk erre egy példát:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "JgNsmUy-b51Q", "outputId": "538d0865-b448-422c-9fab-32451f85774f", "colab": {} }, "source": [ "if 2+2==4:\n", " print('A matematika még mindig működik')\n" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "A matematika még mindig működik\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "dIyyFspVb51S" }, "source": [ "\n", "---\n", "\n", "

Figyelem, a második sort beljebb húztuk!

A behúzás a Python jelölése az utasítások csoportosítására!

\n", "\n", "A behúzás mértékére általánosan bevett szokás, hogy a szintaktikailag alacsonyabb szintű programrészek négy szóközzel beljebb vannak tolva. \n", "\n", "Ha tehát két **`if`** utasítást ágyazunk egymásba, akkor a második által teljesítendő utasítások 8 szóközzel lesznek beljebb húzva. \n", "\n", "Ez a behúzás a `jupyter` notebook kódcelláiban automatikusan is megtörténik. A `:` utáni ENTER leütése után a következő sor 4 szóközzel kerül beljebb, további ENTER leütése hatására a hierarchia azonos szintjén kezdjük az új sort. \n", "\n", "Ha feljebb szeretnénk lépni, akkor a behúzást ki kell törölni. A C, C++, Java nyelvekben kapcsos zárójeleket {} használnak az egybefüggő kódrészletek elkülönítésére, kb. így: \n", "```C\n", "if (i==10) {\n", "print i\n", "}\n", "```\n", " 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-e. \n", " \n", " (A TAB néhol megengedett, de kerülendő. A modern python kódolási stílusirányzat minden behúzást, ahogy azt fent is említettük, 4 szóköznek javasol.)\n", " \n", " ---\n", " " ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "0Hy1wAyKb51T", "outputId": "a24613f5-9152-4e21-88e6-a51c565c14c5", "colab": {} }, "source": [ "today='Monday';\n", "time='12:00';\n", "if today=='Monday':\n", " if time=='12:00':\n", " print('Nyomassuk a pythont!')" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "Nyomassuk a pythont!\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "Mv35VjO-b51V" }, "source": [ "Bonyolultabb kritériumszerkezetet az **`else`** és **`elif`** parancsok segítségével konstruálhatunk:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "MRpaNwynb51W", "outputId": "7174b4b1-e5a1-4d73-b787-937e55f64599", "colab": {} }, "source": [ "x = 1\n", "if x < 0:\n", " x = 0\n", " print('Negatív, lecseréltem nullára')\n", "elif x == 0:\n", " print('Nulla')\n", "elif x == 1:\n", " print('Egy')\n", "else:\n", " print('Egynél több.')" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "Egy\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "aNha81szb51Y" }, "source": [ "Hiányozhat, de lehet egy vagy akár egynél több **`elif`** rész, az **`else`** rész szintén elmaradhat. Az **`elif`** kulcsszó – amely az ‘else if’ rövidítése – hasznos a felesleges behúzások elkerülésre. Egy **`if`** ...**`elif`** ... **`elif`** ... sor helyettesíti a más nyelvekben található `switch` és `case` utasításokat." ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "nWV255XYb51Y" }, "source": [ "\n", "---\n", "\n", "## A **`for`** utasítás\n", "A számítógépek legfontosabb tulajdonságai közt szerepel az, hogy nagyon gyorsak és \"fáradhatatlanok\". \n", "\n", "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\"). \n", "\n", "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", "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", "\n", "---\n" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "vrWz_IkOb51Z", "colab": {} }, "source": [ "days_of_the_week = [\"Sunday\",\"Monday\",\"Tuesday\",\"Wednesday\",\"Thursday\",\"Friday\",\"Saturday\"]" ], "execution_count": 0, "outputs": [] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "V8yy6-8yb51b", "outputId": "3126d438-4493-42f0-9e20-db95ac37c5cf", "colab": {} }, "source": [ "for day in days_of_the_week:\n", " print(day)" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "Sunday\n", "Monday\n", "Tuesday\n", "Wednesday\n", "Thursday\n", "Friday\n", "Saturday\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "azAqSuu-b51d" }, "source": [ "---\n", "\n", "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. \n", "\n", "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. \n", "\n", "Miután vége a beljebb tabulált régiónak, kilép a ciklusból.\n", "\n", "Annak semmi jelentősége nincs, hogy a példában a **day** nevet adtuk az iterációban szereplő *ciklusváltozó*nak. \n", "\n", "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:\n", "\n", "---\n" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "Aem53Rssb51d", "outputId": "a41105ec-f0fc-4b98-d080-6a206a70af54", "colab": {} }, "source": [ "for macska in days_of_the_week:\n", " print(macska)" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "Sunday\n", "Monday\n", "Tuesday\n", "Wednesday\n", "Thursday\n", "Friday\n", "Saturday\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "DKUrrDPvb51h" }, "source": [ "A ciklus utasításblokkja állhat több utasításból is:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "ehL9xyNmb51i", "outputId": "cffa9035-7c2b-4c5e-d16e-c5e092a42c91", "colab": {} }, "source": [ "for day in days_of_the_week:\n", " statement = \"Today is \" + day\n", " print(statement)" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "Today is Sunday\n", "Today is Monday\n", "Today is Tuesday\n", "Today is Wednesday\n", "Today is Thursday\n", "Today is Friday\n", "Today is Saturday\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "_oz-Fw4zb51k" }, "source": [ "A **`range()`** parancs remekül használható, ha a **`for`** ciklusban adott számú műveletet szeretnénk elvégezni:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "DxFcDXisb51k", "outputId": "12bb693f-45a9-46a7-ef5d-1f5c8ec70932", "colab": {} }, "source": [ "for i in range(20):\n", " print(i,\" szer \",i ,\"az pontosan \",i*i)" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "0 szer 0 az pontosan 0\n", "1 szer 1 az pontosan 1\n", "2 szer 2 az pontosan 4\n", "3 szer 3 az pontosan 9\n", "4 szer 4 az pontosan 16\n", "5 szer 5 az pontosan 25\n", "6 szer 6 az pontosan 36\n", "7 szer 7 az pontosan 49\n", "8 szer 8 az pontosan 64\n", "9 szer 9 az pontosan 81\n", "10 szer 10 az pontosan 100\n", "11 szer 11 az pontosan 121\n", "12 szer 12 az pontosan 144\n", "13 szer 13 az pontosan 169\n", "14 szer 14 az pontosan 196\n", "15 szer 15 az pontosan 225\n", "16 szer 16 az pontosan 256\n", "17 szer 17 az pontosan 289\n", "18 szer 18 az pontosan 324\n", "19 szer 19 az pontosan 361\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "rvYQ6a5ub51m" }, "source": [ "Akkor válik mindez még érdekesebbé, ha az eddig tanult iterációt és feltételvizsgálatot kombináljuk:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "18DXZnZfb51n", "outputId": "82cb838f-8054-4cd3-ca15-52844d8c8785", "colab": {} }, "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\")" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "Today is Sunday\n", " Sleep in\n", "Today is Monday\n", " Go to work\n", "Today is Tuesday\n", " Go to work\n", "Today is Wednesday\n", " Go to work\n", "Today is Thursday\n", " Go to work\n", "Today is Friday\n", " Go to work\n", "Today is Saturday\n", " Do chores\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "t_S9_0ehb51o" }, "source": [ "Figyeljük meg, a fenti példában hogy ágyazódik egymás alá a **`for`** és az **`if`**! " ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "WDnLMxbVb51p" }, "source": [ "## Egy példaprogram: Fibbonacci-sorozat\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": "code", "metadata": { "colab_type": "code", "id": "wNp9lIdtb51q", "outputId": "dd076bac-0033-4604-9c3c-52814aea4755", "colab": {} }, "source": [ "n = 10 # ennyi elemet szeretnénk meghatározni\n", "sequence = [0,1] # az első két elem\n", "for i in range(2,n): # számok 2-től n-ig, Figyelni kell, hogy n ne legyen kisebb mint 2!!\n", " sequence.append(sequence[i-1]+sequence[i-2])\n", "print (sequence)" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "sdItq72Qb51r" }, "source": [ "\n", "---\n", "\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 listamé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.\n", "\n", "---\n" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "3TCdXU9Db51s" }, "source": [ "# Függvények\n", "\n", "Számos programozási nyelvben szokás a felhasználó által megalkotott bonyolultabb utasításokat függvényekbe szervezni. Jól megírt függvények használata általában rövidebbé és jobban átláthatóvá teszi a programokat.\n", "\n", "## Függvények deklarálása\n", "Ha más hosszúságú sorozatot szeretnénk, átmásolhatjuk a fenti kódot egy új cellába, és átírhatjuk az **`n=10`**-et pl. **`n=100`**-ra. Van azonban egy hatékonyabb módszer, új *függvény*-ként definiálhatjuk a **def** utasítás segítségével:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "Y4JhqMn3b51s", "colab": {} }, "source": [ "def fibonacci(sequence_length):\n", " \"A Fibonacci sorozat elso *sequence_length* darab eleme\" # ez csak a 'help'-hez kell\n", " sequence = [0,1]\n", " if 0 < sequence_length < 3:\n", " return sequence[:sequence_length]\n", " for i in range(2,sequence_length): \n", " sequence.append(sequence[i-1]+sequence[i-2])\n", " return sequence" ], "execution_count": 0, "outputs": [] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "ybjhJU31b51u" }, "source": [ "Most már *meghívhatjuk* a **`fibonacci()`** függvényt különböző hosszakra:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "Nsajbwd2b51v", "outputId": "89af7f7c-9d28-46aa-c233-5433cd45bec7", "colab": {} }, "source": [ "fibonacci(5)" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "[0, 1, 1, 2, 3]" ] }, "metadata": { "tags": [] }, "execution_count": 12 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "ru7AWhSQb51x" }, "source": [ "Elemezzük a fenti kódot! A már megszokott módon a kettőspont és behúzás határozza meg a függvénydefinícióhoz tartozó kódblokkot. \n", "A 2. sorban idézőjelek közt szerepel a [\"**docstring**\"](http://django.arek.uni-obuda.hu/python3-doc/html/tutorial/controlflow.html#a-dokumentacios-karakterlancok), ami a függvény működését magyarázza el röviden, és később a **help** paranccsal hívható elő:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "_WqNx2r4b51x", "outputId": "a6b2e53d-9dd5-4e53-a949-674d4d5d218b", "colab": {} }, "source": [ "help(fibonacci)" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "Help on function fibonacci in module __main__:\n", "\n", "fibonacci(sequence_length)\n", " A Fibonacci sorozat elso *sequence_length* darab eleme\n", "\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "XbVEFgwQb51z" }, "source": [ "A notebookos környezetben a docstring a ? segítségével is elérhető:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "0boWFXoEb510", "colab": {} }, "source": [ "?fibonacci" ], "execution_count": 0, "outputs": [] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "al3abChab512" }, "source": [ "A `docstring`-et `jupyter` környezetben úgy is megtekinthetjük, ha egyes függvények hasában, azaz a zárójelek között SHIFT+TAB-ot nyomunk. Próbáld ki ezt az alábbi cellán (annélkül hogy lefuttatnád azt)!" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "sXR-6pK7b512", "colab": {} }, "source": [ "fibonacci()" ], "execution_count": 0, "outputs": [] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "ihDaVSpjb515" }, "source": [ "A függvény kimenetelét a **`return`** kulcsszó határozza meg. Ha a fügvény definiálása során nem használtunk **`return`** utasítást akkor a függvény **None** (semmi) értéket ad vissza. Ha egy függvény lefutott, és nem hajtott végre **`return`** utasítást, akkor is **None** értékkel tér vissza. A **fibonacci** fügvény például egy listát ad vissza:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "beCQyQePb516", "outputId": "c9ecca8c-99f9-47fb-c37e-7bda5738b598", "colab": {} }, "source": [ "x=fibonacci(10)\n", "x" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]" ] }, "metadata": { "tags": [] }, "execution_count": 15 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "SDL5RKOxb519" }, "source": [ "Ez a függvény viszont nem tér vissza sehol:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "3nPOofP-b519", "colab": {} }, "source": [ "def ures_fuggveny(x):\n", " print('Én egy ures fuggvény vagyok,\\nannak ellenére hogy beszélek,\\nnem térek vissza változóval!!')\n", " y=x-2;" ], "execution_count": 0, "outputs": [] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "m1vjpPbIb51_" }, "source": [ "Így a **z** válltozóban nem tárolódik semmilyen érték!" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "sAz46FqNb52A", "outputId": "fe026dbf-2a71-4213-c0b8-0e846b6c7ed2", "colab": {} }, "source": [ "z=ures_fuggveny(3)\n", "z" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "Én egy ures fuggvény vagyok,\n", "annak ellenére hogy beszélek,\n", "nem térek vissza változóval!!\n" ], "name": "stdout" } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "CwuvlsJXb52B", "outputId": "8ca3c656-2f3c-467a-df13-fc908e5b1266", "colab": {} }, "source": [ "print(z)" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "None\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "Zu9nX0cFb52D" }, "source": [ "Egy függvénynek lehet több bemeneti változója is:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "1IO7uetvb52E", "colab": {} }, "source": [ "def osszead(a,b):\n", " return a+b" ], "execution_count": 0, "outputs": [] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "ar9lyytnb52F" }, "source": [ "Az is előfordulhat, hogy több értéket szeretnénk visszakapni egy függvényből. Ezt például az alábbiak alapján tehetjük meg:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "Xm94VZPyb52G", "colab": {} }, "source": [ "def plusminus(a,b):\n", " return a+b,a-b" ], "execution_count": 0, "outputs": [] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "d1_T36cfb52I", "outputId": "78bb9b2a-6496-4106-8d30-1c5a4d3823fb", "colab": {} }, "source": [ "p,m=plusminus(2,3)\n", "print (p)\n", "print (m)" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "5\n", "-1\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "OqAphANBb52K" }, "source": [ "\n", "## Paraméter lista és a \"kicsomagolás\"\n" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "4XXpouC6b52L" }, "source": [ "\n", "\n", "Előfordulhat, hogy egy függvénynek sok bemenő paramétere van, vagy hogy egy függvény bemenő paramétereit egy másik függvény eleve egy listába rendezi. \n", "\n", "Egy tipikus ilyen példa, amint azt későb látni fogjuk, a függvényillesztés esete. Ilyenkor a paramétereket tartalmazó lista \"kicsomagolásával\", amit a \\*-jellel tehetünk meg, kompaktabb kódot érhetünk el. \n", "\n", "Vegyünk például egy olyan esetet amikor egy adatsorra egy ötödfokú polinomot illesztünk. \n", "\n" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "hXM1NlGpb52L" }, "source": [ "$$f(x)=a_0+a_1x+a_2x^2+a_3x^3+a_4x^4+a_5x^5$$" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "MTbFu30ob52M" }, "source": [ "Definiáljunk egy függvényt ami egy \"futó\" $x$ változó és az ötödfokó polinomnak megfelelően hat darab \"paraméter\" $a_i$ változó segítségével kiértékeli a fenti polinomot:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "collapsed": true, "id": "_Sklagdhb52O", "colab": {} }, "source": [ "# ez lesz az illesztendő függvény\n", "def poly5(x,a0,a1,a2,a3,a4,a5):\n", " return a0+a1*x+a2*x**2+a3*x**3+a4*x**4+a5*x**5" ], "execution_count": 0, "outputs": [] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "pQMtRdHQb52R" }, "source": [ "Az illesztés során hat darab illesztési paramétert határozunk meg: $a_0,a_1,a_2,a_3,a_4,a_5$ ám ezeket az illesztő program egy listába rendezve adja a kezünkbe:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "collapsed": true, "id": "NHUng-gHb52S", "colab": {} }, "source": [ "# ezek az illesztés során meghatározott paraméterek\n", "# az alábbi sorrendnek megfelelően\n", "# params=[a0,a1,a2,a3,a4,a5]\n", "params=[ 2.27171539, -1.1368942 , 0.65380304, -0.25005187, -0.1751268 , -0.48828309];" ], "execution_count": 0, "outputs": [] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "jDEM2V_Ab52T" }, "source": [ "Ha ki szeretnénk értékelni az illesztett polinomot az $x=0.3$ helyen, akkor azt megtehetjük az alábbi módon:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "2nUULPkZb52U", "outputId": "d8912156-f0c1-4e43-c8fa-38e9a2b1670e", "colab": {} }, "source": [ "poly5(0.3,params[0],params[1],params[2],params[3],params[4],params[5])" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "1.9801329481213" ] }, "metadata": { "tags": [] }, "execution_count": 24 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "6HzRqLxfb52V" }, "source": [ "vagy az ennél sokkal kompaktabb módszerrel:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "d8w-JUAqb52W", "outputId": "4cb7e951-7f76-4605-8bf3-7fbd18258061", "colab": {} }, "source": [ "poly5(0.3,*params)" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "1.9801329481213" ] }, "metadata": { "tags": [] }, "execution_count": 25 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "c0Bk5uSNb52X" }, "source": [ "Ez a konstrukció lehetővé teszi, hogy a függvény definiálása során felkészísük a függvényt arra, hogy a bemenő\n", "paraméterek száma ne legyen rögzített. Ha a függvény deklaráció során egy paraméter elé **\\***-t teszünk akkor az a paraméter tetszőleges hosszúságú lehet! Vizsgáljuk meg az alábbi példát:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "collapsed": true, "id": "znTqL5nEb52Y", "colab": {} }, "source": [ "def adok_mit_kapok(*argv): #Így, a *-al, készítünk fel egy függvényt \n", " #válltozó számú paraméter fogadására\n", " print(\"Nekem \",len(argv),\"db bemenő paraméterem jött\")\n", " for arg in argv:\n", " print (\"Ez egy paraméter :\", arg)\n", " return argv[-1] #a bemenő paraméterek elemeire mint \n", " #szokványos lista elemekre hivatkozunk" ], "execution_count": 0, "outputs": [] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "-GPuNCvkb52a" }, "source": [ "A fenti blokkban definiált függvény tetszőleges számú bemenő paramétert elfogad! A futás során közli, hogy hány paraméter érkezett, kiírja azokat, illetve a paraméterlista utolsó tagját mint a függvény vissza térési értékét állítja be." ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "O0ADoHrlb52a", "outputId": "fdc31c48-7440-4a36-f247-51ed37d9d475", "colab": {} }, "source": [ "adok_mit_kapok('Gáspár','Menyhért','Boldizsár')" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "Nekem 3 db bemenő paraméterem jött\n", "Ez egy paraméter : Gáspár\n", "Ez egy paraméter : Menyhért\n", "Ez egy paraméter : Boldizsár\n" ], "name": "stdout" }, { "output_type": "execute_result", "data": { "text/plain": [ "'Boldizsár'" ] }, "metadata": { "tags": [] }, "execution_count": 27 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "nw1qJUPCb52c" }, "source": [ "Természetesen a tetszőleges paraméter helyett egy \"kicsomagolt\" tetszőleges hosszúságú listát is használhatunk!" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "fuady3SIb52c", "outputId": "08687ef4-2a08-4443-bf1e-8037f10c46e6", "colab": {} }, "source": [ "adok_mit_kapok(*params) #természetesen itt is működik a kicsomagolás.." ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "Nekem 6 db bemenő paraméterem jött\n", "Ez egy paraméter : 2.27171539\n", "Ez egy paraméter : -1.1368942\n", "Ez egy paraméter : 0.65380304\n", "Ez egy paraméter : -0.25005187\n", "Ez egy paraméter : -0.1751268\n", "Ez egy paraméter : -0.48828309\n" ], "name": "stdout" }, { "output_type": "execute_result", "data": { "text/plain": [ "-0.48828309" ] }, "metadata": { "tags": [] }, "execution_count": 28 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "_EWRCGLAb52e" }, "source": [ "## Függvények kulcsszavakkal" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "NWnqZD8Kb52f" }, "source": [ "\n", "\n", "Azon kívül, hogy a szótárak már önmagukban is igen hasznos adatstruktúrák, később látni fogjuk, hogy sokszor függvények bizonyos paramétereit is szokás szótárakba szedni. \n", "\n", "Az ilyen paramétereket szokás kulcsszavas változóknak vagy kulcsszavas argumentumnak (angol nyelven keyword argument) hívni. \n", "\n", "Ezek használata olvashatóbbá és emberi szemmel is jóval értelmezhetőbbé teszi a programot, ezenfelül további flexibilitást is ad a programozó kezébe. \n", "\n", "\n", "Nézzük ezt meg az alábbi példán:\n" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "collapsed": true, "id": "KCWNMrEkb52f", "colab": {} }, "source": [ "#Így adunk meg alapértelmezett értékeket\n", "def students(ido, allapot='lelkesen figyelik a tanárt', tevekenyseg='kísérletezés', ora='fizika'):\n", " print(\"Ezek a diákok \"+ora+\"órán \"+tevekenyseg+\" közben mindig \"+allapot+\"!\");\n", " print(\"Még akkor is, ha épp \",ido,\"-t mutat az óra!\");" ], "execution_count": 0, "outputs": [] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "x8sEU07_b52j" }, "source": [ "A függvény első paraméterét meg kell adnunk, ha nem adunk többet, akkor az alapértelmezett értékek ugranak be:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "VaaoNbs5b52j", "outputId": "25de0c93-6e00-4c7b-db72-d70bb9b20c7a", "colab": {} }, "source": [ "students('17:00') " ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "Ezek a diákok fizikaórán kísérletezés közben mindig lelkesen figyelik a tanárt!\n", "Még akkor is, ha épp 17:00 -t mutat az óra!\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "2n4euMGOb52n" }, "source": [ "Ha egy kulcsszavas argumentumot kap a függvény, akkor azt értelemszerűen használja:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "5YQY0hqSb52n", "outputId": "7dd3f655-5f39-4710-96ce-7f4a13af2882", "colab": {} }, "source": [ "students('8:00',allapot='unott képet vágnak')" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "Ezek a diákok fizikaórán kísérletezés közben mindig unott képet vágnak!\n", "Még akkor is, ha épp 8:00 -t mutat az óra!\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "J-JCu0H7b52r" }, "source": [ "A kulcsszavas argumentumok sorrendjére nem kell figyelni:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "vx12VWp9b52r", "outputId": "1493c22b-8e8f-4340-a3a8-e166b3b71a9c", "colab": {} }, "source": [ "students('8:00',ora='ógörög',allapot='pánikolva izzadnak',tevekenyseg='TÉMAZÁRÓ')" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "Ezek a diákok ógörögórán TÉMAZÁRÓ közben mindig pánikolva izzadnak!\n", "Még akkor is, ha épp 8:00 -t mutat az óra!\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "rY8fHXWpb52t" }, "source": [ "Ha a deklaráció során nem használt kulcsszót adunk meg, akkor hibát kapunk:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "tNopMEplb52t", "outputId": "87fb0794-6359-4adc-e0ca-e5e233cc0b78", "colab": {} }, "source": [ "students('17:00',tanar='Mici néni')" ], "execution_count": 0, "outputs": [ { "output_type": "error", "ename": "TypeError", "evalue": "students() got an unexpected keyword argument 'tanar'", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mstudents\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'17:00'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mtanar\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'Mici néni'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mTypeError\u001b[0m: students() got an unexpected keyword argument 'tanar'" ] } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "uStEmIQub52v" }, "source": [ "Hasonlóan problémába ütközünk, ha egy kulcsszót kétszer is alkalmazunk:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "vtqlQ6e1b52v", "outputId": "334148c1-c4c6-4068-8347-176e1627fdcf", "colab": {} }, "source": [ "students('8:00',ora='ógörög',ora='kémia')" ], "execution_count": 0, "outputs": [ { "output_type": "error", "ename": "SyntaxError", "evalue": "keyword argument repeated (, line 1)", "traceback": [ "\u001b[0;36m File \u001b[0;32m\"\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m students('8:00',ora='ógörög',ora='kémia')\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m keyword argument repeated\n" ] } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "8f_T7C3vb52w" }, "source": [ "Kulcsszavas argumentumok szótárának kicsomagolása \\*\\*-jel segítségével történik:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "YfGZSxkOb52x", "outputId": "f40ad577-9e52-4ba8-b718-449119b5eb5a", "colab": {} }, "source": [ "diak_hozzaallas={'ora':'ének','allapot':'nyüszítenek'};\n", "students(12,**diak_hozzaallas)" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "Ezek a diákok énekórán kísérletezés közben mindig nyüszítenek!\n", "Még akkor is, ha épp 12 -t mutat az óra!\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "cGsXbnfhb52z" }, "source": [ "Amint a sima paramétereknél is, itt is előfordulhat az, hogy tetszőleges hosszúságú dict-et szeretnénk feldolgozni. Erre példa, ha egy olyan függvényt írunk, amely esetleg több más fügvényt hív, melyeknek tovább akarjuk adni a bejövő paraméterek egy részét. \n", "\n", "Az alábbi függvény egy tetszőleges szótárat vár a bemenetre, megnézi hogy milyen hosszú, és ha a szótárban van 'hamburger' címkéjű kulcsszó, akkor annak az értékét adja vissza:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "collapsed": true, "id": "oh7QEuSRb52z", "colab": {} }, "source": [ "def kulcsot_adok_amit_kapok(**szotar):\n", " print('A szotár hossza:',len(szotar))\n", " for kulcs in list(szotar.keys()):\n", " if kulcs=='hamburger':\n", " print('Van hamburger!')\n", " return szotar[kulcs]" ], "execution_count": 0, "outputs": [] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "SxcrgPHJb522", "outputId": "c846fa24-abeb-490d-f8c8-e388ed0bca32", "colab": {} }, "source": [ "kulcsot_adok_amit_kapok(makaróni=1,torta='finom') #itt már nem jelent hibát ha előre meg nemhatározott kulcsszavaink vannak!" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "A szotár hossza: 2\n" ], "name": "stdout" } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "70ttBJ0Rb524", "outputId": "386334c3-fa19-4352-d7d8-4428a4416a42", "colab": {} }, "source": [ "kaja={'makaróni':1,'torta':'finom','hamburger':137,'saláta':'nincs'}\n", "kulcsot_adok_amit_kapok(**kaja) " ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "A szotár hossza: 4\n", "Van hamburger!\n" ], "name": "stdout" }, { "output_type": "execute_result", "data": { "text/plain": [ "137" ] }, "metadata": { "tags": [] }, "execution_count": 38 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "d8McYu2-b525" }, "source": [ "## Általános függvénydeklarációs szokások" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "5fYhT_Mhb526" }, "source": [ "Amint azt a fentiekben láttuk, függvényeknek többféleképpen is adhatunk paramétereket, \n", "\n", "1. változók (ezek lehetnek sima változók, meghatározott hosszúságú listák, vagy akár kulcsszavas változók is)\n", "2. előre meg nem határozott hosszúságú változó lista\n", "3. kulcsszavas változók tetszőleges hosszú listája\n", "\n", "Sokszor előfordul, hogy egy függvénynek mind a négy fajta bemenete is lehet. Illetve hogy néhány változónak alapértelmezett értéket is adunk. Függvények definiálásánál használjuk a fenti sorrendet!\n", "\n", "Például:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "k8g9zUNTb526", "colab": {} }, "source": [ "def bonyolult_fuggveny(valtozo1,valtozo2,valtozo3='ELZETT',*args,**kwargs):\n", " if ((len(args)==0 and len(kwargs)==0)):\n", " return valtozo3+str(valtozo2)+str(valtozo1)\n", " elif (len(args)!=0 and len(kwargs)==0):\n", " return 'Van valami az args-ban!'\n", " elif (len(args)==0 and len(kwargs)!=0):\n", " return 'Van valami az kwargs-ban!'\n", " else:\n", " return 'Mindenféle változónk van:'+str(valtozo1)+str(valtozo2)+valtozo3+str(args)+str(kwargs)" ], "execution_count": 0, "outputs": [] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "collapsed": true, "id": "is0E1fPTb528" }, "source": [ "A fenti függvény első két változója \"sima\" változó, a harmadik egy kulcsszavas változó az alapértelmezett 'ELZETT' értékkel, és ezen kívül megengedünk még egyéb tetszőleges hosszú \"sima\" változók listáját (args), illetve tetszőleges hosszú kulcsszavas változók listáját (kwargs). Nézzük meg hogy a notebook során korábban definiált változókat felhasználva milyen viselkedést mutat a fent deklarált függvény:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "Mn4tcX8Kb528", "outputId": "7293c61f-4c9d-480f-ea41-2e3f70c02e7a", "colab": {} }, "source": [ "bonyolult_fuggveny(1,2)" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "'ELZETT21'" ] }, "metadata": { "tags": [] }, "execution_count": 40 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "quA6muPsb52-", "outputId": "659dc439-38e9-4333-ab70-e91ed3e0d0cb", "colab": {} }, "source": [ "bonyolult_fuggveny(1,2,valtozo3='MULTLOCK')" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "'MULTLOCK21'" ] }, "metadata": { "tags": [] }, "execution_count": 41 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "_PRwnQ3Sb53A", "outputId": "acb7c98d-550e-40a1-af76-fbb0a9daa9c8", "colab": {} }, "source": [ "bonyolult_fuggveny(1,2,*days_of_the_week)" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "'Van valami az args-ban!'" ] }, "metadata": { "tags": [] }, "execution_count": 42 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "qZzVRuCQb53B", "outputId": "c30b5297-81d7-41c1-d45b-b3a1f61d1eb6", "colab": {} }, "source": [ "bonyolult_fuggveny(1,2,**kaja)" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "'Van valami az kwargs-ban!'" ] }, "metadata": { "tags": [] }, "execution_count": 43 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "E7c8bA7-b53C", "outputId": "5fedb156-4564-4b6d-b01c-7d8d97457c4f", "colab": {} }, "source": [ "bonyolult_fuggveny(1,2,*days_of_the_week,**kaja)" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "\"Mindenféle változónk van:12Sunday('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'){'torta': 'finom', 'hamburger': 137, 'makaróni': 1, 'saláta': 'nincs'}\"" ] }, "metadata": { "tags": [] }, "execution_count": 44 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "6V0p5crxb53D" }, "source": [ "\n", "---\n", "\n", "## A [Lambda](http://www.secnetix.de/olli/Python/lambda_functions.hawk)-formák \n", "\n", "Egy függvénynek nemcsak változókat, hanem más függvényeket is megadhatunk bemenetként. Például gondolhatunk egy olyan függvényre, ami egy matematikai függvényt ábrázol! \n", "\n", "Ilyen esetekben, amikor egy függvény a bemenetére másik függvényt vár, sokszor előfordul, hogy hosszadalmas külön definiálni a bemeneti függvényt. Ekkor tömörebb használni az úgynevezett `lambda`-formákat.\n", "\n", "Nézzünk erre egy példát! Definiáljunk egy függvényt, ami egy másik függvényt értékel ki egy adott helyen, kiírja a kiértékelési helyet, és visszatér a kiértékelt függvényértékkel:\n", "\n", "---\n" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "collapsed": true, "id": "XzHsrgsWb53E", "colab": {} }, "source": [ "def funfun(g,x):\n", " print('Ez volt az x változó: ',x)\n", " return g(x)" ], "execution_count": 0, "outputs": [] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "Qp3YVb0Lb53F", "outputId": "10414f51-4ba8-4085-8b8b-a9d8403f9e24", "colab": {} }, "source": [ "def fx(x):\n", " return x**2-1/x;\n", "funfun(fx,0.1)" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "Ez volt az x változó: 0.1\n" ], "name": "stdout" }, { "output_type": "execute_result", "data": { "text/plain": [ "-9.99" ] }, "metadata": { "tags": [] }, "execution_count": 46 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "hj9p1w7ib53I" }, "source": [ "Ekkor egy úgynevezett `lambda`-forma segítségével alkalmazhatjuk az ennél kicsivel kompaktabb kifejezést (megúszva a függvénydeklarációt):" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "5lgdnAYub53J", "outputId": "5166e677-5daa-49f9-eba6-3bde1e56e278", "colab": {} }, "source": [ "funfun(lambda x:x**2-1/x,0.1)" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "Ez volt az x változó: 0.1\n" ], "name": "stdout" }, { "output_type": "execute_result", "data": { "text/plain": [ "-9.99" ] }, "metadata": { "tags": [] }, "execution_count": 47 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "0ZoA0yorb53L" }, "source": [ "A fenti kifejezésben a \n", ">```Python\n", "lambda x:x**2-1/x\n", "```\n", "\n", "kódrészlet egy \"anonim\" függvényt definiál, amely az $x$ változóhoz hozzárendeli az $x^2-1/x$-et." ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "we79f5mqb53L" }, "source": [ "A `lambda`-kifejezésekkel lehet többváltozós függvényeket is definiálni. Például az alábbi\n", ">```python\n", "lambda x,y:x**2-1/y\n", "```\n", "\n", "kifejezés a\n", "\n", ">```python\n", "def fxy(x,y):\n", " return x**2-1/y\n", "```\n", "\n", "függvénnyel ekvivalens." ] }, { "cell_type": "code", "metadata": { "id": "R6_7aUbRY9jK", "colab_type": "code", "colab": {} }, "source": [ "# Lambda kifejezés minták\n", "\n", "\n", "def square_root(x): return math.sqrt(x)\n", "\n", "# ==== ugyan ez lambda kifelyezéssel:\n", "\n", "square_root = lambda x: math.sqrt(x)\n", "\n", " \n", "#------------------------------------------\n", " \n", "\n", "\n", "def sum(x,y): return x + y\n", "\n", "# ==== ugyan ez lambda kifelyezéssel:\n", "\n", "sum = lambda x, y: x + y \n", "\n", "#------------------------------------------\n", " " ], "execution_count": 0, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "OyDeaTxrY9jL", "colab_type": "text" }, "source": [ "\n", "---\n", "\n", "\n", "## IO Input/Output Bemenet és imenet műveletek\n", "\n", "\n", "### Standard adatfolyamok\n", "Az operációs rendszer indításkor minden folyamathoz hozzárendel 3 szabványos adatfolyamot: \n", "\n", " - a standard bemenetet, \n", " - a standard kimenetet, \n", " - és a standard hibakimenetet. \n", "\n", "\n", "#### Alapértelmezés szerint :\n", " - a standard bemenet a billentyűzettel, \n", " - a standard kimenet és hibakimenet pedig a képernyővel van összekötve. \n", " \n", "\n", "Ez a beállítás módosítható, pl. a standard bemenet érkezhet egy fájlból vagy egy másik programból, \n", "a standard kimenet és hibakimenet pedig íródhat fájlba vagy továbbítódhat másik programnak.\n", "\n", "---\n", " \n", " \n", "## Standard bemenet \n", "\n", "A standard bemenetről adatokat bekérni az input függvény segítségével lehet. \n", "\n", "Az eredmény sztring típusú. Ha más adattípusra van szükség, akkor konvertálni kell.\n", "\n", "\n" ] }, { "cell_type": "code", "metadata": { "id": "kDdzlGtOY9jM", "colab_type": "code", "colab": {}, "outputId": "b10d555b-f3e6-4e3d-d4f6-5dbce16ccdaa" }, "source": [ "## Sztring típusú adat beolvasása. \n", "x = input('Kérek egy szöveget: ') \n", "print(x)\n", "\n", "## Egész típusú adat beolvasása. \n", "y = int(input('Kérek egy egész számot: ')) \n", "print(y)\n" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "Kérek egy szöveget: ez egy szöveg\n", "ez egy szöveg\n", "Kérek egy egész számot: 42\n", "42\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "sup0touiY9jP", "colab_type": "text" }, "source": [ "\n", "---\n", "\n", "## Standard kimenet és hibakimenet \n", "\n", "A standard kimenetre és hibakimenetre kiírni a print függvény segítségével lehet.\n", "\n" ] }, { "cell_type": "code", "metadata": { "id": "Vz3FtBvtY9jP", "colab_type": "code", "colab": {}, "outputId": "2eeebecf-8ca8-40d5-ffe3-9dc202be1006" }, "source": [ "print('hello') ## Kiírás a standard kimenetre.\n", "print('hello', end='') ## Kiírás soremelés nélkül. \n", "print() ## Egyetlen soremelés kiírása.\n", "\n", "import sys \n", "print('Hiba történt.', file=sys.stderr) ## Kiírás a standard hibakimenetre.\n" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "hello\n", "hello" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "s9FceyBBY9jS", "colab_type": "text" }, "source": [ "\n", "---\n", "\n", "\n", "### Formázott kiírás\n" ] }, { "cell_type": "code", "metadata": { "id": "VYdq5nQRY9jS", "colab_type": "code", "colab": {}, "outputId": "e9cfa1c6-a0e8-4eb4-f012-b8d28847ef63" }, "source": [ "\n", "x1 = 12.3456\n", "x2 = 4.5678 \n", "print('Az első szám {}, a második szám {}.'.format(x1, x2)) ## Formázott kiírás format metódussal.\n", "\n", "print('Az első szám {:.1f}, a második szám {:.1f}.'.format( x1, x2 )) ## Kiírás 1 tizedesjegy pontossággal. \n", "\n", "print('egész szám: {}, sztring: {}'.format(42, 'Marcika')) ## Egész szám ill. sztring kiírása. \n", "\n", "print('Az első szám %f, a második szám %f.' % (x1, x2)) ## Formázott kiírás % operátorral. \n", "\n", "print('Az első szám %.1f, a második szám %.1f.' % (x1, x2)) ## Kiírás 1 tizedesjegy pontossággal. \n", "\n", "print('egész szám: %d, sztring: %s' % (42, 'Móricka')) ## Egész szám ill. sztring kiírása. \n", "\n", "print('X1 szám, {}!'.format(x1)) ## % használata nálkül" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "Az első szám 12.3456, a második szám 4.5678.\n", "Az első szám 12.3, a második szám 4.6.\n", "egész szám: 42, sztring: Marcika\n", "Az első szám 12.345600, a második szám 4.567800.\n", "Az első szám 12.3, a második szám 4.6.\n", "egész szám: 42, sztring: Móricka\n", "X1 szám, 12.3456!\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "utIG-fhLY9jU", "colab_type": "text" }, "source": [ "\n", "---\n", "\n", "## Comprehension-ök\n", "\n", "\n", "\n", "A comprehension egy olyan nyelvi elem a Pythonban, amely szekvenciák tömör megadását teszi lehetővé.\n", "\n", "Acomprehension némileghasonlít a matematikában alkalmazott, tulajdonság alapján történő halmazmegadásra \n", "\n", "Megjegyzés: A Python stabil rendezőlgoritmust alkalmaz\n", "\n", "\n", "\n", "\n", "### Feltétel nélküli comprehension\n" ] }, { "cell_type": "code", "metadata": { "id": "5G-t_Tq9Y9jV", "colab_type": "code", "colab": {}, "outputId": "719c2705-e6ce-4389-f56c-37df45ec6b36" }, "source": [ "## Állítsuk el® az első 10 négyzetszám listáját győjtőváltozó használatával! \n", "l = [] \n", "for i in range(1, 11): \n", " l.append(i**2) \n", "print('norm', l)\n", "\n", "## Ugyanez tömörebben, lista comprehension-nel: \n", "l = [i**2 for i in range(1, 11)] \n", "print('comp', l)\n", "\n", "##--------------------------------------------\n", "## Állítsuk elő az első 10 négyzetszám halmazát gyűjtőváltozó használatával! \n", "s = set() \n", "for i in range(1, 11): \n", " s.add(i**2) \n", "print(s)\n", "\n", "\n", "## Ugyanez tömörebben, halmaz comprehension-nel: \n", "s = {i**2 for i in range(1, 11)} \n", "print(s)\n", "\n", "##--------------------------------------------\n", "## Állítsunk elő egy szótárat, amely az angol kisbetűs magánhangzókhoz \n", "## hozzárendeli az ASCII-kódjukat! Használjunk gyűjtőváltozót! \n", "d = {} \n", "for ch in 'aeiou': \n", " d[ch] = ord(ch) \n", " print(d)\n", "\n", " \n", "## Ugyanez tömörebben, szótár comprehension-nel: \n", "d = {ch: ord(ch) for ch in 'aeiou'} \n", "print(d)\n", "\n", "\n", "## Feladat: Párok tagjainak megcserélése egy listában. \n", "pairs = [('alma', 10), ('körte', 20), ('barack', 30)] \n", "[(p[1], p[0]) for p in pairs]\n", "print(pairs) # [(10, 'alma'), (20, 'körte'), (30, 'barack')] \n", "\n", "\n" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "norm [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n", "comp [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n", "{64, 1, 4, 36, 100, 9, 16, 49, 81, 25}\n", "{64, 1, 4, 36, 100, 9, 16, 49, 81, 25}\n", "{'a': 97}\n", "{'a': 97, 'e': 101}\n", "{'a': 97, 'e': 101, 'i': 105}\n", "{'a': 97, 'e': 101, 'i': 105, 'o': 111}\n", "{'a': 97, 'e': 101, 'i': 105, 'o': 111, 'u': 117}\n", "{'a': 97, 'e': 101, 'i': 105, 'o': 111, 'u': 117}\n", "[('alma', 10), ('körte', 20), ('barack', 30)]\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "bOmAvMEmY9jW", "colab_type": "text" }, "source": [ "\n", "---\n", "\n", "\n", "### Feltételes comprehension\n", "\n", "\n" ] }, { "cell_type": "code", "metadata": { "id": "l6XPztIQY9jW", "colab_type": "code", "colab": {} }, "source": [ "## Feltételes lista comprehension. \n", "[i**2 for i in range(1, 11) if i % 2 == 0]\n", "\n", "\n", "## Feltételes halmaz comprehension. \n", "{i**2 for i in range(1, 11) if i % 2 == 0}\n", "\n", "## Feltételes szótár comprehension. \n", "{ch: ord(ch) for ch in 'aeiou' if ch != 'u'}\n", "\n", "\n", "\n" ], "execution_count": 0, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "-YNMqqGmY9jY", "colab_type": "text" }, "source": [ "\n", "---\n", "\n", "## Rendezés\n", "\n" ] }, { "cell_type": "code", "metadata": { "id": "GrBjdvKeY9jZ", "colab_type": "code", "colab": {}, "outputId": "194ef3e8-9464-440a-b124-29e6cab11113" }, "source": [ "\n", "## Lista rendezése helyben. \n", "l = [10, 2, 11, 3] \n", "l.sort()\n", "print(l)\n", "\n", "\n", "## Rendezés csökkenő sorrendbe. \n", "l.sort(reverse=True) \n", "print(l)\n", "\n", "\n", "## Fontos, hogy az elemek összehasonlíthatók legyenek! \n", "q = [1, 2, 'alma'] \n", "#q.sort() ## hibaüzenet, \n", "\n", "\n", "## Ha csak sztringeket tartalmaz a lista, akkor lehet rendezni. \n", "q = ['alma', 'szilva', 'körte'] \n", "print(q.sort())\n", "\n", " \n", "## Kollekció rendezése listába. \n", "l1 = [10, 4, 20, 5] \n", "l2 = sorted(l1)\n", "print(l2)\n", "\n", "\n", "## Tuple elemeit is rendezhetjük egy új listába. \n", "print(sorted(('c', 'a', 'b')))\n", "\n", "\n", "## ...és halmaz elemeit is. \n", "print(sorted({'c', 'a', 'b'}))\n", "\n", "\n", "## Szótár esetén a sorted a kulcsokat rendezi. \n", "print(sorted({'b': 10, 'a': 20}))\n", "\n", "\n", "\n", "## Párok listájának rendezése (lexikografikusan). \n", "print(sorted([('sör', 10), ('bor', 20), ('pálinka', 30), ('bor', 50)]))\n" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "[2, 3, 10, 11]\n", "[11, 10, 3, 2]\n", "None\n", "[4, 5, 10, 20]\n", "['a', 'b', 'c']\n", "['a', 'b', 'c']\n", "['a', 'b']\n", "[('bor', 20), ('bor', 50), ('pálinka', 30), ('sör', 10)]\n" ], "name": "stdout" } ] } ] }