1 - Introduction to Notebooks and Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Jupyter Notebooks\n",
    "### Charles Burton"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The \"notebook\" is a computing paradigm first introduced by Mathematica. It is a powerful way of interacting with a computer.\n",
    "\n",
    "The notebook is arranged in cells.  There are multiple kinds of cells:\n",
    "* \"markdown cells\" render text into word-processor-style cells.\n",
    "* \"code cells,\" when run, execute processes on the computer.\n",
    "* \"raw cells\" appear exactly as typed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Markdown Cells\n",
    "This is a markdown cell. They are pretty versatile. You can use html tags to make <b>bold</b>, <i>italic</i>, or <font color=red>colored</font> text. Or, you can use html tags to show images or links to web sites. (The notebook runs in a web browser, so anything a web page can do, so too can a notebook.) However, you can double click on this cell to see how the formatting was done. After double-clicking on a <it>Markdown</it> cell, it will just show you the <it>html</it> code. To render it again, click on the cell and press `shift + enter`.\n",
    "\n",
    "Another interesting feature is the notebook can compile $\\LaTeX$ code. So you can add bad math jokes to your document, such as $$\\int \\frac{d\\mbox{cabin}}{\\mbox{cabin}}=\\log\\mbox{cabin}.$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise - Arithmetic\n",
    "To evaluate a code cell, you press `shift + enter`, just like how you render markdown cells.  Evaluate the following cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 + 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Go back and edit that cell to be another math expression. Each time pressing shift-enter. Create expressions using each of the following symbols: `+`,`-`,`*`,`/`,`%`,`^`,`**`,`&`,`|`. Deduce what each means. If you really get stuck you can do a web search. If you want a record of your exploration, figure out which of the buttons in the toolbar above creates a new cell. Don't forget to save regularly."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise - Assignment and Boolean Operators\n",
    "Evalute the following cells."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = a + 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a==3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a==7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "del(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'a' 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<ipython-input-34-3f786850e387>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ma\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'a' is not defined"
     ]
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise - Package Imports\n",
    "Python only has a few built-in functions, shown here. <img src=\"https://i.stack.imgur.com/LxITc.png\">\n",
    "\n",
    "Everything else has to be imported from things called \"packages,\" which is a distribution of a group of software resources. One commonly-used one is a group of numerical computing tools called `NumPy`. Here we will \"import\" the package, allowing us to use its functions and classes in this notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aside: the `as` keyword is just a python shorthand. If you wanted to call the `NumPy` \"mean\" function, which calculates the mean value of a set of numbers, you would then just type `np.mean` instead of `numpy.mean`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise - Containers\n",
    "Evaluate the following."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 6, 2]"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [1, 4, 6, 2]\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 4, 6, 2])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = numpy.array(a)\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 6, 2, 1, 4, 6, 2]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a + a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2,  8, 12,  4])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The object `a` is known as a list--an object type that is built-in to Python. It is an ordered list of elements. The object `b` is known as an array. It is what we normally think of as a vector."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 4, 6, 2)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = (1, 4, 6, 2)\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 4, 6, 2, 1, 4, 6, 2)"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c + c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The object `c` is a tuple. It acts similarly to a list, except for some subtleties in setting elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 6, 2] 1 6\n"
     ]
    }
   ],
   "source": [
    "print(a, a[0], a[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[7, 4, 6, 2]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[0] = 7\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 4, 6, 2) 1 6\n"
     ]
    }
   ],
   "source": [
    "print (c, c[0], c[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-46-912532efac70>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mc\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m7\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mc\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "c[0] = 7\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python tuples are \"immutable.\" Once they are instantiated, their elements cannot be changed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise - Advanced Containers (Dictionaries)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "d[\"name\"] = \"Henry\"\n",
    "d[\"color\"] = \"red\"\n",
    "d[\"age\"] = 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Henry'"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d[\"name\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['name', 'color', 'age'])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise - Advanced Containers (Classes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Funkytown:\n",
    "    '''funkytown is an empty class that we are using as a container object'''\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = Funkytown"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "f.x = 7\n",
    "f.y = 8\n",
    "f.color = \"red\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To see what attributes f has, type \"f.\" then the tab key: a dropdown should appear"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-56-ecbd3b12d2e2>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-56-ecbd3b12d2e2>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    f.\u001b[0m\n\u001b[0m      ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "f."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise - Plotting\n",
    "Again, we will need to import a library for plotting. A popular one is `Matplotlib`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aside: The `as` keyword allows you to set an abbreviation for the package name. Suppose you want to call the `plot` function, instead of writing `matplotlib.pyplot.plot()`, one would just say `plt.plot()`.\n",
    "\n",
    "Here is a simple figure:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f56831f45b0>]"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "xvalues = (0, 1, 2, 3, 4)\n",
    "yvalues=(1, 1, -2, 1, 1)\n",
    "plt.plot(xvalues, yvalues)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is a more complex one"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f56b65ef4f0>]"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "plt.ylim(-2.5,1.5)\n",
    "plt.title('A Curve')\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y')\n",
    "plt.plot(xvalues, yvalues)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, reproduce the plot from the previous cell, but this time, plot just the points (not joined with a line). Make the points red. (Google is your friend.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise - Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "def addtwo(x):\n",
    "    '''Adds the number 2 to the input and returns it as output'''\n",
    "    y = x + 2\n",
    "    return y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "addtwo(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9.4"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "addtwo(7.4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "?addtwo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "??addtwo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**A note on variable scope:** A variable's \"scope\" is where it is available. Everything we have been defining above has been in the \"global scope\". That is, once the variable is defined, it can be accessed everywhere else in the notebook. Functions are in part useful because they allow you to limit the scope of your variables to only where you want them to exist. This helps both for computer resource management and avoiding bugs in your code, and is very good programming practice.\n",
    "\n",
    "For example, in the `addtwo` function, we have defined a local variable `y`, but it is not accessable anywhere outside of that function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'y' 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<ipython-input-66-9063a9f0e032>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0my\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'y' is not defined"
     ]
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Back to the main discussion... Complete the following function, which is supposed to tell if an integer is even.  Test it in the cells below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "def iseven(x):\n",
    "    '''returns True if the input is even, and False if it is odd'''\n",
    "    # This is a comment -- replace it with the function\n",
    "    # Hint: Use the \"Modulo\" operator %\n",
    "    # Hint: You want the last line of your function to use the Python keyword return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "iseven(7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "iseven(2020)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise - List Comprehension\n",
    "A useful syntax in python is the \"list comprehension,\" which generates new lists from old. Suppose you wanted to find the squares of a set of numbers. The way to do this with a `for` loop would look something like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_list = [7, 4, 6, 2] # the list of values that we would like to square"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[49, 16, 36, 4]"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squares = []\n",
    "for x in x_list:\n",
    "    square = x**2\n",
    "    squares.append(square)\n",
    "squares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instead, we can do this with list comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[49, 16, 36, 4]"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[x**2 for x in x_list]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can even add conditional statements to your list comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[x**2 for x in x_list if iseven(x)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we use arrays, these operations are often even easier since many of the arithmetic operations are defined to work over arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numpy.arange(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  4,  9, 16, 25, 36, 49, 64, 81])"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numpy.arange(10)**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise - Matrix Multiplication\n",
    "We can make matrices out of multi-dimensional arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [2, 3]])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat = numpy.array([[1, 2], [2, 3]])\n",
    "mat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec = numpy.array([1, 2])\n",
    "vec"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is how you do matrix multiplication."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5,  8],\n",
       "       [ 8, 13]])"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat.dot(mat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 8])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat.dot(vec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec.dot(vec)"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Tags",
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}