Prg_alapjai,_8_előadás.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Prg. alapjai, 8. előadás.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# NumPy alapok\n",
        "\n",
        "## Mátrixok használata, motiváló példa\n",
        "\n",
        "Mátrix: számok téglalap alakú elrendezése. Mátrixokat listák vagy tuple-ök egymásba ágyazásával készíthetünk.\n",
        "\n",
        "(A [Matlab](https://uk.mathworks.com/products/matlab.html) alaptípusa a mátrix, mert sok matematikai probléma megoldása így egyszerűbb, kifejezőbb.)\n",
        "\n",
        "Egy lineáris egyenletrendszer megoldható [Gauss-eliminációval](https://hu.wikipedia.org/wiki/Gauss-elimin%C3%A1ci%C3%B3). Ebben az esetben az együtthatók ábrázolhatók mátrixban (*A*), az egyenletek jobb oldala (*b*) pedig vektorban.\n",
        "\n"
      ],
      "metadata": {
        "id": "yMRrP-v2MMAc"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vfLvv9htMGJF",
        "outputId": "e334888d-7c01-4d1f-ff3a-ea79b0f5c58f"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1.3478260869565215, 0.47826086956521746, 0.8695652173913044]\n"
          ]
        }
      ],
      "source": [
        "from typing import List\n",
        "\n",
        "def gauss(a : List[List[float]], b : List[float]) -> List:\n",
        "  n = len(a)\n",
        "  x = [None]*n\n",
        "  for k in range(n-1):\n",
        "    for i in range(k+1, n):\n",
        "      if a[k][k] == 0.: # A sorok átrendezése talán segítene\n",
        "        return x\n",
        "      l = a[i][k] / a[k][k]\n",
        "      b[i] -= l*b[k]\n",
        "      for j in range(k, n):\n",
        "        a[i][j] -= l*a[k][j]\n",
        "  for i in range(n-1, -1, -1):\n",
        "    s = 0\n",
        "    for j in range(i+1, n):\n",
        "      s += a[i][j]*x[j]\n",
        "    x[i] = (b[i]-s)/a[i][i]\n",
        "  return x\n",
        "\n",
        "a = [\n",
        "     [1,  5,  -2],\n",
        "     [2,  3,  1],\n",
        "     [2,  4,  -3]\n",
        "]\n",
        "b = [\n",
        "     2,\n",
        "     5,\n",
        "     2\n",
        "]\n",
        "x = gauss(a, b)\n",
        "print(x)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## NumPy\n",
        "\n",
        "Numerikus számításokhoz készített függvénykönyvtár\n",
        "- Alacsony szintű megvalósítás -> gyors\n",
        "- Alaptípusa az *n* dimenziós tömb\n",
        "- Kiválthatja a Matlab kódokat\n",
        "- Számos magasabb szintű függvénykönyvtár épül rá, vagy képes használni (pl. Matplotlib)\n",
        "\n",
        "Ha telepíteni szükséges (Colab-ban nem lesz rá szükség), próbálkozni lehet pl. az alábbiakkal:\n",
        "> pip3 install numpy --user\n",
        "\n",
        "Python csomag telepítése kizárólag az aktív felhasználó részére\n",
        "\n",
        "> sudo apt-get install python3-numpy\n",
        "\n",
        "Debian-alapú Linux rendszereken a szükséges csomag telepítése\n",
        "\n",
        "> conda install numpy\n",
        "\n",
        "[Conda](https://docs.conda.io) csomagkezelővel történő telepítés\n",
        "\n",
        "### Tömbök létrehozása\n",
        "\n",
        "- NumPy tömböt létrehozni egymásba ágyazott listákat/tuple-öket felhasználva lehet, esetleg valamilyen függvénnyel lehet adott tulajdonságú tömböket generáltatni.\n",
        "- A tárolt adatok típusát a *dtype* tulajdonság mondja meg. A lehetséges értékeket lásd pl. [itt](https://numpy.org/doc/stable/user/basics.types.html#array-types-and-conversions-between-types) és [itt](https://numpy.org/doc/stable/reference/arrays.scalars.html#sized-aliases)\n",
        "- A dimenziószám könnyen megállapítható az *ndim* tulajdonság értékének lekérdezésével.\n",
        "- Az egyes dimenziók mentén mért elemszámot szolgáltatja a *shape* tulajdonság."
      ],
      "metadata": {
        "id": "wRZ5qiNzYZlT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "np_b = np.array([\n",
        "  2, \n",
        "  5, \n",
        "  2\n",
        "])\n",
        "\n",
        "np_a = np.array([\n",
        "  [1,  5,  -2],\n",
        "  [2,  3,  1],\n",
        "  [2,  4,  -3]\n",
        "])\n",
        "\n",
        "print('Összetett típusok: ', type(b), type(np_b))\n",
        "\n",
        "print('Alaptípusok: ', type(a[0][0]), np_a.dtype)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jtYZdeOJzPNG",
        "outputId": "a656a81d-e4f0-4838-aa86-0380bdfba3e2"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Összetett típusok:  <class 'list'> <class 'numpy.ndarray'>\n",
            "Alaptípusok:  <class 'int'> int64\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "nullak = np.zeros((3, 2), np.int32) # Az alaptípus elhagyható; https://numpy.org/doc/stable/reference/generated/numpy.zeros.html\n",
        "egyesek = np.ones((3, 2)) # https://numpy.org/doc/stable/reference/generated/numpy.ones.html\n",
        "egyesek2 = np.array([[1.] * 2] * 3)\n",
        "egysegmatrix = np.eye(3) # https://numpy.org/doc/stable/reference/generated/numpy.eye.html\n",
        "\n",
        "print('Nullmátrix:\\n', nullak)\n",
        "print('Egyesekből álló mátrix:\\n', egyesek)\n",
        "print('Egyesek másképp létrehozva:\\n', egyesek2)\n",
        "print('Egységmátrix:\\n', egysegmatrix)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2sLK8ZMpzi0u",
        "outputId": "8f818a97-80f4-4a5d-a6c8-2f32bd916732"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Nullmátrix:\n",
            " [[0 0]\n",
            " [0 0]\n",
            " [0 0]]\n",
            "Egyesekből álló mátrix:\n",
            " [[1. 1.]\n",
            " [1. 1.]\n",
            " [1. 1.]]\n",
            "Egyesek másképp létrehozva:\n",
            " [[1. 1.]\n",
            " [1. 1.]\n",
            " [1. 1.]]\n",
            "Egységmátrix:\n",
            " [[1. 0. 0.]\n",
            " [0. 1. 0.]\n",
            " [0. 0. 1.]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Ha az eredeti elemtípus nem megfelelő, később is át lehet alakítani a tömböt."
      ],
      "metadata": {
        "id": "NFE087AK4fxu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(nullak.astype('float32'))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-g45HOMq4mys",
        "outputId": "b2d92505-3bb0-4cf8-b9a9-43497fa370a1"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[0. 0.]\n",
            " [0. 0.]\n",
            " [0. 0.]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from typing import List\n",
        "\n",
        "def tartomanyLepeskoz(tol: float, ig: float, lepes: float) -> List[float]:\n",
        "  lista = []\n",
        "  while tol < ig:\n",
        "    lista.append(tol)\n",
        "    tol += lepes\n",
        "  return lista\n",
        "\n",
        "tartomany1 = tartomanyLepeskoz(-1, 1, 0.2)\n",
        "np_tartomany1 = np.arange(-1, 1, 0.2) # https://numpy.org/doc/stable/reference/generated/numpy.arange.html\n",
        "\n",
        "print('Adott tartományba tartozó értékek előállítása a lépésköz megadásával:\\n', tartomany1, '\\n', np_tartomany1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EUr7PPa_z0JL",
        "outputId": "4dd1968e-b09d-419b-b153-c5f0f03c95a2"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Adott tartományba tartozó értékek előállítása a lépésköz megadásával:\n",
            " [-1, -0.8, -0.6000000000000001, -0.4000000000000001, -0.20000000000000007, -5.551115123125783e-17, 0.19999999999999996, 0.39999999999999997, 0.6, 0.8] \n",
            " [-1.00000000e+00 -8.00000000e-01 -6.00000000e-01 -4.00000000e-01\n",
            " -2.00000000e-01 -2.22044605e-16  2.00000000e-01  4.00000000e-01\n",
            "  6.00000000e-01  8.00000000e-01]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def tartomanyElemszam(tol: float, ig: float, elemszam: int) -> List[float]:\n",
        "  szelesseg = ig-tol\n",
        "  return [tol+(szelesseg*e)/(elemszam-1) for e in range(0, elemszam)]\n",
        "\n",
        "tartomany2 = tartomanyElemszam(-1, 1, 9)\n",
        "np_tartomany2 = np.linspace(-1, 1, 9) # https://numpy.org/doc/stable/reference/generated/numpy.linspace.html\n",
        "\n",
        "print('Adott tartományba tartozó értékek előállítása az elemszám megadásával:\\n', tartomany2, '\\n', np_tartomany2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iffI0RKbz88c",
        "outputId": "f4bf5ae7-a433-401a-83d9-59c366a2f2ff"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Adott tartományba tartozó értékek előállítása az elemszám megadásával:\n",
            " [-1.0, -0.75, -0.5, -0.25, 0.0, 0.25, 0.5, 0.75, 1.0] \n",
            " [-1.   -0.75 -0.5  -0.25  0.    0.25  0.5   0.75  1.  ]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!wget -q https://raw.githubusercontent.com/sze-info/gknb_intm023/main/adatfajlok/engine.csv\n",
        "import csv\n",
        "\n",
        "def betolt(fnev: str, elvalaszto: str, fejlec: int) -> List[List[float]]:\n",
        "  with open(fnev, 'r') as f:\n",
        "    olvaso = csv.reader(f, delimiter=elvalaszto)\n",
        "    for i in range(fejlec):\n",
        "      next(olvaso)\n",
        "    mtx = []\n",
        "    for sor in olvaso:\n",
        "      mtx.append(sor)\n",
        "    return mtx\n",
        "\n",
        "motor = betolt('engine.csv', ';', 1)\n",
        "\n",
        "# https://numpy.org/doc/stable/reference/generated/numpy.loadtxt.html\n",
        "# https://numpy.org/doc/stable/reference/generated/numpy.genfromtxt.html\n",
        "np_motor = np.genfromtxt(fname='https://raw.githubusercontent.com/sze-info/gknb_intm023/main/adatfajlok/engine.csv',\n",
        "                      delimiter=';', skip_header=1)\n",
        "\n",
        "print('Szövegfájlból betöltött adatok:\\n', motor, '\\n', np_motor)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2qoC7Zk-0GaK",
        "outputId": "dabffc7a-a6cc-4ed6-a450-98de83344cdd"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Szövegfájlból betöltött adatok:\n",
            " [['1500', '97.8', '15.355'], ['2000', '115.3', '24.136'], ['2500', '116.1', '30.380'], ['3000', '114.2', '35.859'], ['3500', '118.4', '43.395'], ['4000', '120.4', '50.407'], ['4500', '119.3', '56.190'], ['5000', '115.7', '60.550'], ['5500', '109.2', '63.200']] \n",
            " [[1500.      97.8     15.355]\n",
            " [2000.     115.3     24.136]\n",
            " [2500.     116.1     30.38 ]\n",
            " [3000.     114.2     35.859]\n",
            " [3500.     118.4     43.395]\n",
            " [4000.     120.4     50.407]\n",
            " [4500.     119.3     56.19 ]\n",
            " [5000.     115.7     60.55 ]\n",
            " [5500.     109.2     63.2  ]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# https://numpy.org/doc/stable/reference/generated/numpy.savetxt.html\n",
        "np.savetxt('np_motor.csv', np_motor, fmt='%.3f', delimiter=';', header='Engine speed (RPM);Torque (Nm);Shaft power (kW)')\n",
        "!cat np_motor.csv"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-1K4SnLZ8_WE",
        "outputId": "9d5d83f0-3426-4f6e-a58f-a4284b961a74"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "# Engine speed (RPM);Torque (Nm);Shaft power (kW)\n",
            "1500.000;97.800;15.355\n",
            "2000.000;115.300;24.136\n",
            "2500.000;116.100;30.380\n",
            "3000.000;114.200;35.859\n",
            "3500.000;118.400;43.395\n",
            "4000.000;120.400;50.407\n",
            "4500.000;119.300;56.190\n",
            "5000.000;115.700;60.550\n",
            "5500.000;109.200;63.200\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def dimenzio(tomb : List, d=1) -> int:\n",
        "  if isinstance(tomb[0], list):\n",
        "    return dimenzio(tomb[0], d+1)\n",
        "  return d\n",
        "\n",
        "print('Dimenziók: ', dimenzio(a), np_a.ndim)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MjNHQQu70Ovs",
        "outputId": "d6fa164a-735f-457f-f4aa-e5ad1757207a"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Dimenziók:  2 2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def meret(tomb : List):\n",
        "  vissza = [len(tomb)]\n",
        "  if isinstance(tomb[0], list):\n",
        "      vissza += meret(tomb[0])\n",
        "  return vissza\n",
        "\n",
        "print('Méretek: ', meret(a), np_a.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "g6lmTECs0Wqf",
        "outputId": "59a3105d-2861-44de-dcc5-a5336fd5c75f"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Méretek:  [3, 3] (3, 3)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Mentés és betöltés"
      ],
      "metadata": {
        "id": "eN-x54yq_7JD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "np.save(\"np_motor\", np_motor) # A kiterjesztés elhagyható, alapértelmezetten npy\n",
        "np_motor2 = np.load(\"np_motor.npy\") # Itt már kötelező megadni a kiterjesztést\n",
        "print(np_motor2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UAa4EnnMAEjL",
        "outputId": "1d92221c-50bf-44a1-fc26-60c6c6d195e5"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1500.      97.8     15.355]\n",
            " [2000.     115.3     24.136]\n",
            " [2500.     116.1     30.38 ]\n",
            " [3000.     114.2     35.859]\n",
            " [3500.     118.4     43.395]\n",
            " [4000.     120.4     50.407]\n",
            " [4500.     119.3     56.19 ]\n",
            " [5000.     115.7     60.55 ]\n",
            " [5500.     109.2     63.2  ]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Indexelés, elemek elérése"
      ],
      "metadata": {
        "id": "-XC0--Q5BVaB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "ma = np.array((\n",
        "    (11, 12), \n",
        "    (21, 22), \n",
        "    (31, 32)))\n",
        "\n",
        "print('Bal felső elem:', ma[0][0])\n",
        "print('Első sor:', ma[0], 'vagy', ma[0, :])\n",
        "print('Első és utolsó sor:\\n', ma[[0, -1], :])\n",
        "print('Első oszlop:', ma[:, 0])\n",
        "print('Utolsó oszlop:', ma[:, -1])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wH20kI4RBZre",
        "outputId": "d519064d-0799-49b5-b019-e625cbcbbc46"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Bal felső elem: 11\n",
            "Első sor: [11 12] vagy [11 12]\n",
            "Első és utolsó sor:\n",
            " [[11 12]\n",
            " [31 32]]\n",
            "Első oszlop: [11 21 31]\n",
            "Utolsó oszlop: [12 22 32]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "A tömbelemek módosíthatók."
      ],
      "metadata": {
        "id": "VOn4DkUQ3m0r"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mMod = np.array([\n",
        "  [1, 2],\n",
        "  [3, 4],\n",
        "  [5, 6]\n",
        "])\n",
        "mMod[0][0] = -1\n",
        "print(mMod[0][0])\n",
        "mMod[:,1] = [10, 20, 30]\n",
        "print(mMod)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NECtt_oc3qz8",
        "outputId": "dd67f9b4-6a32-4561-b56b-2df16ef29b1e"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "-1\n",
            "[[-1 10]\n",
            " [ 3 20]\n",
            " [ 5 30]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Arra viszont figyeljünk, hogy az értékadás nem jelenti új tömb létrehozását."
      ],
      "metadata": {
        "id": "IoqzEYjP7ol_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mMasolat = mMod\n",
        "mMod[0][0] = -2\n",
        "print('mMasolat tartalma:\\n', mMasolat)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8zerEjj97vJy",
        "outputId": "1bd6156a-a488-45ff-d256-d59f56c8f0eb"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "mMasolat tartalma:\n",
            " [[-2 10]\n",
            " [ 3 20]\n",
            " [ 5 30]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "mMasolat = mMod.copy() # https://numpy.org/doc/stable/reference/generated/numpy.copy.html\n",
        "mMod[0][0] = -3\n",
        "print('mMasolat tartalma:\\n', mMasolat)\n",
        "mMasolat[0][0] = -4\n",
        "print('mMasolat tartalma:\\n', mMasolat)\n",
        "print('maMod tartalma:\\n', mMod)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "O3LzSBtB8GS8",
        "outputId": "b7c3201a-0038-4e81-9ee2-1e4f41514c61"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "mMasolat tartalma:\n",
            " [[-2 10]\n",
            " [ 3 20]\n",
            " [ 5 30]]\n",
            "mMasolat tartalma:\n",
            " [[-4 10]\n",
            " [ 3 20]\n",
            " [ 5 30]]\n",
            "maMod tartalma:\n",
            " [[-3 10]\n",
            " [ 3 20]\n",
            " [ 5 30]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Logikai kifejezések"
      ],
      "metadata": {
        "id": "nX34uc7WDltQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mb = np.array((\n",
        "    (0, 12),\n",
        "    (0, 22),\n",
        "    (31, 0)\n",
        "))\n",
        "\n",
        "print('Mely elemek nagyobbak 12-nél?\\n', ma > 12)\n",
        "print('Melyek az egyforma elemek?\\n', ma == mb)\n",
        "print('A 12-nél nagyobb elemek\\n', ma[ma > 12])\n",
        "print('Csak az egyforma elemek\\n', ma[ma == mb])\n",
        "print('11 és 32 értékű elemek index:\\n', (ma==11) | (ma==32))\n",
        "print('Páros és 20-nál nagyobb elemek:\\n', (ma%2==0) & (ma>20))\n",
        "print('Nem 22 értékű elemek:\\n', ma != 22)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CeYCcuGQCua4",
        "outputId": "eb4b758c-5684-46cc-a8ee-8dca15ee3f13"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mely elemek nagyobbak 12-nél?\n",
            " [[False False]\n",
            " [ True  True]\n",
            " [ True  True]]\n",
            "Melyek az egyforma elemek?\n",
            " [[False  True]\n",
            " [False  True]\n",
            " [ True False]]\n",
            "A 12-nél nagyobb elemek\n",
            " [21 22 31 32]\n",
            "Csak az egyforma elemek\n",
            " [12 22 31]\n",
            "11 és 32 értékű elemek index:\n",
            " [[ True False]\n",
            " [False False]\n",
            " [False  True]]\n",
            "Páros és 20-nál nagyobb elemek:\n",
            " [[False False]\n",
            " [False  True]\n",
            " [False  True]]\n",
            "Nem 22 értékű elemek:\n",
            " [[ True  True]\n",
            " [ True False]\n",
            " [ True  True]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "mc = np.array((\n",
        "    (1, 2),\n",
        "    (3, 4),\n",
        "    (5, 6)\n",
        "))\n",
        "\n",
        "# https://numpy.org/doc/stable/reference/generated/numpy.where.html\n",
        "print('A páratlan számok ma-ból, a többi mc-ből származik:\\n', np.where(mc%2 == 1, ma, mc))\n",
        "\n",
        "idx = np.where(ma > 30)\n",
        "print('A 30-nál nagyobb elemek indexei: ', idx)\n",
        "print('Maguk az értékek pedig:')\n",
        "for i in range(2):\n",
        "  print(ma[idx[0][i], idx[1][i]])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MV-rsLVgF8UB",
        "outputId": "94d3bec2-ec80-4299-e70e-775e17c05776"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "A páratlan számok ma-ból, a többi mc-ből származik:\n",
            " [[11  2]\n",
            " [21  4]\n",
            " [31  6]]\n",
            "A 30-nál nagyobb elemek indexei:  (array([2, 2]), array([0, 1]))\n",
            "Maguk az értékek pedig:\n",
            "31\n",
            "32\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Műveletek tömbökkel"
      ],
      "metadata": {
        "id": "DD8CTdZjMLcl"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Vektor - skalár\n",
        "\n",
        "A vektor minden elemén végrehajtja a műveletet egy skalár értékkel."
      ],
      "metadata": {
        "id": "R9TlinF4M9my"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "va = np.array((1, 2, 3))\n",
        "vb = np.array((4, 5, 6))\n",
        "\n",
        "print('va + 3 =', va + 3)\n",
        "print('vb - 3 =', vb - 3)\n",
        "print('va * 2 =', va * 2)\n",
        "print('va / 2 =', va / 2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JReMLf3PNAN5",
        "outputId": "bfaf253e-b3ae-4527-8d7f-10d4170744c8"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "va + 3 = [4 5 6]\n",
            "vb - 3 = [1 2 3]\n",
            "va * 2 = [2 4 6]\n",
            "va / 2 = [0.5 1.  1.5]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Vektor - vektor\n",
        "\n",
        "Két vektor elemei között elemenként elvégzi a kért műveletet."
      ],
      "metadata": {
        "id": "fS9aFPuGM8Ow"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print('va + vb =', va + vb)\n",
        "print('va - vb =', va - vb)\n",
        "print('va * vb =', va * vb)\n",
        "print('va / vb =', va / vb)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AdqZdL0PMVKn",
        "outputId": "a403dac2-2011-4c6d-afe9-5d057030ff3a"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "va + vb = [5 7 9]\n",
            "va - vb = [-3 -3 -3]\n",
            "va * vb = [ 4 10 18]\n",
            "va / vb = [0.25 0.4  0.5 ]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Vektorok [skaláris szorzata](https://hu.wikipedia.org/wiki/Skal%C3%A1ris_szorzat)"
      ],
      "metadata": {
        "id": "BBsoouYm5UOC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print('Skaláris szorzat:', va @ vb)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bsjbAhaz5s_3",
        "outputId": "9733b141-5d92-4580-de20-4eb16e37dfec"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Skaláris szorzat: 32\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Mátrix - mátrix\n",
        "\n",
        "[Mátrixszorzás](https://hu.wikipedia.org/wiki/M%C3%A1trix_(matematika)#M%C3%A1trixszorz%C3%A1s)"
      ],
      "metadata": {
        "id": "yHpWOWyA57YJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "md = np.array([\n",
        "  [1, 1, 1],\n",
        "  [1, 1, 1]\n",
        "])\n",
        "print(ma)\n",
        "print('Mátrixok szorzata:\\n', ma @ md)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ex65AK8-5_e_",
        "outputId": "5f6f5927-5d19-4b9e-e317-f8b12baa0047"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[11 12]\n",
            " [21 22]\n",
            " [31 32]]\n",
            "Mátrixok szorzata:\n",
            " [[23 23 23]\n",
            " [43 43 43]\n",
            " [63 63 63]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Néhány egyoperandusos művelet\n",
        "\n",
        "[Transzponálás](https://hu.wikipedia.org/wiki/M%C3%A1trix_(matematika)#Transzpon%C3%A1l%C3%A1s), egyedi elemek"
      ],
      "metadata": {
        "id": "T9ymXdMF830p"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print('ma transzponáltja:\\n', ma.T)\n",
        "print('md egyedi eleme:', np.unique(md)) # https://numpy.org/doc/stable/reference/generated/numpy.unique.html"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RU8_6PEQ85_B",
        "outputId": "64efa3a5-e061-4d89-d227-8fb66d425147"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "ma transzponáltja:\n",
            " [[11 21 31]\n",
            " [12 22 32]]\n",
            "md egyedi eleme: [1]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Statisztikai jellegű műveletek"
      ],
      "metadata": {
        "id": "DJy6TUkuII2I"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print('Elemek összege:', np.sum(ma), ma.sum()) # https://numpy.org/doc/stable/reference/generated/numpy.sum.html\n",
        "print('Legkisebb elem:', np.min(ma), ma.min()) # https://numpy.org/doc/stable/reference/generated/numpy.ndarray.min.html\n",
        "print('Legnagyobb elem:', np.max(ma), ma.max()) # https://numpy.org/doc/stable/reference/generated/numpy.ndarray.max.html\n",
        "print('Átlag:', np.average(ma)) # https://numpy.org/doc/stable/reference/generated/numpy.average.html\n",
        "print('Szórás', np.std(ma), ma.std()) # https://numpy.org/doc/stable/reference/generated/numpy.std.html\n",
        "print('Medián:', np.median(ma)) # https://numpy.org/doc/stable/reference/generated/numpy.median.html"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EImjg5lRILeF",
        "outputId": "3d58c899-f8ce-4975-d392-ac13972719b9"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Elemek összege: 129 129\n",
            "Legkisebb elem: 11 11\n",
            "Legnagyobb elem: 32 32\n",
            "Átlag: 21.5\n",
            "Szórás 8.180260794538684 8.180260794538684\n",
            "Medián: 21.5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "A trigonometrikus függvények elemenként dolgoznak"
      ],
      "metadata": {
        "id": "ZzY9AMCPKUcq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import math\n",
        "mSzogek = np.linspace(0, 2*math.pi, 7)\n",
        "print('Szögek radiánban:', mSzogek)\n",
        "print('Ezek szinusza:', np.sin(mSzogek)) # https://numpy.org/doc/stable/reference/generated/numpy.sin.html\n",
        "print('Koszinusza:', np.cos(mSzogek)) # https://numpy.org/doc/stable/reference/generated/numpy.cos.html"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qeHKQ5hPKZ7M",
        "outputId": "57030854-93f2-48fc-b9cd-a481ebb45323"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Szögek radiánban: [0.         1.04719755 2.0943951  3.14159265 4.1887902  5.23598776\n",
            " 6.28318531]\n",
            "Ezek szinusza: [ 0.00000000e+00  8.66025404e-01  8.66025404e-01  1.22464680e-16\n",
            " -8.66025404e-01 -8.66025404e-01 -2.44929360e-16]\n",
            "Koszinusza: [ 1.   0.5 -0.5 -1.  -0.5  0.5  1. ]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Rendezés"
      ],
      "metadata": {
        "id": "Xp6gQO199pzp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import random\n",
        "mRendezetlen = np.array([random.randint(1, 100) for i in range(5)])\n",
        "print('Rendezetlen adatok:', mRendezetlen)\n",
        "mRendezett = np.sort(mRendezetlen) # https://numpy.org/doc/stable/reference/generated/numpy.sort.html\n",
        "print('Növekvő sorrend:', mRendezett)\n",
        "print('Fordított sorrendben:', np.flip(mRendezett)) # https://numpy.org/doc/stable/reference/generated/numpy.flip.html\n",
        "mRendezetlen.sort()\n",
        "print('Növekvő sorrend, helyben rendezés:', mRendezetlen)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_1bwTFnO9rAy",
        "outputId": "8a6cf6cd-51a2-49c7-ddbd-9dfe6bb678ba"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Rendezetlen adatok: [92 72 72 65 99]\n",
            "Növekvő sorrend: [65 72 72 92 99]\n",
            "Fordított sorrendben: [99 92 72 72 65]\n",
            "Növekvő sorrend, helyben rendezés: [65 72 72 92 99]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Tömbök elemeinek összefűzése"
      ],
      "metadata": {
        "id": "O7ZN0CSvNy2B"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print('Vektorok elemeinek egymás után írása:', np.concatenate([va, vb])) # https://numpy.org/doc/stable/reference/generated/numpy.concatenate.html\n",
        "print('Mátrixok elemeinek egymás után írása:\\n', np.concatenate([ma, mc]))\n",
        "print('Vízszintesen egymás után írt vektorok', np.hstack([va, vb])) # https://numpy.org/doc/stable/reference/generated/numpy.hstack.html\n",
        "print('Vízszintesen egymás után írt mátrixok\\n', np.hstack([ma, mc]))\n",
        "print('Függőlegesen egymás után írt vektorok\\n', np.vstack([va, vb])) # https://numpy.org/doc/stable/reference/generated/numpy.vstack.html\n",
        "print('Függőlegesen egymás után írt mátrixok\\n', np.vstack([ma, mc]))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CBWm4nCxxUf2",
        "outputId": "4c61d695-f805-40e8-bc22-2dfe4c2ae19e"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Vektorok elemeinek egymás után írása: [1 2 3 4 5 6]\n",
            "Mátrixok elemeinek egymás után írása:\n",
            " [[11 12]\n",
            " [21 22]\n",
            " [31 32]\n",
            " [ 1  2]\n",
            " [ 3  4]\n",
            " [ 5  6]]\n",
            "Vízszintesen egymás után írt vektorok [1 2 3 4 5 6]\n",
            "Vízszintesen egymás után írt mátrixok\n",
            " [[11 12  1  2]\n",
            " [21 22  3  4]\n",
            " [31 32  5  6]]\n",
            "Függőlegesen egymás után írt vektorok\n",
            " [[1 2 3]\n",
            " [4 5 6]]\n",
            "Függőlegesen egymás után írt mátrixok\n",
            " [[11 12]\n",
            " [21 22]\n",
            " [31 32]\n",
            " [ 1  2]\n",
            " [ 3  4]\n",
            " [ 5  6]]\n"
          ]
        }
      ]
    }
  ]
}