python_notebook_tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Overview of Python Notebooks\n",
    "Python notebooks (sometimes called Jupyter notebooks after the Jupyter project that introduced Python notebooks) provide an interactive way to program in the Python programming language. Libraries are available for linear algebra ([numpy](http://www.numpy.org/)), scientific computing ([scipy](https://www.scipy.org/)), plotting ([matplotlib](https://matplotlib.org/)), and symbolic math ([sympy](https://www.sympy.org/en/index.html)). The Jupyter notebook version of Python notebooks and all of these libraries are available for free as open source software. The easiest way to install Jupyter, Python, and these libraries is to install the Anaconda Python Distribution available [here](https://www.anaconda.com/download/). Installers are available for Windows, Mac, and Linux. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Cell Types\n",
    "\n",
    "There are two primary types of cells in a notebook. A markdown cell, such as this one, contains text that can be used to document your work. A description of the syntax used in markdown cells is [here](http://jupyter-notebook.readthedocs.io/en/latest/examples/Notebook/Working%20With%20Markdown%20Cells.html). To view the markdown that was used to create this cell, double click it.\n",
    "\n",
    "The second primary type of cell is a code cell. Code cells are the default cell type. Code cells can be executed with either Ctrl-Enter or Shift-Enter. Shift-Enter excecutes the current cell and goes to the next cell. Ctrl-Enter executes the current cell and remains on the current cell.\n",
    "\n",
    "Execute the following code cell:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "a = 1\n",
    "b = 1\n",
    "\n",
    "print(\"a + b =\", a+b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that, if the last line of a code cell is an expression, the result of evaluating that expression will be printed as the output. For example, $ a+b $ can be printed using:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a+b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Notebook Magic Commands\n",
    "\n",
    "Commands specific to the Python notebook environment that are not part of the Python programming language are proceeded by the `%` symbol. There are numerous magic commands with some providing access to the underlying operating system. One example of a magic command is the `%whos` command that lists all of the variables that have been defined during the current session:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%whos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `%magic` command will list all of the available magic commands:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Importing Python Libraries\n",
    "Numourous libraries are avialable for Python. These libraries need to be imported before they can be used. The following code cell imports the libraries required for ploting (matplotlib), the library required for linear algebra (numpy), and Python's built in math library (math). Execute the following code cell:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pylab as plt\n",
    "import numpy as np\n",
    "import math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Using numpy\n",
    "An 2D array can be defined using the following syntax:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "my_array = np.array([[1,2],[3,4]])\n",
    "print(my_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A vector can be defined using the following syntax:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "my_vector = np.array([1,2])\n",
    "print(my_vector)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the numpy library does not make a distinction between column and row vectors. Matrix multiplication can be performed using the following syntax:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "result = my_array.dot(my_vector)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or, equivalently, with the following syntax:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "result = np.dot(my_array,my_vector)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the multiplication operator performs an element-wise matrix opperation rather than a matrix multiplication. Because of this, the following is not equivalent to a matrix multiplication."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "result = my_array*my_vector\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, the @ operator is used for matrix multiplication using the following syntax:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "result = my_array@my_vector\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Square brackets can be used to access individual elements of a array. The first index is the row and the second index is the column. Note that indices in Python start at 0 and not 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(my_array[0,1]) # print the array element at the 0 row and the 1 column"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An entire row or column can be indexed by using the colon for the position where you want all of the values. See the following examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(\"Column 0: \", my_array[:,0]) # print the first column\n",
    "print(\"Row 1: \", my_array[1,:]) # print the second row"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For a numpy vector, the Python index slicing format can be used to access ranges of values. See the examples below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "my_second_vector = np.array([0,1,2,3,4,5,6,7,8,9])\n",
    "\n",
    "print(\"First 2 elements of the vector: \", my_second_vector[:2])\n",
    "\n",
    "print(\"The last element of the vector: \", my_second_vector[-1])\n",
    "\n",
    "print(\"The second through third elements of the vector: \", my_second_vector[1:3])\n",
    "\n",
    "print(\"Skip every other element of the vector: \", my_second_vector[0:10:2])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A numpy tutorial can be found [here](http://docs.scipy.org/doc/numpy/user/quickstart.html). If you're familiar with Matlab, a numpy tutorial for Matlab users is available [here](https://docs.scipy.org/doc/numpy/user/numpy-for-matlab-users.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plotting using matplotlib\n",
    "\n",
    "The matplotlib library provides plotting capabilities to the Python notebook. A syntax similar to Matlab is used. A matplotlib tuorial is available [here](https://matplotlib.org/stable/tutorials/introductory/pyplot.html#sphx-glr-tutorials-introductory-pyplot-py). The following command plots a sine function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# fig = plt.figure() # create a new figure\n",
    "\n",
    "time = np.linspace(0,2*math.pi)   # This numpy linspace function returns a vector of evenly spaced values between 0 and 2*pi\n",
    "plt.plot(time,np.sin(time))  # The numpy sin function is used since it can handle vector inputs\n",
    "plt.plot(time,np.cos(time))\n",
    "\n",
    "# The following commands add axis labels and a title to the plot\n",
    "plt.title('Plot of sine and cosine functions')\n",
    "plt.xlabel('Time')\n",
    "plt.ylabel('Amplitude')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Symbolic Math\n",
    "The sympy library addes symbolic math capabilities to the Python notebook such as integration and differentiation. Below are a couple of simple examples. A sympy tutorial is available [here](http://docs.sympy.org/latest/tutorial/index.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sympy as sp  # import the sympy library\n",
    "sp.init_printing()  # printing equations using mathematical notion in the Python notebook\n",
    "\n",
    "x,y,z = sp.symbols('x,y,z') # define symbolic variables x, y, and z\n",
    "\n",
    "sp.integrate(sp.cos(x)) # Take the integral of cos(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sp.diff(sp.sin(x),x) # Take the defivative of sine(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sp.plot(sp.sin(x),(x,0,2*math.pi)) # plot a sympolic function for 0 <= x <= 2*pi"
   ]
  },
  {
   "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}