07-array-computing-with-numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Programming and Data Analysis\n",
    "\n",
    "> Array Computing with NumPy\n",
    "\n",
    "Kuo, Yao-Jen <yaojenkuo@ntu.edu.tw> from [DATAINPOINT](https://www.datainpoint.com/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# Importing libraries\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Getting Started with NumPy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## What is NumPy?\n",
    "\n",
    "> NumPy, as in numerical Python is the fundamental package for scientific computing in Python. It is a Python library that provides a multidimensional array object and an assortment of routines for fast operations on arrays, including mathematical, logical, shape manipulation, sorting, selecting, I/O, discrete Fourier transforms, basic linear algebra, basic statistical operations, random simulation and much more.\n",
    "\n",
    "Source: <https://numpy.org/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Two Python array packages existed before NumPy\n",
    "\n",
    "- The `Numeric` package was developed in the mid-1990s.\n",
    "- The `Numarray` package was a reimplementation of `Numeric`.\n",
    "- `NumPy` emerged as a best of both combining the features of `Numarray` and `Numeric` in 2005.\n",
    "\n",
    "Source: <https://www.nature.com/articles/s41586-020-2649-2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Import NumPy with `import` keyword\n",
    "\n",
    "NumPy is officially aliased as `np`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## If NumPy is not installed, we will encounter a `ModuleNotFoundError`\n",
    "\n",
    "```\n",
    "Traceback (most recent call last):\n",
    "  File \"<stdin>\", line 1, in <module>\n",
    "ModuleNotFoundError: No module named 'numpy'\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Use `pip install` at Terminal to install numpy\n",
    "\n",
    "```bash\n",
    "pip install numpy\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Check version and its installation file path\n",
    "\n",
    "- `__version__` attribute\n",
    "- `__file__` attribute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.20.2\n",
      "/Users/kuoyaojen/opt/miniconda3/envs/pyds/lib/python3.8/site-packages/numpy/__init__.py\n"
     ]
    }
   ],
   "source": [
    "print(np.__version__)\n",
    "print(np.__file__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Why NumPy?\n",
    "\n",
    "- Built-in data structures come with great flexibility that is able to contain heterogeneous data types.\n",
    "- To allow these flexible types, each item in the structure must contain its own type info, reference count.\n",
    "- Fixed-type arrays lack this flexibility, but are much more efficient for storing and manipulating data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## A heterogenous `list`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "<class 'bool'>\n",
      "<class 'bool'>\n",
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "heterogeneous_list = [False, True, 5566, 55.66, '5566']\n",
    "print(type(heterogeneous_list))\n",
    "for i in heterogeneous_list:\n",
    "    print(type(i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## A homogeneous `ndarray`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "<class 'numpy.str_'>\n",
      "<class 'numpy.str_'>\n",
      "<class 'numpy.str_'>\n",
      "<class 'numpy.str_'>\n",
      "<class 'numpy.str_'>\n"
     ]
    }
   ],
   "source": [
    "homogeneous_arr = np.array(heterogeneous_list)\n",
    "print(type(homogeneous_arr))\n",
    "for i in homogeneous_arr:\n",
    "    print(type(i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## The advantage of fix typed arrays\n",
    "\n",
    "More efficient for storing and manipulating data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "m = 1000000\n",
    "large_array = np.random.randint(1, 100, size=m)\n",
    "large_list = list(large_array)\n",
    "print(type(large_list))\n",
    "print(type(large_array))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Computing time for 1,000,000 repicprocals: 0.25 seconds.\n"
     ]
    }
   ],
   "source": [
    "# Computing reciprocals for large list\n",
    "start_time = time.time()\n",
    "reciprocals = [1 / i for i in large_list]\n",
    "end_time = time.time()\n",
    "computing_time = end_time - start_time\n",
    "print(f\"Computing time for {m:,} repicprocals: {computing_time:.2f} seconds.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Computing time for 1,000,000 repicprocals: 0.03 seconds.\n"
     ]
    }
   ],
   "source": [
    "# Computing for large array\n",
    "start_time = time.time()\n",
    "reciprocals = 1 / large_array\n",
    "end_time = time.time()\n",
    "computing_time = end_time - start_time\n",
    "print(f\"Computing time for {m:,} repicprocals: {computing_time:.2f} seconds.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Key functionalities we rely on NumPy:\n",
    "\n",
    "- Array manipulations\n",
    "- Universal/aggregate functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Creating arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## What is a `ndarray`?\n",
    "\n",
    "> A ndarray is a grid of values, all of the same type, and is indexed by a tuple of nonnegative integers. The number of dimensions is the rank of the array; the shape of an array is a tuple of integers giving the size of the array along each dimension."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Creating arrays from lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "lst = list(range(1, 11))\n",
    "print(type(lst))\n",
    "arr = np.array(lst)\n",
    "print(type(arr))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Creating arrays from scratch: zeros, ones, and full functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0. 0. 0. 0. 0.]\n",
      "[1. 1. 1. 1. 1.]\n",
      "[6. 6. 6. 6. 6.]\n"
     ]
    }
   ],
   "source": [
    "print(np.zeros(5))\n",
    "print(np.ones(5))\n",
    "print(np.full(5, 6.0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Creating arrays from scratch: generating sequences"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 3 5 7 9]\n",
      "[1. 3. 5. 7. 9.]\n"
     ]
    }
   ],
   "source": [
    "print(np.arange(1, 11, 2))\n",
    "print(np.linspace(1, 9, 5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Creating arrays from scratch: randomness"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.11518008 0.91122876 0.24198936 ... 0.61956849 0.19188777 0.16457691]\n",
      "[ 0.96962901  1.21476032  0.95327719 ...  1.50681251 -1.12642592\n",
      "  0.3546922 ]\n",
      "[1 3 4 ... 4 6 5]\n"
     ]
    }
   ],
   "source": [
    "uniform_arr = np.random.random(10000)\n",
    "normal_arr = np.random.normal(0, 1, 10000)\n",
    "randint_arr = np.random.randint(1, 7, size=10000)\n",
    "print(uniform_arr)\n",
    "print(normal_arr)\n",
    "print(randint_arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Validating distribution with histograms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure()\n",
    "ax = plt.axes()\n",
    "ax.hist(uniform_arr, bins=30)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure()\n",
    "ax = plt.axes()\n",
    "ax.hist(normal_arr, bins=30)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure()\n",
    "ax = plt.axes()\n",
    "uniques, counts = np.unique(randint_arr, return_counts=True)\n",
    "ax.bar(uniques, counts)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Common attributes to examine a `ndarray`\n",
    "\n",
    "- `ndim`: as in number of dimensions\n",
    "- `shape`\n",
    "- `size`\n",
    "- `dtype`: as in data type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "(4,)\n",
      "4\n",
      "int64\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([5, 5, 6, 6])\n",
    "print(arr.ndim)\n",
    "print(arr.shape)\n",
    "print(arr.size)\n",
    "print(arr.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Different nicknames vs. different number of dimensions\n",
    "\n",
    "- Scalar: 0-dimension\n",
    "- Vector: 1-dimension\n",
    "- Matrix: 2-dimension\n",
    "- Tensor: 3-dimension or more"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Scalar, vector, matrix, and tensor\n",
    "\n",
    "![Imgur](https://i.imgur.com/81fM6Hf.png)\n",
    "\n",
    "Source: <https://dev.to/juancarlospaco/tensors-for-busy-people-315k>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5566\n",
      "0\n",
      "()\n"
     ]
    }
   ],
   "source": [
    "scalar = np.array(5566)\n",
    "print(scalar)\n",
    "print(scalar.ndim)\n",
    "print(scalar.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5566]\n",
      "1\n",
      "(1,)\n"
     ]
    }
   ],
   "source": [
    "vector = np.array([5566])\n",
    "print(vector)\n",
    "print(vector.ndim)\n",
    "print(vector.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[5 5]\n",
      " [6 6]]\n",
      "2\n",
      "(2, 2)\n"
     ]
    }
   ],
   "source": [
    "matrix = np.array([[5, 5],\n",
    "                   [6, 6]])\n",
    "print(matrix)\n",
    "print(matrix.ndim)\n",
    "print(matrix.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[5 5]\n",
      "  [6 6]]\n",
      "\n",
      " [[5 5]\n",
      "  [6 6]]\n",
      "\n",
      " [[5 5]\n",
      "  [6 6]]]\n",
      "3\n",
      "(3, 2, 2)\n"
     ]
    }
   ],
   "source": [
    "tensor = np.array([[[5, 5],\n",
    "                    [6, 6]],\n",
    "                   [[5, 5],\n",
    "                    [6, 6]],\n",
    "                   [[5, 5],\n",
    "                    [6, 6]]])\n",
    "print(tensor)\n",
    "print(tensor.ndim)\n",
    "print(tensor.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Indexing/slicing arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Indexing a 1d-array is the same as indexing a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "From start to stop:\n",
      "55\n",
      "66\n",
      "56\n",
      "5566\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([55, 66, 56, 5566])\n",
    "print(\"From start to stop:\")\n",
    "print(arr[0])\n",
    "print(arr[1])\n",
    "print(arr[2])\n",
    "print(arr[arr.size - 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "From stop to start:\n",
      "5566\n",
      "56\n",
      "66\n",
      "55\n"
     ]
    }
   ],
   "source": [
    "print(\"From stop to start:\")\n",
    "print(arr[-1])\n",
    "print(arr[-2])\n",
    "print(arr[-3])\n",
    "print(arr[-arr.size])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Slicing a 1-d array is the same as slicing a list\n",
    "\n",
    "```python\n",
    "arr[start:stop:step]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10 11 12 13 14 15 16 17 18 19]\n",
      "[10 12 14 16 18]\n",
      "[10 11 12 13 14]\n",
      "[15 16 17 18 19]\n",
      "[19 18 17 16 15 14 13 12 11 10]\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(10, 20)\n",
    "print(arr[::])   # default\n",
    "print(arr[::2])  # step=2\n",
    "print(arr[:5])   # stop=5, exclusive\n",
    "print(arr[5:])   # start=5, inclusive\n",
    "print(arr[::-1]) # step=-1, reverse"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Indexing/slicing a multi-dimensional array is more convenient with syntax `[i, j, ...]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]]\n",
      "6\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(1, 13).reshape(3, 4)\n",
    "print(arr)\n",
    "print(arr[1, 1])  # 6 is located at (1, 1)\n",
    "print(arr[2, -3]) # 10 is located at (2, -3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Using syntax `[i, j, ...]` is way more convenient than nested lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 2  6 10]\n",
      "[[ 2]\n",
      " [ 6]\n",
      " [10]]\n"
     ]
    }
   ],
   "source": [
    "print(arr[:, 1])\n",
    "print(arr[:, [1]]) # to keep dimension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Special indexing syntax with `ndarray`\n",
    "\n",
    "- Fancy indexing\n",
    "- Boolean indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## What is fancy indexing?\n",
    "\n",
    "> Passing a sequence of indexes in brackets instead of a single integer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[45 48 65 68 68 10 84 22 37 88]\n",
      "[45 65 37]\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(0)\n",
    "arr = np.random.randint(1, 100, size=(10,))\n",
    "odd_indexes = [0, 2, 8]\n",
    "print(arr)\n",
    "print(arr[odd_indexes])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## What is boolean indexing?\n",
    "\n",
    "> Passing a sequence of booleans in brackets instead of an integer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[45 65 37]\n"
     ]
    }
   ],
   "source": [
    "is_odd = [True, False, True, False, False, False, False, False, True, False]\n",
    "print(arr[is_odd])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ True False  True False False False False False  True False]\n",
      "[45 65 37]\n"
     ]
    }
   ],
   "source": [
    "is_odd = arr % 2 == 1\n",
    "print(is_odd)\n",
    "print(arr[is_odd])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Common array manipulations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Reshaping an array with\n",
    "\n",
    "- `reshape(m, n, ...)`\n",
    "- `ravel()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6 7 8 9]\n",
      "(9,)\n",
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n",
      "(3, 3)\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(1, 10)\n",
    "print(arr)\n",
    "print(arr.shape)\n",
    "print(arr.reshape(3, 3))\n",
    "print(arr.reshape(3, 3).shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## It is more convenient to specify `-1` in one of the dimensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]]\n",
      "[[ 1  2  3]\n",
      " [ 4  5  6]\n",
      " [ 7  8  9]\n",
      " [10 11 12]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(1, 13)\n",
    "print(arr.reshape(3, -1))\n",
    "print(arr.reshape(-1, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Use `ravel()` method to convert n-dimensional arrays back to 1-dimensional"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 3)\n",
      "2\n",
      "(9,)\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(1, 10).reshape(3, -1)\n",
    "print(arr.shape)\n",
    "print(arr.ndim)\n",
    "print(arr.ravel().shape)\n",
    "print(arr.ravel().ndim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Broadcasting\n",
    "\n",
    "- An operation between an array and a single number.\n",
    "- An operation between arrays of two different sizes. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Two dimensions are compatible when\n",
    "\n",
    "- They are equal.\n",
    "- One of them is 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 4 6]\n",
      "[2 4 6]\n"
     ]
    }
   ],
   "source": [
    "arr_a = np.arange(1, 4)           # (3,)\n",
    "arr_b = np.ones(3, dtype=int) * 2 # (3,)\n",
    "b = 2\n",
    "print(arr_a * arr_b)\n",
    "print(arr_a * b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "operands could not be broadcast together with shapes (3,) (4,) \n"
     ]
    }
   ],
   "source": [
    "arr_a = np.arange(1, 4)           # (3,)\n",
    "arr_b = np.ones(4, dtype=int) * 2 # (4,)\n",
    "try:\n",
    "    print(arr_a * arr_b)\n",
    "except ValueError as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 4 6]\n",
      " [2 4 6]\n",
      " [2 4 6]\n",
      " [2 4 6]]\n"
     ]
    }
   ],
   "source": [
    "arr_a = np.arange(1, 4)                            # (3,)\n",
    "arr_b = (np.ones(4, dtype=int) * 2).reshape(-1, 1) # (4, 1)\n",
    "try:\n",
    "    print(arr_a * arr_b)\n",
    "except ValueError as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## The assignment of new object does not copy the array\n",
    "\n",
    "Instead, it creates a view for the original object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[   1    2    3]\n",
      " [   4 5566    6]\n",
      " [   7    8    9]]\n",
      "[   1    2    3    4 5566    6    7    8    9]\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(1, 10)\n",
    "mat = arr.reshape(3, 3)\n",
    "mat[1, 1] = 5566\n",
    "print(mat)\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Specify `copy()` to explicitly copy the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[   1    2    3]\n",
      " [   4 5566    6]\n",
      " [   7    8    9]]\n",
      "[1 2 3 4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(1, 10)\n",
    "mat = arr.copy()\n",
    "mat = mat.reshape(3, 3)\n",
    "mat[1, 1] = 5566\n",
    "print(mat)\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Use ` np.concatenate()`  function to combine arrays\n",
    "\n",
    "- `axis=0`, combining vertically in default.\n",
    "- `axis=1`, combining horizontally."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n",
      "[[5 6]\n",
      " [7 8]]\n"
     ]
    }
   ],
   "source": [
    "arr_a = np.arange(1, 5).reshape(2, 2)\n",
    "arr_b = np.arange(5, 9).reshape(2, 2)\n",
    "print(arr_a)\n",
    "print(arr_b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]\n",
      " [7 8]]\n",
      "[[1 2 5 6]\n",
      " [3 4 7 8]]\n"
     ]
    }
   ],
   "source": [
    "print(np.concatenate([arr_a, arr_b]))         # default, axis=0\n",
    "print(np.concatenate([arr_a, arr_b], axis=1)) # axis=1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Use ` np.split()`  function to split arrays\n",
    "\n",
    "- `axis=0`, splitting vertically in default.\n",
    "- `axis=1`, splitting horizontally."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n",
      "[[5 6]\n",
      " [7 8]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(1, 9).reshape(4, -1)\n",
    "upper_arr, lower_arr = np.split(arr, 2)\n",
    "print(upper_arr)\n",
    "print(lower_arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1]\n",
      " [3]\n",
      " [5]\n",
      " [7]]\n",
      "[[2]\n",
      " [4]\n",
      " [6]\n",
      " [8]]\n"
     ]
    }
   ],
   "source": [
    "left_arr, right_arr = np.split(arr, 2, axis=1)\n",
    "print(left_arr)\n",
    "print(right_arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1]\n",
      " [ 2  3]\n",
      " [ 4  5]\n",
      " [ 6  7]\n",
      " [ 8  9]\n",
      " [10 11]\n",
      " [12 13]]\n",
      "[[14 15]\n",
      " [16 17]\n",
      " [18 19]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(20).reshape(10, -1)\n",
    "upper_arr, lower_arr = np.split(arr, [7])\n",
    "print(upper_arr)\n",
    "print(lower_arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## NumPy functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## NumPy provides abundant functions for fast computations\n",
    "\n",
    "- Universal functions(ufuncs)\n",
    "- Aggregate functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## What is a universal function?\n",
    "\n",
    "> A vectorized wrapper for a function that takes a fixed number of specific inputs and produces a fixed number of specific outputs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n",
      "[ 0  1  4  9 16 25 36 49 64 81]\n"
     ]
    }
   ],
   "source": [
    "# np.power\n",
    "arr = np.arange(10)\n",
    "print(arr)\n",
    "print(np.power(arr, 2)) # arr**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.00000000e+00 2.71828183e+00 7.38905610e+00 2.00855369e+01\n",
      " 5.45981500e+01 1.48413159e+02 4.03428793e+02 1.09663316e+03\n",
      " 2.98095799e+03 8.10308393e+03]\n"
     ]
    }
   ],
   "source": [
    "# np.exp\n",
    "print(np.exp(arr))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1  2  3  4  5  6  7  8  9 10]\n",
      "[0.         0.69314718 1.09861229 1.38629436 1.60943791 1.79175947\n",
      " 1.94591015 2.07944154 2.19722458 2.30258509]\n"
     ]
    }
   ],
   "source": [
    "# np.log\n",
    "arr = np.arange(1, 11)\n",
    "print(arr)\n",
    "print(np.log(arr))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## NumPy offers a way to define ufuncs by ourselves\n",
    "\n",
    "Using `vectorize` to turn a scalar function into a universal function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5566"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# abs as a scalar function\n",
    "abs(-5566)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bad operand type for abs(): 'list'\n"
     ]
    }
   ],
   "source": [
    "# abs as a scalar function\n",
    "try:\n",
    "    lst = [-5, -5, -6, -6]\n",
    "    print(abs(lst))\n",
    "except TypeError as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.vectorize'>\n",
      "[5 5 6 6]\n"
     ]
    }
   ],
   "source": [
    "abs_ufunc = np.vectorize(abs)\n",
    "lst = [-5, -5, -6, -6]\n",
    "print(type(abs_ufunc))\n",
    "print(abs_ufunc(lst))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## What is an aggregate function?\n",
    "\n",
    "> A function where the values of multiple rows are grouped together to form a single summary value."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## There are 2 characteristics in NumPy's aggregate functions\n",
    "\n",
    "1. Aggregate along specific axis.\n",
    "2. Similar function names for array with Not a Number values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "120\n",
      "[18 21 24 27 30]\n",
      "[[15]\n",
      " [40]\n",
      " [65]]\n"
     ]
    }
   ],
   "source": [
    "# Aggregate along specific axis\n",
    "mat = np.arange(1, 16).reshape(3, 5)\n",
    "print(np.sum(mat))\n",
    "print(np.sum(mat, axis=0, keepdims=False)) # column sums\n",
    "print(np.sum(mat, axis=1, keepdims=True))  # row sums"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Not a Number(NaN) is a member of NumPy constants\n",
    "\n",
    "Source: <https://numpy.org/doc/stable/reference/constants.html>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(np.nan)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1.  2.  3.  4.  5.  6.  7.  8.  9. 10. 11. 12. 13. 14. nan]\n",
      "nan\n",
      "105.0\n"
     ]
    }
   ],
   "source": [
    "# Similar function names for array with Not a Number values\n",
    "arr = np.arange(1, 16, dtype=float)\n",
    "arr[-1] = np.nan\n",
    "print(arr)\n",
    "print(np.sum(arr))\n",
    "print(np.nansum(arr))"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python Fifty Plus",
   "language": "python",
   "name": "pythonfiftyplus"
  },
  "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}