e02b-numpy-tablice-rozwiazania.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NumPy - tablice cześć 2 - zadania"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numpy Indexing\n",
    "\n",
    "1. Użyj danych z sekcji \"Input\" (patrz poniżej)\n",
    "1. Stwórz ``result: ndarray``\n",
    "1. Dodaj do ``result`` elementy z ``DATA`` o indeksach:\n",
    "\n",
    "    * wiersz 0, kolumna 2\n",
    "    * wiersz 2, kolumna 2\n",
    "    * wiersz 0, kolumna 0\n",
    "    * wiersz 1, kolumna 0\n",
    "\n",
    "1. Rozmiar ``result`` musi być 2x2\n",
    "1. Typ ``result`` musi być float\n",
    "1. Porównaj wyniki z sekcją \"Output\" (patrz poniżej)\n",
    "\n",
    "Output:\n",
    "```python\n",
    "result: ndarray\n",
    "# array([[3., 9.],\n",
    "#        [1., 4.]])\n",
    "```\n",
    "\n",
    "Hint:\n",
    "* ``np.zeros(shape, dtype)``"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATA = np.array([\n",
    "    [1, 2, 3],\n",
    "    [4, 5, 6],\n",
    "    [7, 8, 9]\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3., 9.],\n",
       "       [1., 4.]])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result = np.array([\n",
    "    [DATA[0,2], DATA[2,2]],\n",
    "    [DATA[0,0], DATA[1,0]],\n",
    "], dtype=np.float)\n",
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3., 9.],\n",
       "       [1., 4.]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result = np.zeros((2,2), dtype=np.float)\n",
    "\n",
    "result[0,0] = DATA[0,2]\n",
    "result[0,1] = DATA[2,2]\n",
    "result[1,0] = DATA[0,0]\n",
    "result[1,1] = DATA[1,0]\n",
    "\n",
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numpy Slice 1\n",
    "\n",
    "1. Użyj danych z sekcji \"Input\" (patrz poniżej)\n",
    "1. Wybierz wewnętrzne 2x2 elementy\n",
    "1. Porównaj wyniki z sekcją \"Output\" (patrz poniżej)\n",
    "\n",
    "Output:\n",
    "```python\n",
    "result: ndarray\n",
    "# array([[8, 4],\n",
    "#        [5, 2]])\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[8, 4],\n",
       "       [5, 2]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "DATA = np.array([\n",
    "    [2, 8, 1, 5],\n",
    "    [8, 8, 4, 4],\n",
    "    [5, 5, 2, 5],\n",
    "    [1, 0, 6, 0],\n",
    "])\n",
    "\n",
    "result = DATA[1:3, 1:3]\n",
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numpy Slice 2\n",
    "\n",
    "1. Użyj danych z sekcji \"Input\" (patrz poniżej)\n",
    "1. Wypisz środkowe 4x4 elementy\n",
    "1. Środkowa macierz jest dokładnie w środku większej\n",
    "\n",
    "Output:\n",
    "```python\n",
    "result: ndarray\n",
    "# array([[2, 0, 7, 5],\n",
    "#        [1, 2, 9, 1],\n",
    "#        [8, 8, 8, 2],\n",
    "#        [4, 3, 6, 9]])\n",
    "```\n",
    "\n",
    "![Inner 4x4 elements](img/inner-square.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 0, 7, 5],\n",
       "       [1, 2, 9, 1],\n",
       "       [8, 8, 8, 2],\n",
       "       [4, 3, 6, 9]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "DATA = np.array([[5, 0, 3, 3, 7, 9, 3, 5, 2, 4, 7, 6, 8, 8, 1, 6],\n",
    "                 [7, 7, 8, 1, 5, 9, 8, 9, 4, 3, 0, 3, 5, 0, 2, 3],\n",
    "                 [8, 1, 3, 3, 3, 7, 0, 1, 9, 9, 0, 4, 7, 3, 2, 7],\n",
    "                 [2, 0, 0, 4, 5, 5, 6, 8, 4, 1, 4, 9, 8, 1, 1, 7],\n",
    "                 [9, 9, 3, 6, 7, 2, 0, 3, 5, 9, 4, 4, 6, 4, 4, 3],\n",
    "                 [4, 4, 8, 4, 3, 7, 5, 5, 0, 1, 5, 9, 3, 0, 5, 0],\n",
    "                 [1, 2, 4, 2, 0, 3, 2, 0, 7, 5, 9, 0, 2, 7, 2, 9],\n",
    "                 [2, 3, 3, 2, 3, 4, 1, 2, 9, 1, 4, 6, 8, 2, 3, 0],\n",
    "                 [0, 6, 0, 6, 3, 3, 8, 8, 8, 2, 3, 2, 0, 8, 8, 3],\n",
    "                 [8, 2, 8, 4, 3, 0, 4, 3, 6, 9, 8, 0, 8, 5, 9, 0],\n",
    "                 [9, 6, 5, 3, 1, 8, 0, 4, 9, 6, 5, 7, 8, 8, 9, 2],\n",
    "                 [8, 6, 6, 9, 1, 6, 8, 8, 3, 2, 3, 6, 3, 6, 5, 7],\n",
    "                 [0, 8, 4, 6, 5, 8, 2, 3, 9, 7, 5, 3, 4, 5, 3, 3],\n",
    "                 [7, 9, 9, 9, 7, 3, 2, 3, 9, 7, 7, 5, 1, 2, 2, 8],\n",
    "                 [1, 5, 8, 4, 0, 2, 5, 5, 0, 8, 1, 1, 0, 3, 8, 8],\n",
    "                 [4, 4, 0, 9, 3, 7, 3, 2, 1, 1, 2, 1, 4, 2, 5, 5]])\n",
    "\n",
    "result = DATA[6:-6, 6:-6]\n",
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numpy Round Rint\n",
    "1. Użyj danych z sekcji \"Input\" (patrz poniżej)\n",
    "1. Zaokrąglij wartości do pełnych liczb całkowitych\n",
    "1. Przekonwertuj typ danych do ``np.int8``\n",
    "1. Porównaj wyniki z sekcją \"Output\" (patrz poniżej)\n",
    "\n",
    "Output:\n",
    "```python\n",
    "result: ndarray\n",
    "# array([1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1], dtype=int8)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1],\n",
       "      dtype=int8)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "DATA = np.array([0.5488135 , 0.71518937, 0.60276338, 0.54488318, 0.4236548 ,\n",
    "                 0.64589411, 0.43758721, 0.891773  , 0.96366276, 0.38344152,\n",
    "                 0.79172504, 0.52889492, 0.56804456, 0.92559664, 0.07103606,\n",
    "                 0.0871293 , 0.0202184 , 0.83261985, 0.77815675, 0.87001215,\n",
    "                 0.97861834])\n",
    "\n",
    "result = np.rint(DATA)\n",
    "result = result.astype(np.int8)\n",
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numpy Round Floor and Ceil\n",
    "\n",
    "1. Użyj danych z sekcji \"Input\" (patrz poniżej)\n",
    "1. Zaokrąglij wartości ``data`` w górę (ceil) i je wypisz\n",
    "1. Zaokrąglij wartości ``data`` w dół (floor) i je wypisz\n",
    "1. Zaokrąglij wartości ``data`` i je wypisz\n",
    "1. Porównaj wyniki z sekcją \"Output\" (patrz poniżej)\n",
    "\n",
    "Output:\n",
    "```python\n",
    "\n",
    "ceil: ndarray\n",
    "# array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
    "#        1., 1., 1., 1.])\n",
    "\n",
    "floor: ndarray\n",
    "# array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
    "#        0., 0., 0., 0.])\n",
    "\n",
    "round: ndarray\n",
    "# array([1., 1., 1., 1., 0., 1., 0., 1., 1., 0., 1., 1., 1., 1., 0., 0., 0.,\n",
    "#        1., 1., 1., 1.])\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATA = np.array([0.5488135 , 0.71518937, 0.60276338, 0.54488318, 0.4236548 ,\n",
    "                 0.64589411, 0.43758721, 0.891773  , 0.96366276, 0.38344152,\n",
    "                 0.79172504, 0.52889492, 0.56804456, 0.92559664, 0.07103606,\n",
    "                 0.0871293 , 0.0202184 , 0.83261985, 0.77815675, 0.87001215,\n",
    "                 0.97861834])\n",
    "\n",
    "ceil = np.ceil(DATA)\n",
    "floor = np.floor(DATA)\n",
    "round = np.round(DATA)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
       "       1., 1., 1., 1.])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ceil"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "       0., 0., 0., 0.])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "floor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 1., 1., 1., 0., 1., 0., 1., 1., 0., 1., 1., 1., 1., 0., 0., 0.,\n",
       "       1., 1., 1., 1.])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "round"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numpy Round Clip\n",
    "\n",
    "1. Użyj danych z sekcji \"Input\" (patrz poniżej)\n",
    "1. Stwórz `result: ndarray` z kopią danych z `DATA`\n",
    "1. Przytnij liczby w pierwszej kolumnie od 50 (włącznie) do 80 (rozłącznie)\n",
    "1. Wypisz ``result``\n",
    "1. Porównaj wyniki z sekcją \"Output\" (patrz poniżej)\n",
    "\n",
    "Output:\n",
    "```python\n",
    "result: ndarray\n",
    "# array([[50, 47, 64],\n",
    "#        [67, 67,  9],\n",
    "#        [79, 21, 36],\n",
    "#        [79, 70, 88],\n",
    "#        [79, 12, 58],\n",
    "#        [65, 39, 87],\n",
    "#        [50, 88, 81]])\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[50, 47, 64],\n",
       "       [67, 67,  9],\n",
       "       [79, 21, 36],\n",
       "       [79, 70, 88],\n",
       "       [79, 12, 58],\n",
       "       [65, 39, 87],\n",
       "       [50, 88, 81]])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "DATA = np.array([[44, 47, 64],\n",
    "                 [67, 67,  9],\n",
    "                 [83, 21, 36],\n",
    "                 [87, 70, 88],\n",
    "                 [88, 12, 58],\n",
    "                 [65, 39, 87],\n",
    "                 [46, 88, 81]])\n",
    "\n",
    "result = DATA.copy()\n",
    "result[:, 0] = result[:, 0].clip(50, 79)\n",
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numpy Sort\n",
    "\n",
    "1. Użyj danych z sekcji \"Input\" (patrz poniżej)\n",
    "1. Posortuj kolumny ``result``\n",
    "1. Flipnij wiersze ``result``\n",
    "1. Wypisz ``result``    \n",
    "\n",
    "Output:\n",
    "```python\n",
    "result: ndarray\n",
    "# array([[36, 70, 87, 88],\n",
    "#        [ 9, 21, 67, 83],\n",
    "#        [44, 47, 64, 67]])\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[36, 70, 87, 88],\n",
       "       [ 9, 21, 67, 83],\n",
       "       [44, 47, 64, 67]])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "DATA = np.array([[44, 47, 64, 67],\n",
    "                 [67,  9, 83, 21],\n",
    "                 [36, 87, 70, 88]])\n",
    "\n",
    "DATA.sort(axis=1)\n",
    "np.flip(DATA, axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numpy Methods\n",
    "\n",
    "1. Użyj danych z sekcji \"Input\" (patrz poniżej)\n",
    "1. Zmień kształt na 3x4\n",
    "1. Wypełnij ostatnią kolumnę zerami (0)\n",
    "1. Transponuj ``result``\n",
    "1. Przekonwertuj ``result`` do float\n",
    "1. Wypełnij pierwszy wiersz ``np.nan``\n",
    "1. Wypisz ``result``\n",
    "\n",
    "Output:\n",
    "```python\n",
    "result: ndarray\n",
    "# array([[nan, nan, nan],\n",
    "#        [47.,  9., 87.],\n",
    "#        [64., 83., 70.],\n",
    "#        [ 0.,  0.,  0.]])\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[nan, nan, nan],\n",
       "       [47.,  9., 87.],\n",
       "       [64., 83., 70.],\n",
       "       [ 0.,  0.,  0.]])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "DATA = np.array([[44, 47, 64, 67],\n",
    "                 [67,  9, 83, 21],\n",
    "                 [36, 87, 70, 88]])\n",
    "\n",
    "result = DATA.reshape(3,4)\n",
    "result[:, -1].fill(0)\n",
    "result = result.transpose()\n",
    "result = result.astype(np.float)\n",
    "result[0] = np.nan\n",
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}