e02b-numpy-tablice-zadania.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NumPy - tablice cześć 2 - zadania"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATA = np.array([\n",
    "    [1, 2, 3],\n",
    "    [4, 5, 6],\n",
    "    [7, 8, 9]\n",
    "])"
   ]
  },
  {
   "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": null,
   "metadata": {},
   "outputs": [],
   "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",
    "])"
   ]
  },
  {
   "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": null,
   "metadata": {},
   "outputs": [],
   "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]])"
   ]
  },
  {
   "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": null,
   "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])"
   ]
  },
  {
   "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": null,
   "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])"
   ]
  },
  {
   "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": null,
   "metadata": {},
   "outputs": [],
   "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]])"
   ]
  },
  {
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATA = np.array([[44, 47, 64, 67],\n",
    "                 [67,  9, 83, 21],\n",
    "                 [36, 87, 70, 88]])"
   ]
  },
  {
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATA = np.array([[44, 47, 64, 67],\n",
    "                 [67,  9, 83, 21],\n",
    "                 [36, 87, 70, 88]])"
   ]
  }
 ],
 "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
}