{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "
Változótípusok és számolás pythonban
\n", "===\n", "\n", "

**Ha valaki az igazságot és a törvényszerűséget keresi, nem tehet különbséget kicsiny és nagy problémák között.
Aki a kicsiny dolgokban nem veszi komolyan az igazságot, abban az emberben nagy dolgokkal kapcsolatban sem bízhatunk meg.**\n", "
*Albert Einstein*

\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Ebben a Notebookban bemutatjuk a python nyelv szintaxisát és néhány alapvető adat típust és adatstruktúrát. Illetőleg megnézzük hogyan lehet a pythonban egyszerű matematikai műveleteket elvégezni." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Adattípusok\n", "### Komment (megjegyzés)\n", "A Pythonban a megjegyzések kettős-kereszttel ('#') kezdődnek és a sor végéig tartanak. Egy megjegyzés lehet sor elején, vagy követhet szóközt, tabulátor-karaktert, de ha egy karakterlánc (string) belsejébe teszed, az nem lesz megjegyzés (lásd a példában!). A kettős-kereszt karakter egy karakterláncon belül csak egy kettős-keresztet jelent." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": true, "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "# ez az első megjegyzés\n", "SPAM = 1 # ez a második megjegyzés\n", " # ... és ez a harmadik.\n", "STRING = \"# Ez nem megjegyzés, mert idézőjelekben van.\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A comment csak a programozónak szól emlékeztetőül, vagy más programozók megértését segíti. Noha gyakran elmarad, a kódok rendszeres dokumentálása megjegyzésekkel, később (amikor már a kód részleteit a feledés homály borítja) nagyon kifizetődő lehet." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Számok\n", "\n", "A Pythonban, mint a programozási nyelvekben többféle számtípust tudunk megkülönböztetni. A különbségtétel oka, hogy miként tudja a program a memóriában tárolni a számokat illetve a CPU (a számítógép számolási feladatait ellátó részegység) miként képes kezelni őket.\n", "\n", "A Pythonban megkülönböztetjük többek között az egész (integer) számokat:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "A=2\n", "print(type(A))\n", "print(A)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Vannak lebegőpontos számok (tizedes ponttal ellátott **véges hosszú** számok):" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "B=3.25\n", "print(type(B))\n", "print(B)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Karakterláncok (Stringek)\n", "\n", "A számok mellett a Python karakterláncokkal is tud műveleteket végezni. A karakterláncokat egyszeres ('...') vagy dupla idézőjelek (\"...\") közé lehet zárni. A két jelölés között nincs jelentős különbség. A \\\\ használható arra, hogy a karakterláncbeli idézőjeleket levédjük:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "'spam eggs'" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "'doesn\\'t'" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "\"doesn't\"" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "\"\\\"Yes,\\\" he said.\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A kimeneti karakterlánc idézőjelekben jelenik meg, és a speciális karakterek vissza-perrel (\\) levédve. Bár ez néha különbözőnek látszik a bemenettől (az idézőjel fajtája megváltozhat), a két karakterlánc egyenértékű. A print() függvény egy sokkal olvashatóbb kimenetet eredményez, elhagyva az idézőjeleket és kiírva a levédett és speciális karaktereket:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "'\"Isn\\'t,\" she said.'\n", "print('\"Isn\\'t,\" she said.')" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "s = 'First line.\\nSecond line.' # \\n újsort jelent\n", "s # print() nélkül a \\n benne van a kimenetben\n", "print(s) # print()-tel az \\n újsort hoz létre\n", "\n", "print('C:\\some\\name') # \\n újsort jelent\n", "print(r'C:\\some\\name') # r van az idézőjel előtt --> Meggátolja a \\. értelmezését" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Karakterláncokat a + művelettel ragaszthatunk össze és *-gal ismételhetünk." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "3 * 'un' + 'ium'" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Két egymást követő literális karakterláncot (azokat, amik idézőjelben vannak, és nem egy változóban, vagy nem egy függvény hoz létre) az értelmező magától összefűz:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "'Py' 'thon'" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "prefix = 'Py'\n", "prefix + 'thon' # csak így tud változót és literális karakterláncot összefűzni" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A karakterláncokat indexelhetjük, az első karakterhez tartozik a 0 index, a következőhöz az 1-es index és így tovább. Nincs külön karakter típus; egy karakter egyszerűen egy egy hosszúságú karakterlánc:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "szo = 'Python'\n", "szo[0] # karakter a 0 pozícióban" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Az indexek negatívak is lehetnek, ilyenkor jobbról kezdünk el számolni:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "szo[-2] # utolsó előtti karakter" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Az indexelésen felül a szeletelés is támogatott. Míg az indexelés egyetlen karaktert jelöl ki, a szeletelés egy rész-karakterláncot:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "szo[2:5] # karakterek a 2 pozíciótól (benne van) a 5-esig (az már nem)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "szo[:2] # karakterek az elejétől a 2-esig (már nincs benne)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "szo[42] # a szo csak 6 karakteres" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A beépített len() függvény a karakterlánc hosszával tér vissza:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "s = 'legeslegelkáposztásíthatatlanságoskodásaitokért'\n", "len(s)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Listák (List)\n", "A Python többfajta összetett adattípust ismer, amellyel több különböző értéket csoportosíthatunk. A legsokoldalúbb a lista, amelyet vesszőkkel elválasztott értékekként írhatunk be szögletes zárójelbe zárva. A lista elemeinek nem kell azonos típusúaknak lenniük, bár gyakran minden elem azonos típusú." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "a = ['spam', 'tojások', 100, 1234]\n", "a\n", "['spam', 'tojások', 100, 1234]" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "a[3]" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "a[2] = a[2] + 23\n", "a" ] }, { "cell_type": "markdown", "metadata": { "hide_input": true }, "source": [ "A listák egymásba ágyazhatóak, azaz listába elhelyezhetünk listát elemként:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "a = ['a', 'b', 'c']\n", "nn = [1, 2, 3]\n", "x = [a, nn]\n", "x" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Logikai Bool-változók és feltételes végrehajtás\n", "Ahhoz hogy a program reagálni tudjon bemenetekre, vagy egy már kiszámolt részeredménytől függhessen további működése, szükség van feltételek vizsgálatára. Gondoljunk például a másodfokú egyenlet megoldóképletére! Attól függően, hogy a diszkrimináns pozitív vagy negatív léteznek ill. nem léteznek valós gyökök, így értelemszerűen egy ilyen programnak \"döntenie\" kell. A döntés, egy feltétel vizsgálatán alapul (pl. poz. vagy neg. diszkrimináns), ami lehet igaz, vagy hamis, angolul *True* ill. *False*. Az igaz és hamis értéket tárolni képes változó típusa: **boolean** (Bool-változó). (Emlékezzünk vissza az **int** ill. **float** típusokra).\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Két objektum azonosságáról dupla egyenlőségjellel, azaz a == operátor segítségével tájékozódhatunk. " ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "1 == 1 # 1 megeggyezik 1-el ?" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "1 == 2 # 1 megeggyezik 2-vel ?" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "1 == '1'" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Ha arról akarunk meggyőződni hogy két objektum nem ugyan az akkor ezt a != operátor segítségével tehetjük meg:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "1!=2 #1 nem 2 ?" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "1 != 1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Természetszerűen számok esetén a <,> operátorok segítségével dönthetjük el hogy melyik szám a nagyobb:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "1>2" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "1<2" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false }, "scrolled": true }, "outputs": [], "source": [ "1 < '1'" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Egy igaz/hamis értéket változóban is tárolhatunk:" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Bool változók és más változók kapcsolata\n", "Ahogy fenntebb láttuk egy objektumot egész számmá (**int()** függvény) vagy lebegőpontos számmá tudunk konvertálni ( **float()** függvény). Objektumokat Bool-változóvá is tudunk konvertálni. Erre szolgál a **bool()** függvény. Alább néhány példát nézzünk meg hogy bizonyos dolgok hogy konvertálódnak a **bool()** függvénnyel.\n", "\n", "egy szám vagy egy karakterlánc **True** értéket ad:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "print(bool(1.0))\n", "print(bool('szoveg'))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Egy látszólag rosszul működő példa:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "'b' == ('a' or 'b') " ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "'a' == ('a' and 'b') " ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "'b' == ('a' and 'b') " ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "'a' and 'b'" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A második példa vajon miért **False** ha az első **True** ? A harmadik miért **False** ha a látszólag hasonló negyedik **True**?\n", "Ezen a ponton úgy tűnhet hogy az **and** és **or** utasítások nem működnek megfelelően! Ha részletesen kiböngésszük hogy mit is csinál a python értelmező akkor kiderül hogy pontosan azt teszi amire megkértük.. DE ez nem pontosan az amire elsőnek gondolnánk! Az első két példa tehát nem azt ellenőrzi hogy a **==** előtt álló karakter az szerepel-e a zárójelben! Mi is történik pontosan?\n", "Amikor a python egy **or** kifejezéssel találkozik (a zárójeleken belül) sorba megy az **or** kifejezés által kapcsolatba hozott elemeken és az első **True** - ként kiértékelhető objektum **értékét** adja vissza, tehát nem **True** vagy **False**-t hanem a változó értékét. Ez azért van így mert ha egy **or** kifejezés egyik tagja igaz akkor az egész kifejezés igaz. Az **and** ezzel szemben addig lépdel végig az alkotó kifejezéseken amíg meggyőződött róla hogy mindegyik kifejezés igaznak számít és a legutolsó értéket adja vissza. A bool operációk ezen viselkedését *rövid zár*-nak hívják és sok programozási nyelvben hasonlóan működik. \n", "Tehát ha arról akarunk meggyőződni hogy egy kifejezés valamely kifejezés csoport egyikével megegyezik akkor az alábbiak szerint szükséges eljárni: " ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "print((('a' == 'a') or ('a' == 'b')))\n", "print((('b' == 'a') or ('b' == 'b')))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Előfordul azonban sokszor hogy az a csoport amihez egy lehetséges elemet össze kell hasonlítani igen népes. Például hogy mondjuk meg hogy egy karakterlánc szerepel egy adott hosszú listában? Erre alkalmazható az **in** kulcsszó:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "Tage_der_Woche=['Montag','Dienstag','Mittwoch','Donnerstag','Freitag','Samstag','Sonntag']\n", "print('hetfo' in Tage_der_Woche)\n", "print('Montag' in Tage_der_Woche)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Python mint számológép\n", "A notebookot lehet úgy használni akárcsak egy sima számológép: be lehet írni egy kifejezést, és az kiszámolja az értékét. A kifejezések nyelvtana a szokásos: a +, -, * és / műveletek ugyanúgy működnek, mint a legtöbb nyelvben (például Pascal vagy C); zárójeleket (()) használhatunk a csoportosításra. Például:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "2 + 2" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "50 - 5*6" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Az egész számok (pl. 2, 4, 20) alkotják az **int** típust, azok, a valós számok (pl 5.0, 1.6) pedig a **float** típust. \n", "A python 3-ban az osztás (/) mindig lebegőpontos értékeket ad vissza. Lefelé kerekítő egész osztás elvégzéséhez, amellyel egész értéket kapunk a // operátor használható; az osztás maradékához a %:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "(50 - 5*6) / 4" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "8 / 5 # az osztás egész számok esetén is lebegőpontos eredményt ad. " ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "17 / 3 # hagyományos osztás lebegőpontos eredménnyel" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "17 // 3 # az egész osztással megszabadulunk a törtrésztől" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "17 % 3 # a % operátor az osztás maradékával tér vissza" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "5 * 3 + 2 # eredmény * osztó + maradék" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "5 ** 2 # 5 négyzete" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "2 ** 7 # 2 7-dik hatványa" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "##### Biztos jól számolunk? A lebegőpontos számok véges hosszúak, és a számítógép csak adott hosszú részt vesz figyelembe!" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "C=0.1 - 0.1000000000000000055511151231257827021181583404541015625 # Biztos jól számolunk?\n", "print(C)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "D=(1/29999999999999999)*30000000000000000\n", "print(D-1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Az itt látható hiba nagyon gyakori hiba a numerikus programokban. Nagyon figyeljünk a számábrázolási hibára, hiszen ez az apró eltérés, hibás működéshez vezethet (amit nem mindig jelez a rendszer hibaüzenettel!):" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "10/(D-1.0)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A C-hez hasonlóan az egyenlőségjellel (=) lehet értéket adni egy változónak. Az értékadás után az értelmező újabb utasításra vár, látszólag nem történik semmi:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": true, "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "szelesseg = 20\n", "magassag = 5*9" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "szelesseg * magassag" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Ha egy változó nincs definiálva (nincs érték rendelve hozzá), és használni próbáljuk, akkor hibaüzenetet kapunk:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "nnn # Az n válltozót még nem definiáltuk" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A programnyelv teljes körűen támogatja a lebegőpontos számokat; azok a műveletek amelyeknél keverednek a típusok, az egészeket lebegőpontossá alakítják:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "3 * 3.75 / 1.5" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Előfordul néha hogy egyes függvények int típusú változót várnak és ezt egy float típusúból kell előállítanunk. A típusok közti konverziót az int() és float() függvények segítségével tehetjük meg." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "int(3.1415)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "float(42)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A Python komplex számokat is tud kezelni – a képzetes részt a j vagy J jellel képezhetjük. A komplex számot (valós+képzetes \"j\") formában írhatjuk:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "1j * 1J" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "(1+2j)/(1+1j)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A komplex számokat gyakran két lebegőpontos számmal ábrázolják: a képzetes és a valós résszel. A z komplex számnak ezeket a részeit a z.real és z.imag utasításokkal olvashatjuk vissza." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": true, "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "a=1.5+0.5j" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "a.real" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "a.imag" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Az utoljára kiírt kifejezés értéke a _ (alsó-vonás) változóban van. Így, ha a Pythont asztali számológépként használod, akkor egyszerűbb folytatni a számolásokat, például:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "ado = 12.5 / 100\n", "ar = 100.50\n", "ar * ado" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "ar + _" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "run_control": { "frozen": false, "read_only": false } }, "outputs": [], "source": [ "int(round(ar, 0)) #kerekítés 2 tizedes jegyre" ] } ], "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 }