01.exercise-python-numpy-basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "# ML-Fundamentals - Python Numpy Basics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "## Table of Contents\n",
    "* [Introduction](#Introduction)\n",
    "* [Requirements](#Requirements) \n",
    "  * [Knowledge](#Knowledge) \n",
    "  * [Modules](#Python-Modules)\n",
    "* [Exercises](#Exercises)\n",
    "* [Summary and Outlook](#Summary-and-Outlook)\n",
    "* [Literature](#Literature) \n",
    "* [Licenses](#Licenses)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "## Introduction\n",
    "\n",
    "In this exercise you will learn numpy operations / features, which you will need throughout nearly all data science tasks, when working with python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "## Requirements\n",
    "### Knowledge\n",
    "\n",
    "You should have a basic knowledge of:\n",
    "- numpy\n",
    "\n",
    "Suitable sources for acquiring this knowledge are:\n",
    "- [numpy quickstart](https://docs.scipy.org/doc/numpy-1.15.1/user/quickstart.html)\n",
    "- [numpy slicing](https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "### Python Modules\n",
    "\n",
    "By [deep.TEACHING](https://www.deep-teaching.org/) convention, all python modules needed to run the notebook are loaded centrally at the beginning. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# External Modules\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "## Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Task:**\n",
    "\n",
    "Generate a numpy-1D array of length 10, all elements being 0, except the 5th element which is 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 0 0 0 1 0 0 0 0 0]\n"
     ]
    }
   ],
   "source": [
    "### Your Solution\n",
    "a =  np.array( [0,0,0,0,1,0,0,0,0,0] )\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Task:**\n",
    "\n",
    "Reverse the order of vector `z`: The first element becomes the last, the second becomes the second last etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 31 30 29 28 27 26\n",
      " 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10  9  8  7  6  5  4  3  2\n",
      "  1  0]\n"
     ]
    }
   ],
   "source": [
    "### Your Solution\n",
    "z = np.arange(50)\n",
    "z = np.flip(z)\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Task:**\n",
    "\n",
    "Find the indices of all elements that are nonzero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(array([0, 1, 4], dtype=int64),)\n"
     ]
    }
   ],
   "source": [
    "### Your Solution\n",
    "z = np.array([1,2,0,0,4,0])\n",
    "index = np.where(z!=0)\n",
    "print(index)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Task:**\n",
    "\n",
    "Generate a 10x10 array with random values and find the smallest and largest value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.75804249 0.59857783 0.4393791  0.05616395 0.87864833 0.57515599\n",
      "  0.91703802 0.11375905 0.71192068 0.23358937]\n",
      " [0.78052476 0.75477095 0.13069233 0.05353046 0.17878921 0.91565577\n",
      "  0.40405964 0.56673008 0.58489715 0.95228043]\n",
      " [0.27675718 0.13439001 0.01257745 0.17306302 0.52499982 0.77326289\n",
      "  0.17802649 0.05219761 0.25119305 0.0542259 ]\n",
      " [0.05726599 0.89197815 0.88624905 0.28345523 0.0922124  0.35442576\n",
      "  0.00729181 0.98943543 0.53497151 0.89941367]\n",
      " [0.69340746 0.50403294 0.03327165 0.76181356 0.63904287 0.78872926\n",
      "  0.4911802  0.59812475 0.62800798 0.31865878]\n",
      " [0.98615948 0.59625133 0.23636446 0.46104211 0.23952292 0.24468949\n",
      "  0.33181406 0.34056705 0.47430393 0.63639779]\n",
      " [0.68024536 0.19480246 0.46993574 0.37915991 0.77804387 0.97110008\n",
      "  0.66472901 0.64851617 0.7798892  0.62532298]\n",
      " [0.77101031 0.07405639 0.21555262 0.46689483 0.99626344 0.05528242\n",
      "  0.33198462 0.49172746 0.60946793 0.10804002]\n",
      " [0.34675944 0.62929475 0.32628785 0.89355125 0.33688239 0.86978454\n",
      "  0.29140575 0.65266701 0.56988172 0.80219506]\n",
      " [0.43570894 0.85311797 0.51486841 0.42915539 0.49747559 0.10373442\n",
      "  0.44477142 0.99492439 0.80873839 0.40511548]]\n",
      "0.007291814334387969\n",
      "0.9962634362638297\n"
     ]
    }
   ],
   "source": [
    "### Your Solution\n",
    "random = np.random.rand(10,10)\n",
    "minValue = np.amin(random)\n",
    "maxValue = np.amax(random)\n",
    "print(random)\n",
    "print(minValue)\n",
    "print(maxValue)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Task:**\n",
    "\n",
    "Generate a vector of length 50 with random values and calculate the mean."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.03104714 0.9525371  0.08318769 0.65135068 0.80139371 0.30062688\n",
      " 0.24728455 0.79601275 0.98127645 0.59179886 0.30042847 0.24258581\n",
      " 0.41363076 0.63053878 0.34224012 0.18325035 0.70011372 0.01661546\n",
      " 0.40564879 0.45943167 0.48193566 0.54313287 0.51829327 0.00498174\n",
      " 0.02496405 0.3212136  0.62994728 0.4588785  0.36025419 0.36951233\n",
      " 0.31213261 0.21615415 0.81347953 0.67143815 0.19748034 0.84398485\n",
      " 0.07863972 0.9463197  0.18670271 0.99731305 0.59598863 0.27917913\n",
      " 0.30010034 0.53072818 0.65369731 0.66579348 0.81041459 0.88539253\n",
      " 0.19941396 0.07340293]\n",
      "0.4620373820841897\n"
     ]
    }
   ],
   "source": [
    "### Your Solution\n",
    "vector = np.random.rand(50)\n",
    "mean = np.mean(vector)\n",
    "print(vector)\n",
    "print(mean)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Task:**\n",
    "\n",
    "Explain the following results:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### print(0 * np.nan)\n",
    "print(np.nan == np.nan) //always wrong because they are two different objects\n",
    "print(np.inf > np.nan)  //cannot compare a number with an object\n",
    "print(np.nan - np.nan)  //not a number - not a number = also not a number\n",
    "print(0.3 == 3 * 0.1)   //https://www.sololearn.com/Discuss/1524665/why-is-0-1-3-not-equal-to-0-3-in-python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Task:**\n",
    "\n",
    "Generate an 8x8 matrix and fill it with a chess pattern like:\n",
    "\n",
    "`\n",
    "array([[1., 0., 1., 0., 1., 0., 1., 0.],\n",
    "       [0., 1., 0., 1., 0., 1., 0., 1.],\n",
    "       [1., 0., 1., 0., 1., 0., 1., 0.],\n",
    "       [0., 1., 0., 1., 0., 1., 0., 1.],\n",
    "       [1., 0., 1., 0., 1., 0., 1., 0.],\n",
    "       [0., 1., 0., 1., 0., 1., 0., 1.],\n",
    "       [1., 0., 1., 0., 1., 0., 1., 0.],\n",
    "       [0., 1., 0., 1., 0., 1., 0., 1.]])\n",
    "`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 0 1 0 1 0 1 0 1]\n",
      " [1 0 1 0 1 0 1 0 1 0]\n",
      " [0 1 0 1 0 1 0 1 0 1]\n",
      " [1 0 1 0 1 0 1 0 1 0]\n",
      " [0 1 0 1 0 1 0 1 0 1]\n",
      " [1 0 1 0 1 0 1 0 1 0]\n",
      " [0 1 0 1 0 1 0 1 0 1]\n",
      " [1 0 1 0 1 0 1 0 1 0]\n",
      " [0 1 0 1 0 1 0 1 0 1]\n",
      " [1 0 1 0 1 0 1 0 1 0]]\n"
     ]
    }
   ],
   "source": [
    "### Your Solution\n",
    "x = np.zeros((10,10),dtype=int)\n",
    "x[1::2,::2] = 1\n",
    "x[::2,1::2] = 1\n",
    "print(x)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Task:**\n",
    "\n",
    "Generate a random 5x5 matrix and normalize (scale) it. That means, the smallest value should become 0.0, the largest 1.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5 4 3 5 8 4 3 2 7 8]\n",
      "[0.5        0.33333333 0.16666667 0.5        1.         0.33333333\n",
      " 0.16666667 0.         0.83333333 1.        ]\n"
     ]
    }
   ],
   "source": [
    "### Your Solution\n",
    "r = np.random.randint(10, size=10)\n",
    "print(r)\n",
    "scaled = np.interp(r, (r.min(), r.max()), (0, +1))\n",
    "print(scaled)\n",
    "#(z-zmin)/(zmax-zmin)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Task:**\n",
    "\n",
    "From each row, subtract the maximum value of that row."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]]\n",
      "[ 3  7 11]\n",
      "[[-3 -2 -1  0]\n",
      " [-3 -2 -1  0]\n",
      " [-3 -2 -1  0]]\n"
     ]
    }
   ],
   "source": [
    "### Your Solution\n",
    "z = np.arange(12).reshape((3,4))\n",
    "print(z)\n",
    "res = z.max(axis=1)\n",
    "print(res)\n",
    "result = z-res[:, None]\n",
    "print(result) #https://howtothink.readthedocs.io/en/latest/PvL_06.html\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Task:**\n",
    "    \n",
    "Divide each column by the sum of that column. Then verify that each column adds up to 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]]\n",
      "[12 15 18 21]\n",
      "[[0.         0.06666667 0.11111111 0.14285714]\n",
      " [0.33333333 0.33333333 0.33333333 0.33333333]\n",
      " [0.66666667 0.6        0.55555556 0.52380952]]\n"
     ]
    }
   ],
   "source": [
    "### Your Solution\n",
    "z = np.arange(12).reshape((3,4))\n",
    "print(z)\n",
    "colmnSum = z.sum(axis=0)\n",
    "print(colmnSum)\n",
    "result = z/colmnSum\n",
    "print(result) #https://howtothink.readthedocs.io/en/latest/PvL_06.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Task:**\n",
    "\n",
    "Negate all elements between 3 and 8 in place."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0  1  2 -3 -4 -5 -6 -7 -8  9 10]\n"
     ]
    }
   ],
   "source": [
    "### Your Solution\n",
    "Z = np.arange(11)\n",
    "m = (Z > 2) & (Z < 9) #mask\n",
    "Z[m] *= -1\n",
    "print(Z)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Task:**\n",
    "\n",
    "Explain the result (output) of the following code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "### Your Solution\n",
    "print(sum(range(5),-1))\n",
    "from numpy import *\n",
    "print(sum(range(5), axis=-1)) # axis -1\n",
    "del sum #das objekt entfernen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Task:**\n",
    "\n",
    "Generate a random vector of length 100 and sort it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[420 398 149 114 385 615 129 385 837 969 624 514 980 364 854 452  91 357\n",
      " 435 697  13 455 662 934 124 478 366 491 669 247  64 481 372 110 292  68\n",
      " 385  61 336 193 175 543 319 648 731 497 800 818 490 111 907  54 831 778\n",
      "  44 294 681 866 628 171 641 463 986 493 376 909  60 353 659 858 599 595\n",
      " 674 627 654 934 694 477 555 457 284 453 291 831 840 538 586 676  20 583\n",
      " 707 924 930 523 616 483  16 173  53 697]\n",
      "[ 13  16  20  44  53  54  60  61  64  68  91 110 111 114 124 129 149 171\n",
      " 173 175 193 247 284 291 292 294 319 336 353 357 364 366 372 376 385 385\n",
      " 385 398 420 435 452 453 455 457 463 477 478 481 483 490 491 493 497 514\n",
      " 523 538 543 555 583 586 595 599 615 616 624 627 628 641 648 654 659 662\n",
      " 669 674 676 681 694 697 697 707 731 778 800 818 831 831 837 840 854 858\n",
      " 866 907 909 924 930 934 934 969 980 986]\n"
     ]
    }
   ],
   "source": [
    "### Your Solution\n",
    "r = np.random.randint(1000, size=100)\n",
    "print(r)\n",
    "sortedArray = np.sort(r)\n",
    "print(sortedArray)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Task:**\n",
    "\n",
    "Check if two arrays are equal:\n",
    "\n",
    "    1. All elements should be exactly the same\n",
    "    2. Equality within a tolerance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.84084476 0.35082536 0.00671228 0.52767661]\n",
      " [0.30550531 0.69287849 0.47801212 0.40278275]\n",
      " [0.62794648 0.26649191 0.14366374 0.30060645]]\n",
      "[[0.84084476 0.35082536 0.00671228 0.52767661]\n",
      " [0.30550531 0.69287849 0.47801212 0.40278275]\n",
      " [0.62794648 0.26649191 0.14366374 0.30060645]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### Your Solution\n",
    "A = np.random.random((3,4))\n",
    "B = A.copy()\n",
    "B[1,2] = A[1,2] * 1.00000000000001\n",
    "print (A)\n",
    "print(B)\n",
    "np.allclose(A, B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Task:**\n",
    "\n",
    "Generate (as little code as possible) the following matrix with `np.array` and save it as the variable `arr`.\n",
    "\n",
    "\\begin{bmatrix}\n",
    "1 & 1 & 1 &1  &1 \\\\ \n",
    "1 & 2 & 1 & 1 & 1\\\\ \n",
    "1 & 1 & 3 & 1 & 1\\\\ \n",
    "1 &1  & 1 & 4 & 1\n",
    "\\end{bmatrix}\n",
    "\n",
    "And calculate:\n",
    "- the sum of each line\n",
    "- the sum of each row"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 1 1 1 1]\n",
      " [1 2 1 1 1]\n",
      " [1 1 3 1 1]\n",
      " [1 1 1 4 1]]\n"
     ]
    }
   ],
   "source": [
    "### Your Solution\n",
    "arr = np.ones((4,5), dtype=int)\n",
    "arr[1,1]=2\n",
    "arr[2,2]=3\n",
    "arr[3,3]=4\n",
    "print(arr)\n",
    "# diagonal function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Task:**\n",
    "\n",
    "Generate a 2x2 matrix from `arr`: It shall consist of the 4 values when taking the values of the 2nd and 4th column of arr and the even rows.\n",
    "\n",
    "Use different methods:\n",
    "(see http://docs.scipy.org/doc/numpy/reference/arrays.indexing.html)\n",
    "- integer array indexes\n",
    "- slices\n",
    "- boolean arrays\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 1]\n",
      " [1 4]]\n",
      "[[2 1]\n",
      " [1 4]]\n",
      "[[2 1]\n",
      " [1 4]]\n"
     ]
    }
   ],
   "source": [
    "### Your Solution\n",
    "\n",
    "##integer array\n",
    "indexed =arr[[1, 1, 3,3], [1, 3,1, 3]]\n",
    "indexed = x.reshape(2,2)\n",
    "print(indexed)\n",
    "\n",
    "\n",
    "##slices\n",
    "sliced = arr[[1,3],:][:,[1,3]]\n",
    "print(sliced)\n",
    "\n",
    "##boolean arrays\n",
    "\n",
    "rows = (arr.sum(-1) % 2) == 0\n",
    "columns = [1,3]\n",
    "boolean = arr[np.ix_(rows, columns)]\n",
    "print(boolean)\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Task:**\n",
    "\n",
    "(see http://docs.scipy.org/doc/numpy-1.10.1/user/basics.broadcasting.html)\n",
    "\n",
    "Explain the following operations on `arr`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 1 1 1 1]\n",
      " [1 2 1 1 1]\n",
      " [1 1 3 1 1]\n",
      " [1 1 1 4 1]]\n",
      "--------1-------\n",
      "[[ 5.  5.  5.  5.  5.]\n",
      " [ 5. 10.  5.  5.  5.]\n",
      " [ 5.  5. 15.  5.  5.]\n",
      " [ 5.  5.  5. 20.  5.]]\n",
      "--------2-------\n",
      "[0 1 2 3 4]\n",
      "[[ 0  1  2  3  4]\n",
      " [ 0  2  2  3  4]\n",
      " [ 0  1  6  3  4]\n",
      " [ 0  1  2 12  4]]\n",
      "--------3------\n",
      "[0 1 2 3]\n",
      "[[ 0  1  2  3]\n",
      " [ 0  2  2  3]\n",
      " [ 0  1  6  3]\n",
      " [ 0  1  2 12]\n",
      " [ 0  1  2  3]]\n",
      "--------4-------\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "operands could not be broadcast together with shapes (4,5) (4,) ",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-17-7898e2ff3aae>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     10\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0marr\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mT\u001b[0m \u001b[1;33m*\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0marange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0marr\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     11\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'--------4-------'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 12\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0marr\u001b[0m \u001b[1;33m*\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0marange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0marr\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m: operands could not be broadcast together with shapes (4,5) (4,) "
     ]
    }
   ],
   "source": [
    "### Your Solution\n",
    "print(arr)\n",
    "print('--------1-------')\n",
    "print(arr * 5.)\n",
    "print('--------2-------')\n",
    "print(np.arange(arr.shape[1]))\n",
    "print(arr * np.arange(arr.shape[1]))\n",
    "print('--------3------')\n",
    "print(np.arange(arr.shape[0]))\n",
    "print(arr.T * np.arange(arr.shape[0]))\n",
    "print('--------4-------')\n",
    "print(arr * np.arange(arr.shape[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Task:**\n",
    "\n",
    "Calculate the matrix-vector product (dot product) of `arr` and $v$:\n",
    "\n",
    "with:\n",
    "\n",
    "$\n",
    "v = (1,2,3,4,5)^T\n",
    "$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[15 17 21 27]\n"
     ]
    }
   ],
   "source": [
    "### Your Solution\n",
    "u = np.arange(5)\n",
    "u = u + 1\n",
    "dotProduct = np.dot(arr,u.T)\n",
    "print(dotProduct)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "## Summary and Outlook\n",
    "\n",
    "In this notebook you've picked up many of the essential numpy operations for maths and data science tasks.\n",
    "\n",
    "The more you use the library, the more of its functionality you'll discover and its usage will grow more intuitive and familiar."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "## Licenses\n",
    "\n",
    "### Notebook License (CC-BY-SA 4.0)\n",
    "\n",
    "*The following license applies to the complete notebook, including code cells. It does however not apply to any referenced external media (e.g., images).*\n",
    "\n",
    "Exercise: Python Numpy Basics <br/>\n",
    "by Klaus Strohmenger <br/>\n",
    "is licensed under a [Creative Commons Attribution-ShareAlike 4.0 International License](http://creativecommons.org/licenses/by-sa/4.0/).<br/>\n",
    "Based on a work at https://gitlab.com/deep.TEACHING.\n",
    "\n",
    "\n",
    "### Code License (MIT)\n",
    "\n",
    "*The following license only applies to code cells of the notebook.*\n",
    "\n",
    "Copyright 2019 Klaus Strohmenger\n",
    "\n",
    "Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the \"Software\"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:\n",
    "\n",
    "The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.\n",
    "\n",
    "THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}