1-Array-Creation-Indexing-Slicing.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Array Creation, Indexing, and Slicing\r\n",
    "\r\n",
    "In numpy everything is centered around the `ndarray` object, which is usually called *array* for simplicity. To quote [the docs](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html), \"\\[a `ndarray`\\] object represents a multidimensional, homogeneous array of fixed-size items\". In many cases, a working analogy to an `ndarray` is a python `list` that has a fixed size and only contains similar items, e.g. all integers or all floats. In N dimensions the analogy is a nested lists of lists where each list on the same level of nesting has the same number of elements. In fact, it is possible to convert between a python list-of-lists and ndarrays. That said, under the hood there are some significant differences between a list or a ndarray and we will look at some of those differences later in this module.\r\n",
    "\r\n",
    "Given that we can convert between lists and ndarrays, let's look at some valid and invalid examples of lists that can be converted to arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a0 = 42\r\n",
    "a1 = [5, 7, 2, 59]\r\n",
    "a2 = [3, False, \"a text\"]\r\n",
    "a3 = [4.5, 99.3, 24]\r\n",
    "a4 = [[1, 0], [0, 1]]\r\n",
    "a5 = [[1, 0, 0], [1, 1], [0, 0, 1]]\r\n",
    "a6 = [[4]]\r\n",
    "a7 = [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 1\r\n",
    "\r\n",
    "Can you guess which of the above lists can be converted into `ndarray`'s?\r\n",
    "\r\n",
    "<details>\r\n",
    "<summary>Answers (click me to reveal)</summary>\r\n",
    "\r\n",
    "a0. Valid. While `a0` is not a list itself, numpy is clever enough to understand that this is a scalar.\r\n",
    "\r\n",
    "a1. Valid. `a1` is a typical example of a vector (1 dimensional array) that you will encounter frequently.\r\n",
    "\r\n",
    "a2. Invalid. The items are not of the same type.\r\n",
    "\r\n",
    "a3. Valid. Another example of a 1d-array.\r\n",
    "\r\n",
    "a4. Valid. A 2-dimensional array. This example represents a 2x2 identity matrix.\r\n",
    "\r\n",
    "a5. Invalid. `len(a5[1]) == 2`, however the length of the other nested lists is 3.\r\n",
    "\r\n",
    "a6. Valid. A 2-dimensional array with dimensions (1, 1), containing a single element. Note that this is different from a scalar.\r\n",
    "\r\n",
    "a7. Valid. A 3-dimensional array (sometimes called a rank-3 tensor) with dimensions (3, 2, 2)\r\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To create a `ndarray` from a given list, or any other valid sequence of sequence, numpy offers a convenience function called `array`. Calling it, will take a sequence of sequences of sequences ... of primitives as input, and return the ndarray object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "my_first_array = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "print(my_first_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An array object has several attributes that describe them. The most important ones are:\r\n",
    "\r\n",
    "- **shape**: A N-tuple containing the number of elements along each axis. In our list-of-lists analogy this is the length of each list at the respective nesting depth, e.g. if the shape is `(2, 3, 4)` then each list at depth 1 contains 3 elements. An array's shape is its most important attribute, and many problems you will encounter initially can be solved by investigating the shapes of each array involved.\r\n",
    "- **dtype**: The data type of each element in the array. In our list-of-lists analogy the dtype is the item's type at the deepest level of nesting, i.e., the type of the items of those lists, that don't contain lists themself. Typically, these are numeric types of which numpy offers a greater variety than python, e.g., `np.float32`, `np.uint8`, or `np.complex128` to name a few.\r\n",
    "- **ndim**: In numpy a single dimension is called *axis* and the total number of axis that span an array is called dimensionality. It is the nesting depth in our list-of-lists analogy, i.e., the dimensionality of an array is equal to the number of lists that need to be nested inside each other to represent the array as a list-of-lists. The dimensionality is sometimes called *rank*.\r\n",
    "\r\n",
    "Here is how to access these attributes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"my_first_array has ...\")\r\n",
    "print(f\"... a shape: {my_first_array.shape}\")\r\n",
    "print(f\"... a data type: {my_first_array.dtype}\")\r\n",
    "print(f\"... a dimensionality: {my_first_array.ndim}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Changing Shape, Axis Order, and Data Type\r\n",
    "\r\n",
    "Since an array has above mentioned properties, it makes sense to ask how they can be changed. For the attributes considered here, this can be done via\r\n",
    "\r\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_array = my_first_array.reshape((1, 6))\r\n",
    "print(new_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "which takes as input the shape (as a tuple) and returns an array of shape (1, 6). Note that the original array is *not* modified in this process. `new_array` will either be a copy of the original array, or - more likely - a `numpy.view` into `my_first_array`, which we will cover in section 4 of this module.\r\n",
    "\r\n",
    "A speciality of the `ndarray.reshape` method is that you are allowed to use a single `-1` in the tuple describing the new shape. The `-1` will be replaced with the appropriate number based on the size of the array (its total number of elements). For example the following is allowed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_array = my_first_array.reshape(3, -1)\r\n",
    "print(new_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To change the datatype of the array you can use `ndarray.astype` and numpy will try - to the extent possible - to convert between the requested types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_one = np.array([1, -2, -3, 4, 42])\r\n",
    "print(f\"Array One: {array_one}\")\r\n",
    "array_two = array_one.astype(np.float32)\r\n",
    "print(f\"Array One: {array_two}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When changing datatypes, you need to be mindful, because these operations come with all the pros and cons of using this particular datatype. This can lead to surprising results, which can introduce hard to debug issues in your code. Your code will still run without exception, but it will not produce the result that you might expect it will; for example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"Something is off here: {array_one.astype(np.uint32)}\")\r\n",
    "print(f\"or even more extreme after going back and forth: {array_one.astype(np.bool8).astype(int)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you need to create a new array of a specific data type, e.g., because you are working with images, their pixels intensities range from 0-255, and you want to save some memory, then you can do that directly  using the optional keyword argument `dtype=...` instad of calling `ndarray.dtype` on the resulting object. Most array creation functions (more on them below) support the `dtype` argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"The following is equivalent: {np.array([1, 2, 3], dtype=np.uint8)} and {np.array([1,2,3]).astype(np.uint8)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, it is possible to reorder the axis of an array and change an arrays dimensionality. We mainly cover this here for completeness, and you will re-encounter this in section 3. To do so you can use\r\n",
    "\r\n",
    "1. [`np.expand_dims`](https://numpy.org/doc/stable/reference/generated/numpy.expand_dims.html)\r\n",
    "2. [`np.moveaxis`](https://numpy.org/doc/stable/reference/generated/numpy.moveaxis.html)\r\n",
    "\r\n",
    "This allow you to perform operations like"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "some_array = np.array([x for x in range(3*3*4*5)]).reshape((3, 3, 4, 5))\r\n",
    "new_array = np.expand_dims(some_array, (2))\r\n",
    "print(f\"Comparing the dimensions: {some_array.ndim} vs {new_array.ndim}\")\r\n",
    "print(f\"... also the shapes: {some_array.shape} vs {new_array.shape}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "reordered = np.moveaxis(new_array, (0, 1), (1, 2))\r\n",
    "print(f\"Reordered axes: {reordered.shape}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In practice, you will not need the above explicit form often. Instead of moving axes, many functions in the numpy API allow you to specify `axis=...`, which controls the axis along which the function operates, and instead of using `np.expand_dims`, you can also use `ndarray.reshape`. For example, you can achieve the above by inserting a clever `1` into the shape tuple via"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"The following is equivalent: {new_array.shape} and {some_array.reshape((3, 3, 1, 4, 5)).shape}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 2\r\n",
    "\r\n",
    "In the cell below the next one, write code that changes the shape, dtype, and/or dimensionality of the arrays found below.\r\n",
    "\r\n",
    "1. Turn `a0` into an array of double precision floating point numbers with shape (5, 5).\r\n",
    "2. Turn `a1` into a 1-dimensional boolean array.\r\n",
    "3. `a2` should have `shape=(?, 1, 2)`.\r\n",
    "\r\n",
    "**Note:** A `?` in the shape is commonly found in tensorflow error messages (we will cover tensorflow in lab 2) and means that the dimension must exist and may have length > 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a0 = np.array([x for x in range(25)])\r\n",
    "a1 = np.array([[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]])\r\n",
    "a2 = np.array([x for x in range(42)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\r\n",
    "<summary>Answers (click me to reveal)</summary>\r\n",
    "\r\n",
    "There are multiple solutions for each problem. Below are some equivalent ones.\r\n",
    "\r\n",
    "Answer for 1.\r\n",
    "\r\n",
    "```\r\n",
    "a0.reshape((5,5)).astype(np.double)\r\n",
    "a0.reshape((5,5)).astype(np.float64)\r\n",
    "a0.astype(np.float64).reshape((5,5))\r\n",
    "```\r\n",
    "\r\n",
    "Answer for 2. (a1)\r\n",
    "```\r\n",
    "a1.reshape(-1)\r\n",
    "a1.ravel()\r\n",
    "a1.flatten()\r\n",
    "```\r\n",
    "**Note**: `ravel()` and `flatten()` have not been introduced yet, but produce the same result as `reshape(-1)`. While `ravel()` and `reshape(-1)` are equivalent (from the user's perspective), `flatten()` will always copy the array. It is important to keep this in mind, because it can have (significant) performance implications.\r\n",
    "\r\n",
    "\r\n",
    "Answer for 3. (a2)\r\n",
    "```\r\n",
    "a2.reshape((-1, 1, 2))\r\n",
    "\r\n",
    "# solution 2\r\n",
    "a2 = a2.reshape((-1, 2))\r\n",
    "a2 = a2.expand_dims(a2, 1)\r\n",
    "```\r\n",
    "\r\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Array Creation\r\n",
    "\r\n",
    "On top of creating arrays from a python list (of lists), numpy offers several functions to create specialized arrays. These functions are more readable, and tend to be more efficient than creating the list-of-lists equivalent. For example `foo = np.ones((3, 4, 5))` will create an array filled with ones with `foo.shape == (3, 4, 5)`. We will cover some of these creation methods below and it is generally advisable to use them if possible. Additionally, many 3d-party libraries offer their own methods of creating specialized numpy arrays. For example, the library [imageio](https://github.com/imageio/imageio) allows you to load image data (from almost 200 different formats) as `ndarray`s.\r\n",
    "\r\n",
    "Numpy's array creation functions (Full List): [https://numpy.org/doc/stable/reference/routines.array-creation.html](https://numpy.org/doc/stable/reference/routines.array-creation.html)\r\n",
    "\r\n",
    "Commonly used array creation functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from a list of lists (or other nested sequences)\r\n",
    "a0 = np.array([[1, 2], [3, 4]]) \r\n",
    "\r\n",
    "# from other arrays\r\n",
    "a1 = np.asarray(a0)             # like np.array but tries to avoid copying data if possible\r\n",
    "a2 = np.copy(a0)                # creates a copy of an existing array\r\n",
    "\r\n",
    "# filled with constant values\r\n",
    "shape = (3, 4)\r\n",
    "a3 = np.ones(shape)\r\n",
    "a4 = np.zeros(shape)\r\n",
    "a5 = np.full(shape, 42)\r\n",
    "\r\n",
    "# filled with constant values, matching another array\r\n",
    "a6 = np.ones_like(a0)\r\n",
    "a7 = np.zeros_like(a0)\r\n",
    "a8 = np.full_like(a0, 42)\r\n",
    "\r\n",
    "# numeric ranges\r\n",
    "a9 = np.arange(start=1, stop=5, step=1)    # [1, 2, 3, 4]\r\n",
    "a10 = np.linspace(start=0, stop=1, num=50)  # 50 evenly spaced numbers from 0 to 1\r\n",
    "\r\n",
    "# special matrix creation functions\r\n",
    "a11 = np.eye(3)          # identity matrix\r\n",
    "a12 = np.diag([2, 3, 4]) # matrix with diagonal elements set to 2, 3, 4\r\n",
    "a13 = np.tri(5)          # 5x5 matrix with 1 on lower triangle and 0 elsewhere"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 3\r\n",
    "\r\n",
    "Which special function can be used to create the following arrays given as lists of lists?\r\n",
    "\r\n",
    "**Note**: This is a great opportunity to familiarize yourself with the [relevant parts](https://numpy.org/doc/stable/reference/routines.array-creation.html) of the libraries documentation (which is generally very excellent). Part 2 and part 4 require you to use additional parameters of the function, which you can read about in the docs.\r\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lists = {\r\n",
    "    \"1.\": [3, 5, 7, 9, 11, 13],\r\n",
    "    \"2.\": [[1., 0., 0., 0.],\r\n",
    "           [1., 1., 0., 0.],\r\n",
    "           [1., 1., 1., 0.]],\r\n",
    "    \"3.\": [[0., 0., 0., 0.],\r\n",
    "           [0., 0., 0., 0.],\r\n",
    "           [0., 0., 0., 0.]],\r\n",
    "    \"4.\": [[ 0.  , 10.  ],\r\n",
    "           [ 0.25,  9.75],\r\n",
    "           [ 0.5 ,  9.5 ],\r\n",
    "           [ 0.75,  9.25],\r\n",
    "           [ 1.  ,  9.  ]],\r\n",
    "    \"5.\": [[1, 0, 0, 0],\r\n",
    "           [0, 3, 0, 0],\r\n",
    "           [0, 0, 3, 0],\r\n",
    "           [0, 0, 0, 7]]\r\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\r\n",
    "<summary>Answers (click me to reveal)</summary>\r\n",
    "\r\n",
    "1. np.arange(3, 15, 2)\r\n",
    "2. np.tri(3, 1)\r\n",
    "3. np.zeros((3, 4))\r\n",
    "4. np.linspace((0, 10), (1, 9), 5)\r\n",
    "5. np.diag([1, 3, 3, 7])\r\n",
    "\r\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 4\r\n",
    "\r\n",
    "Create the following arrays using special functions and methods for changing shape and datatype introduced above.\r\n",
    "\r\n",
    "**Note**: The first one is a pattern you will see very regularly. It is particularily useful when debugging code that reorganizes the array in some way (`np.moveaxis` or `ndarray.reshape`), because it allows you to more easily track what happens."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lists = {\r\n",
    "    \"1.\": [[0, 1, 2],\r\n",
    "           [3, 4, 5],\r\n",
    "           [6, 7, 8]],\r\n",
    "    \"2.\": [[ True, False, False],\r\n",
    "           [ True,  True, False],\r\n",
    "           [ True,  True,  True],\r\n",
    "           [ True,  True,  True]],\r\n",
    "    \"3.\": [0, 0, 1]\r\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\r\n",
    "<summary>Answers (click me to reveal)</summary>\r\n",
    "\r\n",
    "1. np.arange(9).reshape(3,3)\r\n",
    "2. np.tri(4, 3, dtype=bool)\r\n",
    "3. np.linspace(0, 1, 3).astype(int)\r\n",
    "\r\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Intexing and Slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creating an array is usually just the first step. In most cases, we want to do something with it and the most basic thing we can do is access individual elements or segments of the array. Just like our lists of lists, `ndarray` supports indexing using integers and `slice(start, end, step)` objects (you probably know slices in their shorthand form `start:end:step`, e.g. `some_list[4:6]`). The syntax that you know - \r\n",
    "and expect - from lists carries over."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "some_array = np.arange(16).reshape(4, 4)\r\n",
    "print(some_array)\r\n",
    "print(f\"Access single element at (2, 2): {some_array[2][2]}\")\r\n",
    "print(f\"Access single element at (3, 1): {some_array[3][1]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you may have noticed, the indexing follows the same method you may be used to from matrix calculus. the first dimension goes along the columns of the matrix, and the second index goes along the rows. Since it is so common to select elements (and ranges) along multiple dimensions, a `ndarray` also supports so-called tuple-indexing. This allows you to omit some of the brackets and instead use a tuple of the same length as the dimensions to access the elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"Access single element at (2, 2): {some_array[2, 2]}\")\r\n",
    "print(f\"Access single element at (3, 1): {some_array[3, 1]}\")\r\n",
    "print(f\"Access range at (3, 1): {some_array[3, :3]}\")\r\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuple-indexing is more general (and more efficient) than the list-of-list style demonstrated above, because it allows us to easily select sub-matrices of the array. It is often easier and less error-prone to stick to tuple-style indexing, because unexpected things can happen when using the traditional list-of-list style indexing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"Access top left corner w/o tuple-indexing:\\n {some_array[:2][:2]}\")\r\n",
    "print(f\"Access top left corner w/ tuple-indexing:\\n {some_array[:2, :2]}\")\r\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 5\r\n",
    "\r\n",
    "Why does the list-of-list style index produce a new array with shape (2, 4) instead of the expected (2, 2) array?\r\n",
    "\r\n",
    "<details>\r\n",
    "<summary>Answers (click me to reveal)</summary>\r\n",
    "\r\n",
    "The tuple-style index uses a single tuple to describe the section of the array we wish to return. The list-of-lists style index gets executed as two separate calls (just like an actual list-of-lists). The first call takes the original array and returns a new array that consists of the first two elements of the original array ([[0 1 2 3], [4 5 6 7]]). The second call takes the new (2-dimensional) array and, again, returns the first two elements along the first dimension. This is exactly the previous array ([[0 1 2 3], [4 5 6 7]]).\r\n",
    "\r\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While not being a unique feature of tuple-indexing pre se, you will see the empty slice (`slice(None, None, None)` or `:` for short) much more frequently here than in pure list indexing. \r\n",
    "\r\n",
    "In addition to this, numpy also offers `np.newaxis` as valid index. Its alias is `None` and in fact `(np.newaxis is None) == True`. As the name suggests, it will add a new axis at the desired location analogous to `np.expand_dims`, and is yet another way to add dimensions to an array; similar to using `1` in the shape-tuple of `ndarray.reshape`. This may sound unnecessary at first glance, but will become clear and increadibly useful in section 3 when we talk about array broadcasting.\r\n",
    "\r\n",
    "Finally, there is the `Ellipsis` object `...`. This is a very funny object, and was introduced into python specifically for numpy use. Outside of numpy it doesn't have a lot of uptake; however, inside of numpy, and in particular in tuple-indexing, it can be used to refer to \"everything that hasn't been mentioned explicitly\". This is particularly useful in machine learning while working on batched data. For example, you may have a batch of images that are stacked into a 4 dimensional array in the form of `(batch, height, width, colors)`. With an ellipsis accessing the second image becomes `image_batch[1, ...]`.\r\n",
    "\r\n",
    "Let's look at some examples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "some_array = np.arange(25).reshape(5, 5)\r\n",
    "print(some_array)\r\n",
    "print(f\"Access a specific column:\\n {some_array[3, :]}\")\r\n",
    "print(f\"Access a specific row:\\n {some_array[:, 3]}\")\r\n",
    "print(f\"Select a local area around (2,3) and add a dimension:\\n {some_array[None, 1:4, 2:5]}\")\r\n",
    "\r\n",
    "ellipsis_example = np.arange(3*4*4).reshape(3,4,4)\r\n",
    "print(f\"Select the last matrix in a (2d) stack of matrices\\n {ellipsis_example[2, :, :]}\")\r\n",
    "print(f\"Do the same with an ellipsis\\n {ellipsis_example[2, ...]}\")\r\n",
    "print(f\"Works along other axes, too \\n {ellipsis_example[..., 3]}\")\r\n",
    "print(f\"And can be combined with all the other index options \\n {ellipsis_example[:-2, None, ..., 3]}\")  # here the use of ... or : are equivalent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 6\r\n",
    "\r\n",
    "Given the arrays in the cell below, extract the requested sub-arrays.\r\n",
    "\r\n",
    "1. Reverse `a0`.\r\n",
    "2. Extract a 3x3 neighborhood around the element at index (3, 7) of `a1`.\r\n",
    "2. The 2x4 sub-matrix that has the value 52 in it's bottom right corner of `a1`.\r\n",
    "3. Remove the first and last element along each dimension of `a1`. Example: `[[1, 2, 3], [4, 5, 6], [7, 8, 9]]` --> `5`\r\n",
    "4. Extract the array with the largest number of ones inside of `a2`.\r\n",
    "5. The element/cell with value `2` of `a3`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a0 = np.arange(22)\r\n",
    "a1 = np.arange(81).reshape(9,9)\r\n",
    "a2 = np.tri(11)\r\n",
    "a3 = np.array([0, 1, 2, 3]).reshape(2, *(1 for _ in range(21)), 2)\r\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\r\n",
    "<summary>Answers (click me to reveal)</summary>\r\n",
    "1. `a0[::-1]`\r\n",
    "1. `a1[2:5, 6:9]` or `a1[2:5, 6:]`\r\n",
    "2. `a1[4:6, 5:8]`\r\n",
    "3. `a1[1:-1, 1:-1]`\r\n",
    "4. `a2[5:, :6]`\r\n",
    "5. `a3[1, ..., 0]`\r\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we can also set specific elements of an array by indexing it similar to how it works in the list-of-lists example. Again we get tuple-indexing support; however, this time we can not use `None`/`np.newaxis`. If we index a range of elements and assign values to them, then all the values in this sub array are set. One way to utilize this is to assign an array to the selected range, or - forshaddowing broadcasting - to set all elements to the same value using a scalar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "some_array = np.arange(3*3).reshape(3,3)\r\n",
    "print(f\"The original array {some_array}\")\r\n",
    "\r\n",
    "# a simple assignment on a single cell\r\n",
    "some_array[1, 1] = 42\r\n",
    "print(f\"Setting a single element\\n {some_array}\")\r\n",
    "\r\n",
    "some_array[1, :] = [31, 21, 11]\r\n",
    "print(f\"Setting an entire row:\\n {some_array}\")\r\n",
    "\r\n",
    "some_array[1:, ...] = 18\r\n",
    "print(f\"Setting a region to a constant value: \\n {some_array}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 7\r\n",
    "\r\n",
    "Create the following arrays using only functions introduced in this notebook, without using `np.array(...)`.\r\n",
    "\r\n",
    "1. Create a null vector of size 10 but the fifth value which is 1.\r\n",
    "2. Create a 2d array with 1 on the border and 0 inside.\r\n",
    "3. Create a 8x8 matrix and fill it with a checkerboard pattern of 1 and 0.\r\n",
    "4. Create a 4x4 matrix where the two non-overlapping 2x2 blocks along the diagonal have different values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\r\n",
    "<summary>Answers (click me to reveal)</summary>\r\n",
    "\r\n",
    "Exercise 7.1\r\n",
    "```\r\n",
    "vector = np.zeros(10)\r\n",
    "vector[4] = 1\r\n",
    "```\r\n",
    "\r\n",
    "Exercise 7.2\r\n",
    "```\r\n",
    "matrix = np.ones((10,10))\r\n",
    "matrix[1:-1,1:-1] = 0\r\n",
    "```\r\n",
    "\r\n",
    "Exercise 7.3\r\n",
    "```\r\n",
    "matrix = np.zeros((8,8))\r\n",
    "matrix[1::2, ::2] = 1\r\n",
    "matrix[::2, 1::2] = 1\r\n",
    "```\r\n",
    "\r\n",
    "Exercize 7.4\r\n",
    "```\r\n",
    "matrix = np.zeros((4,4))\r\n",
    "matrix[:2, :2] = 3\r\n",
    "matrix[2:, 2:] = 7\r\n",
    "```\r\n",
    "\r\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Final Exercise\r\n",
    "\r\n",
    "Combine what you have learned, and - using only functions from this notebook (except for `np.array()`) - create the following array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[[ 1.,  0.,  0.,  0.,  8.,  0.,  0.,  0.,  0.],\r\n",
    " [ 1.,  1.,  0.,  0.,  7.,  0.,  0.,  0.,  0.],\r\n",
    " [ 1.,  1.,  1.,  0.,  6.,  0.,  0.,  0.,  0.],\r\n",
    " [ 1.,  1.,  1.,  1.,  5.,  0.,  0.,  0.,  0.],\r\n",
    " [ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.],\r\n",
    " [42., 42., 42., 42.,  3.,  5.,  0.,  0.,  0.],\r\n",
    " [42., -2., -2., 42.,  2.,  0.,  6.,  0.,  0.],\r\n",
    " [42., -2., -2., 42.,  1.,  0.,  0.,  7.,  0.],\r\n",
    " [42., 42., 42., 42.,  0.,  0.,  0.,  0.,  8.]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\r\n",
    "<summary>Answers (click me to reveal)</summary>\r\n",
    "\r\n",
    "```\r\n",
    "some_array = np.diag(np.arange(9)).astype(np.float32)\r\n",
    "some_array[5:, :4] = 42\r\n",
    "some_array[6:-1, 1:3] = -2\r\n",
    "some_array[:4, :4] = np.tri(4)\r\n",
    "some_array[4] = np.arange(9)\r\n",
    "some_array[:, 4] = np.arange(9)[::-1]\r\n",
    "```\r\n",
    "</details>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.8.8 64-bit",
   "name": "python388jvsc74a57bd05d69d85edf19066ea65ec45e9305decd722722c415050988d8ca48a84314af7c"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  },
  "orig_nbformat": 2
 },
 "nbformat": 4,
 "nbformat_minor": 2
}