03_NumPy.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "colab": {
      "name": "03_NumPy.ipynb",
      "provenance": [],
      "toc_visible": true,
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/MMRES-PyBootcamp/MMRES-python-bootcamp2021/blob/master/03_NumPy.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H-qec1q_e75x"
      },
      "source": [
        "# 3 NumPy\n",
        "\n",
        "## Introduction\n",
        "\n",
        "After getting used to how Python works, it is the moment to begin getting our hands dirty with data analysis. We will study two packages: [NumPy](http://www.numpy.org/) and [Pandas](http://pandas.pydata.org/). NumPy is the fundamental numeric computing and linear algebra package in Python. We will learn it not only for the data analysis, but more importantly, because it will be a package that will be always present in our `import` section as scientists. In the next notebook, we will dive into Pandas. Pandas is a dedicated data analysis package with more functionalities than NumPy, making our life much easier in terms of data visualization and manipulation. \n",
        "\n",
        "Let us start importing the necessary packages."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JZbfI1L9e750"
      },
      "source": [
        "import numpy as np\n",
        "print('NumPy:', np.__version__)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EszZedIye751"
      },
      "source": [
        "## Numeric Python (NumPy)\n",
        "\n",
        "NumPy is an open-source add-on module to Python that provides common mathematical and numerical routines in pre-compiled, fast functions. These are growing into highly mature packages that provide functionalities that meets that\n",
        "associated with common commercial software like [MATLAB](https://www.mathworks.com/). The [NumPy](http://www.numpy.org/) (Numeric Python) package provides basic routines for manipulating large arrays and matrices of numerical data. With NumPy we will be working with *homogeneous multidimensional array* or, simply, **NumPy arrays**.\n",
        "\n",
        "We will now explore some capabilities of NumPy that will prove very useful not only for data analyisis, but for almost any Python application."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Sgy5vYMFe752"
      },
      "source": [
        "### Creating Arrays\n",
        "\n",
        "As mentioned before, the main object in NumPy is the *array*. Creating one is as easy as calling the command `array`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JCJrbnJoe752"
      },
      "source": [
        "# Create a list\n",
        "mylist = [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
        "\n",
        "# Create a numpy array from a list\n",
        "my1darr = np.array(mylist)\n",
        "\n",
        "# Data type of a numpy array\n",
        "print(type(my1darr))\n",
        "\n",
        "my1darr"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kE8Kv6WWe753"
      },
      "source": [
        "The same applies to multidimensional arrays"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7ARNZR_me753"
      },
      "source": [
        "# Create a numpy array with three elemets, with three elements each.\n",
        "my2darr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])\n",
        "my2darr"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gFq7T_AYe754"
      },
      "source": [
        "# Create a numpy array with three elemets, with three elements each, with a single element each\n",
        "my3darr = np.array([  [[1], [2], [3]], [[4], [5], [6]], [[7], [8], [9]]  ])\n",
        "my3darr"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WjOC0xlge755"
      },
      "source": [
        "A NumPy array has a number of dimensions (or *axes*). To obtain the number of axes and the size of each of them you use the command `shape`. For 2-dimensional arrays (matrices), the order corresponds to (rows, columns)\n",
        "\n",
        "There are two different ways of calling the `shape` command, either with `np.shape(arr)` or `arr.shape`. This is not the only command that works in both formats, and we will be finding some more in our way."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3RCrb7xFe756"
      },
      "source": [
        "# Shape using `.shape`\n",
        "print(my1darr.shape)\n",
        "print(my2darr.shape)\n",
        "print(my3darr.shape)\n",
        "\n",
        "# Shape using `np.shape()`\n",
        "print(np.shape(my1darr))\n",
        "print(np.shape(my2darr))\n",
        "print(np.shape(my3darr))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T9mvYKVQe756"
      },
      "source": [
        "There is one restriction with respect to the use of lists: while we can make lists containing any kind of data, all the data in a numpy array must be of the same type, and it is converted automatically."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xxVbOcAYe756"
      },
      "source": [
        "# Create a list with floats and strings\n",
        "lst = [1., 'cat']\n",
        "print(lst)\n",
        "\n",
        "# Create a numpy array from a list with mixed data types\n",
        "arr = np.array(lst)\n",
        "print(arr)\n",
        "\n",
        "# The data type of the 1. in the list is the same data type than the 1. in the array?\n",
        "print(f\"Type list = type array? {((lst[0])) == type((arr[0]))}\")\n",
        "print(f\"Type list: {type(lst[0])}\")\n",
        "print(f\"Type array: {type(arr[0])}\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PeBhkkbBe757"
      },
      "source": [
        "### Special Arrays\n",
        "\n",
        "There are some functionalities that allow us to create arrays filled with determined values. `ones` and `zeros` provide arrays of the given shape and type (default is float64), filled with ones or zeros, respectively."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Gn8GXq4se757"
      },
      "source": [
        "# Create a zero-filled numpy array of shape 3 x 2\n",
        "np.zeros((3, 2))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_0tqDheme758"
      },
      "source": [
        "# Create a one-filled numpy array of shape 3 x 2 x 4\n",
        "np.ones((3, 2, 4), dtype=np.int8)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mWB_xQJRe758"
      },
      "source": [
        "`eye(d)` returns a 2-D array, of size $d$ with ones in the diagonal and zeros elsewhere. It's an identity matrix."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BoMamZ4Ne758"
      },
      "source": [
        "# Create an numpy array of shape 3 x 3 with ones in the diagonal\n",
        "np.eye(3)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bnS3oxwBe758"
      },
      "source": [
        "`eye` can also make arrays with ones in upper and lower diagonals. To achieve this, you must call `eye(d, d, k)` where $k$ denotes the diagonal (positive for above the center diagonal, negative for below), or `eye(d, k=num)`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HKd4xhfze759"
      },
      "source": [
        "# Create an numpy array of shape 5 x 5 with ones in the diagonal shifted-up 2 positions\n",
        "print(np.eye(5, 5, 2))\n",
        "print('\\n')\n",
        "\n",
        "# Create an numpy array of shape 4 x 4 with ones in the diagonal shifted-down 1 position\n",
        "print(np.eye(4, k=-1))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lr-y04mAe759"
      },
      "source": [
        "`diag`, depending on the input, either constructs a diagonal array (if the input is a 1-D array) or extracts a diagonal from a matrix (if the input is a 2-D array)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k5g-9XNZe75-"
      },
      "source": [
        "# Create a 2-D array with the array `my1darr` shifted-up 1 position with respect the diagonal \n",
        "np.diag(my1darr, 1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ry51T2w1e75-"
      },
      "source": [
        "# The the diagonal from the 2-D array `my2darr`\n",
        "np.diag(my2darr)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GcWhE8RTe75-"
      },
      "source": [
        "# Create a 2-D array with the diagonal from the 2-D array `my2darr` shifted-down 1 position with respect the diagonal \n",
        "np.diag(np.diag(my2darr), -1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ysMwQLqBe75-"
      },
      "source": [
        "`arange(begin, end, step)` returns evenly spaced values within a given interval. Note that the beginning point is included, but not the ending."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Wv748BI8e75-"
      },
      "source": [
        "# Create range with start at 0, stop before 16\n",
        "myrange = np.arange(0, 16)\n",
        "myrange"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AscgRd_oe75_"
      },
      "source": [
        "**Exercise 1**: Create an array of the first million of odd numbers, both with `arange` and using loops. Try timing both methods to see which one is faster. Use the magic command `%timeit`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wEGJb1hie75_"
      },
      "source": [
        "%timeit np.arange(0, 2000000, 2)\n",
        "\n",
        "%timeit [i for i in range(2000000) if i % 2 == 0]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yRa9eYF_e75_"
      },
      "source": [
        "Similarly, `linspace(begin, end, points)` returns evenly spaced numbers over a specified interval. Here, instead of specifying the step, we provide the amount of points that we need. Beware that `linspace` includes the end of the interval!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YjZ-lyEle75_"
      },
      "source": [
        "# Create line with start at 0, stop at 14, with 8 evenly spaced points\n",
        "myline = np.linspace(0, 14, 8) # \n",
        "myline"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Lu0eeQNEe75_"
      },
      "source": [
        "`reshape` changes the shape of an array, but not its data. This is another of the commands that can be called before or after the array."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Mow776Hie75_"
      },
      "source": [
        "# Reshape `myrange` using `np.reshape()`\n",
        "print(np.reshape(myline, (2, 4)))\n",
        "\n",
        "print('\\n')\n",
        "\n",
        "# Reshape `myrange` using `.reshape()`\n",
        "print(myline.reshape(4, 2))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MLD7dllwe75_"
      },
      "source": [
        "Note that, however, this only provides a copy of the array. In order for them to be permanent we need to reasign the variable value."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v1tqeUFYe76A"
      },
      "source": [
        "# After the reshapings above, the original array stays being the same\n",
        "myline  "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SwORozYEe76A"
      },
      "source": [
        "new_line = myline.reshape(2, 4)\n",
        "new_line"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4mXQgMHUe76A"
      },
      "source": [
        "### Combining Arrays\n",
        "\n",
        "The most general command for combining arrays is `concatenate(arrs, d)`. It takes a list of arrays and concatenates them along axis $d$. Remember your 3-D array:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B4l13fMie76A"
      },
      "source": [
        "# Remember the `my2darr` 2-D numpy array\n",
        "print(my2darr)\n",
        "print(my2darr.shape)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XOdbaQoKe76A"
      },
      "source": [
        "# Concatenate `my2darr` with itsef multiplied by 10 along dimension 0\n",
        "conc_along0 = np.concatenate([my2darr, 10*my2darr], 0)\n",
        "print(conc_along0)\n",
        "print(conc_along0.shape)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e2WN-lpSe76A"
      },
      "source": [
        "# Concatenate `my2darr` with itsef multiplied by 10 along dimension 1\n",
        "conc_along1 = np.concatenate([my2darr, 10*my2darr], 1)\n",
        "print(conc_along1)\n",
        "print(conc_along1.shape)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AiX3vFQoe76A"
      },
      "source": [
        "However, for common combinations there are special commands. We can use `vstack` to stack arrays in sequence vertically (row wise) or `hstack` to stack arrays in sequence horizontally (column wise)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lfIS45vJe76A"
      },
      "source": [
        "# Stack `my2darr` vertically and horizontally\n",
        "print(np.vstack([my2darr, 10 * my2darr]))\n",
        "print('\\n')\n",
        "print(np.hstack([my2darr, 10 * my2darr]))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vKEFoQ6ke76B"
      },
      "source": [
        "### Operations\n",
        "\n",
        "We can perform element-wise operations on arrays of any shape."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "enZADVaVe76B"
      },
      "source": [
        "x_list = [1, 2, 3]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vpQ_NfFJe76B"
      },
      "source": [
        "x = np.array([1, 2, 3])\n",
        "\n",
        "print(x + 10)\n",
        "print(3 * x)\n",
        "print(1 / x)\n",
        "print(x ** (-2 / 3))\n",
        "print(2 ** x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_VCVQGCae76B"
      },
      "source": [
        "We can also operate between arrays, which must be of the same shape. If this is the case, they also do element-wise operations"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3RVbwFS2e76B"
      },
      "source": [
        "y = np.arange(4, 7, 1)\n",
        "print(x + y)     # [1+4, 2+5, 3+6]\n",
        "print(x * y)     # [1*4, 2*5, 3*6]\n",
        "print(x / y)     # [1/4, 2/5, 3/6]\n",
        "print(x ** y)    # [1**4, 2**5, 3**6]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iq_ItBgCe76B"
      },
      "source": [
        "For doing vector or matrix multiplication, the command to be used is `dot`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rlAHTYMye76B"
      },
      "source": [
        "print(x)\n",
        "print(y)\n",
        "x.dot(y)  # 1*4 + 2*5 + 3*6"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k_bjejqPe76C"
      },
      "source": [
        "With python 3.5 matrix multiplication got it's own operator"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pIjqTp1be76C"
      },
      "source": [
        "x @ y  # x.dot(y)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Plj2liSee76C"
      },
      "source": [
        "X = np.array([[i + j for i in range(3, 6)] for j in range(3)])\n",
        "Y = np.diag([1, 1], 1) + np.diag([1], -2)\n",
        "\n",
        "print(X)\n",
        "print('\\n')\n",
        "print(Y)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SYqHTg75e76C"
      },
      "source": [
        "The operator `*` returns the elements-wise multiplication of arrays with the same shape."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_AfWjlTve76C"
      },
      "source": [
        "X * Y"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WoMd7msae76C"
      },
      "source": [
        "The operator `@` returns the matrix product of arrays with compatible shapes."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q4dg0Cbee76C"
      },
      "source": [
        "X @ Y"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e-s4fUt3e76C"
      },
      "source": [
        "**Exercise 2**: Take a 10x2 matrix representing $(x1,x2)$ coordinates and transform them into polar coordinates $(r,\\theta)$.\n",
        "\n",
        "*Hint 1: the inverse transformation is given by $x1 = r\\cos\\theta$, $x2 = r\\sin\\theta$*\n",
        "\n",
        "*Hint 2: generate random numbers with the functions in numpy.random*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DinGN-nce76C"
      },
      "source": [
        "z = np.random.random((10, 2))\n",
        "x1, x2 = z[:, 0], z[:, 1]\n",
        "R = np.sqrt(x1 ** 2 + x2 ** 2)\n",
        "T = np.arctan2(x2, x1)\n",
        "print(R)\n",
        "print(T)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GBJqGo0pe76D"
      },
      "source": [
        "#### Transposing\n",
        "\n",
        "Transposition is a very important operation for linear algebra. Although NumPy is capable of correctly doing matrix-vector products regardless of the orientation of the vector, it is not the case for products of matrices."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9M7y6g4qe76D"
      },
      "source": [
        "Z = np.arange(0, 12, 1).reshape((4, 3))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-OLaeVMye76D"
      },
      "source": [
        "print(Z)\n",
        "print(y)\n",
        "Z @ y"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PeEo_G-Se76D"
      },
      "source": [
        "print(Z)\n",
        "print(y.T)\n",
        "Z @ y.T"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PyPIzu0Pe76D"
      },
      "source": [
        "print(Z)\n",
        "print(X)\n",
        "Z @ X  # (4 x 3) @ (3 x 3 cols) yields (4 x 3)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vbkioIufe76D"
      },
      "source": [
        "print(Z.T)\n",
        "print(X)\n",
        "Z.T @ X  # (3 x 4) @ (3 x 3) yields error"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "957z74Vee76D"
      },
      "source": [
        "#### Array Methods\n",
        "\n",
        "NumPy provides some functions to make operations with the elements of our arrays, similar to the list functionalities. In fact, NumPy provides more functionalities than standard Python."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aMHNYgoTe76D"
      },
      "source": [
        "a = np.array([-4, -2, 1, 3, 5])\n",
        "print(a.max())\n",
        "print(a.min())\n",
        "print(a.sum())\n",
        "print(a.mean())\n",
        "print(a.std())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Foch5FFTe76E"
      },
      "source": [
        "Some interesting functions are `argmax` and `argmin`, which return the index of the maximum and minimum values in the array."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Kiq66bwte76E"
      },
      "source": [
        "print(a.argmax())\n",
        "print(a.argmin())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G77gjfrse76E"
      },
      "source": [
        "### Indexing/Slicing\n",
        "\n",
        "We have already seen briefly that to access individual elements you use the bracket notation: `array[ax_0, ax_1, ...]`, where the `ax_i` denotes the coordinate in the `i`-th axis. Just like with lists, we can assign new values to existing elements."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V-sTc_85e76E"
      },
      "source": [
        "r = [4, 5, 6, 7]\n",
        "print(r[2])\n",
        "# Reassigning the value stored in index 0\n",
        "r[0] = 198\n",
        "r"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ennc6NQ9e76E"
      },
      "source": [
        "We can slice within an index using `:`, just like we have seen in lists. A second `:` can be used to indicate the step size. `array[start:stop:stepsize]`. If we do not provide any `start` and `stop`, the selection will go from the very beginning until the end of the array."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gUm1BCkUe76E"
      },
      "source": [
        "s = np.arange(13)**2\n",
        "print(s)\n",
        "\n",
        "# Slice from 2 to 10\n",
        "print(s[3:10])\n",
        "\n",
        "# Starting by index 2, until index 10, take one every 3 elements \n",
        "print(s[2:10:3])\n",
        "\n",
        "# Starting by index -5, until the end, pick every 2 elements\n",
        "print(s[-5::2])\n",
        "\n",
        "# Starting by index -5, until the end, pick every 2 elements backwards\n",
        "print(s[-5::-2])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h2tcvbwBe76E"
      },
      "source": [
        "The same applies to higher-dimensional arrays for every axis they have."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IhyoFupDe76E"
      },
      "source": [
        "r = np.arange(36).reshape((6, 6))\n",
        "r"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tSmgVxq-e76E"
      },
      "source": [
        "# Pick rows 2 to 5, and cols 1 to 3 (remember, row 5 and col 3 not included)\n",
        "r[2:5, 1:3]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c702eMGTe76F"
      },
      "source": [
        "We can select specific rows and columns, separated by commas"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e0JK5tY_e76F"
      },
      "source": [
        "# Pick rows 1, 3 and 4, and cols 1 to 3 (remember, col 3 not included)\n",
        "r[[1, 3, 4], 1:3]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HlRc2kzYe76F"
      },
      "source": [
        "A very useful tool is *boolean indexing*, where we apply a function, assignment... only to those elements of an array that satisfy some condition"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RURCblyCe76F"
      },
      "source": [
        "r[r > 30] = 30\n",
        "r"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U5YiuqbXe76F"
      },
      "source": [
        "**Exercise 3**: Create a random 1-dimensional array, and find which element is closest to 0.7"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NjEVwucfe76F"
      },
      "source": [
        "Z = np.random.uniform(0,1,100)\n",
        "z = 0.7\n",
        "m = Z[np.abs(Z - z).argmin()]\n",
        "print(m)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZCXFtc8ae76F"
      },
      "source": [
        "#### Copying Data\n",
        "\n",
        "**Be very careful with copying and modifying arrays in NumPy!** Defining variables as parts of others will only provide a pointer to the allocated memory. Let us start with an example: let us define `r2` as a slice of `r`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BNHZOLWpe76F"
      },
      "source": [
        "r2 = r[:3,:3]\n",
        "r2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b0LBlPtfe76F"
      },
      "source": [
        "And now let's set all its elements to zero"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MUTIonJ6e76F"
      },
      "source": [
        "r2[:] = 0\n",
        "r2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V38mH3r-e76G"
      },
      "source": [
        "If we now look at `r`, we see that it has also been changed!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tEhRwUKre76G"
      },
      "source": [
        "r"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7-yfBrT6e76G"
      },
      "source": [
        "The proper way of handling selections without modifying the original arrays is through the `copy` command."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9fRcrSk4e76G"
      },
      "source": [
        "r_copy = r.copy()\n",
        "r_copy"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8rbJ7Ya2e76G"
      },
      "source": [
        "Now we can safely modify `r_copy` without affecting `r`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZGKSHHbde76G"
      },
      "source": [
        "r_copy[:] = 10\n",
        "print(f'{r_copy}\\n')\n",
        "print(f'{r}')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Wld6_eEPe76G"
      },
      "source": [
        "### Iterating Over Arrays"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kIutx4lce76G"
      },
      "source": [
        "Finally, you can iterate over arrays in the same way as you iterate over lists"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VFcEfYYDe76G"
      },
      "source": [
        "test = np.random.randint(0, 10, (4,3))\n",
        "test"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XF_H-uDMe76H"
      },
      "source": [
        "By default, we iterate over the first index which, for 2D arrays, corresponds to the rows."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ytTwTJQte76H"
      },
      "source": [
        "for row in test:\n",
        "    print(row)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Nen65LG6e76H"
      },
      "source": [
        "Or by row index"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hfR_0B14e76H"
      },
      "source": [
        "for i in range(len(test)):\n",
        "    print(test[i])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uLnVnXU0e76H"
      },
      "source": [
        "Or by row and index:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c0Fimolze76H"
      },
      "source": [
        "for i, row in enumerate(test):\n",
        "    print(f'Row {i} is {row}')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qqEeNRf-e76H"
      },
      "source": [
        "In the same way as with lists, you can use `zip` to iterate over multiple iterables."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JXZz_vKTe76H"
      },
      "source": [
        "test2 = test**2\n",
        "test2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0RWBUDIoe76H"
      },
      "source": [
        "for i, j in zip(test, test2):\n",
        "    print(f'{i} + {j} = {i+j}')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-tA2eJrhe76I"
      },
      "source": [
        "**Exercise 4**: Create a function that iterates over the columns of a 2-dimensional array"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zGTjYm6Me76I"
      },
      "source": [
        "def iterate(df):\n",
        "    rows, cols = df.shape\n",
        "    for i in range(cols):\n",
        "        column = df[:, i]\n",
        "        print(f'Column {i} is {column}')\n",
        "\n",
        "iterate(test)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UlwmwODoe76I"
      },
      "source": [
        "### Loading and Saving Data\n",
        "\n",
        "To load and save data NumPy has the `loadtxt` and `savetxt` commands. However, they only work for two-dimensional arrays"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kJgi99Yle76I"
      },
      "source": [
        "np.savetxt('numpytest.txt', test)\n",
        "np.loadtxt('numpytest.txt')"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}