kl_py_alapkonyvtar.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "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.7.4"
    },
    "colab": {
      "name": "kl_py_alapkonyvtar.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "h-HQJw-b6lqt",
        "L0bfmZpf6lqz",
        "G0ti8Ekh6lq-",
        "c9rl8XTR6lrB",
        "CtohoFh56lrE",
        "l6sa0zGL6lrM",
        "cJCOubl46lrN",
        "D-8EcCL66lrT",
        "9-hWl6Dc6lrh",
        "enfDIQZx6lrl",
        "5e5_JsPL6lro",
        "1cTS4auU6lru",
        "s-F6ELGP6lrx",
        "MnGG2zwS6lr7"
      ],
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/klajosw/python/blob/master/kl_py_alapkonyvtar.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f2RK262Y6lqN",
        "colab_type": "text"
      },
      "source": [
        "<p align=\"left\"> \n",
        "    <img src=\"https://raw.githubusercontent.com/klajosw/python/master/kl_mie_python_logo_250.jpg\" \n",
        "         align=\"left\" width=\"251\" height=\"251\">\n",
        "    \n",
        "</p>\n",
        "\n",
        "\n",
        "<p> </p>\n",
        "\n",
        "\n",
        "\n",
        "# Python alapkönyvtár (Standard Library)\n",
        "\n",
        "<https://klajosw.blogspot.com/>\n",
        "\n",
        "<http://harp.pythonanywhere.com/python_doc/tutorial/index.html>\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R_f4SGJG6lqO",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "## Modulok importja\n",
        "\n",
        "\n",
        "Fontos, hogy az importálás során az \n",
        " - `import os` alakot használd, \n",
        " - és ne a `from os import *` alakot. \n",
        "\n",
        "Ez megóv attól, hogy az `os.open()` függvény elfedje (és használhatatlanná tegye) a beépített `open()` függvényt, ami teljesen másképp működik.\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "## Az operációs rendszer elérése  \n",
        "\n",
        "\n",
        "### os\n",
        "\n",
        "Az os modul nagyon sok függvényt tartalmaz, melyek az operációs rendszerrel kommunikálnak.\n",
        "\n",
        "Például a beépített `dir()` és `help()` függvények is sokat segíthetnek.\n",
        "\n",
        "\n",
        "### shutil\n",
        "A mindennapi fájl- és könyvtár-műveletekhez az shutil modul magasszintű, könnyen használható felületet nyújt.\n",
        "    \n",
        "---    "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eqa2cnK76lqP",
        "colab_type": "code",
        "colab": {},
        "outputId": "ec77df57-f264-46fb-ca21-cc56caaae9b0"
      },
      "source": [
        "import os\n",
        "import types\n",
        "\n",
        "os.system('time 10:34')                    # FIGYELEM: átállítottuk a rendszer óráját!\n",
        "print('kész 1')\n",
        "\n",
        "print('A pontos idő : ', os.system('time'))\n",
        "\n",
        "print('Az aktuális könyvtár : ', os.getcwd())                              # Az aktuális könyvtár nevét adja vissza.\n",
        "\n",
        "os.chdir(r'c:\\Users\\User\\Documents\\mintak\\jupiter\\kl\\okt')      # és itt könyvtárar váltottunk.\n",
        "print('kész 2')\n",
        "\n",
        "\n",
        "print(dir(os))  ##  kilistázza az összes függvényt, ami az 'os' modulban található\n",
        "print(help(os)) ## egy nagyon részletes manual oldalt generál a modulok dokumentációs karakterláncából\n",
        "\n",
        "\n",
        "\n",
        "# print all types defined in the `types` module\n",
        "print(dir(types))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "kész 1\n",
            "A pontos idő :  1\n",
            "Az aktuális könyvtár :  C:\\Users\\User\\Documents\\mintak\\jupiter\\kl\\okt\n",
            "kész 2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": false,
        "id": "VWwiNHV96lqT",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import shutil\n",
        "shutil.copyfile('eles.db', 'mentes.db')          ## állomány (biztonsági) mentése (másolat)\n",
        "shutil.move('/build/eles', 'mentes_konyvtar')    ## tartalom átmozgatása"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lKBblwkw6lqV",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "\n",
        "## Karakterhelyettesítő jelek – dzsóker karakterek\n",
        "\n",
        "### A glob modulban lévő függvény segít a fájl listák elkészítésében, ha dzsóker karaktert használunk:\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "U0y9bBaH6lqW",
        "colab_type": "code",
        "colab": {},
        "outputId": "20b52d90-cb6c-4727-caf3-38fa9ec07175"
      },
      "source": [
        "## Pyton filek kilistázása\n",
        "import glob\n",
        "print(glob.glob('*.py'))\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['csvmagic.py', 'first.py', 'mprun_demo.py']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WqBOx6MX6lqZ",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "\n",
        "## Parancssori paraméterek\n",
        "\n",
        "A programoknak gyakran fel kell dolgozniuk a parancssori paramétereiket. \n",
        "\n",
        "Ezek a paraméterek a sys modul argv attribútumában tárolódnak, listaknént. \n",
        "\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "y_1opmoJ6lqa",
        "colab_type": "code",
        "colab": {},
        "outputId": "f0dfce0b-7eeb-4b93-a03c-f72d4bbb184b"
      },
      "source": [
        "import sys\n",
        "print(sys.argv)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['C:\\\\Users\\\\User\\\\Anaconda3\\\\lib\\\\site-packages\\\\ipykernel_launcher.py', '-f', 'C:\\\\Users\\\\User\\\\AppData\\\\Roaming\\\\jupyter\\\\runtime\\\\kernel-5c7d07bb-366b-4031-b070-d3961d9a97c6.json']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8sGudES96lqd",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "\n",
        "##  Hiba-kimenet átirányítása, programfutás megszakítása\n",
        "\n",
        "\n",
        "A sys modul szintén rendelkezik stdin, stdout, és stderr attribútummal. \n",
        "\n",
        "Ez utóbbi használatos figyelmeztetések és hibaüzenetek láthatóvá tételére – például akkor, \n",
        "amikor a stdout át van irányítva, mondjuk egy fájlba.\n",
        "\n",
        "A legrövidebb út egy program megszakítására a sys.exit() utasítás.\n",
        "\n",
        "---    "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xVZZSaJG6lqe",
        "colab_type": "code",
        "colab": {},
        "outputId": "c475080a-c36b-4b79-8313-dfa6d54905cc"
      },
      "source": [
        "import sys\n",
        "sys.stderr.write('Figyelem probléma lépett fel\\n') ## error output csatornára kiírás\n",
        "sys.exit()  # A futás megszakításása "
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Figyelem probléma lépett fel\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "error",
          "ename": "SystemExit",
          "evalue": "",
          "traceback": [
            "An exception has occurred, use %tb to see the full traceback.\n",
            "\u001b[1;31mSystemExit\u001b[0m\n"
          ]
        },
        {
          "output_type": "stream",
          "text": [
            "C:\\Users\\User\\Anaconda3\\lib\\site-packages\\IPython\\core\\interactiveshell.py:3334: UserWarning: To exit: use 'exit', 'quit', or Ctrl-D.\n",
            "  warn(\"To exit: use 'exit', 'quit', or Ctrl-D.\", stacklevel=1)\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eYulYW-D6lqh",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "\n",
        "## Reguláris kifejezések - karakterláncok\n",
        "\n",
        "\n",
        "A re modul segítségével reguláris kifejezéseket használhatunk szövegfeldolgozásra. \n",
        "\n",
        "Összetett illeszkedési és módosító szabályokat határozhatunk meg.\n",
        "\n",
        "A reguláris kifejezések rövid, tömör megoldást kínálnak:\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gUj-0x_i6lqi",
        "colab_type": "code",
        "colab": {},
        "outputId": "a2a54cd5-d125-4d01-a7a7-595664f773a2"
      },
      "source": [
        "import re               #  minden b vagy B-vel kezdődő szót kigyüjtünk:\n",
        "print(re.findall(r'\\b[bB][a-z*]*', r'aki belemegy, hogy befizeti a bírságot az nem biztos, hogy nem Balf**sz'))\n",
        "\n",
        "print(re.sub(r'(\\b[a-z]+) \\1', r'\\1', 'sok a a van a a szövegben b b béből pedig c c kevéss'))\n",
        "# sok a van a szövegben b béből pedig c kevéss\n",
        "\n",
        "print('Kecskeméti Pálinka'.replace('Pálinka', 'Lajos'))\n",
        "## Kecskeméti Lajos\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['belemegy', 'befizeti', 'b', 'biztos', 'Balf**sz']\n",
            "sok a van a szövegben b béből pedig c kevéss\n",
            "Kecskeméti Lajos\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TPQtwgSP6lql",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "\n",
        "## Matematika\n",
        "\n",
        "A math modulon keresztül érhetőek el a háttérben működő C függvények, melyekkel lebegőpontos műveleteket végezhetünk\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qFQ_h5cs6lqm",
        "colab_type": "code",
        "colab": {},
        "outputId": "93150c20-bbe3-48b4-9a5b-c715eac324fc"
      },
      "source": [
        "import math\n",
        "print(math.cos(math.pi / 4.0))\n",
        "print('-----')\n",
        "print(math.log(1024, 2))\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0.7071067811865476\n",
            "-----\n",
            "10.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xRr5p5Me6lqp",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "## Random\n",
        "\n",
        "A random modullal véletlenszámokat generálhatunk.\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i-pn-Fjr6lqq",
        "colab_type": "code",
        "colab": {},
        "outputId": "fd0a1855-a570-4ce7-a523-13ca426393b7"
      },
      "source": [
        "import random\n",
        "print('gyümölcs : ', random.choice(['alma', 'korte', 'banan', 'szilva'])) ## Véletlen szerű választás a listából\n",
        "print('lotto1 : ', random.sample(range(90), 5))   # ismetles nelkuli mintavetel\n",
        "print('véletlen szám  :', random.random())         # random float\n",
        "print('lotto2 : ', random.randrange(90)+1)         # véletlen egész szám kiválasztása 1-90ig terjedő tartományban\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "gyümölcs :  szilva\n",
            "lotto1 :  [75, 9, 2, 77, 80]\n",
            "véletlen szám  : 0.5749922024904971\n",
            "lotto2 :  27\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h-HQJw-b6lqt",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "\n",
        "## Internet elérés\n",
        "\n",
        "Több modul is van, amely lehetővé teszi az Internet elérését, és különböző protokollok használatát. \n",
        "\n",
        "A két legegyszerűbb :\n",
        "az urllib + requests –> adatfogadás url címekről, \n",
        "az smtplib -> levelet küldhetünk\n",
        "\n",
        "---\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gLcZnT4L6lqu",
        "colab_type": "code",
        "colab": {},
        "outputId": "dad69c91-8871-49a8-bfcb-604e90396cdb"
      },
      "source": [
        "import requests\n",
        "import urllib\n",
        "link = \"https://klajosw.blogspot.com/\"\n",
        "f = urllib.request.urlopen(link)\n",
        "myfile = f.read() ##\n",
        "\n",
        "print((myfile[:109]))  ## <class 'bytes'>\n",
        "f.close()\n",
        "                                 \n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "b\"<!DOCTYPE html>\\n<html class='v2' dir='ltr' lang='hu'>\\n<head>\\n<link href='https://www.blogger.com/static/v1/wi\"\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "T2jssBc96lqx",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import smtplib\n",
        "server = smtplib.SMTP('localhost')\n",
        "server.sendmail('klajosw@gmail.com', 'mierdekel@gmail.com',\n",
        "\"\"\"To: klajosw@gmail.com\n",
        "From: mierdekel@gmail.com\n",
        "\n",
        "Szevasz! Eljutottal a nyaralásod vegere.\n",
        "\"\"\")\n",
        "server.quit()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L0bfmZpf6lqz",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "\n",
        "## A dátumok és az idő kezelése\n",
        "A datetime modul biztosít osztályokat a dátumok és az időpontok manipulálására – egyszerűbbeket és összetettebbeket is. \n",
        "\n",
        "A dátum- és az idő- aritmetikai műveletek támogatottak – a középpontban a kimenet formázása és módosítása áll. \n",
        "\n",
        "A modul támogatja azokat az objektumokat is, amelyek kezelni tudják az időzónákat.\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eAJZHx366lq0",
        "colab_type": "code",
        "colab": {},
        "outputId": "c5416f9d-8f78-4e63-b5e5-3e388914fc9f"
      },
      "source": [
        "# a dátumok könnyen létrehozhatóak és formázhatóak:\n",
        "from datetime import date\n",
        "most = date.today()\n",
        "print(most)\n",
        "\n",
        "print(most.strftime(\"%m-%d-%y. %d %b %Y is a %A on the %d day of %B.\"))\n",
        "\n",
        "# a dátumok támogatják a naptári műveleteket:\n",
        "szuletesnap = date(1962, 3, 14)\n",
        "kor = most - szuletesnap  \n",
        "print(kor.days)                  # days = napok, itt az eltelt napok szamat jelenti\n",
        "print('hét : ', kor.days / 7)    #  az eltelt hetek szamat jelenti\n",
        "print(dir(kor))                  # milyen belső függvények érhetőek el"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2020-02-02\n",
            "02-02-20. 02 Feb 2020 is a Sunday on the 02 day of February.\n",
            "21144\n",
            "hét :  3020.5714285714284\n",
            "['__abs__', '__add__', '__bool__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__pos__', '__radd__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rmod__', '__rmul__', '__rsub__', '__rtruediv__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', 'days', 'max', 'microseconds', 'min', 'resolution', 'seconds', 'total_seconds']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AKqL4e1j6lq2",
        "colab_type": "code",
        "colab": {},
        "outputId": "fde28d66-0cdd-4230-a80f-a09d5740c288"
      },
      "source": [
        "import datetime\n",
        "kl_today = datetime.date.today()\n",
        "print('ma van   : ',kl_today)\n",
        "\n",
        "kl_now = datetime.datetime.now()\n",
        "print('most van : ',kl_now)\n",
        "\n",
        "kl_year = datetime.date(2020, 1, 1)\n",
        "print('Új év    : ', kl_year)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "ma van   :  2020-02-02\n",
            "most van :  2020-02-02 20:36:46.783317\n",
            "Új év    :  2020-01-01\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mAxYvnlb6lq7",
        "colab_type": "code",
        "colab": {},
        "outputId": "924f9f42-ebae-4a4a-9061-7b1039b1b040"
      },
      "source": [
        "from datetime import datetime, timedelta\n",
        "kl_now = datetime.now()\n",
        "szulinap = datetime(1962, 3, 14)\n",
        "delta = kl_now - szulinap\n",
        "print('Hány napos vagyok : ', delta)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hány napos vagyok :  21144 days, 20:39:39.746807\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G0ti8Ekh6lq-",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "\n",
        "## Tömörítés - zip, gzip, tar...\n",
        "Az elterjedtebb archiváló és tömörítő formátumok közvetlenül támogatottak, \n",
        "a következő modulokban: zlib, gzip, bz2, zipfile, and tarfile.\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XKVUXaHr6lq_",
        "colab_type": "code",
        "colab": {},
        "outputId": "e3d2fdc7-31d4-4111-f1ee-4e0aa5d931ee"
      },
      "source": [
        "import zlib\n",
        "s = 'Nezzünk egy szöveget és próbáljuk betomoríteni'\n",
        "s = 'Nezzunk egy szoveget es probaljuk betomoriteni'\n",
        "\n",
        "print('STR1 :', len(s))\n",
        "print('STR2 :', (s))\n",
        "print('STR3 :', s.encode('utf-8'))\n",
        "\n",
        "## t = zlib.compress(bytes(s))\n",
        "t = zlib.compress(str.encode(s))\n",
        "bytes\n",
        "print('STR2 :', (t))\n",
        "s = str(zlib.compress(s.encode('utf-8')))\n",
        "print('STR1 :', len(s))\n",
        "                  \n",
        "#print('ZIP2 :', len(t))\n",
        "                  \n",
        "#print('DZIP :', zlib.decompress(t))\n",
        "                  \n",
        "#print('CRC1 : ', zlib.crc32(s))\n",
        "                  \n",
        "print('kész')\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "STR1 : 46\n",
            "STR2 : Nezzunk egy szoveget es probaljuk betomoriteni\n",
            "STR3 : b'Nezzunk egy szoveget es probaljuk betomoriteni'\n",
            "STR2 : b'x\\x9c\\xf3K\\xad\\xaa*\\xcd\\xcbVHM\\xafT(\\xae\\xca/KMO-QH-V((\\xcaOJ\\xcc\\xc9*\\xcdVHJ-\\xc9\\xcf\\xcd/\\xca,I\\xcd\\xcb\\x04\\x00\\xa2\\x88\\x12\\x05'\n",
            "STR1 : 132\n",
            "kész\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c9rl8XTR6lrB",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "\n",
        "##  Teljesítménymérés\n",
        "\n",
        "\n",
        "Néhány Python programozó komoly érdeklődést mutatott a különböző probléma- megoldások teljesítményének \n",
        "összehasonlítása iránt. \n",
        "\n",
        "A Pythonban található egy mérőeszköz, amely azonnali választ ad ezekre a kérdésekre.\n",
        "\n",
        "Például használhatunk tuple becsomagolást és kicsomagolást a megszokott paraméter-átadás helyett. \n",
        "\n",
        "A timeit modul gyorsan demonstrál egy egyszerű teljesítmény mérést:\n",
        "    \n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t4opZ9IH6lrC",
        "colab_type": "code",
        "colab": {},
        "outputId": "87a02f59-bf9e-40e3-c669-4508a4daa320"
      },
      "source": [
        "## A timeit modul apró kódrészletek végrehajtási idejének mérésére szolgál. \n",
        "## Ezzel ellentétben a profile és a pstats modulok nagyobb kódrészletek \n",
        "## futási-idő kritikus részeinek meghatározására szolgál.\n",
        "\n",
        "## Betöltése a modulnak\n",
        "from timeit import Timer\n",
        "\n",
        "print('Time 1 : ', Timer('t=a; a=b; b=t', 'a=1; b=2').timeit())  ## változó csere 1 verzio\n",
        "\n",
        "print('Time 2 : ',Timer('a,b = b,a', 'a=1; b=2').timeit())       ## változó csere 2 verzio (pythonic)\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Time 1 :  0.02424119999989216\n",
            "Time 2 :  0.022523900000010144\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CtohoFh56lrE",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "\n",
        "## Minőségellenőrzés\n",
        "\n",
        "A jóminőségű programok fejlesztésnek egyik elmélete az, hogy minden függvényhez próbaadatokat, teszteket írunk – majd a fejlesztési folyamat során ezeket gyakran lefuttatjuk - így azonnal kiderül, ha a várttól eltérően viselkedik a program.\n",
        "\n",
        "\n",
        "A `doctest` modul tartalmaz olyan eszközöket, amelyekkel modulokat vizsgálhatunk, és a program dokumentációs karakterláncába ágyazott teszteket futtathatunk le. \n",
        "\n",
        "A teszt létrehozása olyan egyszerű, mint kivágni és beilleszteni egy tipikus függvényhívás során bejövő-keletkező adatokat.\n",
        "\n",
        "Ez a lehetőség elősegíti a jobb dokumentáltságot, hiszen a felhasználónak rögtön függvényhívási példát mutathatunk – továbbá ellenőrizhetővé teszi a `doctest` modulnak, hogy a kód a dokumentációval összhangban van-e.\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bUClt5Ds6lrF",
        "colab_type": "code",
        "colab": {},
        "outputId": "e9a0fb6a-1c63-401e-9f64-aa0451632b65"
      },
      "source": [
        "def atlag(ertekek):\n",
        "    \"\"\"Listában átadott számok számtani közepét határozza meg a függvény.\n",
        "    \n",
        "       Használata:\n",
        "    print(atlag([20, 30, 70]))\n",
        "    \n",
        "       Eredmény:\n",
        "    40.0\n",
        "    \"\"\"\n",
        "    return sum(ertekek) / len(ertekek)\n",
        "\n",
        "import doctest\n",
        "doctest.testmod()   # a beágyazott tesztet automatikusan kipróbálja."
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "TestResults(failed=0, attempted=0)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q-1YKFcB6lrI",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "---\n",
        "\n",
        "A `unittest` modul kicsit bonyolultabb, mint a doctest modul – viszont több átfogó \n",
        "tesztkészlet kezeléséről gondoskodik, egy különálló fájlban:\n",
        "    \n",
        "----"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Md1yo5Mu6lrK",
        "colab_type": "code",
        "colab": {},
        "outputId": "b10421cd-d9c7-4dee-8e56-d231c8dbeaeb"
      },
      "source": [
        "import unittest\n",
        "\n",
        "class StatisztikaiFuggvenyekTesztelese(unittest.TestCase):\n",
        "\n",
        "    def atlag_tesztelese(self):\n",
        "        self.assertEqual(atlag([20, 30, 70]), 40.0)\n",
        "        self.assertEqual(round(atlag([1, 5, 7]), 1), 4.3)\n",
        "        with self.assertRaises(ZeroDivisionError):\n",
        "            atlag([])\n",
        "        with self.assertRaises(TypeError):\n",
        "            atlag(20, 30, 70)\n",
        "\n",
        "unittest.main()           # A parancssorból történő hívás lefuttatja a teszteket."
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "E\n",
            "======================================================================\n",
            "ERROR: C:\\Users\\User\\AppData\\Roaming\\jupyter\\runtime\\kernel-11129c68-5bb4-44df-b33d-19c95b05a471 (unittest.loader._FailedTest)\n",
            "----------------------------------------------------------------------\n",
            "AttributeError: module '__main__' has no attribute 'C:\\Users\\User\\AppData\\Roaming\\jupyter\\runtime\\kernel-11129c68-5bb4-44df-b33d-19c95b05a471'\n",
            "\n",
            "----------------------------------------------------------------------\n",
            "Ran 1 test in 0.001s\n",
            "\n",
            "FAILED (errors=1)\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "error",
          "ename": "SystemExit",
          "evalue": "True",
          "traceback": [
            "An exception has occurred, use %tb to see the full traceback.\n",
            "\u001b[1;31mSystemExit\u001b[0m\u001b[1;31m:\u001b[0m True\n"
          ]
        },
        {
          "output_type": "stream",
          "text": [
            "C:\\Users\\User\\Anaconda3\\lib\\site-packages\\IPython\\core\\interactiveshell.py:3334: UserWarning: To exit: use 'exit', 'quit', or Ctrl-D.\n",
            "  warn(\"To exit: use 'exit', 'quit', or Ctrl-D.\", stacklevel=1)\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l6sa0zGL6lrM",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "\n",
        "## Elemekkel együtt...\n",
        "\n",
        "\n",
        "A Python filozófiája: “elemekkel együtt”. A legjobban ez úgy látszik, ha észrevesszük nagyszámú moduljainak - csomagjainak kifinomultságát, összetettségét.\n",
        "\n",
        "\n",
        "\n",
        "Az `xmlrpclib` és a `SimpleXMLRPCServer` modulok a távoli eljáráshívásokat egyszerű műveletté teszik számunkra. A neveik ellenére nincs közvetlen XML tudásra szükség.\n",
        "\n",
        "\n",
        "Az `email` csomag egy könyvtár az elektronikus levelek kezelésére – beleértve a MIME és más RFC 2822-alapú üzeneteket is. \n",
        "\n",
        "Eltérően az `smtplib` és `poplib` moduloktól, melyek azonnali levélküldést és fogadást valósítanak meg, az email csomag teljes eszközkészlettel rendelkezik összetett üzenet-struktúrák felépítéséhez és dekódolásához – a csatolt állományokat is beleértve. Továbbá tartalmazza az Interneten használt kódoló és fejléc protokollokat.\n",
        "\n",
        "\n",
        "Az `xml.dom` és az `xml.sax` csomagok nagyon jól használhatók az elterjedt adat-cserélő formátumok kezelésére, értelmezésére és feldolgozására \n",
        "\n",
        "Ugyanúgy a `csv` modul támogatja a csv formátum közvetlen írását és olvasását. Mindent egybevéve ezek a modulok és csomagok remekül leegyszerűsíti a Python programok és más alkalmazások közötti adatcserét.\n",
        "\n",
        "\n",
        "A kultúrális tulajdonságok beállíthatók és támogatottak számos modulban, például: `gettext`, `locale`, és a `codecs` csomagban is.\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cJCOubl46lrN",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "\n",
        "##  A kimenet formázása\n",
        "\n",
        "\n",
        "A `repr()` függvény lehetővé teszi a nagyméretű, mélyen egymásba ágyazott adatszerkezetek rövid, áttekinthető kijelzését.\n",
        "\n",
        "A `pprint` modullal finoman szabályozhatod beépített és a felhasználó által definiált objektumok megjelenítését \n",
        " – úgy, hogy az az értelmező számára továbbra is feldolgozható marad. Amikor az eredmény nem fér el egy sorban, \n",
        " egy “csinos nyomtató” sortöréseket és behúzásokat ad a kimenethez, hogy az jól olvasható leyen.\n",
        " \n",
        "A `textwrap` modullal szövegblokkokak jeleníthetünk meg adott szélességű blokkban.\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": true,
        "id": "F_ZAKYep6lrN",
        "colab_type": "code",
        "colab": {},
        "outputId": "97eae55a-c05b-4df9-c255-ff34b917feec"
      },
      "source": [
        "print('repr  : ', repr(set('elkelkaposztastalanitottatok')))  \n",
        "\n",
        "print('-----------------------------------')\n",
        "\n",
        "import pprint\n",
        "t = [[[['black', 'cyan'], 'white', ['green', 'red']], [['magenta', 'yellow'], 'blue']]]\n",
        "pprint.pprint(t, width=30)\n",
        "\n",
        "print('-----------------------------------')\n",
        "\n",
        "import textwrap\n",
        "doc = \"\"\"The wrap() method is just like fill() except that it returns\n",
        "      a list of strings instead of one big string with newlines to separate\n",
        "      the wrapped lines.\"\"\"\n",
        "\n",
        "print(textwrap.fill(doc, width=40))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "repr  :  {'s', 'o', 'e', 'a', 'k', 'l', 'p', 'i', 'n', 'z', 't'}\n",
            "-----------------------------------\n",
            "[[[['black', 'cyan'],\n",
            "   'white',\n",
            "   ['green', 'red']],\n",
            "  [['magenta', 'yellow'],\n",
            "   'blue']]]\n",
            "-----------------------------------\n",
            "The wrap() method is just like fill()\n",
            "except that it returns       a list of\n",
            "strings instead of one big string with\n",
            "newlines to separate       the wrapped\n",
            "lines.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e6jf-Ix-6lrQ",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "\n",
        "A `locale` modul a különböző kultúrákhoz kötődő egyedi adatformázásokhoz fér hozzá \n",
        "\n",
        "a `locale format` funkciójának `grouping` (csoportosítás, a következő példában helyiérték) \n",
        "tulajdonsága közvetlenül biztosítja az adott kultúrának megfelelő szám-kijelzést.\n",
        "\n",
        "---    "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "A4LxlcO36lrR",
        "colab_type": "code",
        "colab": {},
        "outputId": "86d08c8f-b71f-4d5f-91ab-8c28f43d36d2"
      },
      "source": [
        "import locale\n",
        "\n",
        "locale.setlocale(locale.LC_ALL, 'English_United States.1252')\n",
        "\n",
        "conv = locale.localeconv()          # get a mapping of conventions\n",
        "\n",
        "x = 1234567.8\n",
        "locale.format(\"%d\", x, grouping=True)\n",
        "\n",
        "locale.format(\"%s %.*f\", (conv['currency_symbol'], conv['int_frac_digits'], x), grouping=True)\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "C:\\Users\\User\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:8: DeprecationWarning: This method will be removed in a future version of Python. Use 'locale.format_string()' instead.\n",
            "  \n",
            "C:\\Users\\User\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:10: DeprecationWarning: This method will be removed in a future version of Python. Use 'locale.format_string()' instead.\n",
            "  # Remove the CWD from sys.path while we load stuff.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "error",
          "ename": "ValueError",
          "evalue": "format() must be given exactly one %char format specifier, '%s %.*f' not valid",
          "traceback": [
            "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[1;32m<ipython-input-14-30af6eec32b3>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      8\u001b[0m \u001b[0mlocale\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"%d\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgrouping\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mTrue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      9\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 10\u001b[1;33m \u001b[0mlocale\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"%s %.*f\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mconv\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'currency_symbol'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mconv\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'int_frac_digits'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgrouping\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mTrue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[1;32m~\\Anaconda3\\lib\\locale.py\u001b[0m in \u001b[0;36mformat\u001b[1;34m(percent, value, grouping, monetary, *additional)\u001b[0m\n\u001b[0;32m    254\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[0mmatch\u001b[0m \u001b[1;32mor\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmatch\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mgroup\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m!=\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mpercent\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    255\u001b[0m         raise ValueError((\"format() must be given exactly one %%char \"\n\u001b[1;32m--> 256\u001b[1;33m                          \"format specifier, %s not valid\") % repr(percent))\n\u001b[0m\u001b[0;32m    257\u001b[0m     \u001b[1;32mreturn\u001b[0m \u001b[0m_format\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mpercent\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgrouping\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmonetary\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m*\u001b[0m\u001b[0madditional\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    258\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
            "\u001b[1;31mValueError\u001b[0m: format() must be given exactly one %char format specifier, '%s %.*f' not valid"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D-8EcCL66lrT",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "\n",
        "\n",
        "## Szöveg-sablonok\n",
        "\n",
        "A string modulban található egy nagyon hasznos osztály, a `Template`. \n",
        "\n",
        "Ez lehetőséget ad a végfelhasználóknak sablon-szövegek szerkesztésére.\n",
        "\n",
        "A szövegbe adatmezőket a $ jellel helyezhetünk el, melyek mellé kapcsos zárójelbe Python változóneveket kell írni (ez számot, betűt és alsóvonás karaktert tartalmazhat). \n",
        "\n",
        "A kapcsos zárójelpárra akkor van szükség, ha nem önálló szó a beillesztett adat, például lent a ‘Peternek’ szó lesz \n",
        "ilyen egyébként a zárójelpár elhagyható. \n",
        "\n",
        "Egyszerű $ jelet így írhatsz: $$\n",
        "\n",
        "\n",
        "A `substitute()` medódus `KeyError` kivételt dob, ha az adatmezőkben megadott változónevet a paraméterként átadott szótárban, vagy kulcsszavas paraméterekben nem találja. \n",
        "\n",
        "Elképzelhető olyan helyzet, hogy valamelyik változónév (vagy kulcs, ha szótárról van szó) hiányzik - ilyenkor a `safe_substitute()` metódust érdemes használni, ami a hiányzó adatoknál az adatmezőt változatlanul hagyja\n",
        "\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PzAj1Ywc6lrU",
        "colab_type": "code",
        "colab": {},
        "outputId": "fdc1c92d-6b6c-49b3-ea51-ae2ca6e5d7e0"
      },
      "source": [
        "\n",
        "from string import Template\n",
        "\n",
        "t = Template('${nev}nek kuldunk  10$$-t, hogy $cselekedet.')\n",
        "\n",
        "t.substitute(nev='Peter', cselekedet='csizmat vegyen')\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Peternek kuldunk  10$-t, hogy csizmat vegyen.'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2o22YVb46lrX",
        "colab_type": "code",
        "colab": {},
        "outputId": "ece0ca96-308b-401c-bb84-989c91e5fda1"
      },
      "source": [
        "# ez a pelda nem fut le, hianyzik $owner\n",
        "t = Template('Return the $item to $owner.')\n",
        "d = dict(item='unladen swallow')\n",
        "t.substitute(d)\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "error",
          "ename": "KeyError",
          "evalue": "'owner'",
          "traceback": [
            "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
            "\u001b[1;32m<ipython-input-18-30c92896ae78>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0mt\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mTemplate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Return the $item to $owner.'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0md\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mdict\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mitem\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'unladen swallow'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0mt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msubstitute\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0md\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
            "\u001b[1;32m~\\Anaconda3\\lib\\string.py\u001b[0m in \u001b[0;36msubstitute\u001b[1;34m(*args, **kws)\u001b[0m\n\u001b[0;32m    130\u001b[0m             raise ValueError('Unrecognized named group in pattern',\n\u001b[0;32m    131\u001b[0m                              self.pattern)\n\u001b[1;32m--> 132\u001b[1;33m         \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpattern\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msub\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mconvert\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtemplate\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    133\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    134\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0msafe_substitute\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkws\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
            "\u001b[1;32m~\\Anaconda3\\lib\\string.py\u001b[0m in \u001b[0;36mconvert\u001b[1;34m(mo)\u001b[0m\n\u001b[0;32m    123\u001b[0m             \u001b[0mnamed\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmo\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mgroup\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'named'\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mor\u001b[0m \u001b[0mmo\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mgroup\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'braced'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    124\u001b[0m             \u001b[1;32mif\u001b[0m \u001b[0mnamed\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 125\u001b[1;33m                 \u001b[1;32mreturn\u001b[0m \u001b[0mstr\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmapping\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mnamed\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    126\u001b[0m             \u001b[1;32mif\u001b[0m \u001b[0mmo\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mgroup\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'escaped'\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    127\u001b[0m                 \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdelimiter\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
            "\u001b[1;31mKeyError\u001b[0m: 'owner'"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oJxHgwTi6lrZ",
        "colab_type": "code",
        "colab": {},
        "outputId": "24a97fd8-9fce-4c04-d24a-1d792a5a9bae"
      },
      "source": [
        "## ez a pelda lefut, pedig hianyzik $owner:browse confirm saveas\n",
        "t = Template('Return the $item to $owner.')\n",
        "d = dict(item='unladen swallow')\n",
        "t.safe_substitute(d)    "
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Return the unladen swallow to $owner.'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SWNCahMr6lrc",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "\n",
        "A Template alosztály egyedi határolójelet is tud használni. Például egy tömeges fájl-átnevező funkció esetében (pl. fénykép-karbantartó programnál) az adatmezők jelzésére használhatod a százalék jelet is, az aktuális dátum, a kép sorszáma, vagy a fájl formátumának jelzése esetén.\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vmWGv8TX6lrc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import time, os.path\n",
        "photofiles = ['img_1074.jpg', 'img_1076.jpg', 'img_1077.jpg']\n",
        "class BatchRename(Template):    \n",
        "      delimiter = '%'\n",
        "\n",
        "fmt = raw_input('Add meg az atnevezes modjat: (%d-datum %n-fajl_sorszama %f-fileformatum):  ') ##  Ashley_%n%f\n",
        "\n",
        "t = BatchRename(fmt)\n",
        "date = time.strftime('%d%b%y')\n",
        "for i, filename in enumerate(photofiles):\n",
        "    base, ext = os.path.splitext(filename)\n",
        "    newname = t.substitute(d=date, n=i, f=ext)\n",
        "    print('%s --> %s' % (filename, newname))\n",
        "    \n",
        "    "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YBO95WyX6lrg",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "\n",
        "A szövegsablonok másik felhasználási lehetősége a többféle kimeneti formátumot támogató programokban van. Itt a vezérlési logika a kimenettől el van választva – A kimeneti fájl felépítése más XML fájloknál, szövegfájloknál, vagy html kimenet esetében, viszont az adattartalom értelemszerűen megegyezik.\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9-hWl6Dc6lrh",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "\n",
        "## Bináris adatblokkok használata\n",
        "\n",
        "\n",
        "A `struct` modulban található a `pack()` és az `unpack()` függvények, melyekkel változó hosszúságú bináris adatblokkokat kezelhetsz. \n",
        "\n",
        "A következő példa bemutatja a ZIP fájlok fejléc információinak feldolgozását (a \"H\" és az \"L\" kódcsomag jelképezi a két és négybájtos előjel nélküli számokat):\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sHQupHPZ6lri",
        "colab_type": "code",
        "colab": {},
        "outputId": "3b907b7a-6b73-496e-bf82-3f433a30c114"
      },
      "source": [
        "import struct\n",
        "\n",
        "data = open(r'c:\\Users\\User\\Downloads\\Feladatcsomag10.zip', 'rb').read()\n",
        "\n",
        "start = 0\n",
        "for i in range(3):                      # megnezzuk az elso harom fajl fejlecet\n",
        "    start += 14\n",
        "    fields = struct.unpack('LLLHH', data[start:start+16])\n",
        "    crc32, comp_size, uncomp_size, filenamesize, extra_size =  fields\n",
        "\n",
        "    start += 16\n",
        "    filename = data[start:start+filenamesize]\n",
        "    start += filenamesize\n",
        "    extra = data[start:start+extra_size]\n",
        "    print(filename, hex(crc32), comp_size, uncomp_size)\n",
        "\n",
        "    start += extra_size + comp_size     # tovabblepes a kovetkezo fejlechez"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "b'Feladatcsomag10/' 0x0 0 0\n",
            "b'Feladatcsomag10/A Sapphire HD 7870 OC.html' 0x32af6be9 6314 34607\n",
            "b'Feladatcsomag10/A Sapphire HD 7870 OC_elemei/' 0x0 0 0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "enfDIQZx6lrl",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "\n",
        "## Többszálúság\n",
        "\n",
        "\n",
        "A szálkezeléssel lehet az egymástól sorrendileg nem függő folyamatokat párhuzamossá tenni. \n",
        "\n",
        "\n",
        "A szálakkal egyidőben fogadhatjuk a program felhasználójának utasításait, miközben a háttérben a program egy feladaton dolgozik - a két folyamat (kommunikáció, és háttérben munka) egymással párhuzamosan fut.\n",
        "\n",
        "\n",
        "A következő kód bemutatja a threading modul magasszintű használatát, ami egy külön háttérfolyamatot indít, miközben a program fut tovább.\n",
        "\n",
        "A többszálú programok egyik legfontosabb feladata azon szálak működésének koordinálása, melyek megosztott adatokon, vagy közös erőforrásokon dolgoznak. (pl. mi történik ha két szál egyidőben akar egy fájlt írni?) \n",
        "\n",
        "A Threading modul több szinkronizációs elemet tartalmaz – ilyen a zárolás, az eseménykezelés, a feltételes változók és a szemaforok.\n",
        "\n",
        "Igaz ugyan, hogy ezek hatékony eszközök – ám előfordulhatnak kisebb tervezési hibák is, melyek nehezen megismételhetők, és nehezen kinyomozhatók. Mivel a szálak egymástól függetlenül futnak, még végrehajtásuk sorrendje sem biztos - emiatt előfordulhat, hogy a program nem ugyanúgy viselkedik, ha egymás után többször lefuttatjuk – így a hibakeresés is nehezebbé válik.\n",
        "\n",
        "A szálak koordinálására azt javasoljuk, hogy az erőforrások elérését egy szál biztosítsa, és használd a Queue modult a többi szálból érkező kérések kezelésére. \n",
        "\n",
        "Ha egy programban a szálak közötti kommunikációt a Queue objektumokkal biztosítod, a program koordinálásának megtervezése egyszerűbb, olvashatóbb és megbízhatóbb lesz.\n",
        "\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yuMwlRWx6lrm",
        "colab_type": "code",
        "colab": {},
        "outputId": "b7857018-d7fb-492e-f802-0537ce2a209e"
      },
      "source": [
        "import threading, zipfile\n",
        "\n",
        "class AsyncZip(threading.Thread):\n",
        "        def __init__(self, infile, outfile):\n",
        "            threading.Thread.__init__(self)\n",
        "            self.infile = infile\n",
        "            self.outfile = outfile\n",
        "        def run(self):\n",
        "            f = zipfile.ZipFile(self.outfile, 'w', zipfile.ZIP_DEFLATED)\n",
        "            f.write(self.infile)\n",
        "            f.close()\n",
        "            print('Kesz a zip tomoritese ennek a fajlnak: ', self.infile)\n",
        "\n",
        "background = AsyncZip('nfl_height_weight.csv', 'myarchive.zip')\n",
        "background.start()\n",
        "print('A foprogram tovabb fut az eloterben.')\n",
        "\n",
        "background.join()    # Varakozas a hattermuvelet befejezesere\n",
        "print('A foprogram megvarja, hogy a hattermuvelet befejezodjon.')"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "A foprogram tovabb fut az eloterben.\n",
            "Kesz a zip tomoritese ennek a fajlnak:  nfl_height_weight.csv\n",
            "A foprogram megvarja, hogy a hattermuvelet befejezodjon.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5e5_JsPL6lro",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "\n",
        "##  Naplózás\n",
        "\n",
        "\n",
        "A logging modul egy összetett, finoman beállítható naplózó rendszert tartalmaz. \n",
        "\n",
        "\n",
        "A legegyszerűbb esetben a naplózandó üzenetek fájlba, vagy a sys.stderr (szabványos hibakimenetre) - küldhetők:\n",
        "\n",
        "\n",
        "Alapértelmezés szerint az információs és debug üzenetek elfojtottak, és a kimenet a szabványos hiba csatornára kerül. \n",
        "\n",
        "A kimenet célja más is lehet, például email, datagram, socket vagy akár egy HTTP szerver. Az új szűrők az üzenet prioritásától függően más-más kimenetre terelhetik a naplózandó üzenetet. \n",
        "\n",
        "A prioritások: DEBUG, INFO, WARNING, ERROR, és CRITICAL.\n",
        "\n",
        "A naplózó rendszer közvetlenül a Pythonból is beállítható, vagy használhatsz konfigurációs fájlt, s így a programból való kilépés nélkül megváltoztathatod a naplózás beállításait.\n",
        "\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kHjNM_DO6lrq",
        "colab_type": "code",
        "colab": {},
        "outputId": "305355e6-a344-405f-8e77-3070b446f389"
      },
      "source": [
        "import logging\n",
        "logging.debug('Debugging information')\n",
        "logging.info('Informational message')\n",
        "logging.warning('Warning:config file %s not found', 'server.conf')\n",
        "logging.error('Error occurred')\n",
        "logging.critical('Critical error -- shutting down')"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "WARNING:root:Warning:config file server.conf not found\n",
            "ERROR:root:Error occurred\n",
            "CRITICAL:root:Critical error -- shutting down\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1cTS4auU6lru",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "\n",
        "## Gyenge hivatkozások\n",
        "\n",
        "A memóriakezelést a Python automatikusan végzi (hivatkozásszámlálás a legtöbb objektum esetében, és szemétgyűjtés). \n",
        "\n",
        "Az utolsó objektum-hivatkozás megsemmisülése után az elfoglalt memória felszabadul.\n",
        "\n",
        "Ez az automatizmus a legtöbb esetben jó és hasznos, de néha szükség van az objektumok követésére mindaddig, amíg használatban vannak. \n",
        "\n",
        "Érdekes, hogy éppen ez a követés az, ami a hivatkozásokat állandóvá teszi (nem szűnnek meg).\n",
        "\n",
        "A `weakref` modulban olyan eszközök vannak, amelyekkel úgy lehet nyomon követni az objektumokat, \n",
        "hogy a nyomkövetéssel nem hozol létre újabb hivatkozást az objektumra. \n",
        "\n",
        "Amikor az objektumot már senki nem használja, automatikusan törlődik a weakref (gyenge referencia) táblából, \n",
        "és a weakref objektum erről értesítést kap. \n",
        "\n",
        "A tipikus programok tároló objektumokat tartalmaznak, melyek létrehozása erőforrásigényes.\n",
        "    \n",
        "\n",
        "    ---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jyAdIMIb6lrv",
        "colab_type": "code",
        "colab": {},
        "outputId": "be9a2f9d-8273-4fd5-919b-e811c22c9121"
      },
      "source": [
        "\n",
        "import weakref, gc\n",
        "class A:\n",
        "    def __init__(self, ertek):\n",
        "         self.ertek = ertek\n",
        "            \n",
        "    def __repr__(self):\n",
        "          return str(self.ertek)\n",
        "\n",
        "a = A(10)                   # hivatkozas letrehozasa\n",
        "d = weakref.WeakValueDictionary()\n",
        "d['primary'] = a            # itt nem keletkezik hivatkozas\n",
        "d['primary']                # ha az objektum meg letezik, visszaadja az erteket\n",
        "\n",
        "del a                       # toroljuk az egyetlen hivatkozast\n",
        "gc.collect()                # a szemetgyujtest azonnal lefuttatjuk\n",
        "\n",
        "d['primary']                # ez a bejegyzes automatikusan megszunt, nem kell kulon torolni\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "error",
          "ename": "KeyError",
          "evalue": "'primary'",
          "traceback": [
            "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
            "\u001b[1;32m<ipython-input-28-08a65bf9f7b7>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     15\u001b[0m \u001b[0mgc\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcollect\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m                \u001b[1;31m# a szemetgyujtest azonnal lefuttatjuk\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     16\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 17\u001b[1;33m \u001b[0md\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'primary'\u001b[0m\u001b[1;33m]\u001b[0m                \u001b[1;31m# ez a bejegyzes automatikusan megszunt, nem kell kulon torolni\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[1;32m~\\Anaconda3\\lib\\weakref.py\u001b[0m in \u001b[0;36m__getitem__\u001b[1;34m(self, key)\u001b[0m\n\u001b[0;32m    135\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_pending_removals\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    136\u001b[0m             \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_commit_removals\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 137\u001b[1;33m         \u001b[0mo\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    138\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mo\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    139\u001b[0m             \u001b[1;32mraise\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
            "\u001b[1;31mKeyError\u001b[0m: 'primary'"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s-F6ELGP6lrx",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "\n",
        "##  Listakezelő eszközök\n",
        "\n",
        "\n",
        "A legtöbb adatstruktúrának szüksége van a beépített lista típusra. \n",
        "\n",
        "Néha előfordul, hogy a listák egy másfajta megvalósítására van szükség, az eredeti listáktól eltérő viselkedéssel.\n",
        "\n",
        "Az array modulban található array() objektum hasonlít azokhoz a listákhoz, melyek csak hasonló adat-típusokat tárolnak, de ezt a tárolást sokkal tömörebben végzi. \n",
        "\n",
        "A következő példában egy számokból álló tömböt láthatunk, ahol a számok mint két bájtos előjel-nélküli bináris számként tárolódnak (típuskód: \"H\") – ellentétben a hagyományos Python int (egész szám) objektumokból álló listákkal, ahol minden bejegyzés 16 bájtot használ.\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Z2sdgpt36lrx",
        "colab_type": "code",
        "colab": {},
        "outputId": "1b44c141-82ae-4939-b565-f9911e28e191"
      },
      "source": [
        "from array import array\n",
        "a = array('H', [4000, 10, 700, 22222])\n",
        "print('sum : ', sum(a))\n",
        "\n",
        "print('a[] : ', a[1:3])\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "sum :  26932\n",
            "a[] :  array('H', [10, 700])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5YIhI8286lrz",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "\n",
        "A collections modulban lévő deque() objektum egy – a listához hasonló típus – viszont gyorsabban tud új elemet felvenni a lista végére és elemet kiemelni a lista elejéről. \n",
        "\n",
        "Hátránya viszont, hogy a keresésben lassabb - nehézkesebb, mint a hagyományos lista. \n",
        "\n",
        "Ez az objektumtípus hasznos várakozási sorok, listák megvalósítására és mélységi keresés esetén.\n",
        "\n",
        "Ráadásul az Alapkönyvtár más eszközöket is tartalmaz, például a bisect modult, ami rendezett listák módosítására szolgál.\n",
        "\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JZR06_s16lr0",
        "colab_type": "code",
        "colab": {},
        "outputId": "d653c478-3ef3-49aa-be2f-b22c5ceb72ac"
      },
      "source": [
        "from collections import deque\n",
        "d = deque([\"task1\", \"task2\", \"task3\"])\n",
        "d.append(\"task4\")\n",
        "print(\"Handling\", d.popleft())\n",
        "\n",
        "\n",
        "unsearched = deque([\"task1\", \"task2\", \"task3\"])\n",
        "def breadth_first_search(unsearched):\n",
        "    node = unsearched.popleft()\n",
        "    for m in gen_moves(node):\n",
        "        if is_goal(m):\n",
        "            return m\n",
        "        unsearched.append(m)\n",
        "        \n",
        "breadth_first_search(unsearched) \n",
        "print(unsearched)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Handling task1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "name 'gen_moves' is not defined",
          "traceback": [
            "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[1;32m<ipython-input-37-45543bd9f0d9>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     13\u001b[0m         \u001b[0munsearched\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mm\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     14\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 15\u001b[1;33m \u001b[0mbreadth_first_search\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0munsearched\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     16\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0munsearched\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
            "\u001b[1;32m<ipython-input-37-45543bd9f0d9>\u001b[0m in \u001b[0;36mbreadth_first_search\u001b[1;34m(unsearched)\u001b[0m\n\u001b[0;32m      8\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mbreadth_first_search\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0munsearched\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      9\u001b[0m     \u001b[0mnode\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0munsearched\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpopleft\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 10\u001b[1;33m     \u001b[1;32mfor\u001b[0m \u001b[0mm\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mgen_moves\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnode\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     11\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mis_goal\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mm\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     12\u001b[0m             \u001b[1;32mreturn\u001b[0m \u001b[0mm\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
            "\u001b[1;31mNameError\u001b[0m: name 'gen_moves' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RKYrQ-ia6lr2",
        "colab_type": "code",
        "colab": {},
        "outputId": "2fe43e2d-7655-4374-a808-841567740a89"
      },
      "source": [
        "import bisect\n",
        "scores = [(100, 'perl'), (200, 'tcl'), (400, 'lua'), (500, 'python')]\n",
        "bisect.insort(scores, (300, 'ruby'))\n",
        "print(' scores : ',  scores)\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            " scores :  [(100, 'perl'), (200, 'tcl'), (300, 'ruby'), (400, 'lua'), (500, 'python')]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RYlSovF96lr5",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "\n",
        "\n",
        "A `heapq` modulban található függvényekkel megvalósíthatók a hagyományos listákon alapuló adathalmazok kezelése. \n",
        "\n",
        "A legalacsonyabb értékű bejegyzés mindig a nulla pozícióba kerül. \n",
        "\n",
        "Ez hasznos, ha a programodnak gyakran kell elérnie a lista legkisebb elemét, de nem akarod a listát teljes mértékben rendezni:\n",
        "    \n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wlHl1m_Q6lr5",
        "colab_type": "code",
        "colab": {},
        "outputId": "3d1e0f65-1bcc-4633-cf2f-51371f033454"
      },
      "source": [
        "from heapq import heapify, heappop, heappush\n",
        "data = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]\n",
        "heapify(data)                      # átrendezi a listát\n",
        "heappush(data, -5)                 # új elemet ad a listába\n",
        "[heappop(data) for i in range(3)]  # kilistázza a három legkisebb elemet."
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[-5, 0, 1]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MnGG2zwS6lr7",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "\n",
        "##  Lebegőpontos Aritmetika\n",
        "\n",
        "A decimal modulban található a Decimal adattípus, lebegőpontos számításokhoz. \n",
        "\n",
        "A beépített float típushoz képest, amely a bináris lebegőpontos számításokhoz készült, az új osztály nagyon sokat segít pénzügyi programoknál (és ott, ahol véges decimális ábrázolást használnak, a pontosság ellenőrzésével, a törvényeknek vagy a szabályoknak megfelelő kerekítés használatával, a fontos számjegyek nyomkövetésével – vagy olyan programoknál, ahol a felhasználó kézzel végzett számításokhoz akarja hasonlítani a végeredményt.\n",
        "\n",
        "\n",
        "Például számítsuk ki az 5%-os adóját egy 70 centes telefonköltségnek, ami különböző eredményt ad decimális és bináris lebegőpontos számítás használata esetén. \n",
        "\n",
        "A különbség fontos lesz, ha a kerekítés a legközelebbi centhez történik.\n",
        "\n",
        "A Decimal osztály teljesen pontosan ábrázolja a maradékos osztást, és az egyenlőségtesztelést, ami a bináris lebegőpontos ábrázolás esetén helytelen eredményre vezet.\n",
        "\n",
        "\n",
        "A Decimal osztály eredménye egy lezáró nullát tartalmaz, automatikusan négy számjegyűen kerül ábrázolásra, a 2*2 számjegyű (tizedesjegyek) szorzás eredményeképp. A Decimal ugyanolyan matematikát használ, mint amit a papíron végzett számolás, és elkerüli azokat a kérdéseket, amikor a bináris lebegőpontos számítás nem tud abszolút pontosan ábrázolni decimális mennyiségeket.\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Sl-HTMCT6lr8",
        "colab_type": "code",
        "colab": {},
        "outputId": "5f1965d2-f08f-4df6-a861-9bb5d9aaa478"
      },
      "source": [
        "from decimal import *\n",
        "\n",
        "print(Decimal('0.70') * Decimal('1.05'))\n",
        "\n",
        "print(Decimal(\"0.7350\"))\n",
        "\n",
        "print(Decimal('1.00') % Decimal('.10'))\n",
        "\n",
        "print(Decimal(\"0.00\"))\n",
        "\n",
        "\n",
        "print(sum([Decimal('0.1')]*10) == Decimal('1.0'))\n",
        "\n",
        "print(sum([0.1]*10) == 1.0)\n",
        "\n",
        "## A decimal modulban a számítások pontosságát szükség szerint beállíthatod:\n",
        "getcontext().prec = 36\n",
        "\n",
        "print(Decimal(1) / Decimal(7))\n",
        "\n",
        "print(Decimal(\"0.142857142857142857142857142857142857\"))\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0.7350\n",
            "0.7350\n",
            "0.00\n",
            "0.00\n",
            "True\n",
            "False\n",
            "0.142857142857142857142857142857142857\n",
            "0.142857142857142857142857142857142857\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ujRShgn26lsA",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "\n",
        "# Bővítő csomagok\n",
        "\n",
        "\n",
        "## Néhány népszerű, tudományos számításokhoz és képfeldolgozáshoz kapcsolódó csomag\n",
        "\n",
        " -\tNumpy (\"Numerical Python\"). A nyelv kiterjesztése többdimenziós mátrixok hatékony kezelésével. A többi csomag alapját képzi. Célszerű a hatékony adatelérésre kidolgozott MKL (Intel Math Kernel Library) csomaggal együttes változatát használni!\n",
        " -\tSciPy (\"Scientific Python\"). Numpy csomagra épülő, numerikus számítási algoritmusokat tartalmazó csomag.\n",
        " -\tMatPlotLib. Numpy csomagra épülő, diagramrajzoló és vizualizációs csomag.\n",
        " - \tScikit-image. SciPy kiterjesztése további képfeldolgozó műveletekkel.\n",
        " -\tMahotas. Számítógépes látás algoritmusok.\n",
        " -\tPillow. Számos képformátum betöltése és képek feldolgozása.\n",
        " -\tPandas. Adatmanipulációhoz és elemzéshez, magasszintű hozzáférést biztosít táblázatba rendezett adatokhoz. Numpy csomagra épül, de célszerű a SciPy és MatPlotLib csomagok telepítése is.\n",
        "\n",
        "\n",
        "## Több, a képfeldolgozás területén használatos komplex C++ függvénykönyvtár is rendelkezik Python felülettel\n",
        " -\tOpenCV. Képfeldolgozó és számítógépes látás algoritmusok.\n",
        " -\tSimpleITK. Az Insight Toolkit (ITK) egyszerűsített interfésze. Az ITK de-facto szabványnak számít a 3D orvosi képek szegmentálási és regisztrációs algoritmusainál.\n",
        " -\tVTK (\"Visualization Toolkit\"). Inkább 3D számítógépes grafikai csomag, de feladatai közé tartozik a képek vizualizációja és egyszerűbb feldolgozása is.\n",
        " -\tOpen3D. 3D pontfelhők reprezentációja és feldolgozása.\n",
        "\n",
        "\n",
        "## Gépi tanulási csomagok, amelyek képfeldolgozásban is hasznosak\n",
        "\n",
        " - Scikit-learn. A Python alapértelmezett gépi tanulási csomagja.\n",
        " - Tensorflow + Keras. A Google gépi tanulási csomagja magasszintű API felülettel.\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UahchvZN6lsC",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}