Python Whirlwind Tour.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "<img align=\"left\" width=\"130\" src=\"images/Python_color.png\">\n",
    "<p vertical-align=\"middle\"><h1>&nbsp;Python Essentials Part I</h1>\n",
    "</p>\n",
    "\n",
    "<br><br><br><br>\n",
    "\n",
    "&nbsp;\n",
    "\n",
    "<div width=\"100%\">\n",
    "<table style=\"border: none;\">\n",
    "  <tr style=\"border: none;\">\n",
    "    <td rowspan=\"2\" style=\"border: none;\"><img height=\"400\" src=\"https://imgs.xkcd.com/comics/python.png\"></td>\n",
    "    <td width=\"50%\" align=\"right\" style=\"border: none;\"><img height= \"400\" src=\"https://imgs.xkcd.com/comics/new_pet.png\"></td>\n",
    "  </tr>\n",
    "</table>\n",
    "</div>\n",
    "<br>\n",
    "\n",
    "<br>\n",
    "\n",
    "We joke  -- but we choose Python because we can _**get things done**_. [Guido van Rossum](https://gvanrossum.github.io/) was pretty results-focused when he created the language.  Today, it's used _everywhere_ and has replaced both C++ and Java as the programming language of instruction at major Universities.  But you don't really need us to tell you that...you're here! &nbsp; _WELCOME._\n",
    "\n",
    "<br>\n",
    "\n",
    "> _\"The goal of Python is improved productivity. This productivity comes in many ways, but the language is designed to aid you as much as possible, while hindering you as little as possible with arbitrary rules or any requirement that you use a particular set of features. Python is practical; Python language design decisions were based on providing the maximum benefits to the programmer.\" - [**Python3 Patterns and Idioms**](http://python-3-patterns-idioms-test.readthedocs.io/en/latest/PythonForProgrammers.html)_\n",
    "\n",
    "<br>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### We'd like you to build understanding & competence in  the _**Syntax** , **Structures**_  & _**Constructs**_ of Python.\n",
    "\n",
    "<br>\n",
    "\n",
    "**This Section (Part I)**  will cover mostly basics like data structures, conditionals, & looping. _**A Python Syntax Whirlwind, so to speak.**_  We''' also taking a couple of digressions into some things that make Python a bit _different_.\n",
    "\n",
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The Python Syntax Whirlwind Tour\n",
    "\n",
    "_Time for the good stuff -- a whirlwind tour of basic Python syntax! Don't worry if you don't get all this in the first try - we'll have plenty of practice problems & homework, so that you can get dirty with all the details. And we'll be revisiting various pieces as we progress through ML libraries and topics._  \n",
    "\n",
    "But let's see if we can do a (_completely unrealistic_) **45min  Tour**\n",
    "\n",
    "________________\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Digression the first:  `constants` in Python\n",
    "\n",
    "\n",
    "<br><br>\n",
    "\n",
    "\n",
    "<details>\n",
    "    <summary><img align=\"left\" width=\"85\" height=\"35\" src=\"images/TLDR.png\"></summary>\n",
    "\n",
    "<br>\n",
    "\n",
    "\n",
    "> _“No man ever steps in the same river twice, for it's not the same river and he's not the same man.”_\n",
    ">\n",
    "> ― _**Heraclitus**_\n",
    "\n",
    "\n",
    "<br>\n",
    "\n",
    "Unlike many other languages, Python does not have a **`const`** keyword (or Javas **`final`** keyword). The whole _notion_ of **permanently fixing a variable name to a value** is a bit foreign in core Python. Names are just _names_, & can be re-applied at any time. To quote a senior Python developer:\n",
    "\n",
    "> Python treats you like an _**adult**_. If you know you shouldn't be changing something, then _**just don't do it**_ - why does the interpreter need to enforce it?\n",
    "\n",
    "Yeah _**right**_ 🙄\n",
    "\n",
    "....To counter the (ahem) inevitable, the Python community has developed conventions around naming variables that you don't want _changed_ in **ALL CAPITALS**. However, it remains a _**convention**_. In Python, if you know the name of something, you can usually change what that name points to.\n",
    "\n",
    "Python of course has _immutable **values**_ - which are different beasts entirely. \n",
    "\n",
    "**Strings are immutable**, so are **numbers**. In some circles, these are referred to as **\"literal constants\"** - or just **\"literals\"**. **Tuples** are an immutable data structure. Additionally, many scientific & mathematical libraries in Python (_SciPy, Numpy, SymPy_) do indeed have physical & mathematical constant names & values _defined for use_. But underneath it all, Python allows for _**variable names**_ used to point to values to _change_. \n",
    "\n",
    "For those who want to read more and take a look at the C code underneath, check out this [**Stack Overflow Post**](https://stackoverflow.com/questions/46940622/python-compiler-and-constants-defined-inside-a-function).\n",
    "\n",
    "Which is enough of a digression into the deep internals of the language. But if you'd like to read more from the creator, this is a pretty interesting [**blog post on literals, keywords, and builtins**](http://python-history.blogspot.co.uk/2013/11/story-of-none-true-false.html).\n",
    "\n",
    "Python does define a very small number of  [**Built-in Constants**](https://docs.python.org/3/library/constants.html#built-in-consts) that live in the same namespace as Pythons [**built-in functions**](https://docs.python.org/3/library/functions.html):\n",
    "\n",
    "\n",
    "<br>\n",
    "\n",
    "\n",
    "* `True` - the **true** value of the `bool` type\n",
    "* `False` - the **false** value of the `bool` type\n",
    "* `None` - the **sole value** of the `NoneType`\n",
    "\n",
    "  > _**IMPORTANT:**_ **`None`** is a **special object** that represents **nothing**. It is its **own, distinct type** and takes up a little bit of memory in Python. It’s a **singleton** -- there is only one **`None`** object per interpreter instance or program. Items are **never** `==` to **`None`**. Instead, you need to check if something **`is None`**. **None** is frequently used to represent the absence of a value -- **e.g.**, when default arguments are not passed to a function. **None** is also returned from functions that do not otherwise have a specific return value. Assignments to None are illegal & raise a **SyntaxError**.\n",
    "\n",
    "* **`NotImplemented`** - Special value which should be returned by the binary special methods (**e.g.** **eq**, **lt**, **add**, **rsub**, etc.) to indicate that the specific _operation_ is not implemented with respect to the other type.\n",
    "* **`Ellipsis`** or `...` - Special value used mostly in conjunction with extended slicing syntax for user-defined container data types such as slicing in multi-dimensional arrays in numpy.\n",
    "* **`__debug__`** - This constant is true if Python was not started with an -O option. See also [**`assert`**](https://docs.python.org/3/reference/simple_stmts.html#assert).\n",
    "\n",
    "\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "\n",
    "## Digression the Second: on _**variables**_ & **_the naming of variables_**\n",
    "\n",
    "\n",
    "<br>\n",
    "\n",
    "<br>\n",
    "\n",
    "<details>\n",
    "    <summary><img align=\"left\" width=\"85\" height=\"35\" src=\"images/details.png\">\n",
    "      <br>\n",
    "    </summary>\n",
    "\n",
    "   <br>\n",
    "\n",
    "   <br>\n",
    "\n",
    "\n",
    "\n",
    "### From [PEP8](https://www.python.org/dev/peps/pep-0008/#function-and-variable-names)\n",
    "\n",
    ">#### [Prescriptive: Naming Conventions](https://www.python.org/dev/peps/pep-0008/#id37)\n",
    ">\n",
    ">[Names to Avoid](https://www.python.org/dev/peps/pep-0008/#id38)\n",
    ">\n",
    ">* Never use the characters 'l' (lowercase letter el), 'O' (uppercase letter oh), or 'I' (uppercase letter eye) as single character variable names.\n",
    ">\n",
    ">* In some fonts, these characters are indistinguishable from the numerals one and zero. When tempted to use 'l', use 'L' instead.\n",
    ">\n",
    ">\n",
    ">[ASCII Compatibility](https://www.python.org/dev/peps/pep-0008/#id39)\n",
    ">\n",
    ">* Identifiers used in the standard library must be ASCII compatible as described in the [policy section](https://www.python.org/dev/peps/pep-3131/#policy-specification) of [PEP 3131](https://www.python.org/dev/peps/pep-3131).\n",
    ">\n",
    ">\n",
    ">\n",
    ">[Package and Module Names](https://www.python.org/dev/peps/pep-0008/#id40)\n",
    ">\n",
    ">* Modules should have short, all-lowercase names. Underscores can be used in the module name if it improves readability. Python packages should also have short, all-lowercase names, although the use of underscores is discouraged.\n",
    ">\n",
    ">* When an extension module written in C or C++ has an accompanying Python module that provides a higher level (e.g. more object oriented) interface, the C/C++ module has a leading underscore (e.g. `_socket`).\n",
    ">\n",
    ">\n",
    ">\n",
    ">[Class Names](https://www.python.org/dev/peps/pep-0008/#id41)\n",
    ">\n",
    ">* Class names should normally use the CapWords convention.\n",
    ">\n",
    ">* The naming convention for functions may be used instead in cases where the interface is documented and used primarily as a callable.\n",
    ">\n",
    ">* Note that there is a separate convention for builtin names: most builtin names are single words (or two words run together), with the CapWords convention used only for exception names and builtin constants.\n",
    ">\n",
    ">\n",
    ">\n",
    ">[Type Variable Names](https://www.python.org/dev/peps/pep-0008/#id42)\n",
    ">\n",
    ">* Names of type variables introduced in [PEP 484](https://www.python.org/dev/peps/pep-0484) should normally use CapWords preferring short names: `T`, `AnyStr`, `Num`. It is recommended to add suffixes `_co` or `_contra` to the variables used to declare covariant or contravariant behavior correspondingly:\n",
    ">\n",
    ">\n",
    ">```python\n",
    ">from typing import TypeVar\n",
    ">\n",
    ">VT_co = TypeVar('VT_co', covariant=True)\n",
    ">KT_contra = TypeVar('KT_contra', contravariant=True)\n",
    ">```\n",
    ">\n",
    ">\n",
    ">\n",
    ">[Exception Names](https://www.python.org/dev/peps/pep-0008/#id43)\n",
    ">\n",
    ">* Because exceptions should be classes, the class naming convention applies here. However, you should use the suffix \"Error\" on your exception names (if the exception actually is an error).\n",
    ">\n",
    ">\n",
    ">\n",
    ">[Global Variable Names](https://www.python.org/dev/peps/pep-0008/#id44)\n",
    ">\n",
    ">* (Let's hope that these variables are meant for use inside one module only.) The conventions are about the same as those for functions.\n",
    ">\n",
    ">* Modules that are designed for use via `from M import *` should use the `__all__` mechanism to prevent exporting globals, or use the older convention of prefixing such globals with an underscore (which you might want to do to indicate these globals are \"module non-public\").\n",
    ">\n",
    ">\n",
    ">\n",
    ">[Function and Variable Names](https://www.python.org/dev/peps/pep-0008/#id45)\n",
    ">\n",
    ">* Function names should be lowercase, with words separated by underscores as necessary to improve readability.\n",
    ">\n",
    ">* Variable names follow the same convention as function names.\n",
    ">\n",
    ">* mixedCase is allowed only in contexts where that's already the prevailing style (e.g. threading.py), to retain backwards compatibility.\n",
    ">\n",
    ">\n",
    ">\n",
    ">[Function and Method Arguments](https://www.python.org/dev/peps/pep-0008/#id46)\n",
    ">\n",
    ">* Always use `self` for the first argument to instance methods.\n",
    ">\n",
    ">* Always use `cls` for the first argument to class methods.\n",
    ">\n",
    ">* If a function argument's name clashes with a reserved keyword, it is generally better to append a single trailing underscore rather than use an abbreviation or spelling corruption. Thus `class_` is better than `clss`. (Perhaps better is to avoid such clashes by using a synonym.)\n",
    ">\n",
    ">\n",
    ">\n",
    ">[Method Names and Instance Variables](https://www.python.org/dev/peps/pep-0008/#id47)\n",
    ">\n",
    ">Use the function naming rules: lowercase with words separated by underscores as necessary to improve readability.\n",
    ">\n",
    ">Use one leading underscore only for non-public methods and instance variables.\n",
    ">\n",
    ">To avoid name clashes with subclasses, use two leading underscores to invoke Python's name mangling rules.\n",
    ">\n",
    ">Python mangles these names with the class name: if class Foo has an attribute named `__a`, it cannot be accessed by `Foo.__a`. (An insistent user could still gain access by calling `Foo._Foo__a`.) Generally, double leading underscores should be used only to avoid name conflicts with attributes in classes designed to be subclassed. Note: there is some controversy about the use of __names.\n",
    ">\n",
    ">\n",
    ">\n",
    ">[Constants](https://www.python.org/dev/peps/pep-0008/#id48)\n",
    ">\n",
    ">Constants are usually defined on a module level and written in all capital letters with underscores separating words. Examples include `MAX_OVERFLOW` and `TOTAL`.\n",
    "\n",
    "\n",
    "\n",
    "</details>\n",
    "\n",
    "<br>\n",
    "\n",
    "<br>\n",
    "\n",
    "______________"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Comments in Python can be single-line or mulit-line\n",
    "\n",
    "### `#` Denotes a **single-line** or \"inline\" comment.\n",
    "### `'''` or `\"\"\"` Dentoes a **mulit-line, block, or docstring** comment."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Single-line examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": [
    "    import re\n",
    "    \n",
    "    #List of RegEx for various formatting options (single-line comment)\n",
    "    bold         =  re.compile(r'(_{2}(?P<words>[^_]+)_{2})')\n",
    "    italic       =  re.compile(r'(_(?P<words>[a-zA-Z0-9 ]+)_)') #uses a named group in RegEx (in-line comment)\n",
    "    h6           =  re.compile(r'^#{6} (.*)')\n",
    "    h2           =  re.compile(r'^#{2} (.*)')\n",
    "    h1           =  re.compile(r'^# (.*)')\n",
    "    list_elements = re.compile(r'<li>.*</li>') #HTML List Elements (in-line comment)\n",
    "    other_items  =  re.compile(r'<h|<ul|<p|<li')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A multi-line example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "import re\n",
    "\n",
    "\n",
    "def parse_markdown(markdown):\n",
    "    \"\"\"\n",
    "    Order matters here!!  Inside to outside for wrapped formatting to make the replacements work.\n",
    "    Followed by elements that appear at the beginning of lines. When done, leftovers get\n",
    "    <p></p>, and lists get consolidated.\n",
    "    \"\"\"\n",
    "\n",
    "    pass\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A multi-line example with a doctest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def tally(tournament_results):\n",
    "    '''Generate formatted report string for tournament results.\n",
    "\n",
    "     >>> test = (tally(\"Courageous Californians;Devastating Donkeys;win\\\\nAllegoric Alaskans;Blithering Badgers;win\\\\nDevastating Donkeys;Allegoric Alaskans;loss\\\\nCourageous Californians;Blithering Badgers;win\\\\nBlithering Badgers;Devastating Donkeys;draw\\\\nAllegoric Alaskans;Courageous Californians;draw\"))\n",
    "     >>> print(test)\n",
    "     Team                           | MP |  W |  D |  L |  P\n",
    "     Allegoric Alaskans             |  3 |  2 |  1 |  0 |  7\n",
    "     Courageous Californians        |  3 |  2 |  1 |  0 |  7\n",
    "     Blithering Badgers             |  3 |  0 |  1 |  2 |  1\n",
    "     Devastating Donkeys            |  3 |  0 |  1 |  2 |  1\n",
    "    '''\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "__________\n",
    "\n",
    "\n",
    "## Strings can be denoted  with either   **`'`**  OR  **`\"`** (_pick one as  your default_)\n",
    "\n",
    "\n",
    "\n",
    "<br>\n",
    "\n",
    "####  _There's also the [**`str()`**](https://docs.python.org/3.6/library/stdtypes.html#str) constructor, which can be very handy for converting numbers & other types _into_ strings.  If necessary, you can also _escape_ a single- or double- quote with a `\\` character._"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I'd use double quotes to avoid escaping single (') quotes.\n",
      "...but I would use single quotes to avoid having to escape the \"other\" double (\") quotes.\n",
      "If I had to, I'd escape the single quotes with the backslash character\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'12345'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"I'd use double quotes to avoid escaping single (') quotes.\")\n",
    "\n",
    "print('...but I would use single quotes to avoid having to escape the \"other\" double (\") quotes.')\n",
    "\n",
    "print('If I had to, I\\'d escape the single quotes with the backslash character')\n",
    "\n",
    "#...And if I needed these numbers as a string, I'd use the str() method\n",
    "str(12345)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___________\n",
    "\n",
    "\n",
    "##  Strings are **immutable** in Python. To \"change\" a string, make a **_Copy_**\n",
    "\n",
    "#### **`int`**, **`float`**, **`bool`**, **`tuple`**, **`unicode`**, & **`frozenset`** are also **immutable** -- but just about every other type in Python  is _**mutable**_.\n",
    "\n",
    "\n",
    "<br>\n",
    "\n",
    "\n",
    "\n",
    "Python strings represent a collection of [unicode code points](https://stackoverflow.com/questions/27331819/whats-the-difference-between-a-character-a-code-point-a-glyph-and-a-grapheme). These are *analogous* to ASCII characters (which early computers used for text) - but _include_ the representation of things like 🤖 (emoji), العالمية (Arabic script), and 感じ(Kanji) -- as well as other languages.\n",
    "\n",
    "The [**string class**](https://docs.python.org/3/library/string.html) has many more useful methods & ways to manipulate textual data.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!!\n",
      "Hello, World!! Today is a brand-new day.\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "'str' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-7-4596c9d942c1>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m \u001b[0mgreeting\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'J'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "greeting=\"Hello, World!!\"\n",
    "new_greeting = greeting + \" Today is a brand-new day.\"\n",
    "\n",
    "print(greeting)\n",
    "print(new_greeting)\n",
    "\n",
    "\n",
    "greeting[0] = 'J'\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_____\n",
    "\n",
    "\n",
    "## You can _concatenate_ two strings using the shortcut **`+`**\n",
    "\n",
    "####  _But if you're using Python 3.6 & above, there are many options to compose strings.  More on that later._"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Thing One & Thing Two\n"
     ]
    }
   ],
   "source": [
    "string_one = \"Thing One\"\n",
    "string_two = \"Thing Two\"\n",
    "\n",
    "combined = string_one + \" & \" + string_two\n",
    "\n",
    "print(combined)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Strings are also _indexable_, _sliceable_, & _iterable_\n",
    "\n",
    "\n",
    "<br>\n",
    "\n",
    "<details>\n",
    "<summary><img align=\"left\" width=\"85\" height=\"35\" src=\"images/details.png\">\n",
    "<br>\n",
    "</summary>\n",
    "\n",
    "<br>\n",
    "\n",
    "<br>\n",
    "\n",
    "\n",
    "<img align=\"center\" width=\"75%\" src=\"images/str_indexes.png\">\n",
    "\n",
    "<br>\n",
    "\n",
    "<br>\n",
    "\n",
    "<br>\n",
    "\n",
    "<img align=\"center\" height=\"80%\" src=\"images/slicing_teal.png\">\n",
    "\n",
    "<br>\n",
    "\n",
    "<br>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A String Slicing Exercise\n",
    "\n",
    "\n",
    "Write code to answer the questions in the cells below.\n",
    "**A few tips:**\n",
    "\n",
    "1. No need to put the **start** index in a slice if it's zero - Python will start there anyways\n",
    "2. No need to put the **end** index in a slice if it's the end of the string -- Python will end there anyways\n",
    "3. Using negative indexing can be *tricky*. While the indexes are **negative**, Python still moves from left to right when cycling through. *this personally trips me up all the time....*\n",
    "4. Steps are also tricky, and always *include* the first index in the slice.\n",
    "\n",
    "\n",
    "#### our_word = `'superimposed'`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "per\n"
     ]
    }
   ],
   "source": [
    "our_word = 'superimposed'\n",
    "\n",
    "#Example: print 'per': #\n",
    "print(our_word[2:5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Now try to print the Following Using Only _Slices_ of `superimposed`:\n",
    "\n",
    "1. Print only the last letter\n",
    "2. Print only the first 'e'\n",
    "3. Print the second 'p'\n",
    "4. Print 'imp':\n",
    "5. Print 'posed'\n",
    "6. Print 'eri'\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'posed'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#1\n",
    "our_word[-1], our_word[11]\n",
    "\n",
    "#4\n",
    "our_word[5:8]  \n",
    "\n",
    "our_word[our_word.find('i'):our_word.find('o')]\n",
    "our_word[7:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Print the Following Using Only _Slices_ of `superimposed` (_**HINT:**  these use a **`step`** in the slice_):\n",
    "\n",
    "\n",
    "1. Print **`'sprmoe'`**`\n",
    "2. Print **`'ueipsd'`**`\n",
    "3. Print **``'sems'`**\n",
    "4. Print the word in **`reverse`**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "per\n",
      "from the right sprmoe\n",
      "from the left sprmoe\n",
      "reversed desopmirepus\n"
     ]
    }
   ],
   "source": [
    "our_word = 'superimposed'\n",
    "\n",
    "#Example: print 'per': #\n",
    "print(our_word[2:5])\n",
    "\n",
    "print(\"from the right\", our_word[:-1:2])\n",
    "\n",
    "print(\"from the left\", our_word[::2])\n",
    "\n",
    "\n",
    "print(\"reversed\", our_word[::-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **_CHALLENGE: these are tricky_**  Again, use `superimposed`\n",
    "\n",
    "**HINT:**  _when you reverse a slice, it is far easier to count **`from`** where **`to`** where in the **`positive`** index direction....but have the **`step`** be **`negative`**...._\n",
    "\n",
    "\n",
    "\n",
    "1. Print **`'pmi'`**\n",
    "2. Print **`'sopmire'`**\n",
    "\n",
    "\n",
    "<br>\n",
    "\n",
    "\n",
    "**HINT:**  _reversing slices can be more than just a single step..._\n",
    "1. Print **`'doip'`**\n",
    "\n",
    "\n",
    "<br>\n",
    "\n",
    "\n",
    "**Hint:** _Think...from where : where **from the left**, and how many **steps** in **what** direction??_\n",
    "1. Print **`'pie'`**\n",
    "\n",
    "\n",
    "<br>\n",
    "\n",
    "\n",
    "**HINT:**  _Since a slice returns a **string**, you can use '+' to concatenate_\n",
    "1. Print **`'super imp'`** (_yes, we're cheating a bit..._)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Solutions\n",
    "<br>\n",
    "<details>\n",
    "<summary><img align=\"left\" height=\"45\" src=\"images/coding_btn.png\">\n",
    "<br>\n",
    "</summary>\n",
    "\n",
    "<br>\n",
    "\n",
    "<br>\n",
    "\n",
    "\n",
    "\n",
    "```python\n",
    "\n",
    "our_word = 'superimposed'\n",
    "\n",
    "\n",
    "#Print only the last letter: #\n",
    "print(our_word[-1])\n",
    "\n",
    "#OR -- but really?  -1 is the convention#\n",
    "\n",
    "print(our_word[11])\n",
    "print('')\n",
    "\n",
    "#Print only the first 'e': #\n",
    "print(our_word[-9])\n",
    "\n",
    "#OR#\n",
    "\n",
    "print(our_word[3])\n",
    "print('')\n",
    "\n",
    "#Print the second 'p':\n",
    "print(our_word[7])\n",
    "\n",
    "#OR#\n",
    "\n",
    "print(our_word[-5])\n",
    "print('')\n",
    "\n",
    "#Print 'imp': #\n",
    "print(our_word[5:8])\n",
    "print('')\n",
    "\n",
    "#Print 'posed': #\n",
    "print(our_word[-5:])\n",
    "\n",
    "#OR#\n",
    "\n",
    "print(our_word[7:])\n",
    "print('')\n",
    "\n",
    "#Print 'eri':\n",
    "print(our_word[3:6])\n",
    "\n",
    "#OR#\n",
    "\n",
    "print(our_word[-9:-6])\n",
    "print('')\n",
    "#----HINT:  these use a *step----*\n",
    "\n",
    "#Print 'sprmoe': #\n",
    "print(our_word[::2])\n",
    "print('')\n",
    "\n",
    "#Print 'ueipsd': #\n",
    "print(our_word[1::2])\n",
    "print('')\n",
    "\n",
    "#Print 'sems': #\n",
    "print(our_word[::3])\n",
    "print('')\n",
    "\n",
    "#Print the word in reverse:\n",
    "print(our_word[::-1])\n",
    "print('')\n",
    "\n",
    "\n",
    "#----- CHALLENGE: these are *tricky* ------\n",
    "\n",
    "#HINT:  when you reverse a slice, it is far easier to count\n",
    "#       *from* where *to* where in the *positive* index\n",
    "#       direction....but have the *step* be *negative*....\n",
    "\n",
    "#Print 'pmi' :\n",
    "print(our_word[7:4:-1])\n",
    "print('')\n",
    "\n",
    "#Print 'sopmire' :\n",
    "print(our_word[9:2:-1])\n",
    "print('')\n",
    "\n",
    "\n",
    "#HINT:  reversing a slice can be more than just a single step...\n",
    "#Print 'doip':\n",
    "print(our_word[::-3])\n",
    "print('')\n",
    "\n",
    "\n",
    "#Hint: Think...from where : where *from the left*, and how many *steps* in *what direction*??\n",
    "#Print 'pie':\n",
    "print(our_word[7:1:-2])\n",
    "\n",
    "#OR - but this is way harder#\n",
    "\n",
    "print(our_word[-5:-10:-2])\n",
    "print('')\n",
    "\n",
    "\n",
    "#Print 'super imp': (yes, it's cheating a bit...)\n",
    "#HINT:  Since a slice returns a *string*, you can use '+' to concatenate\n",
    "\n",
    "print(our_word[:5] + ' ' + our_word[5:8])\n",
    "print('')\n",
    "\n",
    "```\n",
    "\n",
    "\n",
    "<br>\n",
    "</details>\n",
    "\n",
    "\n",
    "\n",
    "<hr>\n",
    "</details>\n",
    "</details>\n",
    "<br>\n",
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## There are Four Different Ways to Format & Compose Strings in Python\n",
    "\n",
    "\n",
    "\n",
    "<br>\n",
    "\n",
    "\n",
    "\n",
    "- We strongly recommend _**f-strings or new-style**_, unless you're dealing with **user input**.\n",
    "- For **user input** use _**Template strings**_.\n",
    "- For the history of string formatting in Python see -- [**PEP498**](https://www.python.org/dev/peps/pep-0498/)\n",
    "\n",
    "\n",
    "\n",
    "#### Chart courtesy of [**Dan Bader**](https://dbader.org/blog/python-string-formatting):\n",
    "\n",
    "\n",
    "\n",
    "<br>\n",
    "\n",
    "\n",
    "\n",
    "_So you want to use string formatting...**which style??**_\n",
    "\n",
    "\n",
    "\n",
    "<br>\n",
    "<img align=\"center\" height=\"80%\" src=\"images/string_decide.png\">\n",
    "<br>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Code examples of each of the Different Types of String Formatting:\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  1.  **`%`** --> Works the same way it does in C/C++. See [**% formatting**](https://docs.python.org/3.1/library/string.html#formatspecfor)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Greetings, Alice\n"
     ]
    }
   ],
   "source": [
    "\n",
    "name = 'Alice' \n",
    "greeting = 'Greetings, %s' %(name) \n",
    "print(greeting)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.  **`Template Strings`** (_import from standard library_). See [**string.Template**](https://docs.python.org/3.1/library/string.html#template-strings)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello, Alice'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from string import Template \n",
    "\n",
    "name ='Alice' \n",
    "temp = Template('Hello, $name')\n",
    "temp.substitute(name=name)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3. **`{}`** with the **`str.format`** method. See [**{}.format**](https://docs.python.org/3.1/library/string.html#formatstrings)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yo, Bob\n"
     ]
    }
   ],
   "source": [
    "name = 'Bob' \n",
    "greeting = 'Yo, {}'.format(name) \n",
    "\n",
    "print(greeting)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4. **`Literal String Interpolation`** AKA **`f-strings` **(_3.6++ only_)**. See [**String Interpolation**](https://docs.python.org/3/reference/lexical_analysis.html#f-strings)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Bob -- you're not lookin' bad for age 47!\n"
     ]
    }
   ],
   "source": [
    "name = 'Bob' \n",
    "age  = '47'\n",
    "greeting = f\"Hello, {name} -- you're not lookin' bad for age {age}!\" \n",
    "\n",
    "print(greeting)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__________________\n",
    "\n",
    "\n",
    "## In Python, **`Indentation is Significant`**, so are  **`:`** (_colons_) after function & class declarations\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "unindent does not match any outer indentation level (<tokenize>, line 4)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<tokenize>\"\u001b[0;36m, line \u001b[0;32m4\u001b[0m\n\u001b[0;31m    elif name == 'Joe':              #<----note this line is not indented properly.....\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m unindent does not match any outer indentation level\n"
     ]
    }
   ],
   "source": [
    " def iffy(name):                  #<----Function definition, with colon, requires code underneath to be indented\n",
    "             if name == 'Sue':\n",
    "               print('Hello, Susan')\n",
    "           elif name == 'Joe':              #<----note this line is not indented properly.....\n",
    "               print('Howdy, Joe.')\n",
    "             else:  print('Yo!!')```\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_____\n",
    "\n",
    "##  _Whitespace_ is _not_ as Significant, but Don't be _Annoying_\n",
    "\n",
    "\n",
    "<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_silly_def():\n",
    "\n",
    "\n",
    "    print('as silly as it seems')\n",
    "\n",
    "    print(\"python doesn't care how many lines you put in\")\n",
    "\n",
    "    print(3    *   4    +   17)\n",
    "\n",
    "    print('....or horizontal spaces, for that matter....')\n",
    "\n",
    "    print(\"but please be reasonable, or we'll make fun of you\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "____\n",
    "\n",
    "## There are three core numeric types:  **`int`**, **`float`**, & **`complex`**.\n",
    "\n",
    "\n",
    "\n",
    "- But all numbers represented as **`floats`** underneath (_**both**_ components of a complex number!).\n",
    "- Other packages & tools are available for fixing precision when needed.\n",
    "- See [**Floating Point Arithmetic Issues & Limitations**](https://docs.python.org/3/tutorial/floatingpoint.html) &  [**Numeric Types**](https://docs.python.org/3/library/stdtypes.html#typesnumeric) for more details on numeric representation.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'complex'>\n"
     ]
    }
   ],
   "source": [
    "print(type(2))\n",
    "\n",
    "\n",
    "print(type(3.5))\n",
    "\n",
    "\n",
    "print(type(5+6j))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python follows  [**PEMDAS**](https://www.mathsisfun.com/operation-order-pemdas.html) order of mathematical operations\n",
    "\n",
    "\n",
    "<br>\n",
    "\n",
    "<img align=\"left\" height=\"130\" src=\"images/PEMDAS.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  **`if`**, **`elif`** & **`else`** are used for `Flow Control`. There's No **formal `case/switch`** Statement.\n",
    "\n",
    "<br>\n",
    "\n",
    "<details>\n",
    "<summary><img align=\"left\" width=\"85\" height=\"35\" src=\"images/details.png\">\n",
    "<br>\n",
    "</summary>\n",
    "\n",
    "<br>\n",
    "\n",
    "<br>\n",
    "\n",
    "\n",
    "<img align=\"center\" src=\"images/control_flow.png\">\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Susan\n",
      "Yo!!\n",
      "Howdy, Joe.\n"
     ]
    }
   ],
   "source": [
    "def iffy(name):\n",
    "   if name == 'Sue':\n",
    "       print('Hello, Susan')\n",
    "   elif name == 'Joe':\n",
    "       print('Howdy, Joe.')\n",
    "   else:  print('Yo!!')\n",
    "\n",
    "    \n",
    "iffy('Sue')\n",
    "\n",
    "iffy('Bob')\n",
    "\n",
    "iffy('Joe')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "______\n",
    "\n",
    "\n",
    "##  **`Ternary`** operators ...but they're more verbose vs. other C-like Languages:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hey Bobby!!\n",
      "Hey you!\n",
      "Hey Bobby!!\n",
      "Hey you!\n"
     ]
    }
   ],
   "source": [
    "#the \"long way\" of writing it\n",
    "def bobby_I(name):\n",
    "    if name == 'Bobby':\n",
    "        print('Hey Bobby!!')\n",
    "    else:\n",
    "        print('Hey you!')\n",
    "        \n",
    "#the ternary form\n",
    "def bobby(name):\n",
    "         print('Hey Bobby!!') if name == 'Bobby' else print('Hey you!')      #<------- Pythons \"ternary form\" of an if-else.\n",
    "\n",
    "\n",
    "bobby_I('Bobby')\n",
    "bobby_I('Gerald')\n",
    "\n",
    "bobby('Bobby')\n",
    "bobby('Alice')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "______\n",
    "\n",
    "##  **`or`**  | **`and`** | **`not`**  for [**boolean operators**](https://docs.python.org/3/library/stdtypes.html#boolean-operations-and-or-not)\n",
    "\n",
    "\n",
    "\n",
    "<br>\n",
    "\n",
    "<details>\n",
    "<summary><img align=\"left\" width=\"85\" height=\"35\" src=\"images/details.png\">\n",
    "<br>\n",
    "</summary>\n",
    "\n",
    "<br>\n",
    "\n",
    "<br>\n",
    "\n",
    "<br>\n",
    "<img width=\"55%\" align=\"center\" src=\"images/booleans.png\">\n",
    "<br>\n",
    "\n",
    "<br>\n",
    "\n",
    "<hr>\n",
    "</details>\n",
    "\n",
    "\n",
    "\n",
    "<br>\n",
    "\n",
    "<br>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "______\n",
    "\n",
    "## Uses [**`Comparison Operators`**](https://realpython.com/python-operators-expressions/#comparison-operators)\n",
    "\n",
    "\n",
    "\n",
    "<br>\n",
    "\n",
    "\n",
    "\n",
    "All  equal in their evaluation priority, but as a group --  _**higher priority & evaluated ahead**_ of  Boolean Operators.\n",
    "\n",
    "\n",
    "<br>\n",
    "\n",
    "<details>\n",
    "<summary><img align=\"left\" width=\"85\" height=\"35\" src=\"images/details.png\">\n",
    "<br>\n",
    "</summary>\n",
    "\n",
    "<br>\n",
    "\n",
    "<br>\n",
    "  <img align=\"center\" width=\"50%\" height=200 src=\"images/compairison_ops.png\">\n",
    "<br>\n",
    "<br>\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "value of x =  13\n",
      "value of y =  61\n",
      "value of z =  74\n",
      "x < y is True\n",
      "--------------------------\n",
      "y < y is False\n",
      "--------------------------\n",
      "z <= 75 is True\n",
      "--------------------------\n",
      "z == 10 is False\n",
      "--------------------------\n",
      "z!= 10 is True\n"
     ]
    }
   ],
   "source": [
    "x = 13\n",
    "y = 61\n",
    "z = x + y\n",
    "\n",
    "print('value of x = ', x)\n",
    "print('value of y = ', y)\n",
    "print('value of z = ', z)\n",
    "\n",
    "\n",
    "#y is bigger than x. True\n",
    "print(f'x < y is {x < y}')\n",
    "\n",
    "print('--------------------------')\n",
    "\n",
    "#however, y is not bigger than y. False\n",
    "print(f'y < y is {y < y}')\n",
    "\n",
    "print('--------------------------')\n",
    "\n",
    "#z is 74 so this is True\n",
    "print(f'z <= 75 is {z <= 75}')\n",
    "\n",
    "print('--------------------------')\n",
    "\n",
    "#z is != 10 False.\n",
    "print(f'z == 10 is {z == 10}')\n",
    "\n",
    "print('--------------------------')\n",
    "\n",
    "#z is !=10 True.\n",
    "print(f'z!= 10 is {z !=10}')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_______\n",
    "\n",
    "## Loops: \n",
    "\n",
    "### **`while`**, **`for`** using  -- **`for x in range(y)..`**   **`for each`** using  **`for x in y`**\n",
    "\n",
    "<br>\n",
    "\n",
    "\n",
    "Python provides two basic looping constructs: the **`for`** loop & the **`while`** loop. **`for`** loops cycle through a set of instructions a specific number of times; **`while`** loops cycle indefinitely until a certain test or condition is met.\n",
    "\n",
    "Many programming languages have more specific looping types such as the explicit **`for each`** or the **`do while`** (*do while* something is true - **i.e.** check condition *after* doing once first). Python collapses these types down, & has you customize if needed.\n",
    "\n",
    "\n",
    "\n",
    "<br>\n",
    "\n",
    "<br>\n",
    "\n",
    "<details>\n",
    "<summary><img align=\"left\" width=\"85\" height=\"35\" src=\"images/details.png\">\n",
    "<br>\n",
    "</summary>\n",
    "\n",
    "<br>\n",
    "\n",
    "<br>\n",
    "\n",
    "<br>\n",
    "<img align=\"center\" src=\"images/loop_examples.png\">\n",
    "<br>\n",
    "\n",
    "<br>\n",
    "\n",
    "<hr>\n",
    "</details>\n",
    "\n",
    "\n",
    "\n",
    "<br>\n",
    "\n",
    "<br>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For all loop types, **`Conditions`** are checked on loop **entry**\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `While` Loop that prints until the value of the `pile` variable is lower than 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#while loop\n",
    "\n",
    "pile = 14\n",
    "while pile > 7:\n",
    "  print(\"!\", end=\" \")\n",
    "  pile -= 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `For` Loop using `range()`  -- this will print the 5 numbers from zero to 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "#for loop using range\n",
    "\n",
    "for number in range(5):\n",
    "  print(number)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `For Each` Loop using the `in` construct -- this will print each letter of the string with a space between each"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i n s a n e   p o r c u p i n e "
     ]
    }
   ],
   "source": [
    "#implied for each loop using iteration via \"in\"\n",
    "\n",
    "for letter in 'insane porcupine':\n",
    "  print(letter + \" \", end='')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `For Each` Loop using the `enumerate()` method -- this will print each letter of the string on its own line with its corresponding index number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "F - index: 0\n",
      "r - index: 1\n",
      "o - index: 2\n",
      "g - index: 3\n",
      "g - index: 4\n",
      "y - index: 5\n",
      "  - index: 6\n",
      "G - index: 7\n",
      "r - index: 8\n",
      "e - index: 9\n",
      "e - index: 10\n",
      "n - index: 11\n"
     ]
    }
   ],
   "source": [
    "#implied for each loop using enumeration and iteration to print indexs\n",
    "\n",
    "for idx, letter in enumerate('Froggy Green'):\n",
    "  print(letter + \" - index: \" + str(idx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `For Each` Loop using the `enumerate()` method -- this will print each letter of the string on its own line as many times as its index number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "r\n",
      "oo\n",
      "ggg\n",
      "gggg\n",
      "yyyyy\n",
      "      \n",
      "GGGGGGG\n",
      "rrrrrrrr\n",
      "eeeeeeeee\n",
      "eeeeeeeeee\n",
      "nnnnnnnnnnn\n"
     ]
    }
   ],
   "source": [
    "#implied for loop using enumeration and iteration to multiply by indexs\n",
    "\n",
    "for idx, letter in enumerate('Froggy Green'):\n",
    "  print(letter * idx)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `For` Loop using a _string slice with a step_ to skip certain indexes.  This will print every other letter in the string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b a n t e r "
     ]
    }
   ],
   "source": [
    "#for loop skipping indexes using a slice.  This prints \"every other\" letter from left-->right\n",
    "\n",
    "my_string = 'baacnctuesre'\n",
    "\n",
    "for letter in my_string[::2]:\n",
    "  print(letter, end=\" \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `For` Loop using the `range()` & the `Continue` keyword to skip certain indexes.  This will print only odd numbers in the range."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 3 5 7 9 11 "
     ]
    }
   ],
   "source": [
    "#for loop skipping indexes using \"continue\"\n",
    "for number in range(13):\n",
    "  if number % 2 == 0:\n",
    "    continue\n",
    "  else:\n",
    "    print(number, end=\" \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `For` Loop using the `Break` keyword to exit the loop when a condition has been met.  This prints the numbers in the range below 13."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 2 3 4 5 6 7 8 9 10 11 12 "
     ]
    }
   ],
   "source": [
    "#for loop breaking on a condition\n",
    "\n",
    "for number in range(23):\n",
    "  if number == 13:\n",
    "    break\n",
    "  else:\n",
    "    print(number, end=\" \")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "____\n",
    "\n",
    "###  As seen in the previous examples, **`break`** can be  used to exit a loop & \"break out\" to the next line of execution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "for number in range(5): \n",
    "    if number == 3: \n",
    "        break \n",
    "    else: \n",
    "        print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Likewise, **`continue`** can be used in a loop to \"skip forward\" to the next iteration if a condition is met.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for number in range(5):\n",
    "    if number == 3: \n",
    "        continue \n",
    "    else: \n",
    "        print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **`flow control`** can be used in combination with **`loops`**\n",
    "\n",
    "\n",
    "\n",
    "<br>\n",
    "\n",
    "<br>\n",
    "\n",
    "\n",
    "\n",
    "<img align=\"center\" src=\"images/loop variants.png\">\n",
    "\n",
    "<br>\n",
    "<br>\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Example : \n",
    "\n",
    "####  The code below finds prime numbers in a certain range"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 is a prime number\n",
      "4 equals 2 * 2\n",
      "5 is a prime number\n",
      "6 equals 2 * 3\n",
      "7 is a prime number\n",
      "8 equals 2 * 4\n",
      "9 is a prime number\n"
     ]
    }
   ],
   "source": [
    "\n",
    "#Outer Loop will go 8 times.\n",
    "for number in range(2, 10):\n",
    "    \n",
    "    #Inner Loop will go from 2 to number specified by outer loop \n",
    "    for candidate in range(2, number):\n",
    "        \n",
    "        #test to see if there is a factor here\n",
    "        if number % candidate == 0:\n",
    "            print(f\"{number} equals {candidate} * {number//candidate}\")\n",
    "            \n",
    "            #break out of this inner loop if the condition is met\n",
    "            break\n",
    "            \n",
    "        # we didn't find a factor, so we hit this condition\n",
    "        else:  \n",
    "            print(f\"{number} is a prime number\")\n",
    "            \n",
    "            #break out of this inner loop to try the next number in the sequence\n",
    "            break\n",
    "\n",
    "#now, go on to the next iteration of the OUTER loop...\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "____\n",
    "\n",
    "\n",
    "## **`Iteration`** &gt;&gt; A general term for taking _each item of something, one after another_. Any time you use a loop, explicit or implicit, to go over a group of items, that is **`iteration`**.\n",
    "\n",
    "> _**iterables** are objects that have an `__iter__` method which returns an `__iterator__`, or which defines a `__getitem__` method that can take sequential indexes starting from zero (**IndexError** is raised when the indexes are no longer valid). **iterables** are objects that can return an **iterator**. An **iterator** in Python is defined as any object implementing the `__next__` method._\n",
    "\n",
    "\n",
    "\n",
    "<br>\n",
    "\n",
    "\n",
    "\n",
    "### **`iterators`** are built-in for strings, lists, dictionaries & other container data structures. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "c\n",
      "d\n",
      "e\n",
      "f\n",
      "g\n",
      "h\n",
      "i\n"
     ]
    },
    {
     "ename": "StopIteration",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-56-b23488e04994>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     14\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     15\u001b[0m \u001b[0;31m#This raises a \"stop iteration\" error\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 16\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmy_little_iterator\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__next__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mStopIteration\u001b[0m: "
     ]
    }
   ],
   "source": [
    "my_little_iterator = iter(['a','b','c','d','e','f','g','h','i'])\n",
    "\n",
    "print(my_little_iterator.__next__())\n",
    "print(my_little_iterator.__next__())\n",
    "print(my_little_iterator.__next__())\n",
    "print(my_little_iterator.__next__())\n",
    "print(my_little_iterator.__next__())\n",
    "print(my_little_iterator.__next__())\n",
    "print(my_little_iterator.__next__())\n",
    "print(my_little_iterator.__next__())\n",
    "\n",
    "#This prints the last letter, exhausting the iterator\n",
    "print(my_little_iterator.__next__())\n",
    "\n",
    "#This raises a \"stop iteration\" error\n",
    "print(my_little_iterator.__next__())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### strings, loops, maps, list comprehensions, tuples, files, etc. in Python all implement `__next__` -- which is called automatically under the covers to get content in succession.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Looked on shelf 1 ...\n",
      "Where's my afternoon snack?!!?\n",
      "Yum! almonds on shelf 2!\n"
     ]
    }
   ],
   "source": [
    "\n",
    "#Here is a dictionary, representing pantry shelves\n",
    "pantry = {1 :  ['M&Ms', 'crackers', 'Beef Jerky'],\n",
    "       2 :  ['almonds', 'peanuts', 'raisins'],\n",
    "       3 :  ['corn chips','potato chips','cheese sticks'] }\n",
    "\n",
    "#Here is my afternoon Snack \n",
    "afternoon_snack = None\n",
    "\n",
    "#This loops through each shelf number by calling `__next__`\n",
    "for shelf_no, shelf in pantry.items():\n",
    "    if 'almonds' in shelf:\n",
    "        afternoon_snack = shelf.remove('almonds')\n",
    "        print(f\"Yum! almonds on shelf {str(shelf_no)}!\")\n",
    "        break\n",
    "    \n",
    "    if not afternoon_snack:\n",
    "        print(f\"Looked on shelf {str(shelf_no)} ...\")\n",
    "        print(\"Where's my afternoon snack?!!?\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "____\n",
    "\n",
    "\n",
    "## Python has 4 Core **Built-in Data Structures** :  `lists`, `tuples`, `dictionaries`, &  `sets` \n",
    "\n",
    "\n",
    "###    Of course, these have their variations,  methods, & many modifiers. \n",
    "###    You can read more in :\n",
    "### -  [**Python Data Structures Tutorial**](https://docs.python.org/3/tutorial/datastructures.html)\n",
    "### -  [**Python Collections Module**](https://docs.python.org/3/library/collections.html)\n",
    "### -  [**Python Itertools Module**](https://docs.python.org/3/library/itertools.html) \n",
    "\n",
    "### -  [**Create your own Data Structures**](https://code.tutsplus.com/tutorials/how-to-implement-your-own-data-structure-in-python--cms-28723)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "### **`lists`** are declared with **`[]`**\n",
    "\n",
    "*  There is a [**`list()`**](https://docs.python.org/3/library/stdtypes.html#list) constructor that you can use instead.\n",
    "*  Like **`strings`** -- **`lists`**  are _indexable_, _sliceable_, & _iterable_......\n",
    "*  _**Except**_ -- **`lists`** are _**mutable**_ & _**expandable**_ too, via methods like `list.append()`\n",
    "*  Can be sorted in-place by calling **`list.sort()`**.  Call **`sorted()`** for a new list. More on sorting [**here**](https://docs.python.org/3/howto/sorting.html)\n",
    "* Can be reversed by calling [**`reversed()`**](https://docs.python.org/3/library/functions.html#reversed)\n",
    "* More list methods [**here**](https://docs.python.org/3/tutorial/datastructures.html#more-on-lists)\n",
    "* The [**collections module**](https://docs.python.org/3/library/collections.html) has  **`deque()`**, a bi-directional append list-type\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "alphabet=\"abcdefghijklmnopqrstuvwxyz\"\n",
    "vowels=\"aeiou\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#simple constructor version\n",
    "\n",
    "our_list = list(alphabet)\n",
    "print(our_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#loop version, picking only consonants\n",
    "\n",
    "consonants_list=[]\n",
    "\n",
    "for letter in alphabet:\n",
    "  if letter not in vowels:\n",
    "    consonants_list.append(letter)\n",
    "\n",
    "print(consonants_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#comprehension version picking only consonants\n",
    "\n",
    "consonants = [letter for letter in alphabet if letter not in vowels]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cons type is an object:  <class 'filter'>\n",
      "b c d f g h j k l m n p q r s t v w x y z \n",
      " ['b', 'c', 'd', 'f', 'g', 'h', 'j', 'k', 'l', 'm', 'n', 'p', 'q', 'r', 's', 't', 'v', 'w', 'x', 'y', 'z']\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "Doing the same thing via filter() -- but filter() returns an *iterator*\n",
    "which needs to be unpacked as a second step to get the content out.\n",
    "'''\n",
    "\n",
    "cons = filter(lambda n : n not in vowels, alphabet)\n",
    "cons_list = []\n",
    "\n",
    "print(\"cons type is an object: \", type(cons))\n",
    "\n",
    "\n",
    "for item in cons:\n",
    "  cons_list.append(item)\n",
    "  print(item, end=\" \")\n",
    "\n",
    "print(\"\\n\", cons_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Additional List exampes, using numbers & math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 9, 25, 49, 81, 121]\n",
      "[1, 9, 25, 49, 81, 121]\n",
      "1 9 25 49 81 121 \n",
      " [1, 9, 25, 49, 81, 121]\n"
     ]
    }
   ],
   "source": [
    "odd_squares=[]\n",
    "\n",
    "#loop\n",
    "for number in range(13):\n",
    "  if number%2 !=0:\n",
    "    odd_squares.append(number**2)\n",
    "\n",
    "print(odd_squares)\n",
    "\n",
    "\n",
    "#comprehension\n",
    "squared_odds = [number**2 for number in range(13) if number%2 !=0]\n",
    "\n",
    "print(squared_odds)\n",
    "\n",
    "#via map() and filter (remember, if you wnat a list, you have to unpack)\n",
    "sq_odds = map(lambda n: n**2,filter(lambda n: n%2 != 0, range(13)))\n",
    "sqs_odds = []\n",
    "\n",
    "for item in sq_odds:\n",
    "  sqs_odds.append(item)\n",
    "  print(item, end=\" \")\n",
    "\n",
    "print(\"\\n\", sqs_odds)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 5, 7, 11, 13, 17, 19]\n",
      "[2, 3, 5, 7, 11, 13, 17, 19]\n"
     ]
    }
   ],
   "source": [
    "#Sieve of Eratosthenes function with nested loops\n",
    "n=20\n",
    "\n",
    "def sieve_I(n):\n",
    "    not_prime = []\n",
    "    prime = []\n",
    "\n",
    "\n",
    "    for i in range(2, n+1):\n",
    "        if i not in not_prime:\n",
    "            prime.append(i)\n",
    "            for j in range (i*i, n+1, i):\n",
    "                not_prime.append(j)\n",
    "\n",
    "    return prime\n",
    "\n",
    "\n",
    "#Sieve of Eratosthenes function with nested comprehension\n",
    "#Note this uses a generator expression in the middle\n",
    "\n",
    "def sieve_II(n):\n",
    "\n",
    "  return [item for item in range(2, n+1) if \n",
    "          item not in (not_prime for item in range(2, n+1)\n",
    "          for not_prime in range(item*item, n+1, item))]\n",
    "\n",
    "print(sieve_I(n))\n",
    "print(sieve_II(n))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **`dictionaries`** are declared with **`{key : value, key_2 : value_2}`**\n",
    "\n",
    "*  There is a [**`dict()`**](https://docs.python.org/3/library/stdtypes.html#dict) constructor that you can use instead.\n",
    "\n",
    "* **`keys`** must be _unique_, & must be [**_hashable_**](https://stackoverflow.com/questions/14535730/what-do-you-mean-by-hashable-in-python).  **`values`** can be almost _anything_, including nested dictionaries, or even classes or functions.\n",
    "\n",
    "* **`values`** can be accessed by **`key`**:  **dict[`key`]** ---> **`value for key`**\n",
    "\n",
    "* **`dict()`**s are _iterable_.  The default is **`key`**, but **`values`** can be specified as well\n",
    "\n",
    "* dictionary methods [**here**](https://docs.python.org/3/library/stdtypes.html#typesmapping)\n",
    "\n",
    "* The [**collections module**](https://docs.python.org/3/library/collections.html) has many useful variants & extensions of **`dict()`**\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "combo_alphabet = \"AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "alphabet_dict = {}\n",
    "\n",
    "#loop version of adding to a dict\n",
    "for idx, letter in enumerate(combo_alphabet):\n",
    "  alphabet_dict[letter] = idx\n",
    "\n",
    "print(alphabet_dict)\n",
    "\n",
    "\n",
    "#comprehension version\n",
    "alpha_dict = {idx:letter for idx, letter in enumerate(combo_alphabet)}\n",
    "\n",
    "print(\"\\n\", alpha_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Additional Dictionary Example showing ETL (extraction transformation and loading)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 1, 'e': 1, 'i': 1, 'o': 1, 'u': 1, 'l': 1, 'n': 1, 'r': 1, 's': 1, 't': 1, 'd': 2, 'g': 2, 'b': 3, 'c': 3, 'm': 3, 'p': 3, 'f': 4, 'h': 4, 'v': 4, 'w': 4, 'y': 4, 'k': 5, 'j': 8, 'x': 8, 'q': 10, 'z': 10}\n",
      "\n",
      "\n",
      "{'a': 1, 'e': 1, 'i': 1, 'o': 1, 'u': 1, 'l': 1, 'n': 1, 'r': 1, 's': 1, 't': 1, 'd': 2, 'g': 2, 'b': 3, 'c': 3, 'm': 3, 'p': 3, 'f': 4, 'h': 4, 'v': 4, 'w': 4, 'y': 4, 'k': 5, 'j': 8, 'x': 8, 'q': 10, 'z': 10}\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "A function that takes a dictionary with ALL CAPS values &\n",
    "turns it into a dictionary that has all lowercase values as the keys\n",
    "and the index as the values.\n",
    "\n",
    "dict in ---> dict out, i.e. {1:'WORLD'} turns into ---> {'world' : 1}\n",
    "'''\n",
    "input_dict = {1: [\"A\", \"E\", \"I\", \"O\", \"U\", \"L\", \"N\", \"R\", \"S\", \"T\"],\n",
    "              2: [\"D\", \"G\"],\n",
    "              3: [\"B\", \"C\", \"M\", \"P\"],\n",
    "              4: [\"F\", \"H\", \"V\", \"W\", \"Y\"],\n",
    "              5: [\"K\"],\n",
    "              8: [\"J\", \"X\"],\n",
    "              10: [\"Q\", \"Z\"]}\n",
    "\n",
    "output_dict = {}\n",
    "\n",
    "#nested loop solution\n",
    "def transform_I(input_dict):\n",
    "  for (key, values) in input_dict.items():\n",
    "    for item in values:\n",
    "      output_dict[item.lower()] = key\n",
    "\n",
    "  return output_dict\n",
    "\n",
    "\n",
    "#nested comprehension solution\n",
    "def transform_II(input_dict):\n",
    "        return {value.lower():key for key in input_dict for value in input_dict[key]}\n",
    "\n",
    "\n",
    "print(transform_I(input_dict))\n",
    "print(\"\\n\")\n",
    "print(transform_II(input_dict))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **`tuples`** are declared with **`(value_1, value_2)`** & are _immutable_\n",
    "\n",
    "*  [_except when they aren't..._](https://alysivji.github.io/quick-hit-hashable-dict-keys.html)\n",
    "\n",
    "* There is a [**`tuple()`**](https://docs.python.org/3/library/stdtypes.html#tuple) constructor that you can use instead\n",
    "\n",
    "* Can  be used in sets or as dict() keys, _unless_ they're **unhashable**\n",
    "\n",
    "* Commonly used as a data structure to return multiple values from a function\n",
    "\n",
    "* The [**collections module**](https://docs.python.org/3/library/collections.html) has  **`namedtuple()`**\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **`sets`** are declared with **`{value_1, value_2}`** & are _mutable_\n",
    "\n",
    "*  While a set is _mutable_, like dictionary `keys`, set members must be _unique_\n",
    "\n",
    "*  Most convenient way to dedupe a list?  Coerce it into a `set()`\n",
    "\n",
    "* [**`frozenset()`**](https://docs.python.org/3/library/stdtypes.html#frozenset) is the _immutable variant of **`set()`**, and can be used as a `dict()` key\n",
    "\n",
    "* Can be manipulated using [**mathematical set operations **](https://www.programiz.com/python-programming/set#operations)\n",
    "\n",
    "\n",
    "\n",
    "<br>\n",
    "\n",
    "<img align=\"center\" width=80% src=\"images/set_operations.png\">\n",
    "\n",
    "<br>\n",
    "\n",
    "<br>\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'S', 'D', 'P', 'E', 'A', 'M'}\n",
      "{'S', 'D', 'P', 'E', 'A', 'M'}\n",
      "--------------------------------\n",
      "\n",
      "[2, 3, 5, 7, 11, 13, 17, 19]\n"
     ]
    }
   ],
   "source": [
    "word_list=['Parenthesis','Exponents','Multiplication','Division','Addition','Subtraction']\n",
    "first_letter = set()\n",
    "\n",
    "#loop version\n",
    "for word in word_list:\n",
    "  first_letter.add(word[0])\n",
    "\n",
    "print(first_letter)\n",
    "\n",
    "#comprehension\n",
    "fst_letter = {word[0] for word in word_list}\n",
    "\n",
    "print(fst_letter)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Sieve of Eratosthenes function with set comprehensions\n",
    "def sieve_III(n):\n",
    "    numbers = set(item for item in range(2, n+1))\n",
    "\n",
    "\n",
    "    not_prime = set(not_prime for item in range(2, n+1)\n",
    "                    for not_prime in range(item**2, n+1, item))\n",
    "\n",
    "    return  list((numbers - not_prime))\n",
    "\n",
    "print(sieve_III(n))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "first = set(item for item in range(25) if item % 2 == 0) #evens\n",
    "second = set(item for item in range(25) if item % 2 != 0) #odds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24}\n",
      "{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24}\n"
     ]
    }
   ],
   "source": [
    "#union with | operator\n",
    "\n",
    "print(first | second)\n",
    "\n",
    "#unsion with method\n",
    "\n",
    "print(first.union(second))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "fizz = {item for item in range(100) if item % 3 == 0}\n",
    "buzz = {item for item in range(100) if item % 5 == 0}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0, 75, 45, 15, 90, 60, 30}\n",
      "{0, 75, 45, 15, 90, 60, 30}\n"
     ]
    }
   ],
   "source": [
    "#intersection with &\n",
    "\n",
    "print(fizz & buzz)\n",
    "\n",
    "#intersection wtih intersection\n",
    "\n",
    "print(fizz.intersection(buzz))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{3, 6, 9, 12, 18, 21, 24, 27, 33, 36, 39, 42, 48, 51, 54, 57, 63, 66, 69, 72, 78, 81, 84, 87, 93, 96, 99}\n",
      "{3, 6, 9, 12, 18, 21, 24, 27, 33, 36, 39, 42, 48, 51, 54, 57, 63, 66, 69, 72, 78, 81, 84, 87, 93, 96, 99}\n"
     ]
    }
   ],
   "source": [
    "#difference with -\n",
    "\n",
    "print(fizz - buzz)\n",
    "\n",
    "#difference with difference()\n",
    "\n",
    "print(fizz.difference(buzz))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{3, 5, 6, 9, 10, 12, 18, 20, 21, 24, 25, 27, 33, 35, 36, 39, 40, 42, 48, 50, 51, 54, 55, 57, 63, 65, 66, 69, 70, 72, 78, 80, 81, 84, 85, 87, 93, 95, 96, 99}\n",
      "{3, 5, 6, 9, 10, 12, 18, 20, 21, 24, 25, 27, 33, 35, 36, 39, 40, 42, 48, 50, 51, 54, 55, 57, 63, 65, 66, 69, 70, 72, 78, 80, 81, 84, 85, 87, 93, 95, 96, 99}\n"
     ]
    }
   ],
   "source": [
    "#symmetric difference using ^\n",
    "\n",
    "print(fizz ^ buzz)\n",
    "\n",
    "#symmetric difference using symmetric_difference()\n",
    "\n",
    "print(fizz.symmetric_difference(buzz))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "______\n",
    "\n",
    "\n",
    "## As seen in previeous examples, `lists`, `sets` & `dictionaries` can be made via _**`comprehensions`**_\n",
    "\n",
    "\n",
    "<br>\n",
    "\n",
    "\n",
    "> Python's list comprehension syntax is taken (with trivial keyword/symbol modifications) directly from Haskell. The idea was just too good to pass up. _--[Python wiki](https://wiki.python.org/moin/PythonVsHaskell)_\n",
    "\n",
    "\n",
    "\n",
    "<br>\n",
    "\n",
    "\n",
    "\n",
    "**`comprehensions`** are [display expressions](https://docs.python.org/3/reference/expressions.html#displays-for-lists-sets-and-dictionaries) that build data structures declaratively via _iteration_ & _filtering_.  They both accelerate & compact the production of filled lists, sets, & dictionaries. (_almost_) Any series of iterables,  loops & conditions used to fill one of these data structures can be re-written as a **`comprehension`** directly inside the data structure literal.\n",
    "\n",
    "**`comprehensions`** _are_ loops - shortened, flattened & executed in the [**underlying C API**](https://stackoverflow.com/questions/14124610/python-list-comprehension-expensive) that Python itself is written on top of.\n",
    "\n",
    "Here's a set of reminders for making comprehensions:\n",
    "\n",
    "<br>\n",
    "\n",
    "<br><br>\n",
    "\n",
    "<img align=\"left\" width=60% src=\"images/comprehensions_list.png\">\n",
    "<br><br>\n",
    "\n",
    "<img align=\"left\" width=80% src=\"images/comprehensions_dict.png\">\n",
    "<br><br>\n",
    "\n",
    "<img align=\"left\" width=80% src=\"images/comprehensions_set.png\">\n",
    "<br>\n",
    "\n",
    "\n",
    "\n",
    "<br>\n",
    "<br>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comprehension Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1)  Turn the loop into a list comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "my_list = []\n",
    "for number in range(15):\n",
    "    if number%2 != 0:\n",
    "        my_list.append(number**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2)  Turn the loop into a dictionary comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "keys = 'abcdefghijklmnop'\n",
    "values = [1,2,3,4,5,6,7,8,9,10, 11, 12, 13, 14, 15, 16]\n",
    "my_dict = {}\n",
    "\n",
    "for item in zip(keys, values):\n",
    "\t\tmy_dict[item[0]] = item[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3) The following is function (factorialize(n)) which takes an integer n & calculates n! using a FOR loop. Rewrite the function so that it is only two lines long & uses a list comprehension (a lambda might be necessary).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def factorialize(n):\n",
    "    n_factorial = 1\n",
    "    for i in range(1,n+1):\n",
    "        n_factorial=n_factorial*i\n",
    "    return n_factorial"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4) Turn the following loop (which produces the odd numbers that are between 0 and 20) into a list comprehension\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = []\n",
    "for x in range(20):\n",
    "    if x % 2 != 0:\n",
    "        a.append(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5) Turn the following nested loop into a list comprehension\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "alist = []\n",
    "for row in grid:\n",
    "    for n in row:\n",
    "        alist.append(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6) Turn the following loop into a set comprehension\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = set()\n",
    "for x in 'abracadabra':\n",
    "    if x not in 'abc':\n",
    "        a.update(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solutions\n",
    "\n",
    "<br><br>\n",
    "\n",
    "<br>\n",
    "<details>\n",
    "<summary><img align=\"left\" height=\"45\" src=\"images/templates_color.png\">\n",
    "<br>\n",
    "</summary>\n",
    "<br>\n",
    "\n",
    "<br><br>\n",
    "\n",
    "\n",
    "\n",
    "1)\n",
    "\n",
    "```python\n",
    "my_list = [number**2 for number in range(15) if number%2 !=0]\n",
    "```\n",
    "\n",
    "2)\n",
    "\n",
    "```python\n",
    "my_dict ={k: v for k,v in zip(keys, values)}\n",
    "```\n",
    "\n",
    "\n",
    "3)  Solutions might vary, but here's one possible solution\n",
    "\n",
    "```python\n",
    "import functools\n",
    "\n",
    "def factorialize(n):\n",
    "\treturn functools.reduce(lambda x,y: x*y, [i for i in range (1, n+1)])\n",
    "\n",
    "```\n",
    "\n",
    "\n",
    "\n",
    "**_note here:_**  while you **can** *use **`lambda`** in tis, it's slower to evaluate because it triggers a new* **stack frame**, so importing **`operator`** as well as **`functools`**, so that you can use **`operator.mul:`**\n",
    "\n",
    "\n",
    "\n",
    "<br>\n",
    "\n",
    "\n",
    "```python\n",
    "\n",
    "import functools, operator\n",
    "\n",
    "def factorialize_I(n):\n",
    "\treturn functools.reduce(lambda x,y: x*y, [i for i in range (1, n+1)])\n",
    "\n",
    "\n",
    "def factorialize_II(n):\n",
    "\treturn functools.reduce(operator.mul, (item for item in range(1, n+1)))\n",
    "\n",
    "```\n",
    "\n",
    "4)\n",
    "\n",
    "```python\n",
    "a = [x for x in range(20) if x%2 !=0]\n",
    "```\n",
    "\n",
    "\n",
    "5)\n",
    "\n",
    "```python\n",
    " alist = [n for row in grid for n in row]\n",
    "```\n",
    "\n",
    "\n",
    "6)\n",
    "\n",
    "```python\n",
    "a = {x for x in 'abracadabra' if x not in 'abc'}\n",
    "```\n",
    "\n",
    "\n",
    "<br>\n",
    "</details>\n",
    "<br>\n",
    "\n",
    "<hr>\n",
    "</details>\n",
    "<br>\n",
    "\n",
    "<br>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "______\n",
    "\n",
    "##  **`raise`** raises an exception\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "ename": "SystemExit",
     "evalue": "Gah!  It's a Paradox!!",
     "output_type": "error",
     "traceback": [
      "An exception has occurred, use %tb to see the full traceback.\n",
      "\u001b[0;31mSystemExit\u001b[0m\u001b[0;31m:\u001b[0m Gah!  It's a Paradox!!\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/anaconda3/envs/jupyter_turtle_37/lib/python3.7/site-packages/IPython/core/interactiveshell.py:3333: UserWarning: To exit: use 'exit', 'quit', or Ctrl-D.\n",
      "  warn(\"To exit: use 'exit', 'quit', or Ctrl-D.\", stacklevel=1)\n"
     ]
    }
   ],
   "source": [
    "#WATCH OUT: This is an endless loop!!\n",
    "\n",
    "continue_meditating = True\n",
    "\n",
    "while continue_meditating:\n",
    "    if True:\n",
    "        raise SystemExit(\"Gah!  It's a Paradox!!\")\n",
    "    elif False:\n",
    "         continue\n",
    "    else: continue_meditating = False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_____\n",
    "\n",
    "## **`try`**  &  **`except`**  are used for  _**catching**_  exceptions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter a number: r\n",
      "Oops!  That was not a valid number.  Try again...\n",
      "Please enter a number: t\n",
      "Oops!  That was not a valid number.  Try again...\n",
      "Please enter a number: 4\n"
     ]
    }
   ],
   "source": [
    "while True:\n",
    "    try:\n",
    "     x = int(input(\"Please enter a number: \"))\n",
    "     break\n",
    "     \n",
    "    except ValueError:\n",
    "        print(\"Oops!  That was not a valid number.  Try again...\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_____\n",
    "\n",
    "## Functions are _named_ **`function_name`**\n",
    "\n",
    "###  Functions are _run_ using **`()`**  **e.g.**  to run **`my_function`** type  `my_function()`\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hello(name=''):\n",
    "    if name == '': \n",
    "        return 'Hello, World!' \n",
    "    else: \n",
    "        return 'Hello, ' + name + '!'\n",
    "\n",
    "hello('Class')\n",
    "\n",
    "       'Hello, Class!'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "## Declaring a function: `def function_name( required, *args,** kwargs ): `\n",
    "\n",
    "<br><br>\n",
    "<img width=500 height=200 src=\"images/functionanatomy.png\">\n",
    "<br>\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "*  Defined with `def`\n",
    "*  Required args can set _default values_  `def cat(food='yum!')`\n",
    "*  Required args can be _named_ (**keyword args**)\n",
    "*  Can accept a variable number of args  `def dog(*args)`\n",
    "*  Can also accept arbitrary keyword args `def pets(**kwargs)`\n",
    "\n",
    "\n",
    "### **First-class functions** _**???**_.\n",
    "\n",
    "_In sharp contrast to Java (Javas lambda notwithstanding), functions in Python can be passed around & manipulated as if they were _any other kind of object_ like integers, strings, or variables. This makes them **\"first-class citizens\"**._\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "x = 3 \n",
    "y = 6 \n",
    "z = x + y \n",
    "\n",
    "my_little_int = 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#this is a single function call\n",
    "type(my_little_int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The type of the variable is:  <class 'int'>\n"
     ]
    }
   ],
   "source": [
    "#this feeds the result of type() *into* the print() function\n",
    "print('The type of the variable is: ', type(my_little_int))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x==3 and y==6 is True\n"
     ]
    }
   ],
   "source": [
    "#this feeds the return of the comparison to format, which is then fed to the print() function\n",
    "print(f'x==3 and y==6 is {x==3 and y==6}')\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python supports _**`recursion`**_  but not **`tail-call optimization.`**\n",
    "\n",
    "\n",
    "All recursive calls go to the **stack**, where the first call waits for the final call to return [**see this visualization**](https://goo.gl/kC7bL1). To keep things from getting too out of hand, **Python has a default depth of 1000** recursive calls. Recursions taking more than 1000 calls are terminated by the runtime.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#This function eventually collapses under it's own recursive weight, and Python runs out of memory...\n",
    "\n",
    "def fibb(num):\n",
    "            if num == 0 or num == 1:\n",
    "                return num\n",
    "            else:\n",
    "                return fibb(num-1) + fibb(num-2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_____\n",
    "\n",
    "## Python uses the `with` keyword as a generic handle (_context manager_) for files & other resources.\n",
    "\n",
    "<br>\n",
    "\n",
    "\n",
    "\n",
    " `with` allows the execution of **initialization** & **finalization** (read: setup & teardown) code around a given code block. See [**this article**](http://preshing.com/20110920/the-python-with-statement-by-example/) for an excellent rundown on all the ways you can use a _context manager_ such as **with**.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " -- that from these honored dead we take increased devotion to that cause for which they gave the last full measure of devotion\n",
      "  -- that we here highly resolve that these dead shall not have died in vain\n",
      "  -- that this nation, under God, shall have a new birth of freedom\n",
      "  -- and that government of the people, by the people, for the people, shall not perish from the earth.\n",
      "  Abraham Lincoln\n",
      "  November 19, 1863\n"
     ]
    }
   ],
   "source": [
    " '''\n",
    "  opening a file: use the *open* keyword & the *with* keyword\n",
    "  \t1. the full path to the file in quotes.\n",
    "  \t2. the file *mode* ('r' for read, 'w+' for write, 'a' for append)\n",
    "  \t3. keyword as followed by an alias\n",
    "'''\n",
    "\n",
    "with open('address.txt', 'r') as file:\n",
    "    for line in file:\n",
    "        print(line, end='')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "______\n",
    "\n",
    "\n",
    "## An Exercise Combining Iteration & Files\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "Directions:\n",
    "\n",
    "The file \"poems.txt\" has TWO poem/essays written in it.  Small problem:\n",
    "They're interlaced (**every other line** is a different poem/essay)\n",
    "\n",
    "That's where you come in:  write some Python code that will:\n",
    "\n",
    "1.  Open the file and read it\n",
    "2.  Figure out which line is which\n",
    "    (HINT:  enumerate() & modulus will be **very** useful here)\n",
    "3.  Print each poem to find out who wrote it.\n",
    "\n",
    "Hints are in hints.py or under the Solutions button  Also feel free to use google, your teammates & the mentors.\n",
    "Good luck!\n",
    "'''\n",
    "\n",
    "poem_1 = ''\n",
    "poem_2 = ''\n",
    "\n",
    "\n",
    "with open('poems.txt', 'r') as poems:\n",
    "  pass\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Solutions\n",
    "\n",
    "<br>\n",
    "\n",
    "\n",
    "<details>\n",
    "<summary><img align=\"left\" height=\"45\" src=\"images/coding_btn.png\">\n",
    "<br>\n",
    "</summary>\n",
    "\n",
    "<br>\n",
    "\n",
    "<br>\n",
    "\n",
    "<br>\n",
    "\n",
    "<br>\n",
    "\n",
    "\n",
    "\n",
    "```python\n",
    "\n",
    "poem_1 = ''\n",
    "poem_2 = ''\n",
    "\n",
    "\n",
    "with open('poems.txt', 'r') as poems:\n",
    "   for index, line in enumerate(poems):\n",
    "       if index %2 == 0:\n",
    "           poem_2 += line\n",
    "       else:\n",
    "           poem_1 += line\n",
    "\n",
    "\n",
    "print(poem_2)\n",
    "print('')\n",
    "print('')\n",
    "print(poem_1)\n",
    "\n",
    "\n",
    "###############################\n",
    "# OR :  Using a List Comprehension\n",
    "###############################\n",
    "\n",
    "\n",
    "with open('poems.txt', 'r') as poems:\n",
    "  poem_1 = [line.strip() for index, line in enumerate(poems) if index % 2 == 0 ]\n",
    "\n",
    "  #resets the file iterator to the beginning\n",
    "  poems.seek(0)\n",
    "\n",
    "  poem_2 = [line.strip() for index, line in enumerate(poems) if index % 2 > 0 ]\n",
    "\n",
    "for line in poem_1:\n",
    "  print(line)\n",
    "\n",
    "print('')\n",
    "print('')\n",
    "\n",
    "for line in poem_2:\n",
    "  print(line)\n",
    "\n",
    "```\n",
    "\n",
    "\n",
    "\n",
    "<br>\n",
    "</details>\n",
    "\n",
    "\n",
    "<br>\n",
    "<hr>\n",
    "</details>\n",
    "\n",
    "\n",
    "\n",
    "<br>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# Whew!\n",
    "\n",
    "\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}