Lec4_Numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NumPy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[166,\n",
       " 187,\n",
       " 165,\n",
       " 178,\n",
       " 188,\n",
       " 185,\n",
       " 196,\n",
       " 165,\n",
       " 199,\n",
       " 150,\n",
       " 158,\n",
       " 162,\n",
       " 170,\n",
       " 179,\n",
       " 165,\n",
       " 192,\n",
       " 191,\n",
       " 162,\n",
       " 169,\n",
       " 163,\n",
       " 191,\n",
       " 165,\n",
       " 169,\n",
       " 174,\n",
       " 194,\n",
       " 183,\n",
       " 150,\n",
       " 181,\n",
       " 173,\n",
       " 164,\n",
       " 198,\n",
       " 187,\n",
       " 172,\n",
       " 181,\n",
       " 187,\n",
       " 170,\n",
       " 151,\n",
       " 191,\n",
       " 197,\n",
       " 164,\n",
       " 162,\n",
       " 179,\n",
       " 179,\n",
       " 179,\n",
       " 173,\n",
       " 193,\n",
       " 185,\n",
       " 157,\n",
       " 162,\n",
       " 191,\n",
       " 196,\n",
       " 176,\n",
       " 191,\n",
       " 154,\n",
       " 195,\n",
       " 160,\n",
       " 197,\n",
       " 152,\n",
       " 154,\n",
       " 158,\n",
       " 176,\n",
       " 154,\n",
       " 178,\n",
       " 154,\n",
       " 176,\n",
       " 167,\n",
       " 160,\n",
       " 173,\n",
       " 167,\n",
       " 197,\n",
       " 191,\n",
       " 175,\n",
       " 178,\n",
       " 158,\n",
       " 150,\n",
       " 179,\n",
       " 177,\n",
       " 177,\n",
       " 187,\n",
       " 197,\n",
       " 185,\n",
       " 153,\n",
       " 163,\n",
       " 174,\n",
       " 188,\n",
       " 194,\n",
       " 171,\n",
       " 197,\n",
       " 198,\n",
       " 161,\n",
       " 172,\n",
       " 184,\n",
       " 173,\n",
       " 170,\n",
       " 179,\n",
       " 154,\n",
       " 150,\n",
       " 198,\n",
       " 191,\n",
       " 177,\n",
       " 175,\n",
       " 167,\n",
       " 162,\n",
       " 179,\n",
       " 165,\n",
       " 158,\n",
       " 199,\n",
       " 199,\n",
       " 183,\n",
       " 196,\n",
       " 154,\n",
       " 150,\n",
       " 173,\n",
       " 166,\n",
       " 195,\n",
       " 169,\n",
       " 200,\n",
       " 176,\n",
       " 191,\n",
       " 185,\n",
       " 165,\n",
       " 188,\n",
       " 169,\n",
       " 156,\n",
       " 155,\n",
       " 164,\n",
       " 152,\n",
       " 175,\n",
       " 164,\n",
       " 187,\n",
       " 181,\n",
       " 200,\n",
       " 179,\n",
       " 167,\n",
       " 151,\n",
       " 161,\n",
       " 191,\n",
       " 152,\n",
       " 194,\n",
       " 163,\n",
       " 190,\n",
       " 163,\n",
       " 163,\n",
       " 160,\n",
       " 197,\n",
       " 156,\n",
       " 165,\n",
       " 198,\n",
       " 167,\n",
       " 157,\n",
       " 190,\n",
       " 154,\n",
       " 152,\n",
       " 192,\n",
       " 199,\n",
       " 190,\n",
       " 170,\n",
       " 191,\n",
       " 198,\n",
       " 154,\n",
       " 152,\n",
       " 195,\n",
       " 199,\n",
       " 157,\n",
       " 186,\n",
       " 181,\n",
       " 179,\n",
       " 174,\n",
       " 188,\n",
       " 199,\n",
       " 153,\n",
       " 171,\n",
       " 164,\n",
       " 161,\n",
       " 194,\n",
       " 194,\n",
       " 151,\n",
       " 191,\n",
       " 192,\n",
       " 174,\n",
       " 158,\n",
       " 166,\n",
       " 167,\n",
       " 196,\n",
       " 176,\n",
       " 181,\n",
       " 173,\n",
       " 155,\n",
       " 185,\n",
       " 167,\n",
       " 150,\n",
       " 165,\n",
       " 197,\n",
       " 170,\n",
       " 188,\n",
       " 197,\n",
       " 192,\n",
       " 189,\n",
       " 171,\n",
       " 160,\n",
       " 160,\n",
       " 161,\n",
       " 190,\n",
       " 159,\n",
       " 175,\n",
       " 184,\n",
       " 178,\n",
       " 163,\n",
       " 182,\n",
       " 156,\n",
       " 178,\n",
       " 159,\n",
       " 186,\n",
       " 153,\n",
       " 155,\n",
       " 169,\n",
       " 162,\n",
       " 151,\n",
       " 159,\n",
       " 155,\n",
       " 190,\n",
       " 184,\n",
       " 196,\n",
       " 179,\n",
       " 168,\n",
       " 178,\n",
       " 186,\n",
       " 151,\n",
       " 191,\n",
       " 158,\n",
       " 177,\n",
       " 163,\n",
       " 188,\n",
       " 176,\n",
       " 173,\n",
       " 196,\n",
       " 177,\n",
       " 191,\n",
       " 194,\n",
       " 173,\n",
       " 185,\n",
       " 155,\n",
       " 159,\n",
       " 179,\n",
       " 191,\n",
       " 188,\n",
       " 180,\n",
       " 192,\n",
       " 193,\n",
       " 193,\n",
       " 188,\n",
       " 156,\n",
       " 171,\n",
       " 187,\n",
       " 178,\n",
       " 165,\n",
       " 160,\n",
       " 188,\n",
       " 189,\n",
       " 168,\n",
       " 199,\n",
       " 179,\n",
       " 188,\n",
       " 193,\n",
       " 188,\n",
       " 152,\n",
       " 186,\n",
       " 165,\n",
       " 170,\n",
       " 161,\n",
       " 164,\n",
       " 160,\n",
       " 178,\n",
       " 159,\n",
       " 187,\n",
       " 191,\n",
       " 183,\n",
       " 165,\n",
       " 160,\n",
       " 190,\n",
       " 154,\n",
       " 190,\n",
       " 165,\n",
       " 195,\n",
       " 170,\n",
       " 166,\n",
       " 197,\n",
       " 189,\n",
       " 194,\n",
       " 181,\n",
       " 191,\n",
       " 172,\n",
       " 159,\n",
       " 181,\n",
       " 185,\n",
       " 190,\n",
       " 174,\n",
       " 187,\n",
       " 200,\n",
       " 171,\n",
       " 183,\n",
       " 159,\n",
       " 153,\n",
       " 195,\n",
       " 184,\n",
       " 161,\n",
       " 188,\n",
       " 155,\n",
       " 156,\n",
       " 159,\n",
       " 178,\n",
       " 197,\n",
       " 158,\n",
       " 159,\n",
       " 180,\n",
       " 168,\n",
       " 192,\n",
       " 169,\n",
       " 189,\n",
       " 200,\n",
       " 182,\n",
       " 156,\n",
       " 192,\n",
       " 179,\n",
       " 197,\n",
       " 197,\n",
       " 172,\n",
       " 191,\n",
       " 175,\n",
       " 175,\n",
       " 185,\n",
       " 167,\n",
       " 165,\n",
       " 154,\n",
       " 199,\n",
       " 182,\n",
       " 172,\n",
       " 163,\n",
       " 185,\n",
       " 200,\n",
       " 186,\n",
       " 195,\n",
       " 183,\n",
       " 157,\n",
       " 199,\n",
       " 176,\n",
       " 183,\n",
       " 168,\n",
       " 161,\n",
       " 187,\n",
       " 177,\n",
       " 183,\n",
       " 180,\n",
       " 188,\n",
       " 199,\n",
       " 161,\n",
       " 178,\n",
       " 199,\n",
       " 168,\n",
       " 155,\n",
       " 174,\n",
       " 163,\n",
       " 159,\n",
       " 193,\n",
       " 162,\n",
       " 167,\n",
       " 192,\n",
       " 161,\n",
       " 160,\n",
       " 184,\n",
       " 179,\n",
       " 166,\n",
       " 194,\n",
       " 193,\n",
       " 154,\n",
       " 156,\n",
       " 169,\n",
       " 169,\n",
       " 166,\n",
       " 161,\n",
       " 173,\n",
       " 172,\n",
       " 173,\n",
       " 156,\n",
       " 191,\n",
       " 160,\n",
       " 165,\n",
       " 194,\n",
       " 192,\n",
       " 157,\n",
       " 171,\n",
       " 197,\n",
       " 177,\n",
       " 155,\n",
       " 159,\n",
       " 171,\n",
       " 150,\n",
       " 175,\n",
       " 186,\n",
       " 179,\n",
       " 191,\n",
       " 169,\n",
       " 195,\n",
       " 153,\n",
       " 177,\n",
       " 160,\n",
       " 184,\n",
       " 154,\n",
       " 175,\n",
       " 189,\n",
       " 199,\n",
       " 166,\n",
       " 173,\n",
       " 152,\n",
       " 189,\n",
       " 183,\n",
       " 192,\n",
       " 175,\n",
       " 159,\n",
       " 158,\n",
       " 198,\n",
       " 159,\n",
       " 181,\n",
       " 150,\n",
       " 177,\n",
       " 161,\n",
       " 192,\n",
       " 194,\n",
       " 150,\n",
       " 164,\n",
       " 152,\n",
       " 162,\n",
       " 164,\n",
       " 182,\n",
       " 174,\n",
       " 188,\n",
       " 181,\n",
       " 184,\n",
       " 166,\n",
       " 169,\n",
       " 171,\n",
       " 193,\n",
       " 151,\n",
       " 199,\n",
       " 182,\n",
       " 197,\n",
       " 186,\n",
       " 190,\n",
       " 186,\n",
       " 173,\n",
       " 192,\n",
       " 192,\n",
       " 167,\n",
       " 168,\n",
       " 195,\n",
       " 179,\n",
       " 172,\n",
       " 171,\n",
       " 198,\n",
       " 192,\n",
       " 181,\n",
       " 199,\n",
       " 189,\n",
       " 170,\n",
       " 177,\n",
       " 170,\n",
       " 164,\n",
       " 198,\n",
       " 190,\n",
       " 195,\n",
       " 185,\n",
       " 167,\n",
       " 182,\n",
       " 197,\n",
       " 176,\n",
       " 176,\n",
       " 198,\n",
       " 160,\n",
       " 151,\n",
       " 168,\n",
       " 183,\n",
       " 192,\n",
       " 171,\n",
       " 175,\n",
       " 174,\n",
       " 174,\n",
       " 165,\n",
       " 189,\n",
       " 153,\n",
       " 156,\n",
       " 181,\n",
       " 184,\n",
       " 195,\n",
       " 175,\n",
       " 174,\n",
       " 194,\n",
       " 160,\n",
       " 167,\n",
       " 163,\n",
       " 192,\n",
       " 186,\n",
       " 174,\n",
       " 157,\n",
       " 184,\n",
       " 162,\n",
       " 191,\n",
       " 156,\n",
       " 174,\n",
       " 156,\n",
       " 194,\n",
       " 175,\n",
       " 170,\n",
       " 175,\n",
       " 174,\n",
       " 167,\n",
       " 174,\n",
       " 197,\n",
       " 175,\n",
       " 180,\n",
       " 166,\n",
       " 163,\n",
       " 173,\n",
       " 199,\n",
       " 197,\n",
       " 180,\n",
       " 176,\n",
       " 198,\n",
       " 187,\n",
       " 199,\n",
       " 160,\n",
       " 187,\n",
       " 155,\n",
       " 174,\n",
       " 186,\n",
       " 166,\n",
       " 160,\n",
       " 163,\n",
       " 166,\n",
       " 187,\n",
       " 174,\n",
       " 192,\n",
       " 182,\n",
       " 159,\n",
       " 184,\n",
       " 169,\n",
       " 172,\n",
       " 160,\n",
       " 160,\n",
       " 177,\n",
       " 182,\n",
       " 167,\n",
       " 198,\n",
       " 159,\n",
       " 162,\n",
       " 164,\n",
       " 179,\n",
       " 196,\n",
       " 162,\n",
       " 160,\n",
       " 169,\n",
       " 152,\n",
       " 157,\n",
       " 150,\n",
       " 164,\n",
       " 169,\n",
       " 184,\n",
       " 160,\n",
       " 198,\n",
       " 178,\n",
       " 160,\n",
       " 159,\n",
       " 171,\n",
       " 161,\n",
       " 166,\n",
       " 200,\n",
       " 185,\n",
       " 167,\n",
       " 164,\n",
       " 183,\n",
       " 152,\n",
       " 177,\n",
       " 186,\n",
       " 151,\n",
       " 154,\n",
       " 196,\n",
       " 173,\n",
       " 158,\n",
       " 195,\n",
       " 179,\n",
       " 179,\n",
       " 154,\n",
       " 188,\n",
       " 182,\n",
       " 180,\n",
       " 199,\n",
       " 199,\n",
       " 155,\n",
       " 152,\n",
       " 194,\n",
       " 151,\n",
       " 181,\n",
       " 159,\n",
       " 169,\n",
       " 179,\n",
       " 182,\n",
       " 183,\n",
       " 180,\n",
       " 193,\n",
       " 183,\n",
       " 162,\n",
       " 172,\n",
       " 158,\n",
       " 160,\n",
       " 187,\n",
       " 184,\n",
       " 176,\n",
       " 178,\n",
       " 178,\n",
       " 195,\n",
       " 154,\n",
       " 161,\n",
       " 179,\n",
       " 184,\n",
       " 183,\n",
       " 176,\n",
       " 160,\n",
       " 186,\n",
       " 184,\n",
       " 184,\n",
       " 183,\n",
       " 154,\n",
       " 198,\n",
       " 171,\n",
       " 185,\n",
       " 176,\n",
       " 200,\n",
       " 159,\n",
       " 162,\n",
       " 161,\n",
       " 164,\n",
       " 187,\n",
       " 154,\n",
       " 176,\n",
       " 180,\n",
       " 181,\n",
       " 153,\n",
       " 152,\n",
       " 156,\n",
       " 187,\n",
       " 152,\n",
       " 151,\n",
       " 188,\n",
       " 160,\n",
       " 190,\n",
       " 151,\n",
       " 177,\n",
       " 189,\n",
       " 155,\n",
       " 186,\n",
       " 157,\n",
       " 196,\n",
       " 156,\n",
       " 200,\n",
       " 160,\n",
       " 198,\n",
       " 165,\n",
       " 196,\n",
       " 187,\n",
       " 150,\n",
       " 189,\n",
       " 178,\n",
       " 179,\n",
       " 197,\n",
       " 174,\n",
       " 181,\n",
       " 195,\n",
       " 171,\n",
       " 154,\n",
       " 181,\n",
       " 150,\n",
       " 157,\n",
       " 168,\n",
       " 192,\n",
       " 174,\n",
       " 158,\n",
       " 198,\n",
       " 191,\n",
       " 168,\n",
       " 156,\n",
       " 153,\n",
       " 185,\n",
       " 174,\n",
       " 155,\n",
       " 167,\n",
       " 187,\n",
       " 168,\n",
       " 164,\n",
       " 169,\n",
       " 181,\n",
       " 155,\n",
       " 182,\n",
       " 173,\n",
       " 153,\n",
       " 167,\n",
       " 195,\n",
       " 173,\n",
       " 172,\n",
       " 171,\n",
       " 172,\n",
       " 183,\n",
       " 156,\n",
       " 150,\n",
       " 151,\n",
       " 165,\n",
       " 168,\n",
       " 177,\n",
       " 178,\n",
       " 162,\n",
       " 194,\n",
       " 195,\n",
       " 196,\n",
       " 185,\n",
       " 167,\n",
       " 159,\n",
       " 167,\n",
       " 166,\n",
       " 186,\n",
       " 185,\n",
       " 191,\n",
       " 166,\n",
       " 200,\n",
       " 189,\n",
       " 184,\n",
       " 180,\n",
       " 153,\n",
       " 182,\n",
       " 160,\n",
       " 173,\n",
       " 184,\n",
       " 152,\n",
       " 170,\n",
       " 153,\n",
       " 184,\n",
       " 172,\n",
       " 188,\n",
       " 191,\n",
       " 165,\n",
       " 175,\n",
       " 187,\n",
       " 184,\n",
       " 187,\n",
       " 188,\n",
       " 169,\n",
       " 191,\n",
       " 153,\n",
       " 182,\n",
       " 182,\n",
       " 194,\n",
       " 197,\n",
       " 191,\n",
       " 179,\n",
       " 170,\n",
       " 186,\n",
       " 199,\n",
       " 156,\n",
       " 193,\n",
       " 176,\n",
       " 180,\n",
       " 167,\n",
       " 188,\n",
       " 195,\n",
       " 196,\n",
       " 180,\n",
       " 151,\n",
       " 151,\n",
       " 155,\n",
       " 151,\n",
       " 167,\n",
       " 157,\n",
       " 184,\n",
       " 181,\n",
       " 176,\n",
       " 151,\n",
       " 164,\n",
       " 200,\n",
       " 157,\n",
       " 168,\n",
       " 197,\n",
       " 199,\n",
       " 186,\n",
       " 180,\n",
       " 197,\n",
       " 151,\n",
       " 154,\n",
       " 166,\n",
       " 178,\n",
       " 173,\n",
       " 184,\n",
       " 154,\n",
       " 198,\n",
       " 197,\n",
       " 173,\n",
       " 156,\n",
       " 184,\n",
       " 150,\n",
       " 168,\n",
       " 194,\n",
       " 178,\n",
       " 162,\n",
       " 167,\n",
       " 151,\n",
       " 162,\n",
       " 198,\n",
       " 179,\n",
       " 152,\n",
       " 187,\n",
       " 177,\n",
       " 158,\n",
       " 170,\n",
       " 180,\n",
       " 174,\n",
       " 174,\n",
       " 175,\n",
       " 152,\n",
       " 153,\n",
       " 158,\n",
       " 159,\n",
       " 175,\n",
       " 181,\n",
       " 175,\n",
       " 183,\n",
       " 171,\n",
       " 157,\n",
       " 177,\n",
       " 168,\n",
       " 187,\n",
       " 168,\n",
       " 174,\n",
       " 170,\n",
       " 159,\n",
       " 196,\n",
       " 192,\n",
       " 200,\n",
       " 189,\n",
       " 182,\n",
       " 198,\n",
       " 197,\n",
       " 200,\n",
       " 173,\n",
       " 156,\n",
       " 166,\n",
       " 156,\n",
       " 183,\n",
       " 159,\n",
       " 186,\n",
       " 179,\n",
       " 155,\n",
       " 161,\n",
       " 193,\n",
       " 170,\n",
       " 195,\n",
       " 166,\n",
       " 151,\n",
       " 158,\n",
       " 180,\n",
       " 176,\n",
       " 166,\n",
       " 196,\n",
       " 173,\n",
       " 168,\n",
       " 184,\n",
       " 194,\n",
       " 158,\n",
       " 176,\n",
       " 167,\n",
       " 157,\n",
       " 184,\n",
       " 180,\n",
       " 198,\n",
       " 173,\n",
       " 175,\n",
       " 183,\n",
       " 151,\n",
       " 174,\n",
       " 158,\n",
       " 159,\n",
       " 175,\n",
       " 185,\n",
       " 158,\n",
       " 190,\n",
       " 199,\n",
       " 184,\n",
       " 197,\n",
       " 180,\n",
       " 181,\n",
       " 184,\n",
       " 199,\n",
       " 160,\n",
       " 177,\n",
       " 200,\n",
       " 153,\n",
       " 176,\n",
       " 192,\n",
       " 150,\n",
       " 156,\n",
       " 162,\n",
       " 160,\n",
       " 179,\n",
       " 199,\n",
       " 169,\n",
       " 181,\n",
       " 180,\n",
       " 188,\n",
       " 175,\n",
       " 151,\n",
       " 190,\n",
       " 196,\n",
       " 187,\n",
       " 184,\n",
       " 188,\n",
       " 187,\n",
       " 197,\n",
       " 151,\n",
       " 154,\n",
       " 193,\n",
       " 153,\n",
       " 185,\n",
       " 155,\n",
       " 154,\n",
       " 193,\n",
       " 186,\n",
       " 196,\n",
       " 171,\n",
       " 186,\n",
       " 156,\n",
       " 168,\n",
       " 185,\n",
       " 195,\n",
       " 171,\n",
       " 165,\n",
       " 180,\n",
       " 183,\n",
       " 186,\n",
       " 159,\n",
       " 186,\n",
       " 172,\n",
       " 196,\n",
       " 156,\n",
       " 158,\n",
       " 158,\n",
       " 157,\n",
       " 177,\n",
       " 176,\n",
       " 180,\n",
       " 200,\n",
       " 173,\n",
       " 167,\n",
       " 174,\n",
       " 157,\n",
       " 156,\n",
       " 193,\n",
       " 166,\n",
       " 198,\n",
       " 160,\n",
       " 180,\n",
       " 196,\n",
       " 197,\n",
       " 191,\n",
       " 161,\n",
       " 175,\n",
       " 176,\n",
       " 180,\n",
       " 197,\n",
       " 180,\n",
       " 183,\n",
       " 199,\n",
       " 191,\n",
       " 190,\n",
       " 150,\n",
       " 184,\n",
       " 163,\n",
       " 169,\n",
       " 184,\n",
       " 160,\n",
       " 173,\n",
       " 158,\n",
       " 186,\n",
       " 179,\n",
       " 174,\n",
       " 159,\n",
       " 165,\n",
       " 183,\n",
       " 190,\n",
       " 175,\n",
       " 160,\n",
       " 166,\n",
       " 166,\n",
       " 197,\n",
       " 174,\n",
       " 167,\n",
       " ...]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import random\n",
    "measurements = [random.randint(150,200) for _ in range(1_000_000)]\n",
    "measurements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "37 ms ± 7.54 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "import random \n",
    "measurements = [random.randint(150, 200) for _ in range(1_000_000)]\n",
    "\n",
    "def calculate_mean(measurements):\n",
    "    accumulator = 0\n",
    "    for measurement in measurements:\n",
    "        accumulator += measurement\n",
    "    \n",
    "    mean = accumulator / len(measurements)\n",
    "    return mean\n",
    "\n",
    "%timeit calculate_mean(measurements)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is rather slow since Python has to rebind a new variable in every loop and then has to check whether the + operation is supported between the accumulator and the current measurement. This prevents it from trying to add together objects that can't be added, but in this case we are pretty sure that we are only dealing with integers. If we could tell the interpreter that we are only adding integers, we could skip all that typechecking and speed up the operation. For this purpose, numpy was invented.\n",
    "\n",
    "To use numpy we have to import it. The import is usuall aliased as np so we have to type less later on. Aliasing things is only recommended if it is well established in the community of the respective package."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([152, 195, 159, ..., 180, 194, 166])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "measurements_array = np.array(measurements)\n",
    "measurements_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(measurements_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "152"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "measurements_array[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([152, 195, 159, 157, 187])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "measurements_array[0:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int32')"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "measurements_array.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "841 µs ± 5.4 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit np.mean(measurements_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Almost 100x speedup in comparision to the pure Python implementation! After convincing ourselfs that NumPy is useful, we have a more in depth look at the numpy array."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Anatomy of arrays\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### dtype "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ".dtype gives information about the data type. arrays can contain bools, ints, unsigned ints, floats or complex numbers of various byte sizes. They can also store strings or Python objects, but that has very few use cases."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0, 1, 2, 3, 4]), dtype('int32'))"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "values = [0, 1, 2, 3, 4]\n",
    "int_arr = np.array(values, dtype='int')\n",
    "int_arr, int_arr.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([False,  True,  True,  True,  True]), dtype('bool'))"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool_arr = np.array(values, dtype='bool')\n",
    "bool_arr, bool_arr.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0. , 1. , 2.5, 3. , 4. ]), dtype('float64'))"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "values = [0, 1, 2.5, 3, 4]\n",
    "float_arr = np.array(values)\n",
    "float_arr, float_arr.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0, 2, 2, 3, 4]), dtype('int32'))"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int_arr[1] = 2.5\n",
    "int_arr, int_arr.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0, 1, 2, 3, 4], dtype=int8), dtype('int8'))"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "values = [0, 1, 2, 3, 4]\n",
    "uint_arr = np.array(values, dtype='int8')\n",
    "uint_arr, uint_arr.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 2, 3, 4], dtype=int8)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "uint_arr[1] += 255\n",
    "uint_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(measurements_array[0]) == type(183)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### shape and ndim "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "values = [0, 1, 2, 3, 4]\n",
    "one_dim_arr = np.array(values)\n",
    "one_dim_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5,)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "one_dim_arr.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "one_dim_arr.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2, 3, 4],\n",
       "       [0, 1, 2, 3, 4],\n",
       "       [0, 1, 2, 3, 4]])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "values = [[0, 1, 2, 3, 4]] * 3\n",
    "two_dim_arr = np.array(values)\n",
    "two_dim_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 5)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "two_dim_arr.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "two_dim_arr.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "two_dim_arr[1,1] = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4],\n",
       "       [ 0, 10,  2,  3,  4],\n",
       "       [ 0,  1,  2,  3,  4]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "two_dim_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[0, 1, 2, 3, 4],\n",
       "        [0, 1, 2, 3, 4],\n",
       "        [0, 1, 2, 3, 4]],\n",
       "\n",
       "       [[0, 1, 2, 3, 4],\n",
       "        [0, 1, 2, 3, 4],\n",
       "        [0, 1, 2, 3, 4]],\n",
       "\n",
       "       [[0, 1, 2, 3, 4],\n",
       "        [0, 1, 2, 3, 4],\n",
       "        [0, 1, 2, 3, 4]],\n",
       "\n",
       "       [[0, 1, 2, 3, 4],\n",
       "        [0, 1, 2, 3, 4],\n",
       "        [0, 1, 2, 3, 4]],\n",
       "\n",
       "       [[0, 1, 2, 3, 4],\n",
       "        [0, 1, 2, 3, 4],\n",
       "        [0, 1, 2, 3, 4]],\n",
       "\n",
       "       [[0, 1, 2, 3, 4],\n",
       "        [0, 1, 2, 3, 4],\n",
       "        [0, 1, 2, 3, 4]]])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "values = [[[0, 1, 2, 3, 4]] * 3] * 6\n",
    "three_dim_arr = np.array(values)\n",
    "three_dim_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(6, 3, 5)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "three_dim_arr.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "three_dim_arr.ndim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Other attributes\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4],\n",
       "       [ 0, 10,  2,  3,  4],\n",
       "       [ 0,  1,  2,  3,  4]])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "two_dim_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  0,  0],\n",
       "       [ 1, 10,  1],\n",
       "       [ 2,  2,  2],\n",
       "       [ 3,  3,  3],\n",
       "       [ 4,  4,  4]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "two_dim_arr.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['T', '__abs__', '__add__', '__and__', '__array__', '__array_finalize__', '__array_function__', '__array_interface__', '__array_prepare__', '__array_priority__', '__array_struct__', '__array_ufunc__', '__array_wrap__', '__bool__', '__class__', '__complex__', '__contains__', '__copy__', '__deepcopy__', '__delattr__', '__delitem__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__iand__', '__ifloordiv__', '__ilshift__', '__imatmul__', '__imod__', '__imul__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__ior__', '__ipow__', '__irshift__', '__isub__', '__iter__', '__itruediv__', '__ixor__', '__le__', '__len__', '__lshift__', '__lt__', '__matmul__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmatmul__', '__rmod__', '__rmul__', '__ror__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__setitem__', '__setstate__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__xor__', 'all', 'any', 'argmax', 'argmin', 'argpartition', 'argsort', 'astype', 'base', 'byteswap', 'choose', 'clip', 'compress', 'conj', 'conjugate', 'copy', 'ctypes', 'cumprod', 'cumsum', 'data', 'diagonal', 'dot', 'dtype', 'dump', 'dumps', 'fill', 'flags', 'flat', 'flatten', 'getfield', 'imag', 'item', 'itemset', 'itemsize', 'max', 'mean', 'min', 'nbytes', 'ndim', 'newbyteorder', 'nonzero', 'partition', 'prod', 'ptp', 'put', 'ravel', 'real', 'repeat', 'reshape', 'resize', 'round', 'searchsorted', 'setfield', 'setflags', 'shape', 'size', 'sort', 'squeeze', 'std', 'strides', 'sum', 'swapaxes', 'take', 'tobytes', 'tofile', 'tolist', 'tostring', 'trace', 'transpose', 'var', 'view']\n"
     ]
    }
   ],
   "source": [
    "print(dir(two_dim_arr))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The equivalent of range."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2,  4,  6,  8, 10, 12])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(2, 14, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2,  4,  6,  8, 10, 12])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(start=2, stop=14, step=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2,  4,  6,  8, 10, 12])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(stop=14, start=2, step=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creating an array with a certain number of values in a certain interval."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-5.        , -3.88888889, -2.77777778, -1.66666667, -0.55555556,\n",
       "        0.55555556,  1.66666667,  2.77777778,  3.88888889,  5.        ])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(-5, 5, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-5.        , -3.88888889, -2.77777778, -1.66666667, -0.55555556,\n",
       "        0.55555556,  1.66666667,  2.77777778,  3.88888889,  5.        ])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(start=-5, stop=5, num=10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An array containing zeros. The default dtype is float."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0., 0.])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[0., 0.],\n",
       "        [0., 0.],\n",
       "        [0., 0.]],\n",
       "\n",
       "       [[0., 0.],\n",
       "        [0., 0.],\n",
       "        [0., 0.]]])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((2, 3, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[1., 1.],\n",
       "        [1., 1.],\n",
       "        [1., 1.]],\n",
       "\n",
       "       [[1., 1.],\n",
       "        [1., 1.],\n",
       "        [1., 1.]]])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones(shape=(2, 3, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[1., 1.],\n",
       "        [1., 1.],\n",
       "        [1., 1.]],\n",
       "\n",
       "       [[1., 1.],\n",
       "        [1., 1.],\n",
       "        [1., 1.]]])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.empty(shape=(2, 3, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[42, 42],\n",
       "        [42, 42],\n",
       "        [42, 42]],\n",
       "\n",
       "       [[42, 42],\n",
       "        [42, 42],\n",
       "        [42, 42]]])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.full(shape=(2, 3, 2), fill_value=42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[1., 1.],\n",
       "        [1., 1.],\n",
       "        [1., 1.]],\n",
       "\n",
       "       [[1., 1.],\n",
       "        [1., 1.],\n",
       "        [1., 1.]]])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.empty(shape=(2, 3, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reshape "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([ 2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13]), (12,))"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(2, 14)\n",
    "a, a.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2,  3,  4,  5],\n",
       "       [ 6,  7,  8,  9],\n",
       "       [10, 11, 12, 13]])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = a.reshape(3, 4)\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2,  3],\n",
       "       [ 4,  5],\n",
       "       [ 6,  7],\n",
       "       [ 8,  9],\n",
       "       [10, 11],\n",
       "       [12, 13]])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.reshape(-1, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-1 as axis automatically figures out the size of the respective dimension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparing Arrays "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False,  True,  True],\n",
       "       [ True,  True,  True],\n",
       "       [ True,  True,  True]])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "epsilon = 0.000000000001\n",
    "a = np.zeros((3,3))\n",
    "b = np.zeros((3,3))\n",
    "a[0,0] += 0.5*epsilon\n",
    "a == b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(a == b).all()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-if either a or b is empty and the other one contains a single element, this will return True. (the comparison a==b returns an empty array, for which the all-operator returns True)\n",
    "\n",
    "-If a and b don't have the same shape and aren't broadcastable, then this approach will raise an error.\n",
    "\n",
    "Instead, use numpys provided functions!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array_equal(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.allclose(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ True,  True,  True],\n",
       "       [ True,  True,  True],\n",
       "       [ True,  True,  True]])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.isclose(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Masking "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Logical arrays, i.e. arrays containing boolean values, can be used to index other arrays. These logical arrays are then called masks. This is especially useful to index based on logical conditions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.arange(1, 6)\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True, False,  True, False,  True])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mask = np.array([True, False, True, False, True])\n",
    "mask"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the mask for indexing returns an array with only elements at positions where mask is True."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 3, 5])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[mask]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True,  True,  True,  True,  True])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr < 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[arr < 10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10,  2, 10,  4, 10])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[mask] = 10\n",
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mathematical operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Standard arithmetic "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.arange(9)\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  3,  6,  9, 12, 15, 18, 21, 24])"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr * 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  2,  6, 12, 20, 30, 42, 56, 72])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr + (arr ** 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 0, 0, 0, 0, 0, 0])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr - arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Z0014236\\Desktop\\WPy64-3720\\python-3.7.2.amd64\\lib\\site-packages\\ipykernel_launcher.py:1: RuntimeWarning: invalid value encountered in true_divide\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([nan,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr / arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Some standard functions "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.        ,  0.84147098,  0.90929743,  0.14112001, -0.7568025 ,\n",
       "       -0.95892427, -0.2794155 ,  0.6569866 ,  0.98935825])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sin(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 1, 1, 1, 1, 1, 1, 1])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sign(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int32')"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sign(arr).dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Z0014236\\Desktop\\WPy64-3720\\python-3.7.2.amd64\\lib\\site-packages\\ipykernel_launcher.py:1: RuntimeWarning: divide by zero encountered in log\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([      -inf, 0.        , 0.69314718, 1.09861229, 1.38629436,\n",
       "       1.60943791, 1.79175947, 1.94591015, 2.07944154])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.log(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Broadcasting "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What happens if you try to add arrays of different shapes? Numpy will try to expand the arrays according to three rules and try to make their shapes match, so the operation can be applied elementwise.\n",
    "\n",
    "1. Rule If the arrays have different numbers of dimensions, the smaller shape is padded with ones on its left side.\n",
    "Example: (5 x 3) + (3) → (5 x 3) + (1 x 3)\n",
    "2. Rule If the number of the dimensions matches, but the size of a dimension does not, dimensions with the size of 1 are expanded.\n",
    "Example: (5 x 3) + (1 x 3) → (5 x 3) + (5 x 3)\n",
    "3. Rule If the shapes of the arrays still defer after applying the Rule 1 and 2, a broadcasting error is raised.\n",
    "\n",
    "<img src=\"broadcasting.png\"/>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2],\n",
       "       [ 3,  4,  5],\n",
       "       [ 6,  7,  8],\n",
       "       [ 9, 10, 11],\n",
       "       [12, 13, 14]])"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(15).reshape((5, 3))\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = np.arange(3)\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  2,  4],\n",
       "       [ 3,  5,  7],\n",
       "       [ 6,  8, 10],\n",
       "       [ 9, 11, 13],\n",
       "       [12, 14, 16]])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Aggregations functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aggregation function are functions that reduce the dimensionality of an array. They provide an axis argument, to specify which dimension to reduce."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5, 11, 12,  8],\n",
       "       [ 9, 11,  5, 15],\n",
       "       [ 0, 16,  1, 12],\n",
       "       [ 7, 13,  6, 18]])"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.seed(1)\n",
    "two_dim_arr = np.random.randint(0, high=20, size=(4, 4))\n",
    "two_dim_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.min(two_dim_arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The optional axis argument allows us to specify, which dimension should be aggregated. You can think of it as the operation being applied to all entries that are obtained by keeping the indices in all dimensions fixed except for the axis dimension. Let's look at the result of the minimum operation with axis=0:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0, 11,  1,  8])"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.min(two_dim_arr, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 5, 11, 12,  8],\n",
       "        [ 9, 11,  5, 15],\n",
       "        [ 0, 16,  1, 12],\n",
       "        [ 7, 13,  6, 18]],\n",
       "\n",
       "       [[ 5, 18, 11, 10],\n",
       "        [14, 18,  4,  9],\n",
       "        [17,  0, 13,  9],\n",
       "        [ 9,  7,  1,  0]],\n",
       "\n",
       "       [[17,  8, 13, 19],\n",
       "        [15, 10,  8,  7],\n",
       "        [ 3,  6, 17,  3],\n",
       "        [ 4, 17, 11, 12]],\n",
       "\n",
       "       [[16, 13, 19,  9],\n",
       "        [18, 15,  0,  4],\n",
       "        [15,  2,  7,  8],\n",
       "        [ 9,  3,  7,  4]]])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.seed(1)\n",
    "three_dim_arr = np.random.randint(0, high=20, size=(4, 4, 4))\n",
    "three_dim_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5,  8, 11,  8],\n",
       "       [ 9, 10,  0,  4],\n",
       "       [ 0,  0,  1,  3],\n",
       "       [ 4,  3,  1,  0]])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.min(three_dim_arr, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "5\n",
      "17\n",
      "16\n"
     ]
    }
   ],
   "source": [
    "for i in range(4):\n",
    "    print(three_dim_arr[i, 0, 0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([[[2,4],[6,9]],[[3,1],[7,8]],[[4,5],[9, 0]]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[[2, 4],\n",
       "         [6, 9]],\n",
       " \n",
       "        [[3, 1],\n",
       "         [7, 8]],\n",
       " \n",
       "        [[4, 5],\n",
       "         [9, 0]]]), (3, 2, 2))"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a, a.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.min(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 1],\n",
       "       [6, 0]])"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.min(a, axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Advanced indexing "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multidimensional indexing "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "two_dim_list = [\n",
    "    [ 0,  1,  2],\n",
    "    [ 3,  4,  5],\n",
    "    [ 6,  7,  8],\n",
    "    [ 9, 10, 11],\n",
    "    [12, 13, 14]\n",
    "]\n",
    "\n",
    "two_dim_list[2][1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inner_list = two_dim_list[2]\n",
    "inner_list[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "two_dim_arr = np.array(two_dim_list)\n",
    "two_dim_arr[2,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8],\n",
       "       [ 9, 10, 11, 12, 13, 14, 15, 16, 17],\n",
       "       [18, 19, 20, 21, 22, 23, 24, 25, 26],\n",
       "       [27, 28, 29, 30, 31, 32, 33, 34, 35],\n",
       "       [36, 37, 38, 39, 40, 41, 42, 43, 44],\n",
       "       [45, 46, 47, 48, 49, 50, 51, 52, 53],\n",
       "       [54, 55, 56, 57, 58, 59, 60, 61, 62],\n",
       "       [63, 64, 65, 66, 67, 68, 69, 70, 71],\n",
       "       [72, 73, 74, 75, 76, 77, 78, 79, 80]])"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "large_two_dim_arr = np.arange(81).reshape(9, 9)\n",
    "large_two_dim_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, 10, 19, 28, 37, 46, 55, 64, 73])"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "large_two_dim_arr[:,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2],\n",
       "       [10, 11],\n",
       "       [19, 20],\n",
       "       [28, 29],\n",
       "       [37, 38],\n",
       "       [46, 47],\n",
       "       [55, 56],\n",
       "       [64, 65],\n",
       "       [73, 74]])"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "large_two_dim_arr[:, 1:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2,  4,  6],\n",
       "       [11, 13, 15],\n",
       "       [20, 22, 24],\n",
       "       [29, 31, 33],\n",
       "       [38, 40, 42],\n",
       "       [47, 49, 51],\n",
       "       [56, 58, 60],\n",
       "       [65, 67, 69],\n",
       "       [74, 76, 78]])"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "large_two_dim_arr[:,2:7:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  0,  2,  3,  4,  5,  6,  7,  8],\n",
       "       [ 9,  0, 11, 12, 13, 14, 15, 16, 17],\n",
       "       [18,  0, 20, 21, 22, 23, 24, 25, 26],\n",
       "       [27,  0, 29, 30, 31, 32, 33, 34, 35],\n",
       "       [36,  0, 38, 39, 40, 41, 42, 43, 44],\n",
       "       [45,  0, 47, 48, 49, 50, 51, 52, 53],\n",
       "       [54,  0, 56, 57, 58, 59, 60, 61, 62],\n",
       "       [63,  0, 65, 66, 67, 68, 69, 70, 71],\n",
       "       [72,  0, 74, 75, 76, 77, 78, 79, 80]])"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr_slice = large_two_dim_arr[:,1]\n",
    "arr_slice[:] = 0\n",
    "large_two_dim_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  0,  0,  3,  4,  5,  6,  7,  8],\n",
       "       [ 9,  0,  0, 12, 13, 14, 15, 16, 17],\n",
       "       [18,  0,  0, 21, 22, 23, 24, 25, 26],\n",
       "       [27,  0,  0, 30, 31, 32, 33, 34, 35],\n",
       "       [36,  0,  0, 39, 40, 41, 42, 43, 44],\n",
       "       [45,  0,  0, 48, 49, 50, 51, 52, 53],\n",
       "       [54,  0,  0, 57, 58, 59, 60, 61, 62],\n",
       "       [63,  0,  0, 66, 67, 68, 69, 70, 71],\n",
       "       [72,  0,  0, 75, 76, 77, 78, 79, 80]])"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "large_two_dim_arr[:,2] =0\n",
    "large_two_dim_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  0,  0,  3,  4,  5,  6,  7,  8],\n",
       "       [ 9,  0,  0, 12, 13, 14, 15, 16, 17],\n",
       "       [18,  0,  0, 21, 22, 23, 24, 25, 26],\n",
       "       [27,  0,  0, 30, 31, 32, 33, 34, 35],\n",
       "       [36,  0,  0, 39, 40, 41, 42, 43, 44],\n",
       "       [45,  0,  0, 48, 49, 50, 51, 52, 53],\n",
       "       [54,  0,  0, 57, 58, 59, 60, 61, 62],\n",
       "       [63,  0,  0, 66, 67, 68, 69, 70, 71],\n",
       "       [72,  0,  0, 75, 76, 77, 78, 79, 80]])"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l2 = np.copy(large_two_dim_arr)\n",
    "l2[:, 6] =0\n",
    "large_two_dim_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  0,  0,  3,  4,  5,  0,  7,  8],\n",
       "       [ 9,  0,  0, 12, 13, 14,  0, 16, 17],\n",
       "       [18,  0,  0, 21, 22, 23,  0, 25, 26],\n",
       "       [27,  0,  0, 30, 31, 32,  0, 34, 35],\n",
       "       [36,  0,  0, 39, 40, 41,  0, 43, 44],\n",
       "       [45,  0,  0, 48, 49, 50,  0, 52, 53],\n",
       "       [54,  0,  0, 57, 58, 59,  0, 61, 62],\n",
       "       [63,  0,  0, 66, 67, 68,  0, 70, 71],\n",
       "       [72,  0,  0, 75, 76, 77,  0, 79, 80]])"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ellipsis\n"
     ]
    }
   ],
   "source": [
    "print(...)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[[1., 1., 1.],\n",
       "         [1., 1., 1.],\n",
       "         [1., 1., 1.]],\n",
       "\n",
       "        [[1., 1., 1.],\n",
       "         [1., 1., 1.],\n",
       "         [1., 1., 1.]],\n",
       "\n",
       "        [[1., 1., 1.],\n",
       "         [1., 1., 1.],\n",
       "         [1., 1., 1.]]],\n",
       "\n",
       "\n",
       "       [[[2., 2., 2.],\n",
       "         [2., 2., 2.],\n",
       "         [2., 2., 2.]],\n",
       "\n",
       "        [[2., 2., 2.],\n",
       "         [2., 2., 2.],\n",
       "         [2., 2., 2.]],\n",
       "\n",
       "        [[2., 2., 2.],\n",
       "         [2., 2., 2.],\n",
       "         [2., 2., 2.]]],\n",
       "\n",
       "\n",
       "       [[[3., 3., 3.],\n",
       "         [3., 3., 3.],\n",
       "         [3., 3., 3.]],\n",
       "\n",
       "        [[3., 3., 3.],\n",
       "         [3., 3., 3.],\n",
       "         [3., 3., 3.]],\n",
       "\n",
       "        [[3., 3., 3.],\n",
       "         [3., 3., 3.],\n",
       "         [3., 3., 3.]]],\n",
       "\n",
       "\n",
       "       [[[4., 4., 4.],\n",
       "         [4., 4., 4.],\n",
       "         [4., 4., 4.]],\n",
       "\n",
       "        [[4., 4., 4.],\n",
       "         [4., 4., 4.],\n",
       "         [4., 4., 4.]],\n",
       "\n",
       "        [[4., 4., 4.],\n",
       "         [4., 4., 4.],\n",
       "         [4., 4., 4.]]]])"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "four_dim_arr = np.stack((np.ones((3, 3, 3)), \n",
    "                         np.ones((3, 3, 3)) * 2, \n",
    "                         np.ones((3, 3, 3)) * 3, \n",
    "                         np.ones((3, 3, 3)) * 4))\n",
    "four_dim_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4, 3, 3, 3)"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "four_dim_arr.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "four_dim_arr.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[4., 4., 4.],\n",
       "        [4., 4., 4.],\n",
       "        [4., 4., 4.]],\n",
       "\n",
       "       [[4., 4., 4.],\n",
       "        [4., 4., 4.],\n",
       "        [4., 4., 4.]],\n",
       "\n",
       "       [[4., 4., 4.],\n",
       "        [4., 4., 4.],\n",
       "        [4., 4., 4.]]])"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "four_dim_arr[3, :, :, :]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2., 2., 2.],\n",
       "       [2., 2., 2.],\n",
       "       [2., 2., 2.]])"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "four_dim_arr[1,...,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[1., 1., 1.],\n",
       "        [1., 1., 1.],\n",
       "        [1., 1., 1.]],\n",
       "\n",
       "       [[2., 2., 2.],\n",
       "        [2., 2., 2.],\n",
       "        [2., 2., 2.]],\n",
       "\n",
       "       [[3., 3., 3.],\n",
       "        [3., 3., 3.],\n",
       "        [3., 3., 3.]],\n",
       "\n",
       "       [[4., 4., 4.],\n",
       "        [4., 4., 4.],\n",
       "        [4., 4., 4.]]])"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "four_dim_arr[..., 1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fancy indexing "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 11, 12, 13, 14, 15, 16, 17, 18])"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.arange(9) + 10\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([11, 14, 15])"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "indices = np.array([1, 4, 5])\n",
    "arr[indices]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[11, 14],\n",
       "       [15, 17]])"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "indices = np.array([[1, 4],\n",
    "                    [5, 7]])\n",
    "arr[indices]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2],\n",
       "       [ 3,  4,  5],\n",
       "       [ 6,  7,  8],\n",
       "       [ 9, 10, 11],\n",
       "       [12, 13, 14]])"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "two_dim_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 14])"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_indices = np.array([3, 4])\n",
    "y_indices = np.array([1, 2])\n",
    "two_dim_arr[x_indices, y_indices]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [3, 4, 5],\n",
       "       [6, 7, 8]])"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.arange(9).reshape(3,3)\n",
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use indexing to swap rows and columns of an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[6, 7, 8],\n",
       "       [3, 4, 5],\n",
       "       [0, 1, 2]])"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[[2, 1, 0], :]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[6, 7, 8],\n",
       "       [3, 4, 5],\n",
       "       [0, 1, 2]])"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Advanced Masking "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8])"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(9)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True, False, False,  True, False, False,  True, False, False])"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a % 3 == 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "a[a % 3 == 0] = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 0, 4, 5, 0, 7, 8])"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10,  1,  2, 10,  4,  5, 10,  7,  8])"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[np.array([0, 3, 6])] = 10\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using np.where "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using masking always changes the original array, whereas sometimes the original array should rather be unchanged. np.where figures out the indices of an array where the given condition is true."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [0, 4, 5],\n",
       "       [0, 7, 8]])"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(9).reshape(3, 3)\n",
    "a[a % 3 == 0] = 0\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0, 1, 2], dtype=int64), array([0, 0, 0], dtype=int64))"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(9).reshape(3, 3)\n",
    "tmp = np.where(a % 3 == 0)\n",
    "tmp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Extending arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding new dimensions with np.newaxis "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instead of np.newaxis, None can be used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0, 1, 2, 3, 4]), (5,))"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "one_dim_arr = np.arange(5)\n",
    "one_dim_arr, one_dim_arr.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[0, 1, 2, 3, 4]]), (1, 5))"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "two_dim_arr = one_dim_arr[np.newaxis, :]\n",
    "two_dim_arr, two_dim_arr.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[[0]],\n",
       " \n",
       "        [[1]],\n",
       " \n",
       "        [[2]],\n",
       " \n",
       "        [[3]],\n",
       " \n",
       "        [[4]]]), (5, 1, 1))"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "two_dim_arr = one_dim_arr[:, np.newaxis, None]\n",
    "two_dim_arr, two_dim_arr.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0],\n",
       "       [1],\n",
       "       [2],\n",
       "       [3],\n",
       "       [4]])"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "one_dim_arr[:, None]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5,)"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "one_dim_arr.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Removing dimensions "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "arr.squeeze() removes dimensions of size 1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[0, 1, 2, 3, 4]]), (1, 5))"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "one_dim_arr = np.arange(5)\n",
    "two_dim_arr = one_dim_arr[np.newaxis, :]\n",
    "two_dim_arr, two_dim_arr.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0, 1, 2, 3, 4]), (5,))"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "two_dim_arr.squeeze(), two_dim_arr.squeeze().shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[[0]],\n",
       "\n",
       "        [[1]],\n",
       "\n",
       "        [[2]],\n",
       "\n",
       "        [[3]],\n",
       "\n",
       "        [[4]]]])"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(5).reshape(1, -1, 1, 1)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.squeeze()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Combining arrays "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are many ways to combine existing arrays, like np.append, np.concatenate and np.stack. However, these operations always require the whole array to be copied. Therefore, it often makes more sense to allocate an array of the size you need later upfront and then just fill the respective parts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0]))"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(10), np.arange(10)[::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0])"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.concatenate((np.arange(10),np.arange(10)[::-1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A quick and easy way to combine scalars and arrays is using np.r_, with the demanded arrays, lists, or numbers in square brackets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 2, 2, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 9, 8, 7, 6, 5, 4, 3, 2, 1,\n",
       "       0, 0, 1, 2])"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.r_[2, 2, 2, np.arange(10), np.arange(10)[::-1], [0, 1, 2]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "np.append uses concatenation internally:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.append(np.arange(10), np.arange(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For highr-dimensional arrays, other functions are useful:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],\n",
       "       [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]])"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.stack((np.arange(10), np.arange(10)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are also the functions np.vstack (row-wise-stacking) and np.hstack (column-wise-stacking):\n",
    "\n",
    "* hstack is equivalent to concatenation along the second axis, except for 1-D arrays where it concatenates along the first axis\n",
    "* vstack is equivalent to concatenation along the first axis after 1-D arrays of shape (N,) have been reshaped to (1,N)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2, 3, 4]])"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "two_dim_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]\n",
      " [12 13 14 15]]\n",
      "[[16 17 18 19]\n",
      " [20 21 22 23]\n",
      " [24 25 26 27]\n",
      " [28 29 30 31]]\n"
     ]
    }
   ],
   "source": [
    "two_dim_arr = np.arange(16).reshape(4, -1)\n",
    "two_dim_arr_2 = np.arange(16).reshape(4, -1) + 16\n",
    "print(two_dim_arr)\n",
    "print(two_dim_arr_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3, 16, 17, 18, 19],\n",
       "       [ 4,  5,  6,  7, 20, 21, 22, 23],\n",
       "       [ 8,  9, 10, 11, 24, 25, 26, 27],\n",
       "       [12, 13, 14, 15, 28, 29, 30, 31]])"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.hstack((two_dim_arr, two_dim_arr_2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 4,  5,  6,  7],\n",
       "       [ 8,  9, 10, 11],\n",
       "       [12, 13, 14, 15],\n",
       "       [16, 17, 18, 19],\n",
       "       [20, 21, 22, 23],\n",
       "       [24, 25, 26, 27],\n",
       "       [28, 29, 30, 31]])"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.vstack((two_dim_arr, two_dim_arr_2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## random.seed "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If a random seed is set, the random-number-generator re-uses the same numbers over and over again. This is very useful for testing, but of course this takes any randomness out of anything, so it should not be used in final code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.5488135  0.71518937 0.60276338 0.54488318 0.4236548 ]\n",
      "[0.5488135  0.71518937 0.60276338 0.54488318 0.4236548 ]\n",
      "[0.5488135  0.71518937 0.60276338 0.54488318 0.4236548 ]\n",
      "[0.5488135  0.71518937 0.60276338 0.54488318 0.4236548 ]\n",
      "[0.5488135  0.71518937 0.60276338 0.54488318 0.4236548 ]\n"
     ]
    }
   ],
   "source": [
    "for _ in range(5):\n",
    "    np.random.seed(0)\n",
    "    print(np.random.random(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Shuffling arrays "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "np.random.shuffle shuffles an array among the first index. That means, a one-dimensional is completely shuffled, whereas for multidimensional arrays, t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 7, 6, 2, 8, 9, 1, 0, 3, 5])"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(10)\n",
    "np.random.shuffle(a)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [6, 7, 8],\n",
       "       [3, 4, 5]])"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(9).reshape(3, 3)\n",
    "np.random.shuffle(a)\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To shuffle the array completely, you can flatten it and afterwards reshape it to its original shape:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [3, 4, 5],\n",
       "       [6, 7, 8]])"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(9).reshape(3, 3)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 7, 4],\n",
       "       [8, 6, 2],\n",
       "       [0, 3, 5]])"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = a.flatten()\n",
    "np.random.shuffle(b)\n",
    "a = b.reshape(a.shape)\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that np.shuffle shuffles the array in-place. To return a permutation, you'd use np.permutation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [3, 4, 5],\n",
       "       [6, 7, 8]])"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(9).reshape(3, 3)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[8, 2, 0],\n",
       "       [1, 7, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.permutation(a.flatten()).reshape(a.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [3, 4, 5],\n",
       "       [6, 7, 8]])"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you are dealing with different arrays you want to shuffle while keeping them matched to each other, \n",
    "it is more useful to shuffle the indices instead:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3,  4,  5,  6,  7,  8,  9],\n",
       "       [ 1,  4,  9, 16, 25, 36, 49, 64, 81]])"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(9) + 1\n",
    "b = a**2\n",
    "np.vstack((a, b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  3,  8,  5,  6,  2,  7,  4,  9],\n",
       "       [ 1,  9, 64, 25, 36,  4, 49, 16, 81]])"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "order = np.random.permutation(a.shape[0])\n",
    "np.vstack((a[order], b[order]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## np.random.choice "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "np.random.choice generates a sub-array from a given 1D-array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 8, 9, 5, 0])"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.seed(1)\n",
    "a = np.arange(10)\n",
    "np.random.choice(a, size=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([6, 3, 9, 2, 8])"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.choice(a, size=5, replace=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also specify probabilities which which to take certain elements. To generate another array where roughly a quarter of elements are True, you can use:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False, False,  True, False],\n",
       "       [False, False, False, False, False],\n",
       "       [False, False,  True, False, False],\n",
       "       [False, False, False,  True, False],\n",
       "       [False, False, False,  True, False]])"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.choice(np.r_[True, False], size=(5,5), p=[0.25, 0.75])"
   ]
  },
  {
   "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.7.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}