08-numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8.Numpy - N Array\n",
    "NumPy is a Python library used for working with multi-dimensional arrays. The code within the `numpy` module allows us to manipulate large quantities of numerical values in complex arrangements, which is very useful when dealing with large quantity of data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is an example of 2 dimensinal python lifst\n",
    "two_dim_list = [\n",
    "    [1,2,3,4],\n",
    "    [5,6,7,8],\n",
    "    [9,10,11,12],\n",
    "    [13,14,15,16]\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for row in two_dim_list:\n",
    "    print(\"new row:\",row)\n",
    "    for element in row:\n",
    "        print(element)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a= two_dim_list[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "two_dim_list[0][2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list1 = [1,2,3,4,5]\n",
    "list1[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can print each row of the list\n",
    "print(\"row 1:\", two_dim_list[0])\n",
    "print(\"row 2:\", two_dim_list[1])\n",
    "print(\"row 3:\", two_dim_list[2])\n",
    "print(\"row 4:\", two_dim_list[3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the `numpy` module, we can use the `array` function provided by this module to turn our \"list of lists\" into a **numpy array**:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Aliasing Modules using \"import as\" Statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#import numpy using alias np\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The following create an numpy array\n",
    "\n",
    "my_array = np.array(two_dim_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Printing type of arr object\n",
    "print(\"Array is of type: \", type(my_array))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Printing array dimensions (axes)\n",
    "print(\"No. of dimensions: \", my_array.ndim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Printing shape of array\n",
    "print(\"Shape of array: \", my_array.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Printing size (total number of elements) of array\n",
    "print(\"Size of array: \", my_array.size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Printing data type of elements in array\n",
    "print(\"Array stores elements of type: \", my_array.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " type a `.` after the name of the object and hit the `Tab` key to see the attributes and methods contained within this object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Array indexing and Slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.array([1, 2, 3, 4, 5, 6])\n",
    "\n",
    "arr.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr[0] # Get the first element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr[-1] # Last element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr[1:3] # slicing start:stop(exclude)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr[:3] # First 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Indexing in 2D array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print an array\n",
    "my_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# printing selected element in numpy array\n",
    "print(\"first row, first column:\", my_array[0,0])\n",
    "print(\"first second, forth column:\", my_array[1,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "using a colon (`:`) for the column index means that we want \"all the columns\" for the specified row, and using it for the row index implies that we want \"all the rows\"  for the specified column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"the first row:\")\n",
    "print(my_array[0,:])\n",
    "print(\"the first column:\")\n",
    "print(my_array[:,0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_array "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:red;font-weight:bold\">Try It</span>\n",
    ": Using the special `:` syntax above, print the fourth column of `my_array`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data types in Numpy\n",
    "\n",
    "Below is a list of all data types in NumPy and the characters used to represent them.\n",
    "\n",
    "i - integer   \n",
    "b - boolean  \n",
    "u - unsigned integer  \n",
    "f - float  \n",
    "c - complex float  \n",
    "m - timedelta  \n",
    "M - datetime  \n",
    "O - object  \n",
    "S - string  \n",
    "U - unicode string  \n",
    "V - fixed chunk of memory for other type ( void )  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Change data type to float\n",
    "arr2 = arr.astype('f')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Iterating Arrays\n",
    "\n",
    "The first **for** loops through the *rows* of the **my_array**, while the second **for** loops the individual *elements* of each row. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "two_d_array = np.array([\n",
    "    [1,2,3,4],\n",
    "    [5,6,7,8],\n",
    "    [9,10,11,12],\n",
    "    [13,14,15,16]\n",
    "])\n",
    "for row in two_d_array:\n",
    "    print(\"new row:\",row)\n",
    "    for element in row:\n",
    "        print(element)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1,2,3,4]\n",
    "\n",
    "for i in a:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:blue;font-weight:bold\">Exercise</span>: Write a function called **count_ones** that accepts an array called **arr_1** as argument. The function should returns the total number of **ones** in the array. For example, if you use the following array as input argument: \n",
    "\n",
    "```\n",
    "[[1,2,1,4],\n",
    " [5,1,5,1],\n",
    " [1,8,1,1]]\n",
    "```\n",
    "the function should return 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# YOUR CODE HERE\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample_array = np.array([\n",
    "    [1,2,1,4],\n",
    "    [5,1,5,1],\n",
    "    [1,8,1,1]\n",
    "])\n",
    "print(count_ones(sample_array))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numpy functions\n",
    "use `np.zeros` to create an array filled with zeros, which is often a useful initial condition for our programs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "five_zeros = np.zeros(5)\n",
    "print(five_zeros)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5 by6 zeros\n",
    "five_by_six = np.zeros((5,6))\n",
    "print(five_by_six)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.ones((3,4))\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = np.eye(5)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Evenly round to the given number of decimals.\n",
    "\n",
    "np.around([.5, 1.5, 2.5, 3.5, 4.5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Arange function\n",
    "You may use the `np.arange` function to construct arrays that span a particular numerical range:\n",
    "<br>\n",
    "np.arange(0,30,2)\n",
    "1. The *start* number: `0`\n",
    "2. The *end* number (will not be included in the output): `30`\n",
    "3. The *step* by which to increment at each position: `2`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  np.arrange(start, stop,step) \n",
    "\n",
    "range_arr = np.arange(0,30,2)\n",
    "print(range_arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_array = np.arange(0,15)\n",
    "my_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mathematical Operations on Numpy Arrays\n",
    "You can use exponential function $e^x$ to every element of an array at once using the `np.exp` function call:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_array = np.array([0,1,2])\n",
    "np.exp(num_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multiplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# input_array \n",
    "list1 = [2, 2, 2, 2, 2] \n",
    "list2 = [2, 3, 4, 5, 6] \n",
    "\n",
    "# Convert list1 into a NumPy array\n",
    "a1 = np.array(list1)\n",
    " \n",
    "# Convert list2 into a NumPy array\n",
    "a2 = np.array(list2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a1*a2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numpy Power\n",
    "Array element from first array is raised to the power of element from second array(all happens element-wise)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "  \n",
    "# output_array \n",
    "np.power(first_arr, second_arr) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " You may find the `mean`, `min` and `max` of a given array. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "two_by_five = [\n",
    "    [1,2,3,4,5],\n",
    "    [6,7,8,9,10],\n",
    "]\n",
    "print(np.mean(two_by_five))\n",
    "print(np.min(two_by_five))\n",
    "print(np.max(two_by_five))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  numpy mean, axis = 0 means along the column and axis = 1 means working along the row.\n",
    "print(np.mean(two_by_five,axis=0))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reshape Arrays\n",
    "\n",
    "We change the number of row/column using the built in **reshape** function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr.reshape(2,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr.reshape(3,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.array([\n",
    "    [1,2,3,4],\n",
    "    [5,5,6,4],\n",
    "    [7,7,9,10]\n",
    "])\n",
    "\n",
    "# One shape dimension can be -1 (unknown dimension). It means numpy will figure this by looking at the \n",
    "#'length of the array and remaining dimensions'.\n",
    "reshaped_arr = arr.reshape(-1,2)\n",
    "print(reshaped_arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "reshaped_arr = arr.reshape(10,2)\n",
    "print(reshaped_arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for a simple row array\n",
    "row_array = np.array([1,2,3,3,4,5,6,7])\n",
    "print(row_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can convert it to a column array\n",
    "col_array = row_array.reshape(-1,1)\n",
    "print(col_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# use np.arrange to generate array of 0-9\n",
    "np.arange(0, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:blue;font-weight:bold\">Exercise</span>:\n",
    "\n",
    "Convert following 1D array with 10 elements to 2D array with 5 rows 2 columns:\n",
    "\n",
    "arr_10 = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:blue;font-weight:bold\">Exercise</span>: Define a function called **build_range_arr** that accepts 4 numeric arguments: **start**,**end**,**n_rows**, and **n_cols**. The function should return a numpy array that contains the numbers ranging from **start** to **end** (excluding the last numeric value-**end**), with **n_rows** number of rows, **n_cols** number of columns.  \n",
    "\n",
    "For example, **build_range_arr(1,13,4,3)**, should return the following numpy array:\n",
    "\n",
    "```\n",
    "array([[ 1,  2,  3],\n",
    "       [ 4,  5,  6],\n",
    "       [ 7,  8,  9],\n",
    "       [10, 11, 12]])\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# YOUR CODE HERE\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "build_range_arr(1,13,4,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.9.9"
  },
  "vscode": {
   "interpreter": {
    "hash": "26de051ba29f2982a8de78e945f0abaf191376122a1563185a90213a26c5da77"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}