{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>VĂĄltozĂłtĂ­pusok ĂŠs szĂĄmolĂĄs pythonban</center>\n",
    "===\n",
    "\n",
    "<p style=\"text-align: right;\">**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. <br>Aki a kicsiny dolgokban nem veszi komolyan az igazsĂĄgot, abban az emberben nagy dolgokkal kapcsolatban sem bĂ­zhatunk meg.**\n",
    "<br>*Albert Einstein*</p>\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": 1,
   "metadata": {
    "collapsed": 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": [
    "### 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": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 == 1  # 1 megeggyezik 1-el ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 == 2 # 1 megeggyezik 2-vel ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1!=2 #1 nem 2 ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1>2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1<2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unorderable types: int() < str()",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-10-9ee3bb6f2cf3>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;36m1\u001b[0m \u001b[1;33m<\u001b[0m \u001b[1;34m'1'\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: unorderable types: int() < str()"
     ]
    }
   ],
   "source": [
    "1 < '1'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Egy igaz/hamis ĂŠrtĂŠket vĂĄltozĂłban is tĂĄrolhatunk:"
   ]
  },
  {
   "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": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'spam eggs'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'spam eggs'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"doesn't\""
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'doesn\\'t'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"doesn't\""
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"doesn't\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\"Yes,\" he said.'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"Isn't,\" she said.\n"
     ]
    }
   ],
   "source": [
    "'\"Isn\\'t,\" she said.'\n",
    "print('\"Isn\\'t,\" she said.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First line.\n",
      "Second line.\n",
      "C:\\some\n",
      "ame\n",
      "C:\\some\\name\n"
     ]
    }
   ],
   "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": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'unununium'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Py' 'thon'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'P'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'o'"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'tho'"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Py'"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "szo[:2]  # karakterek az elejétől a 2-esig (már nincs benne)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "string index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-37-f7e2d342191a>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mszo\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m42\u001b[0m\u001b[1;33m]\u001b[0m  \u001b[1;31m# a szo csak 6 karakteres\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m: string index out of range"
     ]
    }
   ],
   "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": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "47"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['spam', 'tojĂĄsok', 100, 1234]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = ['spam', 'tojĂĄsok', 100, 1234]\n",
    "a\n",
    "['spam', 'tojĂĄsok', 100, 1234]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1234"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['spamspamspamspamspamspamspamspamspamspamspamspamspamspamspamspamspamspamspamspamspamspamspam',\n",
       " 'tojĂĄsok',\n",
       " 123,\n",
       " 1234]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['a', 'b', 'c'], [1, 2, 3]]"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = ['a', 'b', 'c']\n",
    "nn = [1, 2, 3]\n",
    "x = [a, nn]\n",
    "x"
   ]
  },
  {
   "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": 53,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "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": 55,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'b' == ('a' or 'b') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'a' == ('a' and 'b') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'b' == ('a' and 'b') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'b'"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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, thá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": 65,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "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": 66,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "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": [
    "### 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": 67,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "2\n"
     ]
    }
   ],
   "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": 68,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n",
      "3.25\n"
     ]
    }
   ],
   "source": [
    "B=3.25\n",
    "print(type(B))\n",
    "print(B)"
   ]
  },
  {
   "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": 69,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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észosztá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": 71,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(50 - 5*6) / 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.6"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "8 / 5  # az osztás egész számok esetén is lebegőpontos eredményt ad. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.666666666666667"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "17 / 3  # hagyományos osztás lebegőpontos eredménnyel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "17 // 3  # az egészosztással megszabadulunk a törtrésztől"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "17 % 3  # a % operĂĄtor az osztĂĄs maradĂŠkĂĄval tĂŠr vissza"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 * 3 + 2  # eredmĂŠny * osztĂł + maradĂŠk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 ** 2  # 5 nĂŠgyzete"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "128"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 79,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0\n"
     ]
    }
   ],
   "source": [
    "C=0.1 - 0.1000000000000000055511151231257827021181583404541015625   #  Biztos jĂłl szĂĄmolunk?\n",
    "print(C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0\n"
     ]
    }
   ],
   "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": 81,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "ZeroDivisionError",
     "evalue": "float division by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-81-5719aabadcb1>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;36m10\u001b[0m\u001b[1;33m/\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mD\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m1.0\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mZeroDivisionError\u001b[0m: float division by zero"
     ]
    }
   ],
   "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": 82,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "szelesseg = 20\n",
    "magassag = 5*9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "900"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 84,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'nnn' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-84-c3bcdf959d54>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mnnn\u001b[0m  \u001b[1;31m# Az n vĂĄlltozĂłt mĂŠg nem definiĂĄltuk\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'nnn' is not defined"
     ]
    }
   ],
   "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": 85,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7.5"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 89,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(3.1415)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42.0"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 91,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-1+0j)"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1j * 1J"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.5+0.5j)"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 93,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a=1.5+0.5j"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.5"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.real"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 120,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12.5625"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ado = 12.5 / 100\n",
    "ar = 100.50\n",
    "ar * ado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "113.0625"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ar + _"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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.1"
  },
  "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": 0
}