lectures/L01_python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction: python\n",
    "\n",
    "*Davide Gerosa (Milano-Bicocca)*\n",
    "\n",
    "**Sources**: Michael Zingale at Stony Brook University: https://sbu-python-class.github.io"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Why python?\n",
    "\n",
    "* Python is a very high-level language\n",
    "\n",
    "  * it provides many complex data-structures (lists, dictionaries, ...)\n",
    "\n",
    "  * your code is shorter than a comparable algorithm in a compiled language\n",
    "\n",
    "* Many powerful libraries to perform complex tasks\n",
    "\n",
    "  * Parse structured inputs files\n",
    "\n",
    "  * send e-mail\n",
    "\n",
    "  * interact with the operating system\n",
    "\n",
    "  * make plots\n",
    "\n",
    "  * make GUIs\n",
    "\n",
    "  * do scientific computations\n",
    "\n",
    "  * ...\n",
    "\n",
    "* Python makes it easy to prototype new tools\n",
    "\n",
    "* Python is cross-platform and Free\n",
    "\n",
    "## Language Features\n",
    "\n",
    "Some of the language features are:\n",
    "\n",
    "* Dynamical typing\n",
    "\n",
    "* Object-oriented foundation\n",
    "\n",
    "* Extensible (easy to call Fortran, C/C++, ...)\n",
    "\n",
    "* Automatic memory management (garbage collection)\n",
    "\n",
    "* Ease of readability (whitespace matters)\n",
    "\n",
    "\n",
    "## Scientific python\n",
    "\n",
    "Perhaps most importantly, and why we are here:\n",
    "\n",
    "> Python has been widely adopted in the scientific community.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Questions\n",
    "\n",
    "\n",
    "- What's your research about? What are you more/less interested in this class?\n",
    "\n",
    "- Have you ever used python?\n",
    "    1. Never ever ever\n",
    "    2. Seen it but never used it for research\n",
    "    3. Used it but only some basic operations\n",
    "    4. I'm up to speed\n",
    "    5. I'm a Python developer already\n",
    "\n",
    "I designed this class to both provide an introduction to people that have never used python, but also to give solid foundations to those that have used it already (also applies to myself: preparing this class definitely improved my python skills!).\n",
    "\n",
    "### Some of my coding projects\n",
    "\n",
    "I used python and/or git for \n",
    "\n",
    "- Black holes spins: https://github.com/dgerosa/precession\n",
    "- Gravitational waves detectability with machine learning: https://github.com/dgerosa/pdetclassifier \n",
    "- Write papers: https://github.com/dgerosa/writeapaper\n",
    "- Handle latex bibliographies: https://github.com/dgerosa/filltex\n",
    "- Keep my CV automatically updated:  https://github.com/dgerosa/CV\n",
    "- Teaching: https://github.com/dgerosa/astrostatistics_bicocca_2023 \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ok, let's go..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Getting python\n",
    "\n",
    "You will want to install python and the associated libraries on your\n",
    "laptop that you can bring to classes. Hopefully you have done this already.\n",
    "\n",
    "On Linux machines, you probably already have python and you can get\n",
    "the needed libraries through your system package manager.\n",
    "\n",
    "For Windows, I recommend the free Anaconda distribution:\n",
    "\n",
    "https://www.anaconda.com/products/individual\n",
    "\n",
    "For Mac, I recommend using homwbrew (not just for python, that's a general package manager for mac)\n",
    "\n",
    "https://brew.sh/\n",
    "\n",
    "If you have python successfully installed, you should be able to start\n",
    "the python interpreter at the command line as: `python`.  A shell will\n",
    "come up, and you can try out your first program:\n",
    "\n",
    "```\n",
    "print(\"hello, world\")\n",
    "```\n",
    "\n",
    "You will also need to be able to install packages. So try\n",
    "\n",
    "```\n",
    "pip install jupyter\n",
    "```\n",
    "\n",
    "and see if that works. You might need to add the `--user` option, depending on what privileges you have on your laptop and your python installation. \n",
    "\n",
    "\n",
    "## Following along in class\n",
    "\n",
    "All of the class notes are hosted as Jupyter notebooks on github:\n",
    "\n",
    "https://github.com/dgerosa/scientificcomputing_bicocca_2023\n",
    "\n",
    "If you know some git already, go ahead and fork + clone the repository. If \"fork\" still makes you think of lunch instead of computers no worries, we'll talk about git later on. For now just use the green download button for dummies."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Jupyter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll be using Jupyter for all of our examples -- this allows us to run python in a web-based notebook, keeping a history of input and output, along with text and images.\n",
    "\n",
    "For Jupyter help, visit:\n",
    "https://jupyter.readthedocs.io/en/latest/content-quickstart.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We interact with python by typing into _cells_ in the notebook.  By default, a cell is a _code_ cell, which means that you can enter any valid python code into it and run it.  Another important type of cell is a _markdown_ cell.  This lets you put text, with different formatting (italics, bold, etc) that describes what the notebook is doing.\n",
    "\n",
    "You can change the cell type via the menu at the top, or using the shortcuts:\n",
    "\n",
    "  * ctrl-m m : mark down cell\n",
    "  * ctrl-m y : code cell"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some useful short-cuts:\n",
    "\n",
    " * shift+enter = run cell and jump to the next (creating a new cell if there is no other new one)\n",
    " * ctrl+enter = run cell-in place\n",
    " * alt+enter = run cell and insert a new one below\n",
    "\n",
    "ctrl+m h lists other commands"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A \"markdown cell\" enables you to typeset LaTeX equations right in your notebook.  Just put them in `$` or `$$`:\n",
    "\n",
    "$$\\frac{\\partial \\rho}{\\partial t} + \\nabla \\cdot (\\rho U) = 0$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-danger\">\n",
    "    \n",
    "**Important**: when you work through a notebook, everything you did in previous cells is still in memory and _known_ by python, so you can refer to functions and variables that were previously defined.  Even if you go up to the top of a notebook and insert a cell, all the information done earlier in your notebook session is still defined -- it doesn't matter where physically you are in the notebook.  If you want to reset things, you can use the options under the _Kernel_ menu.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "    \n",
    "<span class=\"fa fa-flash\"></span> Quick Exercise:\n",
    "\n",
    "Create a new cell below this one.  Make sure that it is a _code_ cell, and enter the following code and run it:\n",
    "    \n",
    "```\n",
    "\n",
    " print(\"Hello, World\")\n",
    " \n",
    "```\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`print()` is a _function_ in python that takes arguments (in the `()`) and outputs to the screen.  You can print multiple quantities at once like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3\n"
     ]
    }
   ],
   "source": [
    "print(1, 2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the default behavior in Jupyter is to print the return value from the last statement in a cell, so we don't need to `print` if we just want the value of something like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 10\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Basic Python Datatypes\n",
    "\n",
    "Python is a dynamically typed language -- this means that you don't\n",
    "need to specify ahead of time what kind of data you are going to store\n",
    "in a variable.  Nevertheless, there are some core datatypes that we\n",
    "need to become familiar with as we use the language.\n",
    "\n",
    "The first set of datatypes are similar to those found in other\n",
    "languages (like C/C++ and Fortran): floating point numbers, integers,\n",
    "and strings.\n",
    "\n",
    "Floating point is essential for computational science.  A great\n",
    "introduction to floating point and its limitations is: [What every\n",
    "computer scientist should know about floating-point\n",
    "arithmetic](http://dl.acm.org/citation.cfm?id=103163) by\n",
    "D. Goldberg.\n",
    "\n",
    "The next set of datatypes are containers.  In python, unlike some\n",
    "languages, these are built into the language and make it very easy to\n",
    "do complex operations.  We'll look at these later.\n",
    "\n",
    "\n",
    "Some examples come from the python tutorial:\n",
    "http://docs.python.org/3/tutorial/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Integers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Integers are numbers without a decimal point.  They can be positive or negative.  Most programming languages use a finite-amount of memory to store a single integer, but in python will expand the amount of memory as necessary to store large integers.\n",
    "\n",
    "The basic operators, `+`, `-`, `*`, and `/` work with integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2+2+3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-8"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2*-4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: integer division is one place where python 2 and python 3 different\n",
    "    \n",
    "In python 3.x, dividing 2 integers results in a float.  In python 2.x, dividing 2 integers results in an integer.  The latter is consistent with many strongly-typed programming languages (like Fortran or C), since the data-type of the result is the same as the inputs, but the former is more inline with our expectations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.5"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3/2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get an integer result, we can use the // operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3//2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python is a _dynamically-typed language_&mdash;this means that we do not need to declare the datatype of a variable before initializing it.  \n",
    "\n",
    "Here we'll create a variable (think of it as a descriptive label that can refer to some piece of data).  The `=` operator assigns a value to a variable.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 1\n",
    "b = 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions operate on variables and return a result.  Here, `print()` will output to the screen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a * b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that variable names are case sensitive, so a and A are different"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = 2048"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2048\n"
     ]
    }
   ],
   "source": [
    "print(a, A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we initialize 3 variable all to `0`, but these are still distinct variables, so we can change one without affecting the others."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = y = z = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0 0\n"
     ]
    }
   ],
   "source": [
    "print(x, y, z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has some built in help (and Jupyter/ipython has even more)\n",
    "\n",
    "try doing:\n",
    "```\n",
    "help(x)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "alternatively, try:\n",
    "```\n",
    "x?\n",
    "```\n",
    "\n",
    "(this only works in Jupyter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on int object:\n",
      "\n",
      "class int(object)\n",
      " |  int([x]) -> integer\n",
      " |  int(x, base=10) -> integer\n",
      " |  \n",
      " |  Convert a number or string to an integer, or return 0 if no arguments\n",
      " |  are given.  If x is a number, return x.__int__().  For floating point\n",
      " |  numbers, this truncates towards zero.\n",
      " |  \n",
      " |  If x is not a number or if base is given, then x must be a string,\n",
      " |  bytes, or bytearray instance representing an integer literal in the\n",
      " |  given base.  The literal can be preceded by '+' or '-' and be surrounded\n",
      " |  by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.\n",
      " |  Base 0 means to interpret the base from the string as an integer literal.\n",
      " |  >>> int('0b100', base=0)\n",
      " |  4\n",
      " |  \n",
      " |  Built-in subclasses:\n",
      " |      bool\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __abs__(self, /)\n",
      " |      abs(self)\n",
      " |  \n",
      " |  __add__(self, value, /)\n",
      " |      Return self+value.\n",
      " |  \n",
      " |  __and__(self, value, /)\n",
      " |      Return self&value.\n",
      " |  \n",
      " |  __bool__(self, /)\n",
      " |      True if self else False\n",
      " |  \n",
      " |  __ceil__(...)\n",
      " |      Ceiling of an Integral returns itself.\n",
      " |  \n",
      " |  __divmod__(self, value, /)\n",
      " |      Return divmod(self, value).\n",
      " |  \n",
      " |  __eq__(self, value, /)\n",
      " |      Return self==value.\n",
      " |  \n",
      " |  __float__(self, /)\n",
      " |      float(self)\n",
      " |  \n",
      " |  __floor__(...)\n",
      " |      Flooring an Integral returns itself.\n",
      " |  \n",
      " |  __floordiv__(self, value, /)\n",
      " |      Return self//value.\n",
      " |  \n",
      " |  __format__(self, format_spec, /)\n",
      " |      Default object formatter.\n",
      " |  \n",
      " |  __ge__(self, value, /)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |  \n",
      " |  __getnewargs__(self, /)\n",
      " |  \n",
      " |  __gt__(self, value, /)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __hash__(self, /)\n",
      " |      Return hash(self).\n",
      " |  \n",
      " |  __index__(self, /)\n",
      " |      Return self converted to an integer, if self is suitable for use as an index into a list.\n",
      " |  \n",
      " |  __int__(self, /)\n",
      " |      int(self)\n",
      " |  \n",
      " |  __invert__(self, /)\n",
      " |      ~self\n",
      " |  \n",
      " |  __le__(self, value, /)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __lshift__(self, value, /)\n",
      " |      Return self<<value.\n",
      " |  \n",
      " |  __lt__(self, value, /)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __mod__(self, value, /)\n",
      " |      Return self%value.\n",
      " |  \n",
      " |  __mul__(self, value, /)\n",
      " |      Return self*value.\n",
      " |  \n",
      " |  __ne__(self, value, /)\n",
      " |      Return self!=value.\n",
      " |  \n",
      " |  __neg__(self, /)\n",
      " |      -self\n",
      " |  \n",
      " |  __or__(self, value, /)\n",
      " |      Return self|value.\n",
      " |  \n",
      " |  __pos__(self, /)\n",
      " |      +self\n",
      " |  \n",
      " |  __pow__(self, value, mod=None, /)\n",
      " |      Return pow(self, value, mod).\n",
      " |  \n",
      " |  __radd__(self, value, /)\n",
      " |      Return value+self.\n",
      " |  \n",
      " |  __rand__(self, value, /)\n",
      " |      Return value&self.\n",
      " |  \n",
      " |  __rdivmod__(self, value, /)\n",
      " |      Return divmod(value, self).\n",
      " |  \n",
      " |  __repr__(self, /)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __rfloordiv__(self, value, /)\n",
      " |      Return value//self.\n",
      " |  \n",
      " |  __rlshift__(self, value, /)\n",
      " |      Return value<<self.\n",
      " |  \n",
      " |  __rmod__(self, value, /)\n",
      " |      Return value%self.\n",
      " |  \n",
      " |  __rmul__(self, value, /)\n",
      " |      Return value*self.\n",
      " |  \n",
      " |  __ror__(self, value, /)\n",
      " |      Return value|self.\n",
      " |  \n",
      " |  __round__(...)\n",
      " |      Rounding an Integral returns itself.\n",
      " |      \n",
      " |      Rounding with an ndigits argument also returns an integer.\n",
      " |  \n",
      " |  __rpow__(self, value, mod=None, /)\n",
      " |      Return pow(value, self, mod).\n",
      " |  \n",
      " |  __rrshift__(self, value, /)\n",
      " |      Return value>>self.\n",
      " |  \n",
      " |  __rshift__(self, value, /)\n",
      " |      Return self>>value.\n",
      " |  \n",
      " |  __rsub__(self, value, /)\n",
      " |      Return value-self.\n",
      " |  \n",
      " |  __rtruediv__(self, value, /)\n",
      " |      Return value/self.\n",
      " |  \n",
      " |  __rxor__(self, value, /)\n",
      " |      Return value^self.\n",
      " |  \n",
      " |  __sizeof__(self, /)\n",
      " |      Returns size in memory, in bytes.\n",
      " |  \n",
      " |  __sub__(self, value, /)\n",
      " |      Return self-value.\n",
      " |  \n",
      " |  __truediv__(self, value, /)\n",
      " |      Return self/value.\n",
      " |  \n",
      " |  __trunc__(...)\n",
      " |      Truncating an Integral returns itself.\n",
      " |  \n",
      " |  __xor__(self, value, /)\n",
      " |      Return self^value.\n",
      " |  \n",
      " |  as_integer_ratio(self, /)\n",
      " |      Return integer ratio.\n",
      " |      \n",
      " |      Return a pair of integers, whose ratio is exactly equal to the original int\n",
      " |      and with a positive denominator.\n",
      " |      \n",
      " |      >>> (10).as_integer_ratio()\n",
      " |      (10, 1)\n",
      " |      >>> (-10).as_integer_ratio()\n",
      " |      (-10, 1)\n",
      " |      >>> (0).as_integer_ratio()\n",
      " |      (0, 1)\n",
      " |  \n",
      " |  bit_count(self, /)\n",
      " |      Number of ones in the binary representation of the absolute value of self.\n",
      " |      \n",
      " |      Also known as the population count.\n",
      " |      \n",
      " |      >>> bin(13)\n",
      " |      '0b1101'\n",
      " |      >>> (13).bit_count()\n",
      " |      3\n",
      " |  \n",
      " |  bit_length(self, /)\n",
      " |      Number of bits necessary to represent self in binary.\n",
      " |      \n",
      " |      >>> bin(37)\n",
      " |      '0b100101'\n",
      " |      >>> (37).bit_length()\n",
      " |      6\n",
      " |  \n",
      " |  conjugate(...)\n",
      " |      Returns self, the complex conjugate of any int.\n",
      " |  \n",
      " |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)\n",
      " |      Return an array of bytes representing an integer.\n",
      " |      \n",
      " |      length\n",
      " |        Length of bytes object to use.  An OverflowError is raised if the\n",
      " |        integer is not representable with the given number of bytes.  Default\n",
      " |        is length 1.\n",
      " |      byteorder\n",
      " |        The byte order used to represent the integer.  If byteorder is 'big',\n",
      " |        the most significant byte is at the beginning of the byte array.  If\n",
      " |        byteorder is 'little', the most significant byte is at the end of the\n",
      " |        byte array.  To request the native byte order of the host system, use\n",
      " |        `sys.byteorder' as the byte order value.  Default is to use 'big'.\n",
      " |      signed\n",
      " |        Determines whether two's complement is used to represent the integer.\n",
      " |        If signed is False and a negative integer is given, an OverflowError\n",
      " |        is raised.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods defined here:\n",
      " |  \n",
      " |  from_bytes(bytes, byteorder='big', *, signed=False) from builtins.type\n",
      " |      Return the integer represented by the given array of bytes.\n",
      " |      \n",
      " |      bytes\n",
      " |        Holds the array of bytes to convert.  The argument must either\n",
      " |        support the buffer protocol or be an iterable object producing bytes.\n",
      " |        Bytes and bytearray are examples of built-in objects that support the\n",
      " |        buffer protocol.\n",
      " |      byteorder\n",
      " |        The byte order used to represent the integer.  If byteorder is 'big',\n",
      " |        the most significant byte is at the beginning of the byte array.  If\n",
      " |        byteorder is 'little', the most significant byte is at the end of the\n",
      " |        byte array.  To request the native byte order of the host system, use\n",
      " |        `sys.byteorder' as the byte order value.  Default is to use 'big'.\n",
      " |      signed\n",
      " |        Indicates whether two's complement is used to represent the integer.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  __new__(*args, **kwargs) from builtins.type\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  denominator\n",
      " |      the denominator of a rational number in lowest terms\n",
      " |  \n",
      " |  imag\n",
      " |      the imaginary part of a complex number\n",
      " |  \n",
      " |  numerator\n",
      " |      the numerator of a rational number in lowest terms\n",
      " |  \n",
      " |  real\n",
      " |      the real part of a complex number\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another function, `type()` returns the data type of a variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note in languages like Fortran and C, you specify the amount of memory an integer can take (usually 2 or 4 bytes).  This puts a restriction on the largest size integer that can be represented.  Python will adapt the size of the integer so you don't *overflow*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12345678901234567890123456789012345123456789012345678901234567890\n",
      "213\n",
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "a = 12345678901234567890123456789012345123456789012345678901234567890\n",
    "print(a)\n",
    "print(a.bit_length())\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Floating point"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When operating with both floating point and integers, the result is promoted to a float."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1. + 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But note the special integer division operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1.//2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is important to understand that since there are infinitely many real numbers between any two bounds, on a computer we have to approximate this by a finite number.  There is an IEEE standard for floating point that pretty much all languages and processors follow.  \n",
    "\n",
    "This means two things\n",
    "\n",
    "* not every real number will have an exact representation in floating point\n",
    "* there is a finite precision to numbers -- below this, we lose track of differences (this is usually called *roundoff* error)\n",
    "\n",
    "This paper is an amazing reference to understand how a computer stores numbers:\n",
    "\n",
    "[Goldberg 1991: What every computer scientist should know about floating-point arithmetic](https://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html)\n",
    "\n",
    "Consider the following expression, for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-4.440892098500626e-16"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.3/0.1 - 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.3/0.1 == 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's another example: The number 0.1 cannot be exactly represented on a computer.  In our print, we use a format specifier (the stuff inside of the {}) to ask for more precision to be shown:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "        0.10000000000000000555\n"
     ]
    }
   ],
   "source": [
    "a = 0.1\n",
    "print(\"{:30.20}\".format(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can ask python to report the limits on floating point"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import sys\n",
    "sys.float_info"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that this says that we can only store numbers between 2.2250738585072014e-308 and 1.7976931348623157e+308\n",
    "\n",
    "We also see that the precision is 2.220446049250313e-16 (this is commonly called _machine epsilon_).  To see this, consider adding a small number to 1.0.  We'll use the equality operator (`==`) to test if two numbers are equal:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "    \n",
    "<span class=\"fa fa-flash\"></span> Quick Exercise:\n",
    "\n",
    "Define two variables, $a = 1$, and $e = 10^{-16}$.\n",
    "\n",
    "Now define a third variable, `b = a + e`\n",
    "\n",
    "We can use the python `==` operator to test for equality.  What do you expect `b == a` to return? run it an see if it agrees with your guess.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modules\n",
    "\n",
    "The core python language is rather small. Most happens in modules. Some modules are part of a standard library that provides additional functionality.  These added pieces are in the form of modules that we can _import_ into our python session (or program).\n",
    "\n",
    "The `math` module provides functions that do the basic mathematical operations as well as provide constants (note there is a separate `cmath` module for complex numbers).\n",
    "\n",
    "In python, you `import` a module.  The functions are then defined in a separate _namespace_&mdash;this is a separate region that defines names and variables, etc.  A variable in one namespace can have the same name as a variable in a different namespace, and they don't clash.  You use the \"`.`\" operator to access a member of a namespace.\n",
    "\n",
    "By default, when you type stuff into the python interpreter or here in the Jupyter notebook, or in a script, it is in its own default namespace, and you don't need to prefix any of the variables with a namespace indicator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`math` provides the value of pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.141592653589793"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.pi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is distinct from any variable `pi` we might define here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "pi = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 3.141592653589793\n"
     ]
    }
   ],
   "source": [
    "print(pi, math.pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note here that `pi` and `math.pi` are distinct from one another&mdash;they are in different namespaces."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Floating point operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The same operators, `+`, `-`, `*`, `/` work are usual for floating point numbers.  To raise an number to a power, we use the `**` operator (this is the same as Fortran)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "R = 2.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12.566370614359172"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.pi * R**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Operator precedence follows that of most languages.  See\n",
    "\n",
    "https://docs.python.org/3/reference/expressions.html#operator-precedence\n",
    "    \n",
    "in order of precedence:\n",
    "* quantites in `()`\n",
    "* slicing, calls, subscripts\n",
    "* exponentiation (`**`)\n",
    "* `+x`, `-x`, `~x`\n",
    "* `*`, `@`, `/`, `//`, `%`\n",
    "* `+`, `-`\n",
    "\n",
    "(after this are bitwise operations and comparisons)\n",
    "\n",
    "Parentheses can be used to override the precedence."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "    \n",
    "<span class=\"fa fa-flash\"></span> Quick Exercise:\n",
    "\n",
    "Consider the following expressions.  Using the ideas of precedence, think about what value will result, then try it out in the cell below to see if you were right.\n",
    "\n",
    "  * `1 + 3*2**2`\n",
    "  * `1 + (3*2)**2`\n",
    "  * `2**3**2`\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The math module provides a lot of the standard math functions. Most are actually repeated in `numpy`, so in practice, I personally almost never use `math`.\n",
    "\n",
    "For the trig functions, the expectation is that the argument to the function is in radians&mdash;you can use `math.radians()` to convert from degrees to radians, ex:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7071067811865476"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.cos(math.radians(45))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that in that statement we are feeding the output of one function (`math.radians()`) into a second function, `math.cos()`\n",
    "\n",
    "When in doubt, as for help to discover all of the things a module provides:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function sin in module math:\n",
      "\n",
      "sin(x, /)\n",
      "    Return the sine of x (measured in radians).\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(math.sin)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Complex numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "python uses '`j`' to denote the imaginary unit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1+2j)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1.0 + 2j"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3+3j)\n",
      "(-2+3j)\n"
     ]
    }
   ],
   "source": [
    "a = 1j\n",
    "b = 3.0 + 2.0j\n",
    "print(a + b)\n",
    "print(a * b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we can use `abs()` to get the magnitude and separately get the real or imaginary parts "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "magnitude:  3.605551275463989\n",
      "real part:  0.0\n",
      "imag part:  1.0\n"
     ]
    }
   ],
   "source": [
    "print(\"magnitude: \", abs(b))\n",
    "print(\"real part: \", a.real)\n",
    "print(\"imag part: \", a.imag)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python doesn't care if you use single or double quotes for strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "a = \"this is my string\"\n",
    "b = 'another string'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is my string\n",
      "another string\n"
     ]
    }
   ],
   "source": [
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Many of the usual mathematical operators are defined for strings as well.  For example to concatenate or duplicate:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'this is my stringanother string'"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'this is my string. another string'"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a + \". \" + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'this is my stringthis is my string'"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are several escape codes that are interpreted in strings.  These start with a backwards-slash, `\\`.  E.g., you can use `\\n` for new line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is my string\n",
      "hello\n"
     ]
    }
   ],
   "source": [
    "a = a + \"\\n\" + \"hello\"\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "    \n",
    "<span class=\"fa fa-flash\"></span> Quick Exercise:\n",
    "    \n",
    "The `input()` function can be used to ask the user for input.\n",
    "\n",
    "  * Use `help(input)` to see how it works.  \n",
    "  * Write code to ask for input and store the result in a variable.  `input()` will return a string.\n",
    "\n",
    "  * Use the `float()` function to convert a number entered as input to a floating point variable.  \n",
    "  * Check to see if the conversion worked using the `type()` function.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Triple quotes \"\"\" can enclose multiline strings.  This is useful for docstrings at the start of functions (more on that later...)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "c = \"\"\"\n",
    "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor \n",
    "incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis \n",
    "nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. \n",
    "Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore \n",
    "eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt \n",
    "in culpa qui officia deserunt mollit anim id est laborum.\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor \n",
      "incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis \n",
      "nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. \n",
      "Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore \n",
      "eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt \n",
      "in culpa qui officia deserunt mollit anim id est laborum.\n"
     ]
    }
   ],
   "source": [
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A raw string does not replace escape sequences (like \\n).  Just put a `r` before the first quote:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'this is a raw string\\\\n hello'"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = r\"this is a raw string\\n hello\"\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slicing is used to access a portion of a string.\n",
    "\n",
    "Slicing a string can seem a bit counterintuitive if you are coming from C or Fortran.  The trick is to think of the index as representing the left edge of a character in the string.  When we do arrays later, the same will apply.\n",
    "\n",
    "Also note that python (like C) uses 0-based indexing\n",
    "\n",
    "Negative indices count from the right."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ti '"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[0:5:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is my string\n",
      "is\n",
      "t\n",
      "this is a raw string\\n hello\n",
      "l\n"
     ]
    }
   ],
   "source": [
    "a = \"this is my string\"\n",
    "print(a)\n",
    "print(a[5:7])\n",
    "print(a[0])\n",
    "print(d)\n",
    "print(d[-2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "    \n",
    "<span class=\"fa fa-flash\"></span> Quick Exercise:\n",
    "\n",
    "Strings have a lot of _methods_ (functions that know how to work with a particular datatype, in this case strings).  A useful method is `.find()`.  For a string `a`,\n",
    "`a.find(s)` will return the index of the first occurrence of `s`.\n",
    "\n",
    "For our string `c` above, find the first `.` (identifying the first full sentence), and print out just the first sentence in `c` using this result\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are also a number of methods and functions that work with strings.  Here are some examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "that is my string\n",
      "17\n",
      "this is my string\n",
      "g\n"
     ]
    }
   ],
   "source": [
    "print(a.replace(\"this\", \"that\"))\n",
    "print(len(a))\n",
    "print(a.strip())    # Also notice that strip removes the \\n\n",
    "print(a.strip()[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that our original string, `a`, has not changed.  In python, strings are *immutable*.  Operations on strings return a new string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'this is my string'"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As usual, ask for help to learn more:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "#help(str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can format strings when we are printing to insert quantities in particular places in the string.  A `{}` serves as a placeholder for a quantity and is replaced using the `.format()` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = 1; b = 2.0; c = test\n"
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "b = 2.0\n",
    "c = \"test\"\n",
    "print(\"a = {}; b = {}; c = {}\".format(a, b, c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "But the more modern way to do this is to use *f-strings*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = 1; b = 2.0; c = test\n"
     ]
    }
   ],
   "source": [
    "print(f\"a = {a}; b = {b}; c = {c}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note the `f` preceding the starting `\"`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Advanced Datatypes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These notes follow the official python tutorial pretty closely: http://docs.python.org/3/tutorial/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists group together data.  Many languages have arrays (we'll look at those in a bit in python).  But unlike arrays in most languages, lists can hold data of all different types -- they don't need to be homogeneous.  The data can be a mix of integers, floating points or complex #s, strings, or other objects (including other lists).\n",
    "\n",
    "A list is defined using square brackets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1, 2.0, \"my list\", 4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2.0, 'my list', 4]"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can index a list to get a single element -- remember that python starts counting at 0:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'my list'"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2.0, 'my list', 4, 'hello']"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a+[\"hello\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like with strings, mathematical operators are defined on lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2.0, 'my list', 4, 1, 2.0, 'my list', 4]"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a*2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `len()` function returns the length of a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unlike strings, lists are _mutable_ -- you can change elements in a list easily"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2.0, 'my list', 4]\n",
      "[1, -2.0, 'my list', 4]\n"
     ]
    }
   ],
   "source": [
    "print(a)\n",
    "a[1] = -2.0\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, -2.0, 'my list', 4]"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-1, -2.1, -2.0, 'my list', 4]"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[0:1] = [-1, -2.1]   # this will put two items in the spot where 1 existed before\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that lists can even contain other lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-1, ['other list', 3], -2.0, 'my list', 4]"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[1] = [\"other list\", 3]\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just like everything else in python, a list is an object that is the instance of a class.  Classes have methods (functions) that know how to operate on an object of that class.\n",
    "\n",
    "There are lots of methods that work on lists.  Two of the most useful are append, to add to the end of a list, and pop, to remove the last element:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-1, ['other list', 3], -2.0, 'my list', 4, 6]"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.append(6)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-1, ['other list', 3], -2.0, 'my list', 4]"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "    \n",
    "<span class=\"fa fa-flash\"></span> Quick Exercise:\n",
    "\n",
    "An operation we'll see a lot is to begin with an empty list and add elements to it.  An empty list is created as:\n",
    "```\n",
    "\n",
    " a = []\n",
    " \n",
    "```\n",
    "\n",
    "  * Create an empty list\n",
    "  * Append the integers 1 through 10 to it.  \n",
    "  * Now pop them out of the list one by one.\n",
    "  \n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Copying lists\n",
    "\n",
    "Copying may seem a little counterintuitive at first.  The best way to think about this is that your list lives in memory somewhere and when you do \n",
    "\n",
    "```\n",
    "a = [1, 2, 3, 4]\n",
    "```\n",
    "\n",
    "then the variable `a` is set to point to that location in memory, so it refers to the list.\n",
    "\n",
    "If we then do\n",
    "```\n",
    "b = a\n",
    "```\n",
    "then `b` will also point to that same location in memory -- the exact same list object.\n",
    "\n",
    "Since these are both pointing to the same location in memory, if we change the list through `a`, the change is reflected in `b` as well:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n",
      "['changed', 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3, 4]\n",
    "b = a  # both a and b refer to the same list object in memory\n",
    "print(a)\n",
    "a[0] = \"changed\"\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to create a new object in memory that is a copy of another, then you can either index the list, using `:` to get all the elements, or use the `list()` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['changed', 'two', 3, 4]\n",
      "['changed', 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "c = list(a)   # you can also do c = a[:], which basically slices the entire list\n",
    "a[1] = \"two\"\n",
    "print(a)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Things get a little complicated when a list contains another mutable object, like another list.  Then the copy we looked at above is only a _shallow copy_."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When in doubt, use the `id()` function to figure out where in memory an object lies (you shouldn't worry about the what value of the numbers you get from `id` mean, but just whether they are the same as those for another object)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4416015744 4416015744 4416493184\n"
     ]
    }
   ],
   "source": [
    "print(id(a), id(b), id(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or use the `is` operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a is b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a is c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are lots of other methods that work on lists (remember, ask for help)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-1, -1, 2, 5, 9, 10, 24]"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list = [10, -1, 5, 24, 2, -1, 9]\n",
    "my_list.sort()\n",
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list.count(-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also insert elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['changed', 'two', 3, 'my inserted element', 4]"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.insert(3, \"my inserted element\")\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "joining two lists is simple.  Like with strings, the `+` operator concatenates:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "b = [1, 2, 3]\n",
    "c = [4, 5, 6]\n",
    "d = b + c\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A dictionary stores data as a `key:value` pair.  Unlike a list where you have a particular order, the keys in a dictionary allow you to access information anywhere easily:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_dict = {\"key1\":1, \"key2\":2, \"key3\":3}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dict[\"key1\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can add a new `key:value` easily, and it can be of any type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'key1': 1, 'key2': 2, 'key3': 3, 'newkey': 'new'}"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dict[\"newkey\"] = \"new\"\n",
    "my_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also easily get the list of keys that are defined in a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['key1', 'key2', 'key3', 'newkey']"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "keys = list(my_dict.keys())\n",
    "keys"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and check easily whether a key exists in the dictionary using the `in` operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(\"key1\" in keys)\n",
    "print(\"invalidKey\" in keys)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "    \n",
    "<span class=\"fa fa-flash\"></span> Quick Exercise:\n",
    "\n",
    "Create a dictionary where the keys are the string names of the numbers zero to nine and the values are their numeric representation (0, 1, ... , 9)\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List Comprehensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List comprehensions provide a compact way to initialize lists.  Some examples from the tutorial"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "squares = [x**2 for x in range(10)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we use another python type, the tuple, to combine numbers from two lists into a pair"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "    \n",
    "<span class=\"fa fa-flash\"></span> Quick Exercise:\n",
    "\n",
    "Use a list comprehension to create a new list from `squares` containing only the even numbers.  It might be helpful to use the modulus operator, `%`\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuples are immutable -- they cannot be changed, but they are useful for organizing data in some situations.  We use () to indicate a tuple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3, 4)"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = (1, 2, 3, 4)\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can unpack a tuple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "w, x, y, z = a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since a tuple is immutable, we cannot change an element:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "tags": []
   },
   "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)",
      "Cell \u001b[0;32mIn[87], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43ma\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m2\u001b[39m\n",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "a[0] = 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But we can turn it into a list, and then we can change it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = list(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'int' 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)",
      "Cell \u001b[0;32mIn[88], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mz\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnew\u001b[39m\u001b[38;5;124m\"\u001b[39m\n",
      "\u001b[0;31mTypeError\u001b[0m: 'int' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "z[0] = \"new\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is often not clear how tuples differ from lists.  The most obvious way is that they are immutable.  Often we'll see tuples used to store related data that should all be interpreted together.  A good example is a Cartesian point, (x, y).  Here is a list of points:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 2), (2, 3), (3, 4)]"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "points = []\n",
    "points.append((1,2))\n",
    "points.append((2,3))\n",
    "points.append((3,4))\n",
    "points"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can even generate these for a curve using a list comprehension:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 5),\n",
       " (1, 7),\n",
       " (2, 9),\n",
       " (3, 11),\n",
       " (4, 13),\n",
       " (5, 15),\n",
       " (6, 17),\n",
       " (7, 19),\n",
       " (8, 21),\n",
       " (9, 23)]"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "points = [(x, 2*x + 5) for x in range(10)]\n",
    "points"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Control Flow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These notes follow the official python tutorial pretty closely: http://docs.python.org/3/tutorial/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To write a program, we need the ability to iterate and take action based on the values of a variable.  This includes if-tests and loops.\n",
    "\n",
    "Python uses whitespace to denote a block of code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## While loop\n",
    "\n",
    "A simple while loop&mdash;notice the indentation to denote the block that is part of the loop.\n",
    "\n",
    "Here we also use the compact `+=` operator: `n += 1` is the same as `n = n + 1`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "n = 0\n",
    "while n < 10:\n",
    "    print(n)\n",
    "    n += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This was a very simple example.  But often we'll use the `range()` function in this situation.  Note that `range()` can take a stride."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n",
      "6\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "for n in range(2, 10, 2):\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## If statements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`if` allows for branching. Python does not have a select/case statement like some other languages, but `if`, `elif`, and `else` can reproduce any branching functionality you might need."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "zero\n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "\n",
    "if x < 0:\n",
    "    print(\"negative\")\n",
    "elif x == 0:\n",
    "    print(\"zero\")\n",
    "else:\n",
    "    print(\"positive\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterating over elements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's easy to loop over items in a list or any _iterable_ object. Looping over indexes like you would do in C is definitely not pythonic. The `in` operator is the key here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2.0\n",
      "three\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "alist = [1, 2.0, \"three\", 4]\n",
    "for a in alist:\n",
    "    print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2.0\n",
      "three\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for i in [0,1,2,3]:\n",
    "    print(alist[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "t\n",
      "h\n",
      "i\n",
      "s\n",
      " \n",
      "i\n",
      "s\n",
      " \n",
      "a\n",
      " \n",
      "s\n",
      "t\n",
      "r\n",
      "i\n",
      "n\n",
      "g\n"
     ]
    }
   ],
   "source": [
    "for c in \"this is a string\":\n",
    "    print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can combine loops and if-tests to do more complex logic, like break out of the loop when you find what you're looking for"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "n = 0\n",
    "for a in alist:\n",
    "    if a == \"three\":\n",
    "        break\n",
    "    else:\n",
    "        n += 1\n",
    "\n",
    "print(n)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(for that example, however, there is a simpler way)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "alist.index(\"three\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For dictionaries, you can also loop over the elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "key = key1, value = 1\n",
      "key = key2, value = 2\n",
      "key = key3, value = 3\n"
     ]
    }
   ],
   "source": [
    "my_dict = {\"key1\":1, \"key2\":2, \"key3\":3}\n",
    "\n",
    "for k, v in my_dict.items():\n",
    "    print(\"key = {}, value = {}\".format(k, v))    # notice how we do the formatting here\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "key1 1\n",
      "key2 2\n",
      "key3 3\n"
     ]
    }
   ],
   "source": [
    "for k in sorted(my_dict):\n",
    "    print(k, my_dict[k])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes we want to loop over a list element and know its index -- `enumerate()` helps here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1\n",
      "1 2.0\n",
      "2 three\n",
      "3 4\n"
     ]
    }
   ],
   "source": [
    "for n, a in enumerate(alist):\n",
    "    print(n, a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "    \n",
    "<span class=\"fa fa-flash\"></span> Quick Exercise:\n",
    "    \n",
    "`zip()` allows us to loop over two iterables at the same time.  Consider the following two\n",
    "lists:\n",
    "\n",
    "```\n",
    "\n",
    " a = [1, 2, 3, 4, 5, 6, 7, 8]\n",
    " b = [\"a\", \"b\", \"c\", \"d\", \"e\", \"f\", \"g\", \"h\"]\n",
    " \n",
    "```\n",
    "\n",
    "`zip(a, b)` will act like a list with each element a tuple with one item from `a` and the corresponding element from `b`. \n",
    "\n",
    "Try looping over these lists together (using `zip()`) and print the corresponding elements from each list together on a single line.\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 a\n",
      "2 b\n",
      "3 c\n",
      "4 d\n",
      "5 e\n",
      "6 f\n",
      "7 g\n",
      "8 h\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3, 4, 5, 6, 7, 8]\n",
    "b = [\"a\", \"b\", \"c\", \"d\", \"e\", \"f\", \"g\", \"h\"]\n",
    "\n",
    "\n",
    "for x,y in zip(a,b):\n",
    "    print(x,y)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 'a'),\n",
       " (2, 'b'),\n",
       " (3, 'c'),\n",
       " (4, 'd'),\n",
       " (5, 'e'),\n",
       " (6, 'f'),\n",
       " (7, 'g'),\n",
       " (8, 'h')]"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(zip(a,b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "zip"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(zip(a,b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "    \n",
    "<span class=\"fa fa-flash\"></span> Quick Exercise:\n",
    "    \n",
    "\n",
    "The `.split()` function on a string can split it into words (separating on spaces).  \n",
    "\n",
    "Using `.split()`, loop over the words in the string\n",
    "\n",
    "`a = \"The quick brown fox jumped over the lazy dog\"`\n",
    "\n",
    "and print one word per line\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions and Classes\n",
    "\n",
    "Functions and classes are the building blocks of complex programs.\n",
    "These allow you to organize your code into logical units that can\n",
    "reused.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions are used to organize program flow, especially to allow us to easily do commonly needed tasks over and over again.  We've already used a lot of functions, such as those that work on lists (`append()` and `pop()`) or strings (like `replace()`).  Here we see how to write our own functions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A function takes arguments, listed in the `()` and returns a value.  Even if you don't explicitly give a return value, one will be return (e.g., `None`). \n",
    "\n",
    "Here's a simple example of a function that takes a single argument, `i`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "in the function, i = 10\n",
      "in the function, i = 5\n"
     ]
    }
   ],
   "source": [
    "def my_fun(i):\n",
    "    print(f\"in the function, i = {i}\")\n",
    "    \n",
    "my_fun(10)\n",
    "my_fun(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "def great(x):\n",
    "    alist='hello'\n",
    "    print(x)\n",
    "    print(alist)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "hello\n"
     ]
    }
   ],
   "source": [
    "great(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "hello\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "print(great(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions are one place where _scope_ comes into play.  A function has its own _namespace_.  If a variable is not defined in that function, then it will look to the namespace from where it was called to see if that variable exists there.  \n",
    "\n",
    "However, you should avoid this as much as possible (variables that persist across namespaces are called global variables)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions always return a value&mdash;if one is not explicitly given, then they return None, otherwise, they can return values (even multiple values) of any type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "in the function, i = 10\n"
     ]
    }
   ],
   "source": [
    "a = my_fun(10)\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's a simple function that takes two numbers and returns their product."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def multiply(a, b):\n",
    "    return a*b\n",
    "\n",
    "c = multiply(3, 4)\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "    \n",
    "<span class=\"fa fa-flash\"></span> Quick Exercise:\n",
    "    \n",
    "\n",
    "Write a simple function that takes a sentence (as a string) and returns an integer equal to the length of the longest word in the sentence.  The `len()` function and the `.split()` methods will be useful here.\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`None` is a special quantity in python (analogous to `null` in some other languages).  We can test on `None`&mdash;the preferred manner is to use `is`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "we didn't do anything\n"
     ]
    }
   ],
   "source": [
    "def do_nothing():\n",
    "    pass\n",
    "\n",
    "a = do_nothing()\n",
    "if a is None:\n",
    "    print(\"we didn't do anything\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a is None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More Complex Functions\n",
    "\n",
    "Here's a more complex example.  We return a pair of variables&mdash;behind the scenes in python this is done by packing them into a tuple and then unpacking on the calling end.  Also note the _docstring_ here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233]"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def fib2(n): # return Fibonacci series up to n (from the python tutorial)\n",
    "    \"\"\"Return a list containing the Fibonacci series up to n.\"\"\"\n",
    "    result = []\n",
    "    a, b = 0, 1\n",
    "    while a < n:\n",
    "        result.append(a)    # see below\n",
    "        a, b = b, a+b\n",
    "    return result, len(result)\n",
    "\n",
    "fib, n = fib2(250)\n",
    "fib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that this function includes a docstring (just after the function definition).  This is used by the help system"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function fib2 in module __main__:\n",
      "\n",
      "fib2(n)\n",
      "    Return a list containing the Fibonacci series up to n.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(fib2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can have optional arguments which provide defaults.  Here's a simple function that validates an answer, with an optional argument that can provide the correct answer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[0;31mSignature:\u001b[0m \u001b[0mfib2\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
       "\u001b[0;31mDocstring:\u001b[0m Return a list containing the Fibonacci series up to n.\n",
       "\u001b[0;31mFile:\u001b[0m      /var/folders/gw/2bhpr_8j1tn515cjl3mdfsw00000gn/T/ipykernel_4299/1529469263.py\n",
       "\u001b[0;31mType:\u001b[0m      function"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "?fib2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "def check_answer(val, correct_answer=\"a\"):\n",
    "    return val == correct_answer\n",
    "\n",
    "print(check_answer(\"a\"))\n",
    "print(check_answer(\"a\", correct_answer=\"b\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is important to note that python evaluates the optional arguments once&mdash;when the function is defined.  This means that if you make the default an empty object, for instance, it will persist across all calls.\n",
    "\n",
    "**This leads to one of the most common errors for beginners**\n",
    "\n",
    "Here's an example of trying to initialize to an empty list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1]\n",
      "[1, 2]\n",
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "def f(a, L=[]):\n",
    "    L.append(a)\n",
    "    return L\n",
    "\n",
    "print(f(1))\n",
    "print(f(2))\n",
    "print(f(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that each call does not create its own separate list.  Instead a single empty list was created when the function was first processed, and this list persists in memory as the default value for the optional argument `L`.  \n",
    "\n",
    "If we want a unique list created each time (e.g., a separate place in memory), we instead initialize the argument's value to `None` and then check its actual value and create an empty list in the function body itself if the default value was unchanged."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1]\n",
      "[2]\n",
      "[3]\n"
     ]
    }
   ],
   "source": [
    "def fnew(a, L=None):\n",
    "    if L is None:\n",
    "        L = []\n",
    "    L.append(a)\n",
    "    return L\n",
    "\n",
    "print(fnew(1))\n",
    "print(fnew(2))\n",
    "print(fnew(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2]\n"
     ]
    }
   ],
   "source": [
    "L = fnew(1)\n",
    "print(fnew(2, L=L))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that the same `None` that we saw previously comes into play here.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2]"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lambdas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lambdas are \"disposable\" functions.  These are small, nameless functions that are often used as arguments in other functions. The following are equivalent:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [],
   "source": [
    "def square(x):\n",
    "    return x**2\n",
    "\n",
    "square = lambda x : x**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For instance: We have a list of tuples and we want to sort the list based on the second item in the tuple.  The `sort` method can take a `key` optional argument that tells us how to interpret the list item for sorting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]\n",
    "pairs.sort(key=lambda p: p[1])\n",
    "pairs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(2, 'two'), (3, 'three'), (4, 'four'), (10, 'one')]"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pairs = [(10, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]\n",
    "\n",
    "pairs.sort()\n",
    "pairs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(2, 'two'), (3, 'three'), (4, 'four'), (10, 'one')]"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pairs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we use a lambda in an extract from a list (with the filter function)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(filter(lambda x:x==1, [1,2,3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0,\n",
       " 36,\n",
       " 144,\n",
       " 324,\n",
       " 576,\n",
       " 900,\n",
       " 1296,\n",
       " 1764,\n",
       " 2304,\n",
       " 2916,\n",
       " 3600,\n",
       " 4356,\n",
       " 5184,\n",
       " 6084,\n",
       " 7056,\n",
       " 8100,\n",
       " 9216]"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squares = [x**2 for x in range(100)]\n",
    "sq = list(filter(lambda x : x%2 == 0 and x%3 == 0, squares))\n",
    "sq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Classes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "Classes are the fundamental concept for object oriented programming.  A class defines a data type with both data and functions that can operate on the data.  An object is an instance of a class.  Each object will have its own namespace (separate from other instances of the class and other functions, etc. in your program).\n",
    "\n",
    "We use the dot operator, `.`, to access members of the class (data or functions).  We've already been doing this a lot, strings, ints, lists, ... are all objects in python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Naming conventions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The python community has some naming convections, defined in PEP-8:\n",
    "\n",
    "https://www.python.org/dev/peps/pep-0008/\n",
    "\n",
    "The widely adopted ones are:\n",
    "\n",
    "* class names start with an uppercase, and use \"camelcase\" for multiword names, e.g. `ShoppingCart`\n",
    "\n",
    "* variable names (including objects which are instances of a class) are lowercase and use underscores to separate words, e.g., `shopping_cart`\n",
    "\n",
    "* module names should be lowercase with underscores\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A simple class"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's a class that holds some student info"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Student:\n",
    "    def __init__(self, name, grade=None):\n",
    "        self.name = name\n",
    "        self.grade = grade"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This has a function, `__init__()` which is called automatically when we create an instance of the class.  \n",
    "\n",
    "The argument `self` refers to the object that we will create, and points to the memory that the object will use to store the class's contents."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mike\n",
      "18\n"
     ]
    }
   ],
   "source": [
    "a = Student(\"Mike\", 18)\n",
    "print(a.name)\n",
    "print(a.grade)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's create a bunch of them, stored in a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [],
   "source": [
    "students = []\n",
    "students.append(Student(\"fry\", \"19\"))\n",
    "students.append(Student(\"leela\", \"30\"))\n",
    "students.append(Student(\"zoidberg\", \"23\"))\n",
    "students.append(Student(\"hubert\", \"10\"))\n",
    "students.append(Student(\"bender\", \"26\"))\n",
    "students.append(Student(\"calculon\", \"27\"))\n",
    "students.append(Student(\"amy\", \"30\"))\n",
    "students.append(Student(\"hermes\", \"30\"))\n",
    "students.append(Student(\"scruffy\", \"12\"))\n",
    "students.append(Student(\"flexo\", \"18\"))\n",
    "students.append(Student(\"morbo\", \"23\"))\n",
    "students.append(Student(\"hypnotoad\", \"30lode\"))\n",
    "students.append(Student(\"zapp\", \"14\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "    \n",
    "<span class=\"fa fa-flash\"></span> Quick Exercise:\n",
    "\n",
    "\n",
    "Loop over the students in the `students` list and print out the name and grade of each student, one per line.\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'fry'"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "students[0].name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use list comprehensions with our list of objects.  For example, let's find all the students who have 30's"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['leela', 'amy', 'hermes', 'hypnotoad']"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "As = [q.name for q in students if q.grade.startswith(\"30\")]\n",
    "As"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Playing Cards"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's a more complicated class that represents a playing card.  Notice that we are using unicode to represent the suits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Card:\n",
    "    \n",
    "    def __init__(self, suit=1, rank=2):\n",
    "        if suit < 1 or suit > 4:\n",
    "            print(\"invalid suit, setting to 1\")\n",
    "            suit = 1\n",
    "            \n",
    "        self.suit = suit\n",
    "        self.rank = rank\n",
    "        \n",
    "    def value(self):\n",
    "        \"\"\" we want things order primarily by rank then suit \"\"\"\n",
    "        return self.suit + (self.rank-1)*14\n",
    "    \n",
    "    # we include this to allow for comparisons with < and > between cards \n",
    "    def __lt__(self, other):\n",
    "        return self.value() < other.value()\n",
    "\n",
    "    def __eq__(self, other):\n",
    "        return self.rank == other.rank and self.suit == other.suit\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return self.__str__()\n",
    "    \n",
    "    def __str__(self):\n",
    "        suits = [u\"\\u2660\",  # spade\n",
    "                 u\"\\u2665\",  # heart\n",
    "                 u\"\\u2666\",  # diamond\n",
    "                 u\"\\u2663\"]  # club\n",
    "        \n",
    "        r = str(self.rank)\n",
    "        if self.rank == 11:\n",
    "            r = \"J\"\n",
    "        elif self.rank == 12:\n",
    "            r = \"Q\"\n",
    "        elif self.rank == 13:\n",
    "            r = \"K\"\n",
    "        elif self.rank == 14:\n",
    "            r = \"A\"\n",
    "                \n",
    "        return r +':'+suits[self.suit-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we can create a card easily."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [],
   "source": [
    "c1 = Card()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can pass arguments to `__init__` in when we setup the class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [],
   "source": [
    "c2 = Card(suit=2, rank=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once we have our object, we can access any of the functions in the class using the `dot` operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c2.value()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "invalid suit, setting to 1\n"
     ]
    }
   ],
   "source": [
    "c3 = Card(suit=0, rank=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `__str__` method converts the object into a string that can be printed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2:♠\n",
      "2:♥\n"
     ]
    }
   ],
   "source": [
    "print(c1)\n",
    "print(c2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The value method assigns a value to the object that can be used in comparisons, and the `__lt__` method is what does the actual comparing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(c1 > c2)\n",
    "print(c1 < c2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that not every operator is defined for our class, so, for instance, we cannot add two cards together:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'Card' and 'Card'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[152], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mc1\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mc2\u001b[49m\n",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'Card' and 'Card'"
     ]
    }
   ],
   "source": [
    "c1 + c2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "    \n",
    "<span class=\"fa fa-flash\"></span> Quick Exercise:\n",
    "\n",
    " * Create a \"hand\" corresponding to a straight (5 cards of any suite, but in sequence of rank)\n",
    " * Create another hand corresponding to a flush (5 cards all of the same suit, of any rank)\n",
    " * Finally create a hand with one of the cards duplicated&mdash;this should not be allowed in a standard deck of cards.  How would you check for this?\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Deck of Cards"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Classes can use other classes as data objects&mdash;here's a deck of cards.  Note that we are using the python random module here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "class Deck:\n",
    "    \"\"\" the deck is a collection of cards \"\"\"\n",
    "\n",
    "    def __init__(self):\n",
    "\n",
    "        self.nsuits = 4\n",
    "        self.nranks = 13\n",
    "        self.minrank = 2\n",
    "        self.maxrank = self.minrank + self.nranks - 1\n",
    "\n",
    "        self.cards = []\n",
    "\n",
    "        for rank in range(self.minrank,self.maxrank+1):\n",
    "            for suit in range(1, self.nsuits+1):\n",
    "                self.cards.append(Card(rank=rank, suit=suit))\n",
    "\n",
    "    def shuffle(self):\n",
    "        random.shuffle(self.cards)\n",
    "\n",
    "    def get_cards(self, num=1):\n",
    "        hand = []\n",
    "        for n in range(num):\n",
    "            hand.append(self.cards.pop())\n",
    "\n",
    "        return hand\n",
    "    \n",
    "    def __str__(self):\n",
    "        string = \"\"\n",
    "        for c in self.cards:\n",
    "            string += str(c) + \" \"\n",
    "        return string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's create a deck, shuffle, and deal a hand (for a poker game)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2:♠ 2:♥ 2:♦ 2:♣ 3:♠ 3:♥ 3:♦ 3:♣ 4:♠ 4:♥ 4:♦ 4:♣ 5:♠ 5:♥ 5:♦ 5:♣ 6:♠ 6:♥ 6:♦ 6:♣ 7:♠ 7:♥ 7:♦ 7:♣ 8:♠ 8:♥ 8:♦ 8:♣ 9:♠ 9:♥ 9:♦ 9:♣ 10:♠ 10:♥ 10:♦ 10:♣ J:♠ J:♥ J:♦ J:♣ Q:♠ Q:♥ Q:♦ Q:♣ K:♠ K:♥ K:♦ K:♣ A:♠ A:♥ A:♦ A:♣ \n",
      "52\n"
     ]
    }
   ],
   "source": [
    "mydeck = Deck()\n",
    "print(mydeck)\n",
    "print(len(mydeck.cards))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that there is no error handling in this class.  `get_cards()` will deal cards from the deck, removing them in the process.  Eventually we'll run out of cards."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4:♥\n",
      "6:♠\n",
      "6:♦\n",
      "9:♠\n",
      "K:♠\n"
     ]
    }
   ],
   "source": [
    "mydeck.shuffle()\n",
    "\n",
    "hand = mydeck.get_cards(5)\n",
    "for c in sorted(hand): print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can define operations like `+` and `-` that work on our objects.  Here's a simple example of currency&mdash;we keep track of the country and the amount"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Currency:\n",
    "    \"\"\" a simple class to hold foreign currency \"\"\"\n",
    "    \n",
    "    def __init__(self, amount, country=\"US\"):\n",
    "        self.amount = amount\n",
    "        self.country = country\n",
    "        \n",
    "    def __add__(self, other):\n",
    "        if self.country != other.country:\n",
    "            return None\n",
    "        return Currency(self.amount + other.amount, country=self.country)\n",
    "\n",
    "    def __sub__(self, other):\n",
    "        return Currency(self.amount - other.amount, country=self.country)\n",
    "\n",
    "    def __str__(self):\n",
    "        return f\"{self.amount} {self.country}\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now create some monetary amounts for different countries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 US\n"
     ]
    }
   ],
   "source": [
    "d1 = Currency(10, \"US\")\n",
    "d2 = Currency(15, \"US\")\n",
    "print(d2 - d1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "    \n",
    "<span class=\"fa fa-flash\"></span> Quick Exercise:\n",
    "    \n",
    "\n",
    "As written, our Currency class has a bug&mdash;it does not check whether the amounts are in the same country before adding.  Modify the `__add__` method to first check if the countries are the same.  If they are, return the new `Currency` object with the sum, otherwise, return `None`.\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Vectors Example\n",
    "\n",
    "Here we write a class to represent 2-d vectors.  Vectors have a direction and a magnitude.  We can represent them as a pair of numbers, representing the `x` and `y` lengths.  We'll use a tuple internally for this\n",
    "\n",
    "We want our class to do all the basic operations we do with vectors: add them, multiply by a scalar, cross product, dot product, return the magnitude, etc.\n",
    "\n",
    "We'll use the math module to provide some basic functions we might need (like sqrt)\n",
    "\n",
    "This example will show us how to overload the standard operations in python.  Here's a list of the builtin methods:\n",
    "https://docs.python.org/3/reference/datamodel.html\n",
    "\n",
    "To make it really clear what's being called when, I've added prints in each of the functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "class Vector:\n",
    "    \"\"\" a general two-dimensional vector \"\"\"\n",
    "    \n",
    "    def __init__(self, x, y):\n",
    "        print(\"in __init__\")\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "        \n",
    "    def __str__(self):\n",
    "        print(\"in __str__\")        \n",
    "        return f\"({self.x} î + {self.y} ĵ)\"\n",
    "    \n",
    "    def __repr__(self):\n",
    "        print(\"in __repr__\")        \n",
    "        return f\"Vector({self.x}, {self.y})\"\n",
    "\n",
    "    def __add__(self, other):\n",
    "        print(\"in __add__\")        \n",
    "        if isinstance(other, Vector):\n",
    "            return Vector(self.x + other.x, self.y + other.y)\n",
    "        else:\n",
    "            # it doesn't make sense to add anything but two vectors\n",
    "            print(f\"we don't know how to add a {type(other)} to a Vector\")\n",
    "            raise NotImplementedError\n",
    "\n",
    "    def __sub__(self, other):\n",
    "        print(\"in __sub__\")        \n",
    "        if isinstance(other, Vector):\n",
    "            return Vector(self.x - other.x, self.y - other.y)\n",
    "        else:\n",
    "            # it doesn't make sense to add anything but two vectors\n",
    "            print(f\"we don't know how to add a {type(other)} to a Vector\")\n",
    "            raise NotImplementedError\n",
    "\n",
    "    def __mul__(self, other):\n",
    "        print(\"in __mul__\")        \n",
    "        if isinstance(other, int) or isinstance(other, float):\n",
    "            # scalar multiplication changes the magnitude\n",
    "            return Vector(other*self.x, other*self.y)\n",
    "        else:\n",
    "            print(\"we don't know how to multiply two Vectors\")\n",
    "            raise NotImplementedError\n",
    "\n",
    "    def __matmul__(self, other):\n",
    "        print(\"in __matmul__\")\n",
    "        # a dot product\n",
    "        if isinstance(other, Vector):\n",
    "            return self.x*other.x + self.y*other.y\n",
    "        else:\n",
    "            print(\"matrix multiplication not defined\")\n",
    "            raise NotImplementedError\n",
    "\n",
    "    def __rmul__(self, other):\n",
    "        print(\"in __rmul__\")        \n",
    "        return self.__mul__(other)\n",
    "\n",
    "    def __truediv__(self, other):\n",
    "        print(\"in __truediv__\")        \n",
    "        # we only know how to multiply by a scalar\n",
    "        if isinstance(other, int) or isinstance(other, float):\n",
    "            return Vector(self.x/other, self.y/other)\n",
    "\n",
    "    def __abs__(self):\n",
    "        print(\"in __abs__\")        \n",
    "        return math.sqrt(self.x**2 + self.y**2)\n",
    "\n",
    "    def __neg__(self):\n",
    "        print(\"in __neg__\")        \n",
    "        return Vector(-self.x, -self.y)\n",
    "\n",
    "    def cross(self, other):\n",
    "        # a vector cross product -- we return the magnitude, since it will\n",
    "        # be in the z-direction, but we are only 2-d \n",
    "        return abs(self.x*other.y - self.y*other.x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a basic class that provides two methods `__str__` and `__repr__` to show a representation of it. These two functions provide a readable version of our object.\n",
    "\n",
    "The convection is what `__str__` is human readable while `__repr__` should be a form that can be used to recreate the object (e.g., via `eval()`).  See:\n",
    "\n",
    "http://stackoverflow.com/questions/1436703/difference-between-str-and-repr-in-python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "in __init__\n",
      "in __repr__\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Vector(1, 2)"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v = Vector(1,2)\n",
    "v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "in __str__\n",
      "(1 î + 2 ĵ)\n"
     ]
    }
   ],
   "source": [
    "print(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vectors have a length, and we'll use the `abs()` builtin to provide the magnitude.  For a vector:\n",
    "\n",
    "$$\\vec{v} = \\alpha \\hat{i} + \\beta \\hat{j}$$\n",
    "\n",
    "we have\n",
    "\n",
    "$$|\\vec{v}| = \\sqrt{\\alpha^2 + \\beta^2}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "in __abs__\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "2.23606797749979"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abs(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's look at mathematical operations on vectors now.  We want to be able to add and subtract two vectors as well as multiply and divide by a scalar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "in __init__\n"
     ]
    }
   ],
   "source": [
    "u = Vector(3,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "in __add__\n",
      "in __init__\n",
      "in __str__\n",
      "(4 î + 7 ĵ)\n"
     ]
    }
   ],
   "source": [
    "w = u + v\n",
    "print(w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "in __sub__\n",
      "in __init__\n",
      "in __repr__\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Vector(2, 3)"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u - v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It doesn't make sense to add a scalar to a vector, so we didn't implement this -- what happens?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "in __add__\n",
      "we don't know how to add a <class 'float'> to a Vector\n"
     ]
    },
    {
     "ename": "NotImplementedError",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNotImplementedError\u001b[0m                       Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[137], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mu\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m2.0\u001b[39;49m\n",
      "Cell \u001b[0;32mIn[130], line 24\u001b[0m, in \u001b[0;36mVector.__add__\u001b[0;34m(self, other)\u001b[0m\n\u001b[1;32m     21\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m     22\u001b[0m     \u001b[38;5;66;03m# it doesn't make sense to add anything but two vectors\u001b[39;00m\n\u001b[1;32m     23\u001b[0m     \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mwe don\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mt know how to add a \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mtype\u001b[39m(other)\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m to a Vector\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m---> 24\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mNotImplementedError\u001b[39;00m\n",
      "\u001b[0;31mNotImplementedError\u001b[0m: "
     ]
    }
   ],
   "source": [
    "u + 2.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now multiplication.  It makes sense to multiply by a scalar, but there are multiple ways to define multiplication of two vectors.  \n",
    "\n",
    "Note that python provides both a `__mul__` and a `__rmul__` function to define what happens when we multiply a vector by a quantity and what happens when we multiply something else by a vector."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "in __mul__\n",
      "in __init__\n",
      "in __repr__\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Vector(6.0, 10.0)"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u*2.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "in __rmul__\n",
      "in __mul__\n",
      "in __init__\n",
      "in __repr__\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Vector(6.0, 10.0)"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2.0*u"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and division: `__truediv__` is the python 3 way of division `/`, while `__floordiv__` is the old python 2 way, also enabled via `//`.\n",
    "\n",
    "Dividing a scalar by a vector doesn't make sense:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "in __truediv__\n",
      "in __init__\n",
      "in __repr__\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Vector(0.6, 1.0)"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u/5.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for /: 'float' and 'Vector'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[141], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;241;43m5.0\u001b[39;49m\u001b[38;5;241;43m/\u001b[39;49m\u001b[43mu\u001b[49m\n",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for /: 'float' and 'Vector'"
     ]
    }
   ],
   "source": [
    "5.0/u"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python 3.5 introduced a new matrix multiplication operator, `@` -- we'll use this to implement a dot product between two vectors:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "in __matmul__\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u @ v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For a cross product, we don't have an obvious operator, so we'll use a function.  For 2-d vectors, this will result in a scalar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u.cross(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, negation is a separate operation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "in __neg__\n",
      "in __init__\n",
      "in __repr__\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Vector(-3, -5)"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "-u"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we import our own module called `myprofile` (we have it in the same directory as this notebook)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [],
   "source": [
    "import myprofile"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have a docstring at the top -- the comments there are what appear when we ask for help"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on module myprofile:\n",
      "\n",
      "NAME\n",
      "    myprofile\n",
      "\n",
      "DESCRIPTION\n",
      "    A very simple profiling class.  Define some timers and methods\n",
      "    to start and stop them.  Nesting of timers is tracked so we can\n",
      "    pretty print the profiling information.\n",
      "    \n",
      "    # define a timer object, labeled 'my timer'\n",
      "    a = timer('my timer')\n",
      "    \n",
      "    This will add 'my timer' to the list of keys in the 'my timer'\n",
      "    dictionary.  Subsequent calls to the timer class constructor\n",
      "    will have no effect.\n",
      "    \n",
      "    # start timing the 'my timer' block of code\n",
      "    a.begin()\n",
      "    \n",
      "    ... do stuff here ...\n",
      "    \n",
      "    # end the timing of the 'my timer' block of code\n",
      "    a.end()\n",
      "    \n",
      "    for best results, the block of code timed should be large\n",
      "    enough to offset the overhead of the timer class method\n",
      "    calls.\n",
      "    \n",
      "    Multiple timers can be instantiated and nested.  The stackCount\n",
      "    global parameter keeps count of the level of nesting, and the\n",
      "    timerNesting data structure stores the nesting level for each\n",
      "    defined timer.\n",
      "    \n",
      "    timeReport() is called at the end to print out a summary of the\n",
      "    timing.\n",
      "    \n",
      "    At present, no enforcement is done to ensure proper nesting.\n",
      "\n",
      "CLASSES\n",
      "    builtins.object\n",
      "        Timer\n",
      "    \n",
      "    class Timer(builtins.object)\n",
      "     |  Timer(name)\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __init__(self, name)\n",
      "     |      Initialize self.  See help(type(self)) for accurate signature.\n",
      "     |  \n",
      "     |  begin(self)\n",
      "     |  \n",
      "     |  end(self)\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  __dict__\n",
      "     |      dictionary for instance variables (if defined)\n",
      "     |  \n",
      "     |  __weakref__\n",
      "     |      list of weak references to the object (if defined)\n",
      "\n",
      "FUNCTIONS\n",
      "    time_report()\n",
      "\n",
      "DATA\n",
      "    stack_count = 0\n",
      "    timer_nesting = {}\n",
      "    timer_order = []\n",
      "    timers = {}\n",
      "\n",
      "FILE\n",
      "    /Users/dgerosa/Documents/reps/scientificcomputing_bicocca_2023/lectures/myprofile.py\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(myprofile)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This module simply provides a way to time routines (python and ipython have built-in methods for this too)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "main loop:  0.00036907196044921875\n",
      "332833500.0\n"
     ]
    }
   ],
   "source": [
    "t = myprofile.Timer(\"main loop\")\n",
    "t.begin()\n",
    "\n",
    "sum = 0.0\n",
    "for n in range(1000):\n",
    "    sum += n**2\n",
    "\n",
    "\n",
    "t.end()\n",
    "myprofile.time_report()\n",
    "\n",
    "print(sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the file `myprofile.py`, you will see a block of code under\n",
    "\n",
    "```\n",
    "if __name__ == \"__main__\":\n",
    "```\n",
    "\n",
    "That code is executed if the file is run directly, either from the commandline as:\n",
    "\n",
    "`python myprofile.py`\n",
    "\n",
    "for through the `%run` magic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1:  10.005089044570923\n",
      "2:  25.006304025650024\n",
      "   3:  20.003389835357666\n"
     ]
    }
   ],
   "source": [
    "%run myprofile"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exceptions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python raises exceptions when it encounters an error.  The idea is that you can trap these exceptions and take an appropriate action instead of causing the code to crash.  The mechanism for this is `try` / `except`.  Here's an example that causes an exception, `ZeroDivisionError`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "ename": "ZeroDivisionError",
     "evalue": "division by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[163], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m a \u001b[38;5;241m=\u001b[39m \u001b[38;5;241;43m1\u001b[39;49m\u001b[38;5;241;43m/\u001b[39;49m\u001b[38;5;241;43m0\u001b[39;49m\n",
      "\u001b[0;31mZeroDivisionError\u001b[0m: division by zero"
     ]
    }
   ],
   "source": [
    "a = 1/0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and here we handle this  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "warning: you divided by zero\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "try:\n",
    "    a = 1/0\n",
    "except ZeroDivisionError:\n",
    "    print(\"warning: you divided by zero\")\n",
    "    a = 1\n",
    "\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rec(a):\n",
    "    try:\n",
    "        b=1/a\n",
    "    except ZeroDivisionError:\n",
    "        print(\"warning: you divided by zero\")\n",
    "        b=None\n",
    "    return b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "warning: you divided by zero\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "print(rec(0))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another example&mdash;trying to access a key that doesn't exist in a dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'d'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[174], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;28mdict\u001b[39m \u001b[38;5;241m=\u001b[39m {\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124ma\u001b[39m\u001b[38;5;124m\"\u001b[39m:\u001b[38;5;241m1\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mb\u001b[39m\u001b[38;5;124m\"\u001b[39m:\u001b[38;5;241m2\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mc\u001b[39m\u001b[38;5;124m\"\u001b[39m:\u001b[38;5;241m3\u001b[39m}\n\u001b[0;32m----> 2\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;28;43mdict\u001b[39;49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43md\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m)\n",
      "\u001b[0;31mKeyError\u001b[0m: 'd'"
     ]
    }
   ],
   "source": [
    "dict = {\"a\":1, \"b\":2, \"c\":3}\n",
    "print(dict[\"d\"])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`KeyError` is the exception that was raised.  We can check for this and take the appropriate action instead"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    val = dict[\"d\"]\n",
    "except KeyError:\n",
    "    val = None\n",
    "\n",
    "print(val)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are a lot of different types of exceptions that you can catch, and you can catch multiple ones per except clause or have multiple except clauses.  You probably won't be able to anticipate every failure mode in advance.  In that case, when you run and your code crashes because of an exception, the python interpreter will print out the name of the exception and you can then modify your code to take the appropriate action."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# File I/O"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One of the main things that we want to do in scientific computing is get data into and out of our programs.  In addition to plain text files, there are modules that can read lots of different data formats we might encounter."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As expected, a file is an object.  Here we'll use the `try`, `except` block to capture exceptions (like if the file cannot be opened). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<_io.TextIOWrapper name='./mywrite.txt' mode='w' encoding='UTF-8'>\n"
     ]
    }
   ],
   "source": [
    "try: f = open(\"./mywrite.txt\", \"w\")   # open for writing -- any file of the same name will be overwritten\n",
    "except: \n",
    "    print(\"cannot open the file\")\n",
    "\n",
    "print(f)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [],
   "source": [
    "f.write(\"this is my first write\\n\")\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can easily loop over the lines in a file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Lorem', 'ipsum', 'dolor', 'sit', 'amet,', 'consectetur', 'adipisicing', 'elit,', 'sed', 'do']\n",
      "['eiusmod', 'tempor', 'incididunt', 'ut', 'labore', 'et', 'dolore', 'magna', 'aliqua.', 'Ut', 'enim', 'ad']\n",
      "['minim', 'veniam,', 'quis', 'nostrud', 'exercitation', 'ullamco', 'laboris', 'nisi', 'ut']\n",
      "['aliquip', 'ex', 'ea', 'commodo', 'consequat.', 'Duis', 'aute', 'irure', 'dolor', 'in']\n",
      "['reprehenderit', 'in', 'voluptate', 'velit', 'esse', 'cillum', 'dolore', 'eu', 'fugiat', 'nulla']\n",
      "['pariatur.', 'Excepteur', 'sint', 'occaecat', 'cupidatat', 'non', 'proident,', 'sunt', 'in']\n",
      "['culpa', 'qui', 'officia', 'deserunt', 'mollit', 'anim', 'id', 'est', 'laborum.']\n",
      "[]\n"
     ]
    }
   ],
   "source": [
    "try: \n",
    "    f = open(\"./test.txt\", \"r\")\n",
    "except:\n",
    "    print(\"error: cannot open the file\")\n",
    "    \n",
    "for line in f:\n",
    "    print(line.split())\n",
    "    \n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "error: cannot open the file\n"
     ]
    }
   ],
   "source": [
    "try: \n",
    "    f = open(\"./tessasssst.txt\", \"r\")\n",
    "except:\n",
    "    print(\"error: cannot open the file\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "as mentioned earlier, there are lots of string functions.  Above we used `strip()` to remove the trailing whitespace and returns."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In practice, we never read files explicitly but use some library, such as `numpy.genfromtxt`. Specific data format ofen have dedicated modules, like `cvs` for cvs files and `configparser` for ini files "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercises\n",
    "\n",
    "Work on those you like the most. For the exam, preparing 2 of these is enough (or 3 if you pick those that are very short)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Q1: Machine precision\n",
    "\n",
    "When talking about floating point, we discussed _machine epsilon_, $\\epsilon$&mdash;this is the smallest number that when added to 1 is still different from 1.\n",
    "\n",
    "We'll compute $\\epsilon$ here:\n",
    "\n",
    "  * Pick an initial guess for $\\epsilon$ of `eps = 1`.  \n",
    "\n",
    "  * Create a loop that checks whether `1 + eps` is different from `1`\n",
    "  \n",
    "  * Each loop iteration, cut the value of `eps` in half\n",
    "  \n",
    "What value of $\\epsilon$ do you find?\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Q2: Iterations\n",
    "\n",
    "### Part 1\n",
    "\n",
    "To iterate over the tuples, where the _i_-th tuple contains the _i_-th elements of certain sequences, we can use `zip(*sequences)` function.\n",
    "\n",
    "We will iterate over two lists, `names` and `age`, and print out the resulting tuples.\n",
    "\n",
    "  * Start by initializing lists `names = [\"Mary\", \"John\", \"Sarah\"]` and `age = [21, 56, 98]`.\n",
    "  \n",
    "  * Iterate over the tuples containing a name and an age, the `zip(list1, list2)` function might be useful here.\n",
    "  \n",
    "  * Print out formatted strings of the type \"*NAME is AGE years old*\".\n",
    "  \n",
    "\n",
    "### Part 2\n",
    "\n",
    "The function `enumerate(sequence)` returns tuples containing indices of objects in the sequence, and the objects. \n",
    "\n",
    "The `random` module provides tools for working with the random numbers. In particular, `random.randint(start, end)` generates a random number not smaller than `start`, and not bigger than `end`.\n",
    "\n",
    "  * Generate a list of 10 random numbers from 0 to 9.\n",
    "  \n",
    "  * Using the `enumerate(random_list)` function, iterate over the tuples of random numbers and their indices, and print out *\"Match: NUMBER and INDEX\"* if the random number and its index in the list match."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Q3: Books\n",
    "\n",
    "Here is a list of book titles (from http://thegreatestbooks.org).  Loop through the list and capitalize each word in each title. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "titles = [\"don quixote\", \n",
    "          \"in search of lost time\", \n",
    "          \"ulysses\", \n",
    "          \"the odyssey\", \n",
    "          \"war and peace\", \n",
    "          \"moby dick\", \n",
    "          \"the divine comedy\", \n",
    "          \"hamlet\", \n",
    "          \"the adventures of huckleberry finn\", \n",
    "          \"the great gatsby\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Q4: Word counts\n",
    "\n",
    "Here's some text (the Gettysburg Address).  Our goal is to count how many times each word repeats.  We'll do a brute force method first, and then we'll look at ways to do it more efficiently (and compactly)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "gettysburg_address = \"\"\"\n",
    "Four score and seven years ago our fathers brought forth on this continent, \n",
    "a new nation, conceived in Liberty, and dedicated to the proposition that \n",
    "all men are created equal.\n",
    "\n",
    "Now we are engaged in a great civil war, testing whether that nation, or \n",
    "any nation so conceived and so dedicated, can long endure. We are met on\n",
    "a great battle-field of that war. We have come to dedicate a portion of\n",
    "that field, as a final resting place for those who here gave their lives\n",
    "that that nation might live. It is altogether fitting and proper that we\n",
    "should do this.\n",
    "\n",
    "But, in a larger sense, we can not dedicate -- we can not consecrate -- we\n",
    "can not hallow -- this ground. The brave men, living and dead, who struggled\n",
    "here, have consecrated it, far above our poor power to add or detract.  The\n",
    "world will little note, nor long remember what we say here, but it can never\n",
    "forget what they did here. It is for us the living, rather, to be dedicated\n",
    "here to the unfinished work which they who fought here have thus far so nobly\n",
    "advanced. It is rather for us to be here dedicated to the great task remaining\n",
    "before us -- that from these honored dead we take increased devotion to that\n",
    "cause for which they gave the last full measure of devotion -- that we here\n",
    "highly resolve that these dead shall not have died in vain -- that this\n",
    "nation, under God, shall have a new birth of freedom -- and that government\n",
    "of the people, by the people, for the people, shall not perish from the earth.\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We've already seen the `.split()` method will, by default, split by spaces, so it will split this into words, producing a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "ga = gettysburg_address.split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Four',\n",
       " 'score',\n",
       " 'and',\n",
       " 'seven',\n",
       " 'years',\n",
       " 'ago',\n",
       " 'our',\n",
       " 'fathers',\n",
       " 'brought',\n",
       " 'forth',\n",
       " 'on',\n",
       " 'this',\n",
       " 'continent,',\n",
       " 'a',\n",
       " 'new',\n",
       " 'nation,',\n",
       " 'conceived',\n",
       " 'in',\n",
       " 'Liberty,',\n",
       " 'and',\n",
       " 'dedicated',\n",
       " 'to',\n",
       " 'the',\n",
       " 'proposition',\n",
       " 'that',\n",
       " 'all',\n",
       " 'men',\n",
       " 'are',\n",
       " 'created',\n",
       " 'equal.',\n",
       " 'Now',\n",
       " 'we',\n",
       " 'are',\n",
       " 'engaged',\n",
       " 'in',\n",
       " 'a',\n",
       " 'great',\n",
       " 'civil',\n",
       " 'war,',\n",
       " 'testing',\n",
       " 'whether',\n",
       " 'that',\n",
       " 'nation,',\n",
       " 'or',\n",
       " 'any',\n",
       " 'nation',\n",
       " 'so',\n",
       " 'conceived',\n",
       " 'and',\n",
       " 'so',\n",
       " 'dedicated,',\n",
       " 'can',\n",
       " 'long',\n",
       " 'endure.',\n",
       " 'We',\n",
       " 'are',\n",
       " 'met',\n",
       " 'on',\n",
       " 'a',\n",
       " 'great',\n",
       " 'battle-field',\n",
       " 'of',\n",
       " 'that',\n",
       " 'war.',\n",
       " 'We',\n",
       " 'have',\n",
       " 'come',\n",
       " 'to',\n",
       " 'dedicate',\n",
       " 'a',\n",
       " 'portion',\n",
       " 'of',\n",
       " 'that',\n",
       " 'field,',\n",
       " 'as',\n",
       " 'a',\n",
       " 'final',\n",
       " 'resting',\n",
       " 'place',\n",
       " 'for',\n",
       " 'those',\n",
       " 'who',\n",
       " 'here',\n",
       " 'gave',\n",
       " 'their',\n",
       " 'lives',\n",
       " 'that',\n",
       " 'that',\n",
       " 'nation',\n",
       " 'might',\n",
       " 'live.',\n",
       " 'It',\n",
       " 'is',\n",
       " 'altogether',\n",
       " 'fitting',\n",
       " 'and',\n",
       " 'proper',\n",
       " 'that',\n",
       " 'we',\n",
       " 'should',\n",
       " 'do',\n",
       " 'this.',\n",
       " 'But,',\n",
       " 'in',\n",
       " 'a',\n",
       " 'larger',\n",
       " 'sense,',\n",
       " 'we',\n",
       " 'can',\n",
       " 'not',\n",
       " 'dedicate',\n",
       " '--',\n",
       " 'we',\n",
       " 'can',\n",
       " 'not',\n",
       " 'consecrate',\n",
       " '--',\n",
       " 'we',\n",
       " 'can',\n",
       " 'not',\n",
       " 'hallow',\n",
       " '--',\n",
       " 'this',\n",
       " 'ground.',\n",
       " 'The',\n",
       " 'brave',\n",
       " 'men,',\n",
       " 'living',\n",
       " 'and',\n",
       " 'dead,',\n",
       " 'who',\n",
       " 'struggled',\n",
       " 'here,',\n",
       " 'have',\n",
       " 'consecrated',\n",
       " 'it,',\n",
       " 'far',\n",
       " 'above',\n",
       " 'our',\n",
       " 'poor',\n",
       " 'power',\n",
       " 'to',\n",
       " 'add',\n",
       " 'or',\n",
       " 'detract.',\n",
       " 'The',\n",
       " 'world',\n",
       " 'will',\n",
       " 'little',\n",
       " 'note,',\n",
       " 'nor',\n",
       " 'long',\n",
       " 'remember',\n",
       " 'what',\n",
       " 'we',\n",
       " 'say',\n",
       " 'here,',\n",
       " 'but',\n",
       " 'it',\n",
       " 'can',\n",
       " 'never',\n",
       " 'forget',\n",
       " 'what',\n",
       " 'they',\n",
       " 'did',\n",
       " 'here.',\n",
       " 'It',\n",
       " 'is',\n",
       " 'for',\n",
       " 'us',\n",
       " 'the',\n",
       " 'living,',\n",
       " 'rather,',\n",
       " 'to',\n",
       " 'be',\n",
       " 'dedicated',\n",
       " 'here',\n",
       " 'to',\n",
       " 'the',\n",
       " 'unfinished',\n",
       " 'work',\n",
       " 'which',\n",
       " 'they',\n",
       " 'who',\n",
       " 'fought',\n",
       " 'here',\n",
       " 'have',\n",
       " 'thus',\n",
       " 'far',\n",
       " 'so',\n",
       " 'nobly',\n",
       " 'advanced.',\n",
       " 'It',\n",
       " 'is',\n",
       " 'rather',\n",
       " 'for',\n",
       " 'us',\n",
       " 'to',\n",
       " 'be',\n",
       " 'here',\n",
       " 'dedicated',\n",
       " 'to',\n",
       " 'the',\n",
       " 'great',\n",
       " 'task',\n",
       " 'remaining',\n",
       " 'before',\n",
       " 'us',\n",
       " '--',\n",
       " 'that',\n",
       " 'from',\n",
       " 'these',\n",
       " 'honored',\n",
       " 'dead',\n",
       " 'we',\n",
       " 'take',\n",
       " 'increased',\n",
       " 'devotion',\n",
       " 'to',\n",
       " 'that',\n",
       " 'cause',\n",
       " 'for',\n",
       " 'which',\n",
       " 'they',\n",
       " 'gave',\n",
       " 'the',\n",
       " 'last',\n",
       " 'full',\n",
       " 'measure',\n",
       " 'of',\n",
       " 'devotion',\n",
       " '--',\n",
       " 'that',\n",
       " 'we',\n",
       " 'here',\n",
       " 'highly',\n",
       " 'resolve',\n",
       " 'that',\n",
       " 'these',\n",
       " 'dead',\n",
       " 'shall',\n",
       " 'not',\n",
       " 'have',\n",
       " 'died',\n",
       " 'in',\n",
       " 'vain',\n",
       " '--',\n",
       " 'that',\n",
       " 'this',\n",
       " 'nation,',\n",
       " 'under',\n",
       " 'God,',\n",
       " 'shall',\n",
       " 'have',\n",
       " 'a',\n",
       " 'new',\n",
       " 'birth',\n",
       " 'of',\n",
       " 'freedom',\n",
       " '--',\n",
       " 'and',\n",
       " 'that',\n",
       " 'government',\n",
       " 'of',\n",
       " 'the',\n",
       " 'people,',\n",
       " 'by',\n",
       " 'the',\n",
       " 'people,',\n",
       " 'for',\n",
       " 'the',\n",
       " 'people,',\n",
       " 'shall',\n",
       " 'not',\n",
       " 'perish',\n",
       " 'from',\n",
       " 'the',\n",
       " 'earth.']"
      ]
     },
     "execution_count": 182,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ga"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, the next problem is that some of these still have punctuation.  In particular, we see \"`.`\", \"`,`\", and \"`--`\".\n",
    "\n",
    "When considering a word, we can get rid of these by using the `replace()` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'end'"
      ]
     },
     "execution_count": 183,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = \"end.,\"\n",
    "b = a.replace(\".\", \"\").replace(\",\", \"\")\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another problem is case&mdash;we want to count \"but\" and \"But\" as the same.  Strings have a `lower()` method that can be used to convert a string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 184,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = \"But\"\n",
    "b = \"but\"\n",
    "a == b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 185,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.lower() == b.lower()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recall that strings are immutable, so `replace()` produces a new string on output."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Your task\n",
    "\n",
    "Create a dictionary that uses the unique words as keys and has as a value the number of times that word appears.  \n",
    "\n",
    "Write a loop over the words in the string (using our split version) and do the following:\n",
    "  * remove any punctuation\n",
    "  * convert to lowercase\n",
    "  * test if the word is already a key in the dictionary (using the `in` operator)\n",
    "     - if the key exists, increment the word count for that key\n",
    "     - otherwise, add it to the dictionary with the appropriate count of `1`.\n",
    "\n",
    "At the end, print out the words and a count of how many times they appear"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### More compact way\n",
    "\n",
    "We can actually do this a lot more compactly by using another list comprehensions and another python datatype called a set.  A set is a group of items, where each item is unique (e.g., no repetitions)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's a list comprehension that removes all the punctuation and converts to lower case:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "words = [q.lower().replace(\".\", \"\").replace(\",\", \"\") for q in ga]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and by using the `set()` function, we turn the list into a set, removing any duplicates:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "unique_words = set(words)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "now we can loop over the unique words and use the `count` method of a list to find how many there are"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'of': 5,\n",
       " 'ago': 1,\n",
       " 'their': 1,\n",
       " 'perish': 1,\n",
       " 'civil': 1,\n",
       " 'should': 1,\n",
       " 'four': 1,\n",
       " 'do': 1,\n",
       " 'not': 5,\n",
       " 'freedom': 1,\n",
       " 'altogether': 1,\n",
       " 'a': 7,\n",
       " 'unfinished': 1,\n",
       " 'measure': 1,\n",
       " 'or': 2,\n",
       " 'little': 1,\n",
       " 'before': 1,\n",
       " 'proposition': 1,\n",
       " 'live': 1,\n",
       " 'all': 1,\n",
       " 'created': 1,\n",
       " 'living': 2,\n",
       " 'struggled': 1,\n",
       " 'say': 1,\n",
       " 'great': 3,\n",
       " 'world': 1,\n",
       " 'note': 1,\n",
       " 'fitting': 1,\n",
       " 'add': 1,\n",
       " 'in': 4,\n",
       " 'resolve': 1,\n",
       " 'rather': 2,\n",
       " 'but': 2,\n",
       " 'nation': 5,\n",
       " 'detract': 1,\n",
       " 'forget': 1,\n",
       " 'power': 1,\n",
       " 'dedicate': 2,\n",
       " 'nor': 1,\n",
       " 'far': 2,\n",
       " 'cause': 1,\n",
       " 'did': 1,\n",
       " 'people': 3,\n",
       " 'new': 2,\n",
       " 'earth': 1,\n",
       " 'long': 2,\n",
       " 'have': 5,\n",
       " 'hallow': 1,\n",
       " 'final': 1,\n",
       " 'these': 2,\n",
       " 'proper': 1,\n",
       " 'testing': 1,\n",
       " 'here': 8,\n",
       " 'be': 2,\n",
       " 'score': 1,\n",
       " 'come': 1,\n",
       " 'whether': 1,\n",
       " 'now': 1,\n",
       " 'liberty': 1,\n",
       " 'endure': 1,\n",
       " 'is': 3,\n",
       " 'honored': 1,\n",
       " 'dead': 3,\n",
       " 'might': 1,\n",
       " 'above': 1,\n",
       " 'battle-field': 1,\n",
       " 'government': 1,\n",
       " 'portion': 1,\n",
       " 'dedicated': 4,\n",
       " 'any': 1,\n",
       " 'increased': 1,\n",
       " 'continent': 1,\n",
       " 'can': 5,\n",
       " 'larger': 1,\n",
       " 'task': 1,\n",
       " 'war': 2,\n",
       " 'highly': 1,\n",
       " 'advanced': 1,\n",
       " 'as': 1,\n",
       " 'those': 1,\n",
       " 'we': 10,\n",
       " 'brought': 1,\n",
       " 'fathers': 1,\n",
       " 'so': 3,\n",
       " 'resting': 1,\n",
       " 'ground': 1,\n",
       " 'brave': 1,\n",
       " 'what': 2,\n",
       " 'from': 2,\n",
       " 'years': 1,\n",
       " 'men': 2,\n",
       " 'field': 1,\n",
       " 'work': 1,\n",
       " 'poor': 1,\n",
       " 'nobly': 1,\n",
       " 'never': 1,\n",
       " 'vain': 1,\n",
       " 'devotion': 2,\n",
       " 'gave': 2,\n",
       " 'will': 1,\n",
       " 'place': 1,\n",
       " 'on': 2,\n",
       " 'thus': 1,\n",
       " 'for': 5,\n",
       " 'to': 8,\n",
       " 'the': 11,\n",
       " 'remaining': 1,\n",
       " 'that': 13,\n",
       " 'birth': 1,\n",
       " 'consecrate': 1,\n",
       " 'forth': 1,\n",
       " 'under': 1,\n",
       " 'and': 6,\n",
       " 'take': 1,\n",
       " 'are': 3,\n",
       " 'consecrated': 1,\n",
       " 'it': 5,\n",
       " 'who': 3,\n",
       " 'equal': 1,\n",
       " 'last': 1,\n",
       " 'remember': 1,\n",
       " 'by': 1,\n",
       " 'engaged': 1,\n",
       " 'shall': 3,\n",
       " 'seven': 1,\n",
       " 'which': 2,\n",
       " 'sense': 1,\n",
       " 'met': 1,\n",
       " '--': 7,\n",
       " 'us': 3,\n",
       " 'god': 1,\n",
       " 'our': 2,\n",
       " 'full': 1,\n",
       " 'lives': 1,\n",
       " 'died': 1,\n",
       " 'they': 3,\n",
       " 'conceived': 2,\n",
       " 'fought': 1,\n",
       " 'this': 4}"
      ]
     },
     "execution_count": 188,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "count = {}\n",
    "for uw in unique_words:\n",
    "    count[uw] = words.count(uw)\n",
    "    \n",
    "count"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Even shorter -- we can use a dictionary comprehension, like a list comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "c = {uw: count[uw] for uw in unique_words}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'of': 5,\n",
       " 'ago': 1,\n",
       " 'their': 1,\n",
       " 'perish': 1,\n",
       " 'civil': 1,\n",
       " 'should': 1,\n",
       " 'four': 1,\n",
       " 'do': 1,\n",
       " 'not': 5,\n",
       " 'freedom': 1,\n",
       " 'altogether': 1,\n",
       " 'a': 7,\n",
       " 'unfinished': 1,\n",
       " 'measure': 1,\n",
       " 'or': 2,\n",
       " 'little': 1,\n",
       " 'before': 1,\n",
       " 'proposition': 1,\n",
       " 'live': 1,\n",
       " 'all': 1,\n",
       " 'created': 1,\n",
       " 'living': 2,\n",
       " 'struggled': 1,\n",
       " 'say': 1,\n",
       " 'great': 3,\n",
       " 'world': 1,\n",
       " 'note': 1,\n",
       " 'fitting': 1,\n",
       " 'add': 1,\n",
       " 'in': 4,\n",
       " 'resolve': 1,\n",
       " 'rather': 2,\n",
       " 'but': 2,\n",
       " 'nation': 5,\n",
       " 'detract': 1,\n",
       " 'forget': 1,\n",
       " 'power': 1,\n",
       " 'dedicate': 2,\n",
       " 'nor': 1,\n",
       " 'far': 2,\n",
       " 'cause': 1,\n",
       " 'did': 1,\n",
       " 'people': 3,\n",
       " 'new': 2,\n",
       " 'earth': 1,\n",
       " 'long': 2,\n",
       " 'have': 5,\n",
       " 'hallow': 1,\n",
       " 'final': 1,\n",
       " 'these': 2,\n",
       " 'proper': 1,\n",
       " 'testing': 1,\n",
       " 'here': 8,\n",
       " 'be': 2,\n",
       " 'score': 1,\n",
       " 'come': 1,\n",
       " 'whether': 1,\n",
       " 'now': 1,\n",
       " 'liberty': 1,\n",
       " 'endure': 1,\n",
       " 'is': 3,\n",
       " 'honored': 1,\n",
       " 'dead': 3,\n",
       " 'might': 1,\n",
       " 'above': 1,\n",
       " 'battle-field': 1,\n",
       " 'government': 1,\n",
       " 'portion': 1,\n",
       " 'dedicated': 4,\n",
       " 'any': 1,\n",
       " 'increased': 1,\n",
       " 'continent': 1,\n",
       " 'can': 5,\n",
       " 'larger': 1,\n",
       " 'task': 1,\n",
       " 'war': 2,\n",
       " 'highly': 1,\n",
       " 'advanced': 1,\n",
       " 'as': 1,\n",
       " 'those': 1,\n",
       " 'we': 10,\n",
       " 'brought': 1,\n",
       " 'fathers': 1,\n",
       " 'so': 3,\n",
       " 'resting': 1,\n",
       " 'ground': 1,\n",
       " 'brave': 1,\n",
       " 'what': 2,\n",
       " 'from': 2,\n",
       " 'years': 1,\n",
       " 'men': 2,\n",
       " 'field': 1,\n",
       " 'work': 1,\n",
       " 'poor': 1,\n",
       " 'nobly': 1,\n",
       " 'never': 1,\n",
       " 'vain': 1,\n",
       " 'devotion': 2,\n",
       " 'gave': 2,\n",
       " 'will': 1,\n",
       " 'place': 1,\n",
       " 'on': 2,\n",
       " 'thus': 1,\n",
       " 'for': 5,\n",
       " 'to': 8,\n",
       " 'the': 11,\n",
       " 'remaining': 1,\n",
       " 'that': 13,\n",
       " 'birth': 1,\n",
       " 'consecrate': 1,\n",
       " 'forth': 1,\n",
       " 'under': 1,\n",
       " 'and': 6,\n",
       " 'take': 1,\n",
       " 'are': 3,\n",
       " 'consecrated': 1,\n",
       " 'it': 5,\n",
       " 'who': 3,\n",
       " 'equal': 1,\n",
       " 'last': 1,\n",
       " 'remember': 1,\n",
       " 'by': 1,\n",
       " 'engaged': 1,\n",
       " 'shall': 3,\n",
       " 'seven': 1,\n",
       " 'which': 2,\n",
       " 'sense': 1,\n",
       " 'met': 1,\n",
       " '--': 7,\n",
       " 'us': 3,\n",
       " 'god': 1,\n",
       " 'our': 2,\n",
       " 'full': 1,\n",
       " 'lives': 1,\n",
       " 'died': 1,\n",
       " 'they': 3,\n",
       " 'conceived': 2,\n",
       " 'fought': 1,\n",
       " 'this': 4}"
      ]
     },
     "execution_count": 190,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Q5: Foxes and dogs\n",
    "\n",
    "### Part 1. Short words\n",
    "\n",
    "Let's practice functions.  Here's a simple function that takes a string and returns a list of all the 4 letter words:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "def four_letter_words(message):\n",
    "    words = message.split()\n",
    "    four_letters = [w for w in words if len(w) == 4]\n",
    "    return four_letters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['over', 'lazy']\n"
     ]
    }
   ],
   "source": [
    "message = \"The quick brown fox jumps over the lazy dog\"\n",
    "print(four_letter_words(message))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a version of this function that takes a second argument, n, that is the word length we want to search for"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 2: Panagrams\n",
    "\n",
    "A _panagram_ is a sentence that includes all 26 letters of the alphabet, e.g., \"_The quick brown fox jumps over the lazy dog_.\"\n",
    "\n",
    "Write a function that takes as an argument a sentence and returns `True` or `False`, indicating whether the sentence is a panagram."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Q6: Catch errors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We want to safely convert a string into a float, int, or leave it as a string, depending on its contents.  As we've already seen, python provides `float()` and `int()` functions for this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0 <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "a = \"2.0\"\n",
    "b = float(a)\n",
    "print(b, type(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But these throw exceptions if the conversion is not possible"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "could not convert string to float: 'this is a string'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[31], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m a \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mthis is a string\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m----> 2\u001b[0m b \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mfloat\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43ma\u001b[49m\u001b[43m)\u001b[49m\n",
      "\u001b[0;31mValueError\u001b[0m: could not convert string to float: 'this is a string'"
     ]
    }
   ],
   "source": [
    "a = \"this is a string\"\n",
    "b = float(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "invalid literal for int() with base 10: '1.2345'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[195], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m a \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m1.2345\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m----> 2\u001b[0m b \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mint\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43ma\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m      3\u001b[0m \u001b[38;5;28mprint\u001b[39m(b, \u001b[38;5;28mtype\u001b[39m(b))\n",
      "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: '1.2345'"
     ]
    }
   ],
   "source": [
    "a = \"1.2345\"\n",
    "b = int(a)\n",
    "print(b, type(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.2345 <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "b = float(a)\n",
    "print(b, type(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that an int can be converted to a float, but if you convert a float to an int, you risk losing significant digits.  A string cannot be converted to either.\n",
    "\n",
    "### Your task\n",
    "\n",
    "Write a function, `convert_type(a)` that takes a string `a`, and converts it to a float if it is a number with a decimal point, an int if it is an integer, or leaves it as a string otherwise, and returns the result.  You'll want to use exceptions to prevent the code from aborting."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Q7: Tic-tac-toe\n",
    "\n",
    "Here we'll write a simple tic-tac-toe game that 2 players can play.  First we'll create a string that represents our game board:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {},
   "outputs": [],
   "source": [
    "board = \"\"\"\n",
    " {s1:^3} | {s2:^3} | {s3:^3}\n",
    "-----+-----+-----\n",
    " {s4:^3} | {s5:^3} | {s6:^3}\n",
    "-----+-----+-----      123\n",
    " {s7:^3} | {s8:^3} | {s9:^3}       456\n",
    "                       789  \n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This board will look a little funny if we just print it&mdash;the spacing is set to look right when we replace the `{}` with `x` or `o`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " {s1:^3} | {s2:^3} | {s3:^3}\n",
      "-----+-----+-----\n",
      " {s4:^3} | {s5:^3} | {s6:^3}\n",
      "-----+-----+-----      123\n",
      " {s7:^3} | {s8:^3} | {s9:^3}       456\n",
      "                       789  \n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(board)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and well use a dictionary to denote the status of each square, \"x\", \"o\", or empty, \"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'s1': '',\n",
       " 's2': '',\n",
       " 's3': '',\n",
       " 's4': '',\n",
       " 's5': '',\n",
       " 's6': '',\n",
       " 's7': '',\n",
       " 's8': '',\n",
       " 's9': ''}"
      ]
     },
     "execution_count": 199,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "play = {}\n",
    "\n",
    "def initialize_board(play):\n",
    "    for n in range(9):\n",
    "        play[\"s{}\".format(n+1)] = \"\"\n",
    "\n",
    "initialize_board(play)\n",
    "play"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that our `{}` placeholders in the `board` string have identifiers (the numbers in the `{}`).  We can use these to match the variables we want to print to the placeholder in the string, regardless of the order in the `format()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2 1'"
      ]
     },
     "execution_count": 200,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = \"{s1:} {s2:}\".format(s2=1, s1=2)\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's an easy way to add the values of our dictionary to the appropriate squares in our game board.  First note that each of the {} is labeled with a number that matches the keys in our dictionary.  Python provides a way to unpack a dictionary into labeled arguments, using **\n",
    "\n",
    "This lets us to write a function to show the tic-tac-toe board."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "     |     |    \n",
      "-----+-----+-----\n",
      "     |     |    \n",
      "-----+-----+-----      123\n",
      "     |     |           456\n",
      "                       789  \n",
      "\n"
     ]
    }
   ],
   "source": [
    "def show_board(play):\n",
    "    \"\"\" display the playing board.  We take a dictionary with the current state of the board\n",
    "    We rely on the board string to be a global variable\"\"\"\n",
    "    print(board.format(**play))\n",
    "    \n",
    "show_board(play)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we need a function that asks a player for a move:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_move(n, xo, play):\n",
    "    \"\"\" ask the current player, n, to make a move -- make sure the square was not \n",
    "        already played.  xo is a string of the character (x or o) we will place in\n",
    "        the desired square \"\"\"\n",
    "    valid_move = False\n",
    "    while not valid_move:\n",
    "        idx = input(\"player {}, enter your move (1-9)\".format(n))\n",
    "        if play[\"s{}\".format(idx)] == \"\":\n",
    "            valid_move = True\n",
    "        else:\n",
    "            print(\"invalid: {}\".format(play[\"s{}\".format(idx)]))\n",
    "            \n",
    "    play[\"s{}\".format(idx)] = xo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function get_move in module __main__:\n",
      "\n",
      "get_move(n, xo, play)\n",
      "    ask the current player, n, to make a move -- make sure the square was not \n",
      "    already played.  xo is a string of the character (x or o) we will place in\n",
      "    the desired square\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(get_move)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Your task\n",
    "\n",
    "Using the functions defined above,\n",
    "  * `initialize_board()`\n",
    "  * `show_board()`\n",
    "  * `get_move()`\n",
    "\n",
    "fill in the function `play_game()` below to complete the game, asking for the moves one at a time, alternating between player 1 and 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def play_game():\n",
    "    \"\"\" play a game of tic-tac-toe \"\"\"\n",
    "    \n",
    "    play ={}\n",
    "    initialize_board(play)\n",
    "    show_board(play)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "play_game()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Q8: Shopping cart"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's write a simple shopping cart class -- this will hold items that you intend to purchase as well as the amount, etc.  And allow you to add / remove items, get a subtotal, etc.\n",
    "\n",
    "We'll use two classes: `Item` will be a single item and `ShoppingCart` will be the collection of items you wish to purchase.\n",
    "\n",
    "First, our store needs an inventory -- here's what we have for sale:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {},
   "outputs": [],
   "source": [
    "INVENTORY_TEXT = \"\"\"\n",
    "apple, 0.60\n",
    "banana, 0.20\n",
    "grapefruit, 0.75\n",
    "grapes, 1.99\n",
    "kiwi, 0.50\n",
    "lemon, 0.20\n",
    "lime, 0.25\n",
    "mango, 1.50\n",
    "papaya, 2.95\n",
    "pineapple, 3.50\n",
    "blueberries, 1.99\n",
    "blackberries, 2.50\n",
    "peach, 0.50\n",
    "plum, 0.33\n",
    "clementine, 0.25\n",
    "cantaloupe, 3.25\n",
    "pear, 1.25\n",
    "quince, 0.45\n",
    "orange, 0.60\n",
    "\"\"\"\n",
    "\n",
    "# this will be a global -- convention is all caps\n",
    "INVENTORY = {}\n",
    "for line in INVENTORY_TEXT.splitlines():\n",
    "    if line.strip() == \"\":\n",
    "        continue\n",
    "    item, price = line.split(\",\")\n",
    "    INVENTORY[item] = float(price)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'apple': 0.6,\n",
       " 'banana': 0.2,\n",
       " 'grapefruit': 0.75,\n",
       " 'grapes': 1.99,\n",
       " 'kiwi': 0.5,\n",
       " 'lemon': 0.2,\n",
       " 'lime': 0.25,\n",
       " 'mango': 1.5,\n",
       " 'papaya': 2.95,\n",
       " 'pineapple': 3.5,\n",
       " 'blueberries': 1.99,\n",
       " 'blackberries': 2.5,\n",
       " 'peach': 0.5,\n",
       " 'plum': 0.33,\n",
       " 'clementine': 0.25,\n",
       " 'cantaloupe': 3.25,\n",
       " 'pear': 1.25,\n",
       " 'quince': 0.45,\n",
       " 'orange': 0.6}"
      ]
     },
     "execution_count": 205,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "INVENTORY"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Item "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's write an item class now -- we want it to hold the name and quantity.  \n",
    "\n",
    "You should have the following features:\n",
    "\n",
    "* The name should be something in our inventory\n",
    "\n",
    "* Our shopping cart will include a list of all the items we want to buy, so we want to be able to check for duplicates.  Implement the equal test, `==`, using `__eq__`\n",
    "\n",
    "* We'll want to consolidate duplicates, so implement the `+` operator, using `__add__` so we can add items together in our shopping cart.  Note, add should raise a ValueError if you try to add two `Items` that don't have the same name.\n",
    "\n",
    "Here's a start:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Item:\n",
    "    \"\"\" an item to buy \"\"\"\n",
    "    \n",
    "    def __init__(self, name, quantity=1):\n",
    "        \"\"\"keep track of an item that is in our inventory\"\"\"\n",
    "        if name not in INVENTORY:\n",
    "            raise ValueError(\"invalid item name\")\n",
    "        self.name = name\n",
    "        self.quantity = quantity\n",
    "        \n",
    "    def __repr__(self):\n",
    "        return \"{}: {}\".format(self.name, self.quantity)\n",
    "        \n",
    "    def __eq__(self, other):\n",
    "        \"\"\"check if the items have the same name\"\"\"\n",
    "        return self.name == other.name\n",
    "    \n",
    "    def __add__(self, other):\n",
    "        \"\"\"add two items together if they are the same type\"\"\"\n",
    "        if self.name == other.name:\n",
    "            return Item(self.name, self.quantity + other.quantity)\n",
    "        else:\n",
    "            raise ValueError(\"names don't match\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here are some tests your code should pass:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = Item(\"apple\", 10)\n",
    "b = Item(\"banana\", 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = Item(\"apple\", 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "names don't match",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[209], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;66;03m# won't work\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m \u001b[43ma\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mb\u001b[49m\n",
      "Cell \u001b[0;32mIn[206], line 23\u001b[0m, in \u001b[0;36mItem.__add__\u001b[0;34m(self, other)\u001b[0m\n\u001b[1;32m     21\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m Item(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mname, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mquantity \u001b[38;5;241m+\u001b[39m other\u001b[38;5;241m.\u001b[39mquantity)\n\u001b[1;32m     22\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m---> 23\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnames don\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mt match\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
      "\u001b[0;31mValueError\u001b[0m: names don't match"
     ]
    }
   ],
   "source": [
    "# won't work\n",
    "a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apple: 30\n"
     ]
    }
   ],
   "source": [
    "# will work\n",
    "a += c\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "invalid item name",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[211], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m d \u001b[38;5;241m=\u001b[39m \u001b[43mItem\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mdog\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n",
      "Cell \u001b[0;32mIn[206], line 7\u001b[0m, in \u001b[0;36mItem.__init__\u001b[0;34m(self, name, quantity)\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"keep track of an item that is in our inventory\"\"\"\u001b[39;00m\n\u001b[1;32m      6\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m name \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m INVENTORY:\n\u001b[0;32m----> 7\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124minvalid item name\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m      8\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mname \u001b[38;5;241m=\u001b[39m name\n\u001b[1;32m      9\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mquantity \u001b[38;5;241m=\u001b[39m quantity\n",
      "\u001b[0;31mValueError\u001b[0m: invalid item name"
     ]
    }
   ],
   "source": [
    "d = Item(\"dog\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 212,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# should be False\n",
    "a == b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 213,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# should be True -- they have the same name\n",
    "a == c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How do they behave in a list?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[apple: 30, banana: 20]"
      ]
     },
     "execution_count": 214,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "items = []\n",
    "items.append(a)\n",
    "items.append(b)\n",
    "items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 215,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# should be True -- they have the same name\n",
    "c in items"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ShoppingCart"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we want to create a shopping cart.  The main thing it will do is hold a list of items."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ShoppingCart:\n",
    "    \n",
    "    def __init__(self):\n",
    "        # the list of items we control\n",
    "        self.items = []\n",
    "        \n",
    "    def subtotal(self):\n",
    "        \"\"\" return a subtotal of our items \"\"\"\n",
    "        pass\n",
    "\n",
    "    def add(self, name, quantity):\n",
    "        \"\"\" add an item to our cart -- the an item of the same name already\n",
    "        exists, then increment the quantity.  Otherwise, add a new item\n",
    "        to the cart with the desired quantity.\"\"\"\n",
    "        pass\n",
    "        \n",
    "    def remove(self, name):\n",
    "        \"\"\" remove all of item name from the cart \"\"\"\n",
    "        pass\n",
    "        \n",
    "    def report(self):\n",
    "        \"\"\" print a summary of the cart \"\"\"\n",
    "        for item in self.items:\n",
    "            print(f\"{item.name} : {item.quantity}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here are some tests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {},
   "outputs": [],
   "source": [
    "sc = ShoppingCart()\n",
    "sc.add(\"orange\", 19)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {},
   "outputs": [],
   "source": [
    "sc.add(\"apple\", 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {},
   "outputs": [],
   "source": [
    "sc.report()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {},
   "outputs": [],
   "source": [
    "sc.add(\"apple\", 9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "metadata": {},
   "outputs": [],
   "source": [
    "# apple should only be listed once in the report, with a quantity of 11\n",
    "sc.report()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {},
   "outputs": [],
   "source": [
    "sc.subtotal()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {},
   "outputs": [],
   "source": [
    "sc.remove(\"apple\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "metadata": {},
   "outputs": [],
   "source": [
    "# apple should no longer be listed\n",
    "sc.report()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Q9: Poker odds"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use the deck of cards class from the notebook we worked through class to write a _Monte Carlo_ code that plays a lot of hands of straight poker (like 100,000).  Count how many of these hands has a particular poker hand (like 3-of-a-kind).  The ratio of # of hands with 3-of-a-kind to total hands is an approximation to the odds of getting a 3-of-a-kind in poker.\n",
    "\n",
    "### Bonus: \n",
    "Just to practice modules, write that into a `.py` file to allow you to import and reuse them here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Q10: Tic-Tac-Toe again\n",
    "\n",
    "Revisit the tic-tac-toe game you developed in the functions exercises but now write it as a class with methods to do each of the main steps.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Q11: Rock-Paper-Scissors\n",
    "\n",
    "Implement a set of games of rock-paper-scissors against the computer.  \n",
    "\n",
    "  * Ask for input from the user (\"rock\", \"paper\", or \"scissors\") and the randomly select one of these for the computer's play.\n",
    "  * Announce who won.\n",
    "  * Keep playing until a player says that they no longer want to play.\n",
    "  * When all games are done, print out how many games were won by the player and by the computer "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Q12: Pascal's triangle\n",
    "\n",
    "Pascal's triangle is created such that each layer has 1 more element than the previous, with `1`s on the side and in the interior, the numbers are the sum of the two above it, e.g.,:\n",
    "```\n",
    "            1\n",
    "          1   1\n",
    "        1   2   1\n",
    "      1   3   3   1\n",
    "    1   4   6   4   1\n",
    "  1   5   10  10  5   1\n",
    "```\n",
    "\n",
    "1. Write a function to return the first `n` rows of Pascal's triangle.  The return should be a list of length `n`, with each element itself a list containing the numbers for that row.\n",
    "2. Write a function to print out Pascal's triangle with proper formatting, so the numbers in each row are centered between the ones in the row above"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Q13: Calendar events\n",
    "\n",
    "We want to keep a schedule of events.  We will do this by creating a class called `Day`.  It is sketched out below.  A `Day` holds a list of events and has methods that allow you to add an delete events.  Our events will be instances of a class `Event`, which holds the time, location, and description of the event.\n",
    "\n",
    "Finally, we can keep track of a list of all the `Day`s for which we have events to make our schedule.\n",
    "\n",
    "Fill in these classes and write some code to demonstrate their use:\n",
    "\n",
    "  * Create a full week of days in your calendar\n",
    "  * Add an event every day at noon called \"lunch\"\n",
    "  * Randomly add some other events to fill out your calendar\n",
    "  * Write some code that tells you the start time of your first meeting and the end time of your last meeting (this is the length of your work day)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Day:\n",
    "    \"\"\"a single day keeping track of the events scheduled\"\"\"\n",
    "    def __init__(self, month, day, year):\n",
    "        # store the month, day, and year as data in the class\n",
    "        \n",
    "        # keep track of the events\n",
    "        self.events = []\n",
    "    \n",
    "    def add_event(self, name, time=None, location=None):\n",
    "        pass\n",
    "    \n",
    "    def delete_event(self, name):\n",
    "        pass\n",
    "    \n",
    "    \n",
    "class Event:\n",
    "    \"\"\"a single event in our calendar\"\"\"\n",
    "    def __init__(self, name, time=9, location=None, duration=1):\n",
    "        self.name = name\n",
    "        self.time = time\n",
    "        self.location = location\n",
    "        self.duration = duration"
   ]
  },
  {
   "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}