{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. előadás\n",
    "_Tartalom_: Ciklusok II., listák, join és split (string listává illetve fordítva), lista- és stringműveletek"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Listák\n",
    "Eddig négy típussal találkoztunk: a szövegeket _stringek_ (str), az egész számokat _int_-ek, a törtszámokat _float_-ok jelölték, és külön típust képeztek még az állítások, amiknek az értéke csak igaz (True) és hamis (False) lehet.\n",
    "\n",
    "Listákat akkor fogunk használni, ha össze szeretnénk gyűjteni több különböző objektumot. A lista arról ismerszik meg, hogy szögletes zárójelek ([]) közötti, vesszővel elválasztott objektumokból áll. Az objektumok bármilyen típusúak lehetnek és keveredhetnek is.\n",
    "\n",
    "Itt egy lista:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 'pingvin', 2.76, 'zsiráf']"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[3, \"pingvin\", 2.76, \"zsiráf\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ez pedig egy üres lista, ez is teljesen szabályos objektum:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ezekben a listákban pedig mind csak stringek szerepelnek:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "torpok = ['Tudor', 'Vidor', 'Szende', 'Szundi', 'Hapci', 'Kuka', 'Morgó']\n",
    "weasleyk = ['Bill', 'Charlie', 'Percy', 'Fred', 'George', 'Ron', 'Ginny']\n",
    "zsirafok = [\"Abigél\", \"Benő\", \"Zsebi\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Változókat is betehetünk egy listába:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Hosszú', 'Katinka']\n"
     ]
    }
   ],
   "source": [
    "vezeteknev = \"Hosszú\"\n",
    "keresztnev = \"Katinka\"\n",
    "teljes_nev = [vezeteknev, keresztnev]\n",
    "print(teljes_nev)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Először nézzünk pár olyan műveletet, amit már ismerünk. Vajon ezek mit csinálnak a listákkal?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A _len_ függvény viselkedése nem túl meglepő, a lista hossza azt mondja meg, hogy hány eleme van a listának"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(torpok)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Az összeadás is azt csinálja, amit várunk tőle: összefűz két listát."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Tudor',\n",
       " 'Vidor',\n",
       " 'Szende',\n",
       " 'Szundi',\n",
       " 'Hapci',\n",
       " 'Kuka',\n",
       " 'Morgó',\n",
       " 'Bill',\n",
       " 'Charlie',\n",
       " 'Percy',\n",
       " 'Fred',\n",
       " 'George',\n",
       " 'Ron',\n",
       " 'Ginny']"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torpok + weasleyk"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Egy listának hivatkozhatunk egyes elemeire, a sorszámuk alapján. A számozás nullától indul, tehát a lista első elemét Pythonban a lista nulladik elemének fogjuk hívni. Ezt leírni pedig így kell:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Tudor'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torpok[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A számozás tehát el van eggyel \"tolódva\", az utolsó törp pl. a 6-os sorszámú:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Morgó'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torpok[6]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ha nem létező sorszámra hivatkozunk, hibát kapunk:\n",
    "``` python \n",
    ">>> torpok[7]\n",
    "IndexError: list index out of range\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hátulról kezdve is számolhatjuk az elemeket, ilyenkor negatív számokat kell használni. Tehát a lista utolsó eleme a -1-es, a hátulról második elem a -2, és így tovább:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Morgó'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torpok[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nyilván itt is túl tudunk indexelni és hibát kapunk:\n",
    "``` python \n",
    ">>> torpok[-8]\n",
    "IndexError: list index out of range\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Kuka'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torpok[-2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A sorszámok (más néven: indexek) segítségével hivatkozhatunk a lista egyes szakaszaira is. Pl. az első 4 törpöt így kérdeznénk le, ahogy más megismertük a itt is működnek a \"szeletelő jelölések\" (célszerűbb az angol terminológia: `slice notation`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Tudor', 'Vidor', 'Szende', 'Szundi']"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torpok[:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A másodikat és a harmadikat így:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Vidor', 'Szende']"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torpok[1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tehát a kettőspont bal oldalán áll az első olyan sorszám, amire kiváncsiak vagyunk, a jobb oldalán pedig az első olyan sorszám, amire már nem. (más néven: balról zárt, jobbról nyílt intervallum). Ezt időbe telhet megszokni, de vannak előnyei is, pl. a két sorszám különbsége megadja, milyen hosszú lesz az új lista."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sorszámként használhatjuk a negatív számokat is, tehát egyszerűen mondhatunk olyat, hogy pl. a második elemtől az utolsó előttiig:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Vidor', 'Szende', 'Szundi', 'Hapci', 'Kuka']"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torpok[1:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ez az eljárás a __slicing__, vagyis szeletelés, és tulajdonképpen egy művelet, ami listából listát csinál. Pont ugyanígy működik stringekre is, ott a betűket \"szeleteljük\":"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Persze ilyen kifejezésekből is kombinálhatunk többet. Pl. megkérdezhetjük, mi az utolsó előtti törpe nevének első három betűje:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Kuk'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torpok[-2][:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahogy azt a stringeknél megszokhattuk, amikor listát vagy stringet \"szeletelünk\", azt is megtehetjük, hogy két pozíció között nem mindegyik elemet vesszük ki a listából/stringből, hanem pl. minden másodikat, minden harmadikat, stb. Ilyenkor egy második kettőspontot is írunk, és ezután adjuk meg, hogy mekkora \"ugrásokat szeretnénk\". Az alábbi példa azt jelenti, hogy a lista harmadik elemétől induljunk, minden második elemet vegyünk ki, és ne menjünk tovább, mint a hetedik:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 5, 7]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista = [1,2,3,4,5,6,7,8,9,10]\n",
    "lista[2:7:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ha az első vagy második indexet üresen hagyjuk, az a lista elejét ill. végét jelenti. Az alábbi tehát azt jelenti, hogy az egész listából kérünk minden harmadik elemet:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 7, 10]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista[::3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista[-1::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 9, 8, 7, 6, 5, 4]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista[-1:2:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Most nézzünk néhány egyszerű műveletet, amivel a listát manipulálhatjuk. Például megváltoztathajuk egy-egy elemét:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[7, 2, 3]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista = [1,2,3]\n",
    "lista[0] = 7\n",
    "lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vagy egy listának egy egész szelete felülírható egy másik listával:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 102, 103, 4, 5]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista = [1,2,3,4,5]\n",
    "lista[1:3] = [102, 103]\n",
    "lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Az __append__ paranccsal új elemeket fűzhetünk egy lista végére:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 102, 103, 4, 5, 9]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista.append(9)\n",
    "lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Törölhetünk elemeket a __remove__ paranccsal:\n",
    "\n",
    "_Megjegyzés:_ listák esetén a __remove__ csak az első előfordulást törli."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 103, 4, 5, 9]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista.remove(102)\n",
    "lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A listát sorbarendezhetjük a __sort__ paranccsal:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 5, 9, 103]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista.sort()\n",
    "lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ha a listában stringek vannak, a __sort__ ábécébe rendezi őket:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Hapci', 'Kuka', 'Morgó', 'Szende', 'Szundi', 'Tudor', 'Vidor']"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torpok.sort()\n",
    "torpok"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Olyan listát, amiben string és szám is van, nem tudunk rendezni, hibát kapunk."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "``` python\n",
    "lista = [3, \"pingvin\", 2, \"jegesmedve\"]\n",
    "lista.sort()\n",
    "lista\n",
    "TypeError: '<' not supported between instances of 'str' and 'int'\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De számokból lehet kétféle (int és float):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2.3, 3.2, 4]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista = [4, 2.3, 1, 3.2]\n",
    "lista.sort()\n",
    "lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A listákat megfordíthatjuk a __reverse__ paranccsal:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 3.2, 2.3, 1]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista.reverse()\n",
    "lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Megkérdezhetjük egy elemről, hogy a lista hányadik helyén található, erre való az __index__ parancs:\n",
    "_Megjegyzés:_ listák esetén az __index__ az első előfordulást adja vissza."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "weasleyk.index(\"Ron\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Megszámolhatjuk, hogy egy elem hányszor szerepel egy listában, a __count__ paranccsal:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista.count(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mindezen műveletek stringekre is működnek, az alábbi kód pl. megmondja, hogy a legidősebb Weasley testvér nevében hány l betű van:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "weasleyk[0].count('l')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Egy listát le is másolhatunk, ha módosítani akarjuk, de nem akarjuk az eredetit elveszíteni:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Bill', 'Charlie', 'Fred', 'George', 'Ginny', 'Percy', 'Ron']"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "weasleyk2 = weasleyk.copy()\n",
    "weasleyk2.sort()\n",
    "weasleyk2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Az __in__ szóval ellenőrizhetjük, hogy egy elem benne van-e egy listában/stringben:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Ron\" in weasleyk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Kuka\" in weasleyk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"k\" in \"Kuka\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"c\" in \"Kuka\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ezek állítások, tehát egy __if__ vagy __elif__ után is állhatnak. Az alábbi program például ellenőrzi, hogy van-e egy szóban i betű:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ebben van i\n"
     ]
    }
   ],
   "source": [
    "#print(\"Írd be a szót!\")\n",
    "#szo = input()\n",
    "szo = \"Csabi\"\n",
    "if \"i\" in szo:\n",
    "    print(\"Ebben van i\")\n",
    "else:\n",
    "    print(\"Ebben nincs i\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A __split__ parancsról már volt szó, szétvág egy stringet a szóközök mentén (_paraméterek nélkül hívva legalábbis_), és a kapott szavakat egy listában adja vissza:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A',\n",
       " 'kockázatok',\n",
       " 'és',\n",
       " 'mellékhatások',\n",
       " 'tekintetében',\n",
       " 'olvassa',\n",
       " 'el',\n",
       " 'a',\n",
       " 'betegtájékoztatót',\n",
       " 'vagy',\n",
       " 'kérdezze',\n",
       " 'meg',\n",
       " 'kezelőorvosát,',\n",
       " 'gyógyszerészét']"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mondat = \"A kockázatok és mellékhatások tekintetében olvassa el a betegtájékoztatót vagy kérdezze meg kezelőorvosát, gyógyszerészét\"\n",
    "szavak = mondat.split()\n",
    "szavak"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A __join__ parancs stringet ad vissza, egy megadott string szeparátorral fűzi össze a lista elemeit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'A--kockázatok--és--mellékhatások--tekintetében--olvassa--el--a--betegtájékoztatót--vagy--kérdezze--meg--kezelőorvosát,--gyógyszerészét'"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"--\".join(szavak)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Lista bejárása ciklussal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Itt az elem egy konkrét listaelem nem pedig integer:\n",
      "A kockázatok és mellékhatások tekintetében olvassa el a betegtájékoztatót vagy kérdezze meg kezelőorvosát, gyógyszerészét \n",
      "\n",
      "While ciklus és i (int) változó:\n",
      "A kockázatok és mellékhatások tekintetében olvassa el a betegtájékoztatót vagy kérdezze meg kezelőorvosát, gyógyszerészét \n",
      "\n",
      "For ciklus és i (int) változó:\n",
      "A kockázatok és mellékhatások tekintetében olvassa el a betegtájékoztatót vagy kérdezze meg kezelőorvosát, gyógyszerészét "
     ]
    }
   ],
   "source": [
    "print(\"Itt az elem egy konkrét listaelem nem pedig integer:\")\n",
    "for elem in szavak:\n",
    "    print(elem, end = \" \")\n",
    "\n",
    "\n",
    "print(\"\\n\\nWhile ciklus és i (int) változó:\")\n",
    "i = 0\n",
    "while i < len(szavak):\n",
    "    print(szavak[i], end = \" \")\n",
    "    i += 1\n",
    "    \n",
    "    \n",
    "print(\"\\n\\nFor ciklus és i (int) változó:\")\n",
    "i = 0\n",
    "for _ in szavak:\n",
    "    print(szavak[i], end = \" \")\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Lista bejárása - comprehension\n",
    "A listaértelmezések (list comprehension) a listák létrehozásának rövidebb módja."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['A', 'kockázatok', 'és', 'mellékhatások', 'tekintetében', 'olvassa', 'el', 'a', 'betegtájékoztatót', 'vagy', 'kérdezze', 'meg', 'kezelőorvosát,', 'gyógyszerészét']\n"
     ]
    }
   ],
   "source": [
    "print([elem for elem in szavak])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## _Used sources_ / Felhasznált források\n",
    "- [Shannon Turner: Python lessons repository](https://github.com/shannonturner/python-lessons) MIT license (c) Shannon Turner 2013-2014\n",
    "- [Siki Zoltán: Python mogyoróhéjban](http://www.agt.bme.hu/gis/python/python_oktato.pdf) GNU FDL license (c) Siki Zoltán\n",
    "- [BME AUT](https://github.com/bmeaut) MIT License Copyright (c) BME AUT 2016-2018"
   ]
  }
 ],
 "metadata": {
  "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}