1.Python Numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "23aa8ec6",
   "metadata": {},
   "source": [
    "# Python Crash Course"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d57aa2fe",
   "metadata": {},
   "source": [
    "Hello! This is a quick intro to programming in Python.\n",
    "\n",
    "There are two ways to enjoy these lessons with Python:\n",
    "\n",
    "1. You can download and install a Python distribution on your computer. For Windows user, we recommend using Windows Subsystem for Linux (WSL) to run the Jupyter notebook for Python programming, following the instruction below (for Mac or Linux users, please find the instruction online): \n",
    "    \n",
    "    STEP 1\n",
    "    Search and click Turn Windows Features On or Off in the Windows search bar. Scroll down and ensure that the box next to Windows Subsystem for Linux (WSL) is checked. \n",
    "    If not, check the box and Restart your Computer. \n",
    "    \n",
    "    STEP 2\n",
    "    Visit Microsoft Store and download the Ubuntu app. This installs the Ubuntu-22.04 distribution to your WSL.\n",
    "\n",
    "    STEP 3\n",
    "    Run the Ubuntu app and type in the following commands to install Jupyter Notebook: https://harshityadav95.medium.com/jupyter-notebook-in-windows-subsystem-for-linux-wsl-8b46fdf0a536\n",
    "    \n",
    "    STEP 4\n",
    "    Navigate in the terminal (i.e., the Ubuntu app) to the folder that contains the .ipynb files or the folder you want to create a new .ipynb file. Then, to launch the notebook server, just type: jupyter notebook\n",
    "  \n",
    "    STEP 5\n",
    "    Copy the link and open it in your browser window. Click on one and start working!\n",
    "    \n",
    "    \n",
    "2. You can also use Google colab (Colaboratory) to create and run Python codes online!\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74e529d2",
   "metadata": {},
   "source": [
    "## Libraries"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "183be32a",
   "metadata": {},
   "source": [
    "Python is a high-level open-source language.  But the _Python world_ is inhabited by many packages or libraries that provide useful things like array operations, plotting functions, and much more. We can import libraries of functions to expand the capabilities of Python in our programs.  \n",
    "\n",
    "OK! We'll start by importing a few libraries to help us out. First: our favorite library is **NumPy**, providing a bunch of useful array operations (similar to MATLAB). We will use it a lot! The second library we need is **Matplotlib**, a 2D plotting library which we will use to plot our results.\n",
    "The following code will be at the top of most of your programs, so execute this cell first:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "fdb1f2a7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# <-- comments in python are denoted by the pound sign, like this one\n",
    "\n",
    "import numpy                 # we import the array library\n",
    "from matplotlib import pyplot    # import plotting library"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1115d76",
   "metadata": {},
   "source": [
    "We are importing one library named numpy and we are importing a module called pyplot of a big library called matplotlib. To use a function belonging to one of these libraries, we have to tell Python where to look for it. For that, each function name is written following the library name, with a dot in between. So if we want to use the NumPy function linspace(), which creates an array with equally spaced numbers between a start and end, we call it by writing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "dcbcdcef",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 0.55555556, 1.11111111, 1.66666667, 2.22222222,\n",
       "       2.77777778, 3.33333333, 3.88888889, 4.44444444, 5.        ])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myarray = numpy.linspace(0, 5, 10)\n",
    "myarray"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "468b9a7c",
   "metadata": {},
   "source": [
    "If we don't preface the linspace() function with numpy, Python will throw an error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "52edd5e7",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'linspace' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_3404/2687275794.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmyarray\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlinspace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'linspace' is not defined"
     ]
    }
   ],
   "source": [
    "myarray = linspace(0, 5, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c5e4619",
   "metadata": {},
   "source": [
    "The function `linspace()` is very useful. Try it changing the input parameters!\n",
    "\n",
    "**Import style:**\n",
    "\n",
    "You will often see code snippets that use the following lines\n",
    "```Python\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "```\n",
    "What's all of this import-as business? It's a way of creating a 'shortcut' to the NumPy library and the pyplot module. You will see it frequently as it is in common usage, but we prefer to keep out imports explicit. We think it helps with code readability.\n",
    "\n",
    "**Pro tip:**\n",
    "\n",
    "Sometimes, you'll see people importing a whole library without assigning a shortcut for it (like `from numpy import *`). This saves typing but is sloppy and can get you in trouble. Best to get into good habits from the beginning!\n",
    "\n",
    "\n",
    "To learn a new function you don't understand, you can just google it or ask ChatGPT to expain it, even giving you some examples! "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e73ac6d6",
   "metadata": {},
   "source": [
    "## Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69458629",
   "metadata": {},
   "source": [
    "Python doesn't require explicitly declared variable types like C and other languages.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0582cd15",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 5        #a is an integer 5\n",
    "b = 'five'   #b is a string of the word 'five'\n",
    "c = 5.0      #c is a floating point 5  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0e8066d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1ce67fcc",
   "metadata": {},
   "outputs": [],
   "source": [
    "type(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "475900c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "type(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "455fc3af",
   "metadata": {},
   "outputs": [],
   "source": [
    "3/2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1e1d4c8",
   "metadata": {},
   "source": [
    "## Whitespace in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e6b9f5b",
   "metadata": {},
   "source": [
    "Python uses indents and whitespace to group statements together.  To write a short loop in C, you might use:\n",
    "\n",
    "    for (i = 0, i < 5, i++){\n",
    "       printf(\"Hi! \\n\");\n",
    "    }\n",
    "    \n",
    "Python does not use curly braces like C, so the same program as above is written in Python as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "2f650060",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi \n",
      "\n",
      "Hi \n",
      "\n",
      "Hi \n",
      "\n",
      "Hi \n",
      "\n",
      "Hi \n",
      "\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    print(\"Hi \\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "886c518f",
   "metadata": {},
   "source": [
    "If you have nested for-loops, there is a further indent for the inner loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "50ae0e15",
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(3):\n",
    "    for j in range(3):\n",
    "        print(i, j)\n",
    "    \n",
    "    print(\"This statement is within the i-loop, but not the j-loop\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12fb7e65",
   "metadata": {},
   "source": [
    "## Slicing Arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a857560f",
   "metadata": {},
   "source": [
    "In NumPy, you can look at portions of arrays in the same way as in `Matlab`, with a few extra tricks thrown in.  Let's take an array of values from 1 to 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2e7d3629",
   "metadata": {},
   "outputs": [],
   "source": [
    "myvals = numpy.array([1, 2, 3, 4, 5])\n",
    "myvals"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76ae131a",
   "metadata": {},
   "source": [
    "Python uses a **zero-based index**, so let's look at the first and last element in the array `myvals`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cf4cfcc3",
   "metadata": {},
   "outputs": [],
   "source": [
    "myvals[0], myvals[4]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dcfbad38",
   "metadata": {},
   "source": [
    "There are 5 elements in the array `myvals`, but if we try to look at `myvals[5]`, Python will be unhappy, as `myvals[5]` is actually calling the non-existant 6th element of that array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8989140b",
   "metadata": {},
   "outputs": [],
   "source": [
    "myvals[5]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96156305",
   "metadata": {},
   "source": [
    "Arrays can also be 'sliced', grabbing a range of values.  Let's look at the first three elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0c06ea88",
   "metadata": {},
   "outputs": [],
   "source": [
    "myvals[0:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92a5858b",
   "metadata": {},
   "source": [
    "Note here, the slice is inclusive on the front end and exclusive on the back, so the above command gives us the values of `myvals[0]`, `myvals[1]` and `myvals[2]`, but not `myvals[3]`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea7dd12a",
   "metadata": {},
   "source": [
    "## Assigning Array Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74ef6868",
   "metadata": {},
   "source": [
    "One of the strange little quirks/features in Python that often confuses people comes up when assigning and comparing arrays of values.  Here is a quick example.  Let's start by defining a 1-D array called $a$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b2045eee",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = numpy.linspace(1,5,5)\n",
    "b = numpy.zeros(5)\n",
    "c = numpy.ones(5)\n",
    "d = numpy.random.rand(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "08c571a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a,b,c,d)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67182b1f",
   "metadata": {},
   "source": [
    "OK, so we have an array $a$, with the values 1 through 5.  I want to make a copy of that array, called $b$, so I'll try the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7d440cf9",
   "metadata": {},
   "outputs": [],
   "source": [
    "b = a\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e04aefab",
   "metadata": {},
   "source": [
    "Great.  So $a$ has the values 1 through 5 and now so does $b$.  Now that I have a backup of $a$, I can change its values without worrying about losing data (or so I may think!)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ea95bf76",
   "metadata": {},
   "outputs": [],
   "source": [
    "a[2] = 17"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9b103f48",
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55b063fe",
   "metadata": {},
   "source": [
    "Here, the 3rd element of $a$ has been changed to 17.  Now let's check on $b$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1966918a",
   "metadata": {},
   "outputs": [],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e12d8029",
   "metadata": {},
   "source": [
    "And that's how things go wrong! When you use a statement like  𝑎=𝑏\n",
    " , rather than copying all the values of  𝑎\n",
    "  into a new array called  𝑏\n",
    " , Python just creates an alias (or a pointer) called  𝑏\n",
    "  and tells it to route us to  𝑎\n",
    " . So if we change a value in  𝑎\n",
    "  then  𝑏\n",
    "  will reflect that change (technically, this is called assignment by reference). If you want to make a true copy of the array, you have to tell Python to copy every element of  𝑎\n",
    "  into a new array. Let's call it  𝑐\n",
    " ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "934a054d",
   "metadata": {},
   "outputs": [],
   "source": [
    "c = a.copy()\n",
    "a[2] = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dd9a68a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e9a2da99",
   "metadata": {},
   "outputs": [],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "001a8654",
   "metadata": {},
   "source": [
    "OK, it worked!  If the difference between `a = b` and `a = b.copy()` is unclear, you should read through this again.  This issue will come back to haunt you otherwise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "3a06d928",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "# Create a numpy array of 100 numbers from 0 to 2*pi\n",
    "x = np.linspace(0, 2*np.pi, 100)\n",
    "\n",
    "# Create a numpy array for the sine of x\n",
    "y = np.sin(x)\n",
    "\n",
    "# Use pyplot to create a line plot of y vs. x\n",
    "plt.plot(x, y)\n",
    "\n",
    "# Add labels to the x and y axes\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('sin(x)')\n",
    "\n",
    "# Add a title\n",
    "plt.title('Plot of the Sine Function')\n",
    "\n",
    "# Display the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "bc788e2a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "# Set default font to Arial\n",
    "plt.rcParams['font.family'] = 'arial'\n",
    "# Set default font size\n",
    "plt.rcParams['font.size'] = 16\n",
    "\n",
    "# Create a numpy array of 100 numbers from 0 to 2*pi\n",
    "x = np.linspace(0, 2*np.pi, 100)\n",
    "\n",
    "# Create a numpy array for the sine of x\n",
    "y = np.sin(x)\n",
    "\n",
    "# Create a new figure with a specific size\n",
    "plt.figure(figsize=(10, 6))\n",
    "\n",
    "# Use pyplot to create a line plot of y vs. x with a specific color, linewidth, and label for the legend\n",
    "plt.plot(x, y, color='blue', linewidth=2, label='sin(x)')\n",
    "\n",
    "# Add labels to the x and y axes with a specific font size\n",
    "plt.xlabel('x', fontsize=16)\n",
    "plt.ylabel('sin(x)', fontsize=16)\n",
    "\n",
    "# Add a title with a specific font size\n",
    "plt.title('Plot of the Sine Function', fontsize=18)\n",
    "\n",
    "# Add a grid\n",
    "plt.grid(True)\n",
    "\n",
    "# Add a legend with a specific location\n",
    "plt.legend(loc='upper right')\n",
    "\n",
    "# Set the limit for the x and y axes\n",
    "plt.xlim([0, 2*np.pi])\n",
    "plt.ylim([-1.5, 1.5])\n",
    "\n",
    "# Set the ticks for the x and y axes\n",
    "plt.xticks(np.arange(0, 2*np.pi, np.pi/2))\n",
    "plt.yticks(np.arange(-1, 1.5, 0.5))\n",
    "\n",
    "# Display the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dadb3136",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "05c1b7c2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "12b1bdd6",
   "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.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}