eload/ea01.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. előadás\n",
    "_Tartalom_: Python bevezetés, Python 2 vs Python 3, IDE, egyszerű matematika, változók, szintaxis, és logika, ciklusok I., string I.\n",
    "\n",
    "A Python egy népszerű, általános célú, magas szintű szkript nyelv, melyet Guido van Rossum holland programozó publikált 1991-ben. A Python keresztplatformos nyelv, futtatókörnyezete több operációs rendszeren (Windows, Linux, OsX, Android) elérhető. A népszerűségéhez nagyban hozzájárul számos kiegészítőcsomagja, mint a később tárgyalandó numpy, matplotlib, TensorFlow, pyQT, openCV, iPython, stb.\n",
    "\n",
    "A Pythont tanuláshoz és egyszerűbb esetekben használhatjuk interaktívan is, az értelmezővel soronként végrehajttathatjuk az utasításainkat. Persze lehetőségünk van `.py` kiterjesztésű fájlokat készíteni és futtatni is, sőt lehet generálni futtatható fájlt vagy telepítőt. Egyelőre viszont maradjunk az alapoknál, ismerkedjünk a szintaktikával és az egyszerű matematikával. \n",
    "\n",
    "_Megjegyzés_: az előadások során a Jupyter notebookot fogjuk használni ez interaktív python notebook (`.ipynb`) fájlokat hoz létre, amiben a kódok és kimenetek szerkeszthetőek, illetve GitHub-on a legutolsó futás lesz látható. A gyakorlati `.py` kiterjesztésű fájlokhoz a Jupyter notebook nem fog kelleni, ez csak a demonstrációt könnyíti meg.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Python 2 vs Python 3\n",
    "\n",
    "Sajnos a Python még relatív széles körben használt 2.x változata, és a 2008 óta elérhető 3.x változat között nincs teljes kompatibilitás. Tehát, ha például az interneten ilyen kóddokat találunk:\n",
    "\n",
    "``` python\n",
    "print \"Hello, World!\"\n",
    "```\n",
    "gyaníthatjuk, hogy Python 2.x -el van dolgunk. Ugyanez a kód Python 3.x-ben így néz ki:\n",
    "``` python\n",
    "print(\"Hello, World!\")\n",
    "```\n",
    "\n",
    "Erről még lesz szó, egyelőre annyit kell tudnunk, hogy ez a segédlet a 3.x verzióval lett tesztelve."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.6.5\n"
     ]
    }
   ],
   "source": [
    "# mivel a Python 2.x és 3.x szintakitiája enyhén eltér ellenőrizzük, hogy a 3-ast használjuk-e\n",
    "# később további magyarázat lesz ezekről is\n",
    "import platform\n",
    "print(platform.python_version())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Térjük tehát rá a matematikai alapokra.\n",
    "#### Egyszerű matematika"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "48"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "6 * 8 # szorzás"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1024"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 ** 10 # hatványozás"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "33.333333333333336"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "100 / 3 # osztás"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "33"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "100 // 3 # egész osztás"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "52 % 10 # modulo osztás"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Pythonban a megszokott *aritmetikai operátorok* jelen vannak, sőt további hasznosak is.\n",
    "\n",
    "| Operátor| Leírás|         \n",
    "| ------------- |-------------|\n",
    "|`+`| összeadás |\n",
    "|`-`| kivonás|\n",
    "|`*`| osztás |\n",
    "|`**`| hatványozás |\n",
    "|`//`| egész osztás |\n",
    "|`/`| osztás |\n",
    "|`%`| modulo osztás |\n",
    "\n",
    "A Python a # karakter utáni szöveget a sor végéig megjegyzésnek értelmezi, több soros megjegyzést 3 idézőjellel vagy aposztróffal kezdhetünk és zárhatunk le.\n",
    "\n",
    "```python\n",
    "\"\"\"\n",
    "Ez több \n",
    "soros komment\n",
    "\"\"\"\n",
    "'''\n",
    "Ez \n",
    "is.\n",
    "'''\n",
    "```\n",
    "#### Változók\n",
    "A változókba mentett értékek esetén interaktív módban nem jelenik meg a művelet adott eredménye. Pl:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = (3 ** 3 ) + 0.2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De kiírhatjuk például a `print` funkcióval"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "27.2\n"
     ]
    }
   ],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python-ban nincs automatikus típus konverzió a változókra, de a  `type` függvénnyel kiírathatjuk egy változó típusát."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = \"1024\"\n",
    "type(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A következő műveletben sincs automatikus típus konverzió, így hibát kapunk. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`x + s`\n",
    "``` python\n",
    "TypeError: unsupported operand type(s) for +: 'float' and 'str'\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(s) is str "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A Python alapvetően 3 numerikus típust ismer: `int`, `float` és `complex`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'complex'>\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "a1 = 120\n",
    "print(type(a1))\n",
    "\n",
    "a2 = 12.0\n",
    "print(type(a2))\n",
    "\n",
    "a3 = 5 + 1j\n",
    "print(type(a3))\n",
    "\n",
    "a4 = float(7)\n",
    "print(type(a4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A `sys.float_info.dig` megadja a tizedesjegyek maximális pontosságát."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import sys\n",
    "sys.float_info.dig"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A változóinkat integerré konvertálhatjuk, például így:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1051.2"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x + int(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'10241024102410241024102410241024102410241024102410241024102410241024102410241024'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s * 20  # ez nem megszorozza, hanem többszörözi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pythonban az osztályokat `StudlyCaps` a konstanasokat `ALLCAPS` a változókat, metódusokat pedig `snake_case` konvenccióval szokás jelölni. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### String I.\n",
    "Stringeket többféleképp definiálhatunk: például aposztróffal és idézőjellel is.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ez az egyik mód. De ez is működik.\n"
     ]
    }
   ],
   "source": [
    "s1 = \"Ez az egyik mód.\"\n",
    "s2 = 'De ez is működik.'\n",
    "print(s1, s2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Emlékeztető a karakterkódolásokról:\n",
    "- Az egybájtos karakterkódolások:\n",
    " - *ASCII* » 128 karakter, 7 bit (2^7 = 128)\n",
    " - *Latin-1* » másnéven ISO8859-1 » az első 128 ugyanaz, mint az ASCII, de, utána még 96 betűt használ (160-255 tartományban), így is belefér az egy bájtba (2^8 = 256) » nincs benn magyar ő és ű csak û és õ\n",
    " - *Latin-2* » hasonló a Latin-1-hez, de ebben a magyar ő és ű is megtalálható\n",
    " - *Windows-1250* » ez hasonlít a Latin-2-hez, többek közt a Windows szöveges fájok is használják, konzolos alkalmazásoknál előfordul.\n",
    " - *OEM-852* » konzolban szintén előfordulhat, de nem hasonlít a Latin2-höz\n",
    "- A többbájtos karakterkódolások:\n",
    " - *Unicode* » A Unicode az előzőekkel ellentétben nem egyetlen szabvány, inkább egy szabványcsomag. Az első 128 karaktere ugyanaz, az ASCII-é, de több, mint 120000 karaktert tartalmaz a világ majdnem összes nyelvén. Több bájtos, de az egybájtosról viszonylag könnyen átalakítható kódolás, de vissza már kevésbé, hiszen egy Unicode karakter nem biztos, hogy létezik pl.: Latin-2-ben. További probléma, hogy a 2 bájtot nem minden architektúra ugyanabban a sorrendben tárolja. Ezt a BOM (byte order mark) hivatott jelezni, mely vagy 0xFEFF vagy 0xFFFE. A Unicode szövegeket különböző karakterkódolással tárolhatjuk. A Unicode szabvány meghatározza az `UTF-8`, `UTF-16` és az `UTF-32` karakterkódolást, de számos más kódolás is használatban van.\n",
    " - *UTF-8* » Változó méretű karakterkódolás, 1 bájtos egységeket használ, így nem csak sorrendben, de tényleges bináris kódban is kompatibilis az ASCIIvel, hiszen az egy bájtba beleférő értékeket egy bájton is tárolja. Neve a 8-bit Unicode Transformation Format, 8 bites Unicode átalakítási formátum, ami utal arra, hogy bármilyen Unicode karaktert képes reprezentálni, gyakran használják internet-alapú karakterkódolásra.\n",
    " \n",
    "A `sys.getdefaultencoding()` megadja, mi az alapértelmezett kódolás."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "utf-8\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "print(sys.getdefaultencoding())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A különbség az aposztróffal és idézőjellel készített stringek között, hogy \n",
    "``` python\n",
    "\"ebben így lehet ' karakter\" \n",
    "'ebben viszont \\' kell a visszaper elé'\n",
    "'illetve fordítva: itt lehet \" '\n",
    "\"itt  viszont így: \\\" \"\n",
    "```\n",
    "\n",
    "#### Formázott kiíratás\n",
    "A `print` funckió rengeteg lehetőséget ad. Később erre még visszatérünk, most nézzük meg a `sep` elválasztó és az `end` működését példákon szemléltetve."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a b c da'sda\"as\"sd--e\n",
      "a b c deas'aaa'asd\n",
      "abcde\n",
      "a***b***c***de\n",
      "x\n",
      "y\n",
      "Ez kerüljön egy sorba.\n"
     ]
    }
   ],
   "source": [
    "print('a','b', 'c', 'da\\'sda\"as\"sd--e')\n",
    "print(\"a\",\"b\", \"c\", \"deas'aaa'asd\")\n",
    "print(\"a\",\"b\", \"c\", \"de\", sep=\"\")\n",
    "print(\"a\",\"b\", \"c\", \"de\", sep=\"***\")\n",
    "print(\"x\\ny\")\n",
    "print(\"Ez kerüljön\", end=\" \")\n",
    "print(\"egy sorba.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ciklusok I., alapvető szintaktika\n",
    "\n",
    "Összetettebb kódsorok készítése előtt ki kell emelni a Python azon sajátosságát, hogy a Python programokban a kód blokkokat\n",
    "a sor elején található szóközökkel  vagy tabulátorokkal jelöljük. Más nyelvekben a blokk elejét és végét jelölik meg, például C-ben, C++-ban stb. `'{'` és `'}'` zárójelekkel. A nyelv ezen tulajdonsága kikényszeríti a könnyen olvasható kód készítését, másik oldalon nagyobb figyelmet igényel a sorok írásánál. A szóköz és tabulátor karaktereket nem lehet keverni, gyakran négy szóközös tagolást alkalmaznak. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "range(6):   \t   0   1   2   3   4   5\n",
      "range(3, 9):   \t   3   4   5   6   7   8\n",
      "range(3,14,2):\t   3   5   7   9  11  13\n",
      "range(14,3,-2):\t  14  12  10   8   6   4\n",
      "array (tömb):\t   2   3   5   7\n",
      "while:\t\t   0   1   2   3   4"
     ]
    }
   ],
   "source": [
    "print(\"range(6):   \\t\", end=\"\")\n",
    "# 0 1 2 3 4 5\n",
    "for x in range(6):\n",
    "    print(\"%4d\" % x, end=\"\")\n",
    "    \n",
    "print(\"\\nrange(3, 9):   \\t\", end=\"\")\n",
    "# 3 4 5 6 7 8\n",
    "for x in range(3, 9):\n",
    "    print(\"%4d\" % x, end=\"\") \n",
    "\n",
    "print(\"\\nrange(3,14,2):\\t\", end=\"\")\n",
    "# 3 5 7 9 11 13\n",
    "for x in range(3, 14, 2):\n",
    "    print(\"%4d\" % x, end=\"\")\n",
    "    \n",
    "\n",
    "print(\"\\nrange(14,3,-2):\\t\", end=\"\")\n",
    "# 14 12 10 8 6 4\n",
    "for x in range(14,3,-2):\n",
    "    print(\"%4d\" % x, end=\"\")\n",
    "    \n",
    "\n",
    "print(\"\\narray (tömb):\\t\", end=\"\") \n",
    "primes = [2, 3, 5, 7] # ez egy tömb, később erről bővebben\n",
    "for prime in primes:\n",
    "    print(\"%4d\"  % prime, end=\"\")\n",
    "\n",
    "\n",
    "print(\"\\nwhile:\\t\\t\", end=\"\")\n",
    "# 0  1  2  3  4 \n",
    "i = 0\n",
    "while i < 5:\n",
    "    print(\"%4d\" % i, end=\"\")\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Comprehension\n",
    "A listaértelmezések (list comprehension) a listák létrehozásának rövidebb módja. _Megjegyzés_: a listákról még később lesz szó."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5]\n",
      "[3, 5, 7, 9, 11, 13]\n",
      "[8, 32, 128, 512, 2048, 8192]\n"
     ]
    }
   ],
   "source": [
    "print([i for i in range(6)])\n",
    "print([i for i in range(3,14,2)])\n",
    "print([2**i for i in range(3,14,2)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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"
   ]
  }
 ],
 "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": 2
}