Prg_alapjai,_4_előadás.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Prg. alapjai, 4. előadás.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "f7eVZMvjwqcQ",
        "E82c9tYmfGrh",
        "Pv66VRZXpLE7",
        "hGH92vZal7sd"
      ]
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2VV7P2cwYj3J"
      },
      "source": [
        "# Kollekciók\n",
        "\n",
        "Adatok csoportjának tárolására használható, összetett adatszerkezetek.\n",
        "\n",
        "## Tuple\n",
        "* sorrendtartó\n",
        "* ismétlődést megenged\n",
        "* indexeléssel választhatók ki a tárolt elemei\n",
        "* az elemek típusa eltérő is lehet\n",
        "* csak olvasható\n",
        "* keresés csak sorosan történhet (O(n))"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qPemJyE8Zp0E",
        "outputId": "da8e5432-e6dd-40f8-86d5-f4ea73a0d331"
      },
      "source": [
        "t = (42, 3.14, 'Cicamica') # 3 elemű tuple\n",
        "print(type(t))\n",
        "print('t elemszáma: ', len(t))\n",
        "i = 0\n",
        "while i < len(t):\n",
        "  print(t[i], end=' ') # az indexelés 0-tól kezdődik\n",
        "  i += 1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'tuple'>\n",
            "t elemszáma:  3\n",
            "42 3.14 Cicamica "
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 174
        },
        "id": "FcGvQNgTaod_",
        "outputId": "bfc93143-e6b7-4dce-cb7f-008ae494df80"
      },
      "source": [
        "t[0] = 'valami' # a tuple csak olvasható"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-11-5d6ffb54e48f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mt\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'valami'\u001b[0m \u001b[0;31m# a tuple csak olvasható\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 174
        },
        "id": "wm0R3y3qaxb-",
        "outputId": "223e633a-d132-4cab-be12-b77910428b5e"
      },
      "source": [
        "print(t[3]) # túlindexelés"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "IndexError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-12-d38b145b557d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# túlindexelés\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mIndexError\u001b[0m: tuple index out of range"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HS-pQL3LbDjY",
        "outputId": "800c4687-c0ac-4112-fc81-aa0ef655c6b6"
      },
      "source": [
        "print(t[-1]) # negatív index: -1 --> hátulról az első\n",
        "t2 = () # üres tuple\n",
        "t3 = (1,) # 1 elemű tuple\n",
        "print(type(t2), type(t3))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Cicamica\n",
            "<class 'tuple'> <class 'tuple'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hP6CdEa5cg-k",
        "outputId": "c698bc2c-9d36-4ee4-82f9-2518de078dfc"
      },
      "source": [
        "t = (42, 3.14, 'Cicamica')\n",
        "print('t azonosítója: ', id(t))\n",
        "t += (True, None) # nem a tuple módosul, hanem új tuple jön létre\n",
        "print('t azonosítója: ', id(t))\n",
        "print(t)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "t azonosítója:  140057169260784\n",
            "t azonosítója:  140060445401264\n",
            "(42, 3.14, 'Cicamica', True, None)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "E0jsbbWmbgGr",
        "outputId": "f4da50d6-5e94-434c-f544-92354152390c"
      },
      "source": [
        "hatizsak = ('tea', 'szendvics', 'svájci bicska', 'telefon', 'kulcs', 'pénztárca')\n",
        "cucc = input('Mit keresünk? ')\n",
        "if cucc in hatizsak: # tartalmazás vizsgálat\n",
        "  print('Nyugi, eltetted.')\n",
        "else:\n",
        "  print('Hoppá, ez kimaradt!')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mit keresünk? szendvics\n",
            "Nyugi, eltetted.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kKZjXcQvYYPM"
      },
      "source": [
        "Tuple-ben tárolt számok minimumának, maximumának és átlagának meghatározása"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "y0WkYMnCy3gT",
        "outputId": "18e9d1a6-272c-4323-e9e9-a24ec8240171"
      },
      "source": [
        "szamok = (1, 3, 2, 4)\n",
        "legkisebb = legnagyobb = osszeg = szamok[0]\n",
        "i = 1\n",
        "while i < len(szamok):\n",
        "  if szamok[i] < legkisebb:\n",
        "    legkisebb = szamok[i]\n",
        "  if szamok[i] > legnagyobb:\n",
        "    legnagyobb = szamok[i]\n",
        "  osszeg += szamok[i]\n",
        "  i += 1\n",
        "print('A legkisebb szám:', legkisebb)\n",
        "print('A legnagyobb szám:', legnagyobb)\n",
        "print(f'Az átlag: {osszeg / len(szamok):.2f}')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "A legkisebb szám: 1\n",
            "A legnagyobb szám: 4\n",
            "Az átlag: 2.50\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hHNI67gHVraw",
        "outputId": "a8db3fb0-eecc-461e-a7e3-7d5d6f3e8c35"
      },
      "source": [
        "import statistics as stat\n",
        "print('Számok minimumának, maximumának és átlagának meghatározása')\n",
        "print('Adjon meg nemnegatív számokat! Kilépés negatív értékre.')\n",
        "szamok = ()\n",
        "while True:\n",
        "  szam = float(input('Következő szám: '))\n",
        "  if szam < 0.:\n",
        "    break\n",
        "  szamok += (szam,)\n",
        "print(f'Minimum: {min(szamok)}, maximum: {max(szamok)}, átlag: {stat.mean(szamok):.2f}')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Számok minimumának, maximumának és átlagának meghatározása\n",
            "Adjon meg nemnegatív számokat! Kilépés negatív értékre.\n",
            "Következő szám: 1 \n",
            "Következő szám: 2\n",
            "Következő szám: 3\n",
            "Következő szám: 4\n",
            "Következő szám: -1\n",
            "Minimum: 1.0, maximum: 4.0, átlag: 2.50\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9eD6TXNrezI1"
      },
      "source": [
        "## Listák\n",
        "\n",
        "Hasonló a tuple-hoz, de megváltoztatható a tartalma."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "j-duUz8GfOaP",
        "outputId": "c75cba41-2a63-4858-ad70-0678abe46bed"
      },
      "source": [
        "lista = [42, 3.14, 'Cicamica'] # 3 elemű lista\n",
        "print(type(lista))\n",
        "lista[0] = 'valami' # a lista módosítható\n",
        "print('lista azonosítója: ', id(lista))\n",
        "lista += ['Frakk']\n",
        "print('lista azonosítója: ', id(lista))\n",
        "print('Tartalma: ', lista)\n",
        "lista += 'Szerénke' # betűnként adja hozzá a karakterláncot\n",
        "print('Tartalma: ', lista)\n",
        "lista = lista[:-len('Szerénke')] # slicing itt is használható\n",
        "lista.append('Szerénke')\n",
        "print('Tartalma: ', lista)\n",
        "lista.insert(0, 'Lukrécia') # beszúrás a 0-s indexű elem elé\n",
        "print('Tartalma: ', lista)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'list'>\n",
            "lista azonosítója:  139670533922480\n",
            "lista azonosítója:  139670533922480\n",
            "Tartalma:  ['valami', 3.14, 'Cicamica', 'Frakk']\n",
            "Tartalma:  ['valami', 3.14, 'Cicamica', 'Frakk', 'S', 'z', 'e', 'r', 'é', 'n', 'k', 'e']\n",
            "Tartalma:  ['valami', 3.14, 'Cicamica', 'Frakk', 'Szerénke']\n",
            "Tartalma:  ['Lukrécia', 'valami', 3.14, 'Cicamica', 'Frakk', 'Szerénke']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3ljtTwXgkgam"
      },
      "source": [
        "Számok beolvasása, majd kiírása fordított sorrendben"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "q_yeq026k0D0",
        "outputId": "404dfaff-d608-4b10-f545-b5ad2ff2841d"
      },
      "source": [
        "db = int(input('Hány számmal szeretne dolgozni? '))\n",
        "szamok = []\n",
        "i = 0\n",
        "while i < db:\n",
        "  szamok.append(int(input('Következő szám: ')))\n",
        "  i += 1\n",
        "print('A megadott értékek fordított sorrendben:')\n",
        "i -= 1\n",
        "while i >= 0:\n",
        "  print(szamok[i])\n",
        "  i -= 1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hány számmal szeretne dolgozni? 3\n",
            "Következő szám: 1\n",
            "Következő szám: 2\n",
            "Következő szám: 3\n",
            "A megadott értékek fordított sorrendben:\n",
            "3\n",
            "2\n",
            "1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "al1gRlP6l4WN"
      },
      "source": [
        "A listák [verem](https://hu.wikipedia.org/wiki/Verem_(adatszerkezet)) szervezésű tárolóként is használhatók"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5Cpvr9bIheX_",
        "outputId": "288c436d-c607-4be7-ae05-a36191947795"
      },
      "source": [
        "# A listák verem szervezésű tárolóként is használhatók\n",
        "tarolo = []\n",
        "tarolo.append(1)\n",
        "tarolo.append(2)\n",
        "tarolo.append(3)\n",
        "print(tarolo.pop()) # alapértelmezetten az utolsó elemet adja vissza / távolítja el, de paraméterezhető\n",
        "print(tarolo.pop())\n",
        "print(tarolo.pop())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n",
            "2\n",
            "1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nuuZ-NIIljix",
        "outputId": "ecfe04b4-0037-4305-fcec-66f0fb54e062"
      },
      "source": [
        "3\n",
        "db = int(input('Hány számmal szeretne dolgozni? '))\n",
        "szamok = []\n",
        "i = 0\n",
        "while i < db:\n",
        "  szamok.append(int(input('Következő szám: ')))\n",
        "  i += 1\n",
        "print('A megadott értékek fordított sorrendben:')\n",
        "while len(szamok) > 0:\n",
        "  print(szamok.pop())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hány számmal szeretne dolgozni? 3\n",
            "Következő szám: 1\n",
            "Következő szám: 2\n",
            "Következő szám: 3\n",
            "A megadott értékek fordított sorrendben:\n",
            "3\n",
            "2\n",
            "1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kyvwyrQJpU60",
        "outputId": "66a85609-968c-436e-e3ae-63ff2120bd53"
      },
      "source": [
        "szinek = ['Fehér', 'Zöld']\n",
        "szinek.insert(0, 'Piros') # Beszúrás adott indexű helyre\n",
        "print(szinek)\n",
        "szinek.remove('Zöld') # Adott értékű elem eltávolítása (egy darab, nem az összes)\n",
        "print(szinek)\n",
        "del szinek[-1] # negatív indelés használható --> utolsó elem törlése\n",
        "print(szinek)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['Piros', 'Fehér', 'Zöld']\n",
            "['Piros', 'Fehér']\n",
            "['Piros']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TN9HJX6Fq3C1",
        "outputId": "dcbce35d-d5b1-45c8-bd9d-9322009f55b5"
      },
      "source": [
        "datum = '2021-03-16'.split('-') # listát készít stringből: elválasztójel (alapértelmezetten szóköz) mentén darabol\n",
        "print(datum)\n",
        "print('.'.join(datum)) # összefűzés, listából string készül"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['2021', '03', '16']\n",
            "2021.03.16\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f0MR7CJHqzX2"
      },
      "source": [
        "## for ciklus\n",
        "\n",
        "Minden iteráció alkalmával egy szekvencia (string betűi, tuple/list elemei) soron következő elemét lehet feldolgozni. A szekvencia generálható is range () függvénnyel."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hTbbNzdUss-k",
        "outputId": "64c78b9a-5479-47bd-cfea-71643f47787f"
      },
      "source": [
        "print(list(range(0, 10, 2))) # range objektum: kezdőérték, végérték (ez nem tartozik bele!), lépésköz\n",
        "print(list(range(0, 10))) # 0 az alapértelmezett kezdőérték, és 1 a lépésköz\n",
        "print(list(range(10)))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0, 2, 4, 6, 8]\n",
            "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
            "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "z7FXpAryz6rI",
        "outputId": "268ef643-deeb-41e4-bd28-87401db31f0a"
      },
      "source": [
        "db = int(input('Hány számmal szeretne dolgozni? '))\n",
        "szamok = []\n",
        "for i in range(1, db+1):\n",
        "  szamok.append(int(input(f'A(z) {i}. szám: ')))\n",
        "print('A megadott értékek fordított sorrendben:')\n",
        "for i in range(len(szamok)-1, -1, -1):\n",
        "  print(szamok[i])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hány számmal szeretne dolgozni? 10\n",
            "A(z) 1. szám: 1\n",
            "A(z) 2. szám: 2\n",
            "A(z) 3. szám: 3\n",
            "A(z) 4. szám: 4\n",
            "A(z) 5. szám: 5\n",
            "A(z) 6. szám: 6\n",
            "A(z) 7. szám: 7\n",
            "A(z) 8. szám: 8\n",
            "A(z) 9. szám: 9\n",
            "A(z) 10. szám: 10\n",
            "A megadott értékek fordított sorrendben:\n",
            "10\n",
            "9\n",
            "8\n",
            "7\n",
            "6\n",
            "5\n",
            "4\n",
            "3\n",
            "2\n",
            "1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oUAGEkf_sd7q",
        "outputId": "2c946019-d99e-43b6-d7b5-9deacc58ba1f"
      },
      "source": [
        "db = int(input('Hány számmal szeretne dolgozni? '))\n",
        "szamok = []\n",
        "for i in range(1, db+1):\n",
        "  szamok.append(int(input(f'A(z) {i}. szám: ')))\n",
        "print('A megadott értékek fordított sorrendben:')\n",
        "szamok.reverse() # lista elemsorrendjének megfordítása\n",
        "for szam in szamok:\n",
        "  print(szam)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hány számmal szeretne dolgozni? 3\n",
            "A(z) 1. szám: 1\n",
            "A(z) 2. szám: 2\n",
            "A(z) 3. szám: 3\n",
            "A megadott értékek fordított sorrendben:\n",
            "3\n",
            "2\n",
            "1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "A range() csak egészekkel használható!"
      ],
      "metadata": {
        "id": "d4e_i_zvLs_U"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for f in range(0, 10, 0.5):\n",
        "  print(f)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 193
        },
        "id": "lQIMthXULkDP",
        "outputId": "623673bc-33e5-48fe-cf51-eeec5873e58e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-1-ea3c49cb7e9d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mfor\u001b[0m \u001b[0mf\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0.5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m   \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mTypeError\u001b[0m: 'float' object cannot be interpreted as an integer"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "for f in range(0, 21):\n",
        "  print(f * 0.5)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zTbGAfvPLylx",
        "outputId": "9a46d39b-43cf-4e55-f148-db598e210867"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.0\n",
            "0.5\n",
            "1.0\n",
            "1.5\n",
            "2.0\n",
            "2.5\n",
            "3.0\n",
            "3.5\n",
            "4.0\n",
            "4.5\n",
            "5.0\n",
            "5.5\n",
            "6.0\n",
            "6.5\n",
            "7.0\n",
            "7.5\n",
            "8.0\n",
            "8.5\n",
            "9.0\n",
            "9.5\n",
            "10.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f7eVZMvjwqcQ"
      },
      "source": [
        "## Lista elemeinek rendezése\n",
        "\n",
        "Két elem sorrendje könnyen biztosítható:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8IlibyfD19vp",
        "outputId": "9927ece6-4126-470b-fbd4-0c72014e6716"
      },
      "source": [
        "szamok = [3, 2]\n",
        "if szamok[1] < szamok[0]:\n",
        "  csere = szamok[0]\n",
        "  szamok[0] = szamok[1]\n",
        "  szamok[1] = csere\n",
        "print('A számok rendezés után:',szamok)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "A számok rendezés után: [2, 3]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y_PF_WU72im3"
      },
      "source": [
        "Még három sorrendje is viszonylag könnyen biztosítható:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zkDwub_32nNl",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2fb3bbac-b25b-4980-cba3-b76847e14b7f"
      },
      "source": [
        "szamok = [3, 2, 1]\n",
        "if szamok[1] < szamok[0]:\n",
        "  csere = szamok[0]\n",
        "  szamok[0] = szamok[1]\n",
        "  szamok[1] = csere\n",
        "if szamok[2] < szamok[1]:\n",
        "  csere = szamok[1]\n",
        "  szamok[1] = szamok[2]\n",
        "  szamok[2] = csere\n",
        "if szamok[1] < szamok[0]:\n",
        "  csere = szamok[0]\n",
        "  szamok[0] = szamok[1]\n",
        "  szamok[1] = csere\n",
        "print('A számok rendezés után:',szamok)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "A számok rendezés után: [1, 2, 3]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_Hf6sppQ2Sqq"
      },
      "source": [
        "[Buborék rendezőalgoritmus](https://hu.wikipedia.org/wiki/Bubor%C3%A9krendez%C3%A9s)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WztDwtsQbJu9",
        "outputId": "2fa2d2ae-e24f-4f37-d61b-8de80a9348a9"
      },
      "source": [
        "szamok = [23, -5, 9, 7, 42, 123, 99, 666, -76, 12]\n",
        "print('Kiinduló állapot:', szamok)\n",
        "for vege in range(len(szamok)-1, 0, -1):\n",
        "  for eleje in range(vege):\n",
        "    if szamok[eleje] > szamok[eleje+1]:\n",
        "      csere = szamok[eleje]\n",
        "      szamok[eleje] = szamok[eleje+1]\n",
        "      szamok[eleje+1] = csere\n",
        "      print('Aktuális állapot:', szamok)\n",
        "  print(f'Egy elem ({szamok[vege]}) a helyére került.')\n",
        "print('A számok rendezés után:',szamok)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Kiinduló állapot: [23, -5, 9, 7, 42, 123, 99, 666, -76, 12]\n",
            "Aktuális állapot: [-5, 23, 9, 7, 42, 123, 99, 666, -76, 12]\n",
            "Aktuális állapot: [-5, 9, 23, 7, 42, 123, 99, 666, -76, 12]\n",
            "Aktuális állapot: [-5, 9, 7, 23, 42, 123, 99, 666, -76, 12]\n",
            "Aktuális állapot: [-5, 9, 7, 23, 42, 99, 123, 666, -76, 12]\n",
            "Aktuális állapot: [-5, 9, 7, 23, 42, 99, 123, -76, 666, 12]\n",
            "Aktuális állapot: [-5, 9, 7, 23, 42, 99, 123, -76, 12, 666]\n",
            "Egy elem (666) a helyére került.\n",
            "Aktuális állapot: [-5, 7, 9, 23, 42, 99, 123, -76, 12, 666]\n",
            "Aktuális állapot: [-5, 7, 9, 23, 42, 99, -76, 123, 12, 666]\n",
            "Aktuális állapot: [-5, 7, 9, 23, 42, 99, -76, 12, 123, 666]\n",
            "Egy elem (123) a helyére került.\n",
            "Aktuális állapot: [-5, 7, 9, 23, 42, -76, 99, 12, 123, 666]\n",
            "Aktuális állapot: [-5, 7, 9, 23, 42, -76, 12, 99, 123, 666]\n",
            "Egy elem (99) a helyére került.\n",
            "Aktuális állapot: [-5, 7, 9, 23, -76, 42, 12, 99, 123, 666]\n",
            "Aktuális állapot: [-5, 7, 9, 23, -76, 12, 42, 99, 123, 666]\n",
            "Egy elem (42) a helyére került.\n",
            "Aktuális állapot: [-5, 7, 9, -76, 23, 12, 42, 99, 123, 666]\n",
            "Aktuális állapot: [-5, 7, 9, -76, 12, 23, 42, 99, 123, 666]\n",
            "Egy elem (23) a helyére került.\n",
            "Aktuális állapot: [-5, 7, -76, 9, 12, 23, 42, 99, 123, 666]\n",
            "Egy elem (12) a helyére került.\n",
            "Aktuális állapot: [-5, -76, 7, 9, 12, 23, 42, 99, 123, 666]\n",
            "Egy elem (9) a helyére került.\n",
            "Aktuális állapot: [-76, -5, 7, 9, 12, 23, 42, 99, 123, 666]\n",
            "Egy elem (7) a helyére került.\n",
            "Egy elem (-5) a helyére került.\n",
            "A számok rendezés után: [-76, -5, 7, 9, 12, 23, 42, 99, 123, 666]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8PsdzjzWb5jy"
      },
      "source": [
        "Rendezzünk növekvő sorrendbe 10 egész számot! (Beépített rendező algoritmus)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8rBhm6wqcwMN",
        "outputId": "9767e9f9-0d3f-4b09-80be-9a454af9af42"
      },
      "source": [
        "szamok = [23, -5, 9, 7, 42, 123, 99, 666, -76, 12]\n",
        "szamok.sort()\n",
        "print('A számok rendezés után:',szamok)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "A számok rendezés után: [-76, -5, 7, 9, 12, 23, 42, 99, 123, 666]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TfJqnkqQkcxi"
      },
      "source": [
        "Hasonlítsuk össze a két megoldás futási idejét 10000 véletlenszerűen előállított szám rendezése során!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0NIcjmaqjLTQ",
        "outputId": "38d58637-ab11-4cad-fe63-986bb8930e42"
      },
      "source": [
        "import time\n",
        "import random\n",
        "for i in range(10000):\n",
        "  szamok.append(random.randint(-100000, +100000))\n",
        "kezdes = time.time()\n",
        "for vege in range(len(szamok)-1, 0, -1):\n",
        "  for eleje in range(vege):\n",
        "    if szamok[eleje]>szamok[eleje+1]:\n",
        "      csere = szamok[eleje]\n",
        "      szamok[eleje] = szamok[eleje+1]\n",
        "      szamok[eleje+1] = csere\n",
        "befejezes = time.time()\n",
        "print(f'A rendezes ideje: {befejezes-kezdes:.2f} mp.')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "A rendezes ideje: 17.71 mp.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-c5FcKu_gAQr",
        "outputId": "bd83f018-e2c1-45c1-80cf-9a0c531c709a"
      },
      "source": [
        "import time\n",
        "import random\n",
        "for i in range(10000):\n",
        "  szamok.append(random.randint(-100000, +100000))\n",
        "kezdes = time.time()\n",
        "szamok.sort()\n",
        "befejezes = time.time()\n",
        "print(f'A rendezes ideje: {befejezes-kezdes:.2f} mp.')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "A rendezes ideje: 0.00 mp.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1ylMJYGBYdPk"
      },
      "source": [
        "A sort metódus alternatívája: sorted. Nem változtatja meg az eredeti listát"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-L2p8VxGYihA",
        "outputId": "b2b14d36-e1f5-418f-c369-c251b066803e"
      },
      "source": [
        "szamok = [23, -5, 9, 7, 42, 123, 99, 666, -76, 12]\n",
        "rendezett = sorted(szamok)\n",
        "print('Számok rendezés előtt:',szamok)\n",
        "print('Számok rendezés után:', rendezett)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Számok rendezés előtt: [23, -5, 9, 7, 42, 123, 99, 666, -76, 12]\n",
            "Számok rendezés után: [-76, -5, 7, 9, 12, 23, 42, 99, 123, 666]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "If4bI1uTcpen"
      },
      "source": [
        "Rendezzük a számokat csökkenő sorrendbe!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "s4gOOSj-cw3-",
        "outputId": "e418bcb6-7be6-4c6f-e40d-879908e46acb"
      },
      "source": [
        "szamok = [23, -5, 9, 7, 42, 123, 99, 666, -76, 12]\n",
        "szamok.sort(reverse=True)\n",
        "print('A számok rendezés után:',szamok)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "A számok rendezés után: [666, 123, 99, 42, 23, 12, 9, 7, -5, -76]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kva7wV7VPGIz"
      },
      "source": [
        "Szöveges adatok rendezése is lehetséges"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QpJ0vvdiOJQe",
        "outputId": "776e13f0-09ef-45ad-c0f5-b020c6688768"
      },
      "source": [
        "nevek = ['Gizi', 'Viki', 'Feri', 'Lali', 'Teri', 'Mari']\n",
        "nevek.sort()\n",
        "print('A nevek rendezés után:', nevek)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "A nevek rendezés után: ['Feri', 'Gizi', 'Lali', 'Mari', 'Teri', 'Viki']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1S8GXgjbPKYg"
      },
      "source": [
        "A rendezési sorrend a betűk Unicode kódértékén alapul, nem az ABC sorrenden!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lquOBFiTOenv",
        "outputId": "95d3a454-2059-4b29-8ee8-aa9219668281"
      },
      "source": [
        "nevek = ['Ádám', 'András', 'Éva', 'Elemér', 'Ödön', 'Olivér']\n",
        "nevek.sort()\n",
        "print('A nevek rendezés után:', nevek)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "A nevek rendezés után: ['András', 'Elemér', 'Olivér', 'Ádám', 'Éva', 'Ödön']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IwSSDijEUO6m"
      },
      "source": [
        "Megoldás: helyi beállításoknak (locale) megfelelő összehasonlítás (bár néhány betűt így is egyformának tekint)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!apt install language-pack-hu\n",
        "!dpkg-reconfigure locales\n",
        "import locale\n",
        "\n",
        "nevek = ['Ádám', 'András', 'Éva', 'Elemér', 'Ödön', 'Olivér']\n",
        "locale.setlocale(locale.LC_ALL, 'hu_HU.UTF-8')\n",
        "nevek.sort(key=locale.strxfrm)\n",
        "print('A nevek rendezés után:', nevek)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "awH4RGaq-kGM",
        "outputId": "bb48d25e-31b0-4669-c98d-03cbfee36400"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Reading package lists... Done\n",
            "Building dependency tree       \n",
            "Reading state information... Done\n",
            "language-pack-hu is already the newest version (1:18.04+20180712).\n",
            "0 upgraded, 0 newly installed, 0 to remove and 39 not upgraded.\n",
            "Generating locales (this might take a while)...\n",
            "  en_US.UTF-8... done\n",
            "  hu_HU.UTF-8... done\n",
            "Generation complete.\n",
            "A nevek rendezés után: ['Ádám', 'András', 'Elemér', 'Éva', 'Olivér', 'Ödön']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E82c9tYmfGrh"
      },
      "source": [
        "## Kétdimenziós listák: egydimenziós lista minden eleme egy egydimenziós lista\n",
        "\n",
        "Állítsuk elő egy mátrix [transzponáltját](https://hu.wikipedia.org/wiki/M%C3%A1trix_(matematika)#Transzpon%C3%A1l%C3%A1s)!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MWINV7shfLa3",
        "outputId": "c84ad474-d995-4956-d1a7-967d8e74d0b1"
      },
      "source": [
        "8# mátrix beolvasása\n",
        "sor = int(input('Hány sora van a mátrixnak? '))\n",
        "oszlop = int(input('Hány oszlopa van a mátrixnak? '))\n",
        "mtx = []\n",
        "for s in range(sor):\n",
        "  ujsor = []\n",
        "  for o in range(oszlop):\n",
        "    ujsor.append(float(input(f'[{s+1}][{o+1}]: ')))\n",
        "  mtx.append(ujsor)\n",
        "# transzponálás\n",
        "tr = []\n",
        "for o in range(oszlop):\n",
        "  ujsor = []\n",
        "  for s in range(sor):\n",
        "    ujsor.append(mtx[s][o])\n",
        "  tr.append(ujsor)\n",
        "# nyomtatás\n",
        "print('Eredeti:', mtx)\n",
        "print('Transzponált:', tr)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hány sora van a mátrixnak? 3\n",
            "Hány oszlopa van a mátrixnak? 3\n",
            "[1][1]: 11\n",
            "[1][2]: 12\n",
            "[1][3]: 13\n",
            "[2][1]: 21\n",
            "[2][2]: 22\n",
            "[2][3]: 23\n",
            "[3][1]: 31\n",
            "[3][2]: 32\n",
            "[3][3]: 33\n",
            "Eredeti: [[11.0, 12.0, 13.0], [21.0, 22.0, 23.0], [31.0, 32.0, 33.0]]\n",
            "Transzponált: [[11.0, 21.0, 31.0], [12.0, 22.0, 32.0], [13.0, 23.0, 33.0]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "o3Z_VxuBoX9f",
        "outputId": "e42f7938-0c2c-42ff-dcc5-a5c2807fcda0"
      },
      "source": [
        "hallgatok = [\n",
        "  ['1Q2W3E', 'Kovács Béla'],\n",
        "  ['ASD123', 'Nagy Ilona'],\n",
        "  ['LKJHGF', 'Kiss Mihály']\n",
        "]\n",
        "print('A kurzus hallgatói:')\n",
        "for hg in hallgatok:\n",
        "  print(hg[0], ': ', hg[1])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "A kurzus hallgatói:\n",
            "1Q2W3E :  Kovács Béla\n",
            "ASD123 :  Nagy Ilona\n",
            "LKJHGF :  Kiss Mihály\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Pv66VRZXpLE7"
      },
      "source": [
        "### Kicsomagolás (unpacking): szekvencia elemeinek egyszerű változókba töltése\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SIKsV9rPpSGt",
        "outputId": "b6d89b52-0fe2-4c6f-def1-5306fea2706e"
      },
      "source": [
        "a, (b, c) = (1, [2, (3, 4)])\n",
        "print(a)\n",
        "print(b)\n",
        "print(c)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "2\n",
            "(3, 4)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mIA4PtmEqDRd",
        "outputId": "de367ae4-a089-48c1-9c87-57032c6b929c"
      },
      "source": [
        "hallgatok = [\n",
        "  ['1Q2W3E', 'Kovács Béla'],\n",
        "  ['ASD123', 'Nagy Ilona'],\n",
        "  ['LKJHGF', 'Kiss Mihály']\n",
        "]\n",
        "print('A kurzus hallgatói:')\n",
        "for neptun, nev in hallgatok:\n",
        "  print(neptun, ': ', nev)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "A kurzus hallgatói:\n",
            "1Q2W3E :  Kovács Béla\n",
            "ASD123 :  Nagy Ilona\n",
            "LKJHGF :  Kiss Mihály\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-W3eF378qS4H",
        "outputId": "25f7b404-d789-4e8d-dc68-7295fdd7d903"
      },
      "source": [
        "a = 1\n",
        "b = 2\n",
        "a, b = b, a\n",
        "print('a = ', a, 'b = ', b)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "a =  2 b =  1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QKz33mEev60W",
        "outputId": "3e55ff49-6bfc-4707-9517-1bd0fd0a6c08"
      },
      "source": [
        "szamok = [23, -5, 9, 7, 42, 123, 99, 666, -76, 12]\n",
        "for vege in range(len(szamok)-1, 0, -1):\n",
        "  for eleje in range(vege):\n",
        "    if szamok[eleje] > szamok[eleje+1]:\n",
        "      szamok[eleje], szamok[eleje+1] = szamok[eleje+1], szamok[eleje]\n",
        "print('A számok rendezés után:',szamok)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "A számok rendezés után: [-76, -5, 7, 9, 12, 23, 42, 99, 123, 666]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-1QJVxe0ttT6",
        "outputId": "51cca375-4a9b-4fa3-9e01-8a7e8a8a98fc"
      },
      "source": [
        "a, b, c = '123'\n",
        "print(a)\n",
        "print(b)\n",
        "print(c)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "2\n",
            "3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZE-PM5JhuEuC",
        "outputId": "c1613862-3549-40f1-8589-d7f8ae10cc60"
      },
      "source": [
        "a, b, c = range(3)\n",
        "print(a)\n",
        "print(b)\n",
        "print(c)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0\n",
            "1\n",
            "2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2Fe7GfTkurOa"
      },
      "source": [
        "Több érték csomagolása egyetlen (list vagy tuple típusú) változóba : * (packing)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qnUIjaqSu1EA",
        "outputId": "6e498cb9-1bd6-4a60-f862-9cd2c3dcebe3"
      },
      "source": [
        "*a, b = 1, 2, 3\n",
        "print(a)\n",
        "print(b)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 2]\n",
            "3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xGWT4myhvB6t",
        "outputId": "5553b4cc-b744-4109-bed8-3f2535cb55a4"
      },
      "source": [
        "a, *b = 1, 2, 3\n",
        "print(a)\n",
        "print(b)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "[2, 3]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IHhTI3MVvGHf",
        "outputId": "98ec9478-0cbe-4614-83cd-ed61c083a993"
      },
      "source": [
        "*a, = 1, 2, 3 # vessző nélkül int-nek tekinti a-t\n",
        "print(a)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 2, 3]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lLsW2iNkvWEM",
        "outputId": "493f51af-b12a-4e87-9d58-38d1bdde3902"
      },
      "source": [
        "*a, b, c = 1, 2\n",
        "print(a)\n",
        "print(b)\n",
        "print(c)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[]\n",
            "1\n",
            "2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pA-MkjDbwVoC",
        "outputId": "d29fe2dc-6589-4d82-a708-4489c8216522"
      },
      "source": [
        "*a, = range(10)\n",
        "print(a)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "016kyYmDxX_X",
        "outputId": "84f855ff-d7c1-4c81-8c74-c7c18e4a7fd9"
      },
      "source": [
        "szamok = range(2, 4)\n",
        "print([0, 1, szamok, 4, 5])\n",
        "print([0, 1, *szamok, 4, 5])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0, 1, range(2, 4), 4, 5]\n",
            "[0, 1, 2, 3, 4, 5]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hGH92vZal7sd"
      },
      "source": [
        "## Keresés\n",
        "\n",
        "Hogyan találjuk meg egy elem összes előfordulásának helyét (indexeit) és értékét?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ApDolhmkq7dy",
        "outputId": "b22e584a-585a-437e-81ba-e65ff9f492bd"
      },
      "source": [
        "nevek = ['Ádám', 'András', 'Ádám', 'Éva', 'Elemér', 'Ödön', 'Olivér', 'Éva', 'Ádám']\n",
        "nev = input('Kit keresünk? ')\n",
        "if nev in nevek:\n",
        "  print('Első előfordulás indexe:', nevek.index(nev))\n",
        "  helyek = []\n",
        "  for i in range(len(nevek)):\n",
        "    if nevek[i] == nev:\n",
        "      helyek.append(i)\n",
        "  if len(helyek) > 1:\n",
        "    print('A további előfordulások indexei:', helyek[1:])\n",
        "else:\n",
        "  print(nev, 'nem található a listában.')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Kit keresünk? Éva\n",
            "Első előfordulás indexe: 3\n",
            "A további előfordulások indexei: [7]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IQnctaV8nY7n"
      },
      "source": [
        "enumerate: visszaadja a szekvencia aktuális elemének indexét és értékét is\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZGVOER_SjVNl",
        "outputId": "7371e8a7-0d85-4972-a8a8-4e3c6c041a1a"
      },
      "source": [
        "nevek = ['Ádám', 'András', 'Ádám', 'Éva', 'Elemér', 'Ödön', 'Olivér', 'Éva', 'Ádám']\n",
        "nev = input('Kit keresünk? ')\n",
        "if nev in nevek:\n",
        "  print('Első előfordulás indexe:', nevek.index(nev))\n",
        "  helyek = []\n",
        "  for i,n in enumerate(nevek):\n",
        "    if n==nev:\n",
        "      helyek.append(i)\n",
        "  if len(helyek) > 1:\n",
        "    print('A további előfordulások indexei:', helyek[1:])\n",
        "else:\n",
        "  print(nev, 'nem található a listában.')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Kit keresünk? Éva\n",
            "Első előfordulás indexe: 3\n",
            "A további előfordulások indexei: [7]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Keresőalgoritmusok"
      ],
      "metadata": {
        "id": "PRwXBeiA8wiE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import random as rnd\n",
        "\n",
        "rendezetlen = []\n",
        "for i in range(100000000):\n",
        "  rendezetlen.append(rnd.random())\n",
        "keresett = rendezetlen[rnd.randint(0, len(rendezetlen)-1)]\n",
        "print('Ezt az értéket keressük:', keresett)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BFzOryk17Z6W",
        "outputId": "3aa27682-5630-4d9a-c7d3-eb4f08aadaa4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ezt az értéket keressük: 0.9322065220060834\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Beépített keresés"
      ],
      "metadata": {
        "id": "X5--l90rsOhf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import time\n",
        "\n",
        "# lista index metódusa\n",
        "kezdes = time.time()\n",
        "index = rendezetlen.index(keresett)\n",
        "befejezes = time.time()\n",
        "print(f'Első elfordulás indexe: {index}, időigény: {befejezes-kezdes:.2f}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1YMhZmFgo3MB",
        "outputId": "4c117dcb-0c08-4a5e-fb03-795151f31b6f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Első elfordulás indexe: 23189309, időigény: 0.38\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Soros keresés: minden elemet egyesével végignézünk, hátha megtaláljuk, amit kerestünk."
      ],
      "metadata": {
        "id": "pAQ9sa-hsHJb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# soros keresés\n",
        "kezdes = time.time()\n",
        "for i in range(len(rendezetlen)-1):\n",
        "  if rendezetlen[i] == keresett:\n",
        "    index = i\n",
        "    break\n",
        "befejezes = time.time()\n",
        "print(f'Első elfordulás indexe: {index}, időigény: {befejezes-kezdes:.2f}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "89TuSu6jkzgh",
        "outputId": "109dad0c-52cb-44a9-98dc-a819fb0a2021"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Első elfordulás indexe: 23189309, időigény: 4.85\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "[Bináris keresés](https://wiki.prog.hu/wiki/Logaritmikus_keres%C3%A9s_(algoritmus)): minden lépésben felére szűkítjük azt a halmazt, amiben a keresett érték előfordulhat. Csak rendezett adatokon használható."
      ],
      "metadata": {
        "id": "pmM6N2iQsZeR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# bináris keresés\n",
        "rendezett = sorted(rendezetlen)\n",
        "kezdes = time.time()\n",
        "index = -1\n",
        "eleje = 0\n",
        "vege = len(rendezett)-1\n",
        "while eleje <= vege:\n",
        "  kozep = (eleje + vege) // 2\n",
        "  if rendezett[kozep] == keresett:\n",
        "    index = kozep\n",
        "    break\n",
        "  elif rendezett[kozep] > keresett:\n",
        "    vege = kozep - 1\n",
        "  else:\n",
        "    eleje = kozep + 1\n",
        "befejezes = time.time()\n",
        "if index != -1:\n",
        "  print(f'Első elfordulás indexe: {index}, időigény: {befejezes-kezdes:.2f}')\n",
        "else:\n",
        "  print('Nem találtuk meg a keresett értéket, de ezen az indexen lenne a helye:', eleje)"
      ],
      "metadata": {
        "id": "LCdfXJbQoyvl",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5d0190f4-b4d2-45b6-ffa5-6f0b07c77ae9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Első elfordulás indexe: 93222731, időigény: 0.00\n"
          ]
        }
      ]
    }
  ]
}