Gyakorlat_1_Bevezeto.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "5T1QHjGAg4eC"
   },
   "source": [
    "# Mindenki töltse: tinyurl.com/tobbvalt2¶\n",
    "# Többváltozós analízis mérnöki alkalmazásai - 1. gyakorlat\n",
    "\"I hear and I forget, I see and I remember, I do and I understand\" - Nem Konfuciusz\n",
    "## Mit várjatok ettől a tárgytól?\n",
    "\n",
    "A tárgy célja nem csak az, hogy a matekból tanultakat kicsit új környezetből szemléljétek, vagy az, hogy megtanuljatok Python-ban (vagy akármilyen nyelven) programozni. Egy tanulási módszert, filozófiát szeretnénk Nektek átadni: \"ha szeretnétek megérteni valamit, használjátok valamire!\": azt a sok-sok szépet, amit a BME-n tanulni lehet, csak akkor fogjátok igazán érteni, ha kezdetek is vele valamit.\n",
    "\n",
    "Az tárgy teljesítésével mélyebben elsajátítjátok azokat a koncepciókat az idei matekból, amik a mérnöki fejlesztői munkában a legfontosabbak, és olyanokat is, amik a mechatronikus képzésnek sajnos nem részei. Félév végére, 4 komplex házi feladat és egy saját projekt teljesítése után olyan szinten tudjátok majd kezelni a Python-t, hogy bármilyen ötletetek támadjon is, kis munkával meg tudjátok benne írni.\n",
    "\n",
    "## Adminisztratív\n",
    "\n",
    "- Az órákat mi (Beni, Bence) fogjuk tartani - elérhetőségünk: fbenedek19@icloud.com és bence.sipos.sb@gmail.com - legyen a tárgyban, hogy [többvált]\n",
    "- A gyakorlatokat minden héten hétfőn, 16.15-17.45-ig, a H607-ben tartjuk - érkezzetek pontosan! \n",
    "- Saját laptopba jegyzetelni érdemes, de nem maradtok le semmiről - [Beni githubján](https://github.com/fbenedek/matek_kiegeszito_2019/tree/master) lesznek a gyakorlatok anyagai. \n",
    "- Mi is csak harmadévesek vagyunk, ne féljetek szólni, ha szerintetek valami nem oké! Óra közben, vagy e-mail-ben, ahogy kényelmesebb, nyugodtan mondjátok meg a véleményeteket. Névtelen véleményezésre is lehetőség van a google [formon.](https://docs.google.com/forms/d/1SwygrTkN6KfTLQR1xny7_Lcp2iXCC2eEGhNJ2byUb6k/edit)\n",
    "- Katalógus lesz (Kahoot! - neptunotok legyen a nickname), a szokásos 70%-os jelenlét kötelező, tehát 4 hiányzás \"igazolatlanul\" megengedett, ha több összejön valami miatt, keressetek minket.\n",
    "- Ezen túl kötelezettségeitek: HF-ek elkészítése, és projektetek beadása. ZH nincs!\n",
    "- Házik: elméleti (kifejtős kérdések) és gyakorlati részeket (saját kód írása) egyaránt tartalmaznak, egyenként 20 pontot érnek.\n",
    "- A házik előreláthatólag a 2.,4.,8.,10. héten lesznek kiadva, 2 hetes határidővel (kiadás utáni 2. vasárnap, CET 23:59:59.99). 40% (vagy 5 pont) alatti teljesítmény / üresen hagyott feladat esetén visszadobjuk. Késés, javítás esetén 50%-ról indultok, adjátok be időben! Pótbeadási határidő: 4 hét a kiadástól számítva.\n",
    "- Projektetek: egy saját magatok által megfogalmazott és megoldott probléma, velünk konzultálva kell kiválasztanotok. Lesznek megadott témák is. 30 pontot ér.\n",
    "- Jegy: 100-85 jeles, 84-70 jó, 69-55 közepes, 54-40 elégséges. Mind a négy házit, és a projektet is kötelező teljesítenetek, nem elegendő \"csak\" 40 pont, de 110 pont érhető el.\n",
    "- Plusz pontszerzési lehetőség: az órákon sokszor lesznek önálló feladatok, az első 5 helyes megoldás +2 pontot ér. Kahoot! helyezésért is jár: 1. helyezett 3, 2. 2, 3. 1 pontot ér."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "5dFaxVaxg4eD"
   },
   "source": [
    "## Python bevezető\n",
    "\n",
    "A Python egy magas szintű, dinamikus típusos nyelv. Tervezésekor az volt a szempont, hogy könnyű legyen a fejlesztés ezen a nyelven (ugyanazt megcsinálni Pythonban (általában) kb. harmadannyi mint C/C++-ban) és szuper könyvtárak vannak hozzá, amiket mi is sokat fogunk használni, pl: NumPy, SciPy, Matplotlib. Az órán az alábbiakat fogjuk összefoglalni:\n",
    "\n",
    "-Változók, alapvető adattípusok (fordító határozza meg általában!): int, float ,bool, str\n",
    "\n",
    "-Alapvető adattípusok (List, Dict, Set, Tuple), függvények\n",
    "\n",
    "-Ciklusok, elágazások\n",
    "\n",
    "Az óra végére elérünk egy olyan szintre, hogy könnyen tudtok majd saját magatok is tanulni a Python-ról: ezért kérünk benneteket, hogy most, félév elején kezdjetek el gondolkozni, hogy milyen projektet szeretnétek csinálni. Lehetséges pl: természetes nyelvfeldolgozás, képfeldolgozás, Big Data, Deep Learning témakörökből valami egyszerű."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "dRpk-tAug4eF"
   },
   "source": [
    "## Anaconda és a Python\n",
    "\n",
    "- Miért kértünk titeket, hogy Anacondát rakjatok és ne Pythont: Python-ban sok kiegészítő package-t fogunk használni, ezeket pedig Anacondával a legkönnyebb és legtisztább kezelni. Sokszor előfordul például, hogy valami olyan kódot szeretnétek futtatni, aminek más függőségei vannak, mint ami Nektek telepítve van. Conda environmentekkel ezt könnyen meg lehet oldani. [link több infóval](https://conda.io/projects/conda/en/latest/user-guide/tasks/manage-environments.html)\n",
    "\n",
    "- Jupyter notebookot indíthatunk cmd-ből, és grafikusan is. Előbbi gyorsabb, és egyszerű, meg nagy hekkelés."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "hZTd3Dmbg4eG"
   },
   "source": [
    "## Jupyter notebook és első Python programunk\n",
    "\n",
    "\n",
    "- Print('Szervusz, világ!')\n",
    "\n",
    "- Markdown cellákban szöveget helyezhetünk el, amit a LaTeX-hez hasonlóan formázhatunk.****[Itt](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet)**** egy gyors puska, és itt olvassatok utána.\n",
    "\n",
    "- Klikkelgetés elég szopás - command mode: Ctrl + Shift + F.\n",
    "\n",
    "- Plusz infó a notebookról ezen a [linken](https://github.com/ikatyang/emoji-cheat-sheet/blob/master/README.md) vagy [itt](https://guides.github.com/features/mastering-markdown/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "AkPGSmAQg4eH"
   },
   "source": [
    "## Adattípusok\n",
    "\n",
    "Int, float, bool és string: ugyanúgy, mint ahogy tavaly tanultátok. Az értékadás kicsit érdekesebb: a Pythonban nem kell deklarálni a változókat, simán leírhatom, hogy x=3, és az compiler tudni fogja, hogy egész értékként kell kezelni. Ha nem jelzem külön a szándékomat, a fordító dönti el, hogy milyen változó milyen típusú."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 100
    },
    "colab_type": "code",
    "id": "1YBkmRqJg4eI",
    "outputId": "fb490736-92f6-4730-ac09-73ed15343aa1"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 <class 'int'>\n",
      "4.2 <class 'float'>\n",
      "string <class 'str'>\n",
      "True <class 'bool'>\n",
      "(1-2j) <class 'complex'>\n"
     ]
    }
   ],
   "source": [
    "#dinamikus típusok megmutatása: beírni int, float, str, bool, complex!\n",
    "\n",
    "x=3\n",
    "print(x, type(x))\n",
    "y=4.20\n",
    "print(y,type(y))\n",
    "z='string'\n",
    "print(z,type(z))\n",
    "we_love_mogi=True\n",
    "print(we_love_mogi, type(we_love_mogi))\n",
    "c=1-2j\n",
    "print(c,type(c))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 33
    },
    "colab_type": "code",
    "id": "gl68FuRog4eO",
    "outputId": "c6b9d382-9477-4e99-b539-11c1136e7f74"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "'''kommentke\n",
    "Multiline string igazából, de ha van előtte kód, a fordító nem foglalkozik vele.\n",
    "kommentke'''\n",
    "print(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 134
    },
    "colab_type": "code",
    "id": "jryA9speg4eR",
    "outputId": "71cd6e82-6e45-414e-ca89-4b61406b4e47"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "2\n",
      "6\n",
      "1.5 <class 'float'>\n",
      "1 <class 'int'>\n",
      "1\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "#Alapműveletek\n",
    "print(x+1) #Összeadok\n",
    "print(x-1) #Kivonok\n",
    "print(x*2) #szorzok\n",
    "print(x/2, type(x/2)) #osztok, típus\n",
    "print(x//2, type(x//2)) #kerekítve osztok, típus\n",
    "print(x%2) #modulus/maradék\n",
    "print(x ** 2) #hatványozok"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 33
    },
    "colab_type": "code",
    "id": "KNkd4qgng4eV",
    "outputId": "784a3e02-1f2a-4ebf-8c7b-466f36e38393"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4 4\n"
     ]
    }
   ],
   "source": [
    "#értékadás\n",
    "a = x-1\n",
    "x = x+1\n",
    "a += 2\n",
    "print(x,a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 50
    },
    "colab_type": "code",
    "id": "5d_NTTqdg4eY",
    "outputId": "c350b609-140d-4e5e-c655-ea4c852df383"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9 <class 'int'>\n",
      "42 <class 'int'>\n"
     ]
    }
   ],
   "source": [
    "#jegyezzük meg: pythonban nincs \"x++\"\n",
    "#Viszont ami van, de nem mindenki szokta tudni, és néha hasznos: kettes\n",
    "#számrendszer+hexa? Ez általában alacsonyabb szintű programozáskor\n",
    "#(pl mikrokontrollerek bitvarázslása) jön jól, de megmutatom azért\n",
    "binaris=0b1001\n",
    "hexadecimalis=0x2A\n",
    "print(binaris, type(binaris))\n",
    "print(hexadecimalis, type(hexadecimalis))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "-8XTs2GXg4eb"
   },
   "source": [
    "## 1. feladat\n",
    "\n",
    "Eleget tudunk ahhoz, hogy megoldjuk az első Python feladatunkat: számoljátok ki Pythonnal a legnagyobb 32 bites (IEEE 754 szerinti) lebegőpontos szám decimális értékét! A wikipédia és az internet segít, ha eltanácstalanodtok.  \n",
    "\n",
    "### Megoldás:\n",
    "\n",
    "Lássuk a Wiki cikket:https://en.wikipedia.org/wiki/Single-precision_floating-point_format. A lebegőpontos számábrázolás lényege tehát: elég, ha csak a kisebb számaim pontosak, a nagyok lehetnek pontatlanok. \"Fix számú\" számjegyem van, és oda teszem a tizedesvesszőt, ahova akarom. Ezt úgy érem el, hogy veszem a \"fix\" számjegyeimet, vagy mantisszát, és kettő valahanyadik hatványával megszorzom (mint tízesben, gondoljatok bele: ha egy tízes számrendszerbeli számot megszorzom 10 első hatványával, az olyan, mintha egy helyiértékkel \"balra tolnám\" az elejét!). A hatvány kitevője a karakterisztika. A cikk alapján a mantissza 24bit, a karaterisztika 8bit. Tehát a legnagyobb mantissza 0b(24 1-es), a legnagyobb mantissza 0b(8 1-es) lenne, de a legnagyobb hatvány külön számot jelöl, úgyhogy a legnagyobb karakterisztika 0b1..10 alakú. Innen már csak behelyettesítés!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 67
    },
    "colab_type": "code",
    "id": "W61_l6Zsg4ec",
    "outputId": "c8c4e489-d497-4908-a51e-f0cb61c6e62c",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "254\n",
      "0.9999999403953552\n",
      "A legnagyobb float32 ezért 3.4028235677973366e+38\n"
     ]
    }
   ],
   "source": [
    "karakterisztika=0b11111110 #8bit karakterisztika (hatvanykitevo) \n",
    "mantissza=2**(-24)*0b111111111111111111111111 #24bit mantissza (hatvanyalap)\n",
    "print(karakterisztika)\n",
    "print(mantissza)\n",
    "ertek=(1+mantissza)*2**(karakterisztika-127)\n",
    "print('A legnagyobb float32 ezért %s' %(ertek))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 50
    },
    "colab_type": "code",
    "id": "XBN1wxTvg4eg",
    "outputId": "9dc4826e-aa1d-4427-98f6-57f557dc9a25"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True <class 'bool'>\n",
      "False <class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "#Logikai értékek\n",
    "t = True\n",
    "f = False\n",
    "print(t, type (t))\n",
    "print(f, type (f))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 67
    },
    "colab_type": "code",
    "id": "e0WYa3Esg4ej",
    "outputId": "b5a68834-d917-4b5e-abe3-416ced7dfd44"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "#Logikai műveletek\n",
    "print(t and f)#Logikai ÉS\n",
    "print(t or f)#Logikai VAGY\n",
    "print(not f) #Logikai NEM/NEGÁCIÓ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 100
    },
    "colab_type": "code",
    "id": "xZvqXqLZg4en",
    "outputId": "1fea912a-03ea-484d-a1e2-fa052ff762fd"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n",
      "True\n",
      "True <class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "#Értékek összehasonlítása\n",
    "print(2<3)\n",
    "print(x==3) #a szokásos hiba: Progalap után ne csináljuk! \n",
    "print(2==3)\n",
    "print(2!=3)\n",
    "t=2<3\n",
    "print(t, type(t))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 50
    },
    "colab_type": "code",
    "id": "gfKOAAcag4eq",
    "outputId": "91c3e4da-4b13-4aca-fe8c-196652386de7"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Így működik az if!\n",
      "mivan, negatív?\n"
     ]
    }
   ],
   "source": [
    "#if feltétel:\n",
    "if(True): print(\"Így működik az if!\")\n",
    "t=-1\n",
    "if(0<t):\n",
    "    print(\"mi van, pozitív\")\n",
    "elif(0>t):\n",
    "    print(\"mivan, negatív?\")\n",
    "else:\n",
    "    print(\"szökik a málna!\")\n",
    "#case nincs: https://jaxenter.com/implement-switch-case-statement-python-138315.html kicsit más gondolkodásmódot igényel.\n",
    "#iterátorral próbáljuk megoldani, amikor lehet, akkor könnyű"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 50
    },
    "colab_type": "code",
    "id": "EYpFsc5Ng4ew",
    "outputId": "20e42374-45f8-40a0-d6b0-595bc75e0fc2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "def fuggvenyem(parameter1,parameter2):\n",
    "    eredmeny=parameter1+parameter2\n",
    "    print(eredmeny)\n",
    "\n",
    "def fuggvenyem_return(parameter1,parameter2):\n",
    "    eredmeny=parameter1+parameter2\n",
    "    return eredmeny\n",
    "\n",
    "fuggvenyem(1,2)\n",
    "eredmeny=fuggvenyem_return(1,2)\n",
    "print(eredmeny)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 67
    },
    "colab_type": "code",
    "id": "LZG1j51hg4e0",
    "outputId": "f00c38fb-872c-4e08-f60c-25d79fcf25d6"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "-1\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "#2. feladat: valósítsátok meg Pythonban az R->R sgn(x) függvényt!\n",
    "def sign(x):\n",
    "    if(x>0):\n",
    "        return 1\n",
    "    elif(0>x):\n",
    "        return -1\n",
    "    else:\n",
    "        return 0\n",
    "print(sign(0))\n",
    "print(sign(-420))\n",
    "print(sign(69))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 33
    },
    "colab_type": "code",
    "id": "jxUFtozxg4e5",
    "outputId": "40f34979-51c4-4d20-ad62-1b6238dd3bee"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "szervusz <class 'str'> 8\n"
     ]
    }
   ],
   "source": [
    "#Stringek\n",
    "hello='szervusz' #egyszeres\n",
    "world=\"világ\" #vagy töbszörös idézőjel, mindegy\n",
    "print(hello, type(hello), len(hello)) #len függvény:dolgok hossza (string, list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 33
    },
    "colab_type": "code",
    "id": "XRLJfgagg4e8",
    "outputId": "ba027708-7c49-4f14-aac8-afefd092c456"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "szervusz világ!\n"
     ]
    }
   ],
   "source": [
    "#Műveletek stringekkel\n",
    "hw = hello + ' ' + world + '!' #konkatenáció\n",
    "print(hw)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 33
    },
    "colab_type": "code",
    "id": "jU4dR45og4fB",
    "outputId": "7699cfc7-64fc-40a4-bb4c-58cf09eee42d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "szervusz világ! 1488\n"
     ]
    }
   ],
   "source": [
    "hw_szam = '%s %s%s %d' %(hello, world, '!', 1488) #sprintf-féle string formatting, itt olvashattok róla: \n",
    "print(hw_szam)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 148
    },
    "colab_type": "code",
    "id": "Igwx0j0Zg4fF",
    "outputId": "67ac78e4-9230-429a-fc73-6fd9c74780fd"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Szervusz világ!\n",
      "SZERVUSZ VILÁG!\n",
      "     szervusz világ!\n",
      "  szervusz világ!   \n",
      "szervusz világ!\n",
      "szervusz világ!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['zold', 'kek', 'piros']"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#még pár hasznos string metódus, jól jöhetnek\n",
    "#mi az a metódus: olyan függvények, amiket \"tulajdonságként\" hívunk meg.\n",
    "print(hw.capitalize())\n",
    "print(hw.upper())\n",
    "print(hw.rjust(20))\n",
    "print(hw.center(20))\n",
    "print(hw.replace('S','SS'))\n",
    "print(hw.center(20).strip())\n",
    "hosszu_string='zold,kek,piros'\n",
    "hosszu_string.split(\",\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "9rjf-XC_g4fP"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 'string']\n",
      "2\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "#Listák: többféle adattípust tartalmazhatnak, címezéssel férhetünk hozzájuk\n",
    "#index 0-tól indul\n",
    "listam = [1,2,3,4,'string']\n",
    "print(listam)\n",
    "print(listam[1])\n",
    "print(len(listam))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "pSSY7IYng4fS"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 'string', 'meg_egy_string']\n",
      "meg_egy_string [1, 2, 3, 4, 'string']\n",
      "3 [1, 2, 4, 'string']\n"
     ]
    }
   ],
   "source": [
    "#elemek hozzáadása, törlése\n",
    "listam.append('meg_egy_string') #append: hozzáfűzök egy elemet a végére\n",
    "print(listam)\n",
    "utolso_elem = listam.pop() #pop: kiveszi az utolsót, és visszaadja\n",
    "print(utolso_elem, listam)\n",
    "valamelyik_elem = listam.pop(2)\n",
    "print(valamelyik_elem, listam)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "cwMyEzHsg4fY"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "[0, 1]\n",
      "[1, 2, 3, 4, 5]\n",
      "[5]\n",
      "[0, 1, 2, 3]\n",
      "[1, 2, 3]\n",
      "[0, 6, 9, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "#Szeletelés, \"slicing\" - nagyon kényelmes és elengáns, mindenki figyelje!\n",
    "szamok= [0,1,2,3,4,5] #beépített funkció intek generálására\n",
    "\n",
    "print(szamok[-1])\n",
    "print(szamok[0:2])\n",
    "print(szamok[1:])\n",
    "print(szamok[-1:]) #üres-e, miért?\n",
    "print(szamok[:-2])\n",
    "print(szamok[1:-2])\n",
    "szamok[1:3] = [6,9]\n",
    "print(szamok)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "tUlqA2Lwg4fb"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "6\n",
      "9\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "#Loop: \"for\" ciklushoz hasonló szerkezetekre: végighalad egy List/Range elemein\n",
    "for i in szamok:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Hi0QGyRYg4fh",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'range'>\n",
      "range(0, 50, 10)\n",
      "0\n",
      "10\n",
      "20\n",
      "30\n",
      "40\n",
      "50\n",
      "40\n",
      "30\n",
      "20\n",
      "10\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "t=range(0,50,10)\n",
    "print(type(t))\n",
    "print(t) \n",
    "\n",
    "\n",
    "'''\n",
    "range elemeit így nem érem el (python 2.7ben még igen, \n",
    "de ott az xrange csinálja ugyanezt\n",
    "\n",
    "'''\n",
    "\n",
    "for szam in t:\n",
    "    print(szam)\n",
    "    \n",
    "t=range(50,-10,-10)\n",
    "\n",
    "for szam in t:\n",
    "    print(szam)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "sSOY1Jscg4fk"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16]\n"
     ]
    }
   ],
   "source": [
    "#Műveletek listákkal:\n",
    "szamok=[0,1,2,3,4]\n",
    "negyzetek=[]\n",
    "for i in szamok:\n",
    "    negyzetek.append(i**2)\n",
    "print(negyzetek)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "0IribD8pg4fo"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 8, 27, 64]\n"
     ]
    }
   ],
   "source": [
    "kobok =[i**3 for i in szamok]\n",
    "print(kobok)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "_fRNKCcSg4fr"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 4, 6, 8, 12]\n"
     ]
    }
   ],
   "source": [
    "#Lehetnek benne feltetelek is!\n",
    "listam=[0,1,2,3,4,5,6]\n",
    "listam_2=[i*2 for i in listam if(i%2==0 or i%3==0)] #ide else-t nem lehet irni\n",
    "print(listam_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "l8QET4dRg4fw"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "#in: tartalmazza-e - nem csak listben, kb. minden másban!\n",
    "print(0 in listam)\n",
    "print('mér' in 'mérnök') #amit méréstechnikán szeretnek hangsúlyozni..\n",
    "print('nők' in 'mérnök') #ami sajnos igaz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "pdQttRFSg4fz"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MOGI\n",
      "ATT\n"
     ]
    }
   ],
   "source": [
    "#Dictek: kulcs, érték párok, {}-al elválasztva. Nem rendezett! Gráfos dolgokhoz kell majd. Egyébként ezek arra jók, hogy értsétek, amit más írt\n",
    "#Nem fogjuk sokat használni.\n",
    "dict = {'Progterv':'MOGI', 'Statika':'MM', 'Mecha_alapjai':'MOGI'}\n",
    "print(dict['Progterv'])\n",
    "#print(dict['Anyagismeret'])\n",
    "dict['Anyagismeret']='ATT'\n",
    "print(dict['Anyagismeret'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "nliz4bu1g4f2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A(z) Progterv-t a MOGI tartja\n",
      "A(z) Statika-t a MM tartja\n",
      "A(z) Mecha_alapjai-t a MOGI tartja\n",
      "A(z) Anyagismeret-t a ATT tartja\n"
     ]
    }
   ],
   "source": [
    "for targy in dict:\n",
    "    tanszek=dict[targy]\n",
    "    print('A(z) %s-t a %s tartja' % (targy, tanszek))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "lnrXnGSyg4f4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A(z) Progterv-t a MOGI tartja\n",
      "A(z) Statika-t a MM tartja\n",
      "A(z) Mecha_alapjai-t a MOGI tartja\n",
      "A(z) Anyagismeret-t a ATT tartja\n"
     ]
    }
   ],
   "source": [
    "for targy,tanszek in dict.items():\n",
    "    print('A(z) %s-t a %s tartja' %(targy, tanszek))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "wX8Q-5YNg4f7"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "#Setek: \n",
    "#Rendezetlen elemek halmaza - matekos halmaz.\n",
    "nyelveim ={'C','C++','Python','Assembly'}\n",
    "print('Python' in nyelveim)\n",
    "print('Java' in nyelveim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "gnUifIH-g4f-"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5, 6) <class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "#Tuple-ok\n",
    "#Inmutable: nem lehet változtatni. List-re hasonlít, de ezt lehet keyként használni\n",
    "#egy dictben\n",
    "t=(5,6)\n",
    "print(t, type(t))\n",
    "#t[0]=1 nem ok!"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "name": "Bevezeto.ipynb",
   "provenance": [],
   "version": "0.3.2"
  },
  "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}