notebooks/numpy_001.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "622ae026-9c45-46a6-8d5c-906dabb133ba",
   "metadata": {},
   "source": [
    "# 1. Creating NumPy Arrays\n",
    "\n",
    "Welcome to the first notebook in this crash course. Here, we will look at different ways to create NumPy arrays.\n",
    "\n",
    "Recall that a NumPy array is similar to a Python list. But it can only contain a single data type, and it is generally much more efficient to work with when handling large amounts of data.\n",
    "\n",
    "We start by importing NumPy under the alias `np` as is convention."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3e143fe2-0cc9-4a9e-a59d-71e903139c9c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "514aff10-30cb-4eb6-874a-29e03cd704a6",
   "metadata": {},
   "source": [
    "One way of creating a NumPy array is from a Python list using `np.array(list)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bb1f0959-8054-4deb-abe5-6d42aedd2ba6",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1, 2, 3]\n",
    "arr = np.array(a)\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f9789b2-a504-4508-ac96-d6e46008cb71",
   "metadata": {},
   "source": [
    "If you pass a list with mixed types to `np.array()`, you either get an error or NumPy will try to cast the values automatically to a single data type.\n",
    "\n",
    "We can force NumPy to convert (if necessary) to a specific type using the argument `dtype=`. We will learn more about `dtype` (data type) and casting in NumPy later in this notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9821463c-a3b8-4506-8cf5-c3dddcdbfe3a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# NumPy automatically casts every element to string type\n",
    "a = [\"1\", 2, 3]\n",
    "arr = np.array(a)\n",
    "print(arr)\n",
    "\n",
    "# Force 64-bit integer type for arr\n",
    "arr = np.array(a, dtype=np.int64)\n",
    "print(arr)\n",
    "\n",
    "# Force str type for arr\n",
    "arr = np.array(a, dtype=np.str_)\n",
    "print(arr)\n",
    "\n",
    "# Force 32-bit floating point type for arr\n",
    "arr = np.array(a, dtype=np.float32)\n",
    "print(arr)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "3740724e-08ee-4836-8553-efa4b4b8ad01",
   "metadata": {},
   "source": [
    "NumPy arrays can also be multidimensional. For example, we can create a 2-dimensional (or 2D) array `arr` storing the matrix $\\begin{pmatrix}1 & 2\\\\4 & 5\\end{pmatrix}$ as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "62fd2a4b-aed8-4ac5-93cc-044d87af58da",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.array([[1, 2],\n",
    "                [4, 5]])\n",
    "print(arr)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "96013437-844b-4ad7-b2f5-b0e170b740b6",
   "metadata": {},
   "source": [
    "To create an array containing only zeros, we use `np.zeros()`. The `shape` argument expects a tuple specifying the shape of the array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7471bed2-1d28-4aea-928f-64ca2257cd68",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr1 = np.zeros(2) # 1-dimensional array of length 2\n",
    "arr2 = np.zeros(shape=(3, 2)) # 3x2 matrix of zeros\n",
    "arr3 = np.zeros(shape=(2, 3, 2)) # A 3-dimensional 2x3x2 array\n",
    "\n",
    "print(f\"arr1 = \\n{arr1}\\n\")\n",
    "print(f\"arr2 = \\n{arr2}\\n\")\n",
    "print(f\"arr3 = \\n{arr3}\\n\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "26fe3064-ffb5-47c8-875d-126448faea88",
   "metadata": {},
   "source": [
    "Similarly, we can create a new array containing only ones using `np.ones()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3e3add0b-d626-43c1-950b-11ad1b2eff42",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr2 = np.ones(shape=(3, 2))\n",
    "print(arr2)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "899c3938-7330-457a-b9ac-5a7b74bfa6f7",
   "metadata": {},
   "source": [
    "The function `np.empty()` can be used to create an “empty” array. We do not know which values it will contain, as it just allocates memory for your array. \n",
    "\n",
    "It is only marginally faster than `np.zeros()` so consider using `np.zeros()` instead (unless you have a good reason to prefer `np.empty()`). "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "7eb7d541-3dcd-4294-a75f-6f1e4e3f008a",
   "metadata": {},
   "source": [
    "There is also a dedicated function `np.eye(n)` returning the $n\\times n$ identity matrix $I_n$ (ones on the diagonal, zeros everywhere else)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "779cf856-e102-4121-909c-a1af2c90a66a",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.eye(4) # 4x4 identity matrix\n",
    "print(arr)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "16677662-79c3-42ef-a052-3a721271c189",
   "metadata": {},
   "source": [
    "NumPy's `np.arange()` is similar to Python's `range()` function but returns a NumPy array instead of a Python list. It supports `start`, `stop` and `step` arguments just like Python's `range()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c0cb4f53-57b0-43c6-b0ff-6b672c7e2e8f",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr1 = np.arange(10)\n",
    "arr2 = np.arange(2, 7)\n",
    "arr3 = np.arange(1, 11, 2)\n",
    "arr4 = np.arange(5, 0, -1)\n",
    "\n",
    "print(f\"arr1 = {arr1}\")\n",
    "print(f\"arr2 = {arr2}\")\n",
    "print(f\"arr3 = {arr3}\")\n",
    "print(f\"arr4 = {arr4}\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "c155e8f2-49bb-4d89-b239-df446f070580",
   "metadata": {},
   "source": [
    "To create an evenly spaced 1-dimensional grid, we can use `np.linspace()`. For example, if we want a grid with $11$ points on the interval $[-1, 1]$, we simply call `np.linspace(-1, 1, 11)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "48e18f70-edd3-4f76-b3ee-cbd7f6849457",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.linspace(-1, 1, 11)\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27f54848-5c11-4718-addf-adadf8e422f7",
   "metadata": {},
   "source": [
    "One usecase for `np.linspace()` is when we want to evaluate a function on a grid."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "45885c0c-b0cd-4a17-a885-0032fa3bc042",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "X = np.linspace(-10, 10, 500) # Create 500 evenly spaced points on [-10, 10]\n",
    "Y = np.sin(X) + np.sin(2 * X) # Compute f(x) = sin(x) + sin(2*x) on all points\n",
    "\n",
    "# Plot the function f(x)\n",
    "plt.plot(X, Y)\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "eec66a50-bd23-4de8-969e-65b2a3bd6d8e",
   "metadata": {},
   "source": [
    "### Shape and data type\n",
    "\n",
    "Every NumPy array has the properties `shape` and `dtype` describing its shape (or size) and data type, respectively.\n",
    "\n",
    "Here is an example with a 1-dimensional integer array of length 3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8cebdc54-58c2-466f-867b-317cdba91394",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.array([1, 2, 3])\n",
    "\n",
    "print(arr)\n",
    "print(f\"dtype: {arr.dtype}\")\n",
    "print(f\"shape: {arr.shape}\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "8064a30d-e80f-4bf9-b8ef-b54996861a0a",
   "metadata": {},
   "source": [
    "Here is another example where we use `np.random.uniform()` to create a random NumPy array with shape $(2, 4, 3)$ sampled uniformly from the interval $[0, 1)$. \n",
    "\n",
    "You can read more about NumPy's random module [here (link)](https://numpy.org/doc/stable/reference/random/index.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7b73d91d-d89d-4833-9d66-174263f58f6b",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.random.uniform(size=(2, 4, 3)) # 2x4x3 array\n",
    "print(arr)\n",
    "print(f\"dtype: {arr.dtype}\")\n",
    "print(f\"shape: {arr.shape}\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "fe90f6b2-f1e3-4d43-ba00-51cb2c7a9163",
   "metadata": {},
   "source": [
    "NumPy arrays can also be of boolean and string types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cee19b08-eaab-4f59-b4dc-05d54577d10d",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr1 = np.array([[True, False], [False, False]])\n",
    "arr2 = np.array([[\"Hel\"], [\"lo\"], [\"wo\"], [\"rld\"]])\n",
    "\n",
    "print(\"arr1:\")\n",
    "print(arr1)\n",
    "print(f\"dtype: {arr1.dtype}\")\n",
    "print(f\"shape: {arr1.shape}\")\n",
    "\n",
    "print(\"\\narr2:\")\n",
    "print(arr2)\n",
    "print(f\"dtype: {arr2.dtype}\")\n",
    "print(f\"shape: {arr2.shape}\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "5133c325-823d-4e39-9987-1c6a80a94b09",
   "metadata": {},
   "source": [
    "By calling `len()` on a NumPy array, we get the size of the first dimension. In other words, `len(arr) == arr.shape[0]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4db1a1d3-e0d1-47b2-a9c0-8d3b6118c3e6",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.array([[1, 2], [3, 4], [5, 6], [7, 8]])\n",
    "print(arr.shape)\n",
    "print(arr.shape[0])\n",
    "print(len(arr))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "2cd5d9ea-2c8b-4bee-afde-d074be563db7",
   "metadata": {},
   "source": [
    "For more details about NumPy data types, see [here (link)](https://numpy.org/doc/stable/user/basics.types.html). To convert an array from one data type to another, one can use `arr.astype()`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "86a0b1b3-e54c-449d-a9d6-398bbc3ee5a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.array([\"2.1\", \"3.6\"])\n",
    "print(arr)\n",
    "\n",
    "arr = arr.astype(np.float64) # Cast to 64-bit floating point\n",
    "print(arr)\n",
    "\n",
    "arr = arr.astype(np.int64) # Cast to 64 (signed) integer\n",
    "print(arr)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "7eeb874e-be1e-4a8d-bb95-010e57b2b869",
   "metadata": {},
   "source": [
    "## Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59661e81-c28a-46d8-842e-751da9dae6e2",
   "metadata": {},
   "source": [
    "### 1. Array From List\n",
    "\n",
    "You are given two lists `temp_list_1` and `temp_list_2` of the average temperature of the last 8 days in two different cities. The first list contains floats and the other contains the temperatures as strings.\n",
    "\n",
    "Create two NumPy arrays of type `np.float64` named `temp_arr_1` and `temp_arr_2` from `temp_list_1` and `temp_list_2`, respectively.\n",
    "\n",
    "Note that since `temp_arr_2` contains strings, you will need to specify the `dtype=` argument when calling `np.array()`, or use `.astype()` after creating the array.\n",
    "\n",
    "Print the two arrays.\n",
    "\n",
    "**Comparing Arrays**\n",
    "\n",
    "Try running  `print(temp_arr_1 == temp_arr_2)` and notice that `temp_arr_1 == temp_arr_2` is a NumPy array of boolean type. What does this boolean array tell us?\n",
    "\n",
    "Furthermore, try to print the array we get from calling `np.where(temp_arr_1 == temp_arr_2)`. This will give us the indices where the two arrays have equal values!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78bdb9ce-af08-4ecc-be3e-8b41b2f9e124",
   "metadata": {},
   "outputs": [],
   "source": [
    "temp_list_1 = [20.3, 19.5, 24.1, 19.5, 16.2, 17.5, 20.8, 13.5]\n",
    "temp_list_2 = [\"16.2\", \"19.5\", \"16.1\", \"16.7\", \"16.2\", \"17.5\", \"14.4\", \"15.5\"]\n",
    "\n",
    "# Your code here\n",
    "temp_arr_1 = ...\n",
    "temp_arr_2 = ..."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "22d20fbe-12bd-4da5-9a3a-c7f2c21078b9",
   "metadata": {},
   "source": [
    "### 2. CSV Data to NumPy Array\n",
    "\n",
    "The variable `csv_content` contains comma separated CSV data with float values. The data has 3 rows and 4 columns.\n",
    "\n",
    "Convert `csv_content` to a NumPy array `arr` of shape `(3, 4)` with type `dtype=np.float64`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9732452c-e2ba-4f09-8dc0-fbeca0321511",
   "metadata": {},
   "outputs": [],
   "source": [
    "csv_content = \"1.5,2.2,7.5,0.1\\n1.2,7.0,8.9,7.5\\n5.5,9.9,9.5,3.4\"\n",
    "\n",
    "# Your code here\n",
    "arr = ...\n",
    "\n",
    "# Automatic tests:\n",
    "assert arr.shape == (3, 4), \"Wrong shape\"\n",
    "assert arr.dtype == np.float64, \"Wrong dtype\"\n",
    "assert (arr == np.array([[1.5, 2.2, 7.5, 0.1], [1.2, 7.,  8.9, 7.5], [5.5, 9.9, 9.5, 3.4]])).all(), \"Wrong value(s)\"\n",
    "print(\"All test passed!\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "1dcdfcaa-16bd-45b6-8e27-492b4887df68",
   "metadata": {},
   "source": [
    "### 3. Function Values on a Grid\n",
    "\n",
    "Use `np.linspace()` to create a grid `X` on $[0, 2\\pi]$ with $8$ evenly spaced points. NumPy provides $\\pi$ as a constant via `np.pi`.\n",
    "\n",
    "Apply `np.cos()` on `X` and store the result in a variable `Y`. Calling `np.cos(X)` will compute `cos(x)` element-wise on `X` and return an array of the same shape as `X`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2f454920-52c8-4b5d-95e7-e4f765608463",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code here\n",
    "X = ...\n",
    "Y = ...\n",
    "\n",
    "# Automatic tests:\n",
    "assert X.shape == Y.shape == (8,), \"Wrong shape\"\n",
    "assert X.dtype == Y.dtype == np.float_, \"Wrong dtype\"\n",
    "assert np.allclose(X, np.array([0.0, 0.8975979010256552, 1.7951958020513104, 2.6927937030769655, 3.5903916041026207, 4.487989505128276, 5.385587406153931, 6.283185307179586])), \"Wrong value(s) in X\"\n",
    "assert np.allclose(Y, np.array([1., 0.6234898, -0.22252093, -0.90096887, -0.90096887, -0.22252093, 0.6234898, 1.])), \"Wrong value(s) in Y\"\n",
    "print(\"All test passed!\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}