module-1/day-3-python-2/python-2-enkeboll.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python 102\n",
    "\n",
    "**Scenario:** Today we are going to build upon the basics of yesterday. Who has ever got to the cash register at Costco or Whole Foods, seen the total and asked \"how did I spend that much?\". Today we have a grocery list of items and prices, but we do not have infinite money (unfortunately), so we need to have a program that will look at our grocery list and help us manage our shopping and cost.\n",
    "\n",
    "### Learning goals:\n",
    "\n",
    "Today we will:\n",
    " - revisit what for loop does, using a dictionary\n",
    " - use `break` to adjust loop activity\n",
    " - use nested loops to navigate a nested dictionary\n",
    " - write a robust function that will take any nested dictionary of items, costs, and print out your shopping list, stopping when the total cost gets to high, and telling you the average cost per item in your cart.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For loops:\n",
    "\n",
    "Let's revisit what a for loop does. Here we have a list of items, and a separate list of costs. We are going to write a loop to print each item, it's cost, and the total of our grocery list.\n",
    "\n",
    "```python\n",
    "items = ['cheese', 'whole milk', 'kefir', 'tofu four-pack', 'kale', 'oranges', 'ham', 'ben & jerry\\'s']\n",
    "cost = [2.79, 3.42, 4.50, 12.00, 2.75, 3.64, 25.00, 5.29]\n",
    "```\n",
    "\n",
    "<img src=\"https://images.pexels.com/photos/1389103/pexels-photo-1389103.jpeg?auto=compress&cs=tinysrgb&dpr=2&h=750&w=1260\" width=550>\n",
    "\n",
    "First, let's create a for-loop that prints each item in the list with \"I need to buy: \" item."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "items = ['cheese', 'whole milk', 'kefir', 'tofu four-pack', 'kale', 'oranges', 'ham', 'ben & jerry\\'s']\n",
    "cost = [2.79, 3.42, 4.50, 12.00, 2.75, 3.64, 25.00, 5.29]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i=0\n",
      "I need to buy: cheese which costs $2.79\n",
      "i=1\n",
      "I need to buy: whole milk which costs $3.42\n",
      "i=2\n",
      "I need to buy: kefir which costs $4.5\n",
      "i=3\n",
      "I need to buy: tofu four-pack which costs $12.0\n",
      "i=4\n",
      "I need to buy: kale which costs $2.75\n",
      "i=5\n",
      "I need to buy: oranges which costs $3.64\n",
      "i=6\n",
      "I need to buy: ham which costs $25.0\n",
      "i=7\n",
      "I need to buy: ben & jerry's which costs $5.29\n"
     ]
    }
   ],
   "source": [
    "for peanutbutter, jelly in enumerate(items):\n",
    "    print(f\"i={peanutbutter}\")\n",
    "#     print(\"I need to buy: \" + item + \" which costs $\" + str(cost[i]))\n",
    "#     print(\"I need to buy: {item} which costs ${cost}\".format(item=item, cost=cost[i]))\n",
    "    print(f\"I need to buy: {jelly} which costs ${cost[peanutbutter]}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I need to buy: cheese which costs $2.79\n",
      "I need to buy: whole milk which costs $3.42\n",
      "I need to buy: kefir which costs $4.5\n",
      "I need to buy: tofu four-pack which costs $12.0\n",
      "I need to buy: kale which costs $2.75\n",
      "I need to buy: oranges which costs $3.64\n",
      "I need to buy: ham which costs $25.0\n",
      "I need to buy: ben & jerry's which costs $5.29\n"
     ]
    }
   ],
   "source": [
    "for item, price in zip(items, cost):\n",
    "    print(f\"I need to buy: {item} which costs ${price}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = dict(zip(items, cost))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{\"ben & jerry's\": 5.29,\n",
       " 'cheese': 2.79,\n",
       " 'ham': 25.0,\n",
       " 'kale': 2.75,\n",
       " 'kefir': 4.5,\n",
       " 'oranges': 3.64,\n",
       " 'tofu four-pack': 12.0,\n",
       " 'whole milk': 3.42}"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's make that a little nicer looking:\n",
    "\n",
    "```python\n",
    "print(\"I need to buy: \")\n",
    "for item in items:\n",
    "   print(\" - [ ] \", item)\n",
    "```\n",
    "\n",
    "Okay, we want to work through a dictionary, so what's one way to convert those two lists to a dictionary?\n",
    "\n",
    "_Hint_: Check [this](https://www.w3schools.com/python/ref_func_zip.asp) documentation. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I need to buy: \n",
      " - [ ]  cheese\n",
      " - [ ]  whole milk\n",
      " - [ ]  kefir\n",
      " - [ ]  tofu four-pack\n",
      " - [ ]  kale\n",
      " - [ ]  oranges\n",
      " - [ ]  ham\n",
      " - [ ]  ben & jerry's\n"
     ]
    }
   ],
   "source": [
    "print(\"I need to buy: \")\n",
    "for item in items:\n",
    "    print(\" - [ ] \", item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I need to buy: \n",
    " - [ ]  cheese\n",
    " - [ ]  whole milk\n",
    " - [ ]  kefir\n",
    " - [ ]  tofu four-pack\n",
    " - [ ]  kale\n",
    " - [x]  oranges\n",
    " - [ ]  ham\n",
    " - [ ]  ben & jerry's"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So let's now add the total grocery bill at the end:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I need to buy: cheese which costs $2.79\n",
      "I need to buy: whole milk which costs $3.42\n",
      "I need to buy: kefir which costs $4.5\n",
      "I need to buy: tofu four-pack which costs $12.0\n",
      "I need to buy: kale which costs $2.75\n",
      "I need to buy: oranges which costs $3.64\n",
      "I need to buy: ham which costs $25.0\n",
      "I need to buy: ben & jerry's which costs $5.29\n",
      "Total bill: $59.39\n"
     ]
    }
   ],
   "source": [
    "total_bill = 0\n",
    "for item, price in zip(items, cost):\n",
    "    print(f\"I need to buy: {item} which costs ${price}\")\n",
    "    total_bill += price\n",
    "print(f\"Total bill: ${total_bill}\")    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Does this look reasonable?\n",
    "\n",
    "What if you only had $25? \n",
    "\n",
    "How can you build it out to stop adding items when the total is over $25?\n",
    "\n",
    "### While, break, and continue\n",
    "What does a while loop look like in Python?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "i = 1\n",
    "while i < 6:\n",
    "    print(i)\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "for i in range(1, 6):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- What is break and continue?\n",
    "- Are they different? How?\n",
    "- Run the following code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "foo\n",
      "4\n",
      "5\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while i < 6:\n",
    "    i += 1\n",
    "    if i == 3:\n",
    "        print(\"foo\")\n",
    "        continue\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How does the code above work?\n",
    "\n",
    "Now run this code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "foo\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while i < 6:\n",
    "    i += 1\n",
    "    if i == 3:\n",
    "        print(\"foo\")\n",
    "        break\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Why is the output different?\n",
    "\n",
    "It stopped at foo, why?\n",
    "\n",
    "We can also include `break` in for-loops.\n",
    "\n",
    "What would we use to **stop** the for loop if the total reached $25?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "items += ['tic tacs']\n",
    "cost += [1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I need to buy: cheese which costs $2.79\n",
      "I need to buy: whole milk which costs $3.42\n",
      "I need to buy: kefir which costs $4.5\n",
      "I need to buy: tofu four-pack which costs $12.0\n",
      "I need to buy: tic tacs which costs $1\n",
      "Total bill: $23.71\n"
     ]
    }
   ],
   "source": [
    "total_bill = 0\n",
    "for item, price in zip(items, cost):\n",
    "    if total_bill + price >= 25:\n",
    "        continue\n",
    "    print(f\"I need to buy: {item} which costs ${price}\")\n",
    "    total_bill += price\n",
    "\n",
    "print(f\"Total bill: ${total_bill}\")  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What if we wanted to use continue and break to stop the program if an item costs more than **$10** ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I need to buy: cheese which costs $2.79\n",
      "I need to buy: whole milk which costs $3.42\n",
      "I need to buy: kefir which costs $4.5\n",
      "I need to buy: kale which costs $2.75\n",
      "I need to buy: oranges which costs $3.64\n",
      "I need to buy: ben & jerry's which costs $5.29\n",
      "I need to buy: tic tacs which costs $1\n",
      "Total bill: $23.39\n"
     ]
    }
   ],
   "source": [
    "total_bill = 0\n",
    "for item, price in zip(items, cost):\n",
    "    if price > 10:\n",
    "        continue\n",
    "    if total_bill + price >= 25:\n",
    "        continue\n",
    "    print(f\"I need to buy: {item} which costs ${price}\")\n",
    "    total_bill += price\n",
    "\n",
    "print(f\"Total bill: ${total_bill}\")  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{\"ben & jerry's\",\n",
       " 'cheese',\n",
       " 'ham',\n",
       " 'kale',\n",
       " 'kefir',\n",
       " 'oranges',\n",
       " 'tic tacs',\n",
       " 'tofu four-pack',\n",
       " 'whole milk'}"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set(items)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nested Loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loop1: 1\n",
      "loop2--- 1\n",
      "loop2--- 2\n",
      "loop2--- 3\n",
      "loop2--- 4\n",
      "loop2--- 5\n",
      "loop1: 2\n",
      "loop2--- 1\n",
      "loop2--- 2\n",
      "loop2--- 3\n",
      "loop2--- 4\n",
      "loop2--- 5\n",
      "loop1: 3\n",
      "loop2--- 1\n",
      "loop2--- 2\n",
      "loop2--- 3\n",
      "loop2--- 4\n",
      "loop2--- 5\n",
      "loop1: 4\n",
      "loop2--- 1\n",
      "loop2--- 2\n",
      "loop2--- 3\n",
      "loop2--- 4\n",
      "loop2--- 5\n",
      "loop1: 5\n",
      "loop2--- 1\n",
      "loop2--- 2\n",
      "loop2--- 3\n",
      "loop2--- 4\n",
      "loop2--- 5\n"
     ]
    }
   ],
   "source": [
    "list2 = [1, 2, 3, 4, 5]\n",
    "\n",
    "for x in list2:\n",
    "    print('loop1:', x)\n",
    "    for y in list2:\n",
    "        print('loop2---', y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What do you expect to see? Why?\n",
    "\n",
    "Here's a more complicated example, what is it doing?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2  is prime\n",
      "3  is prime\n",
      "5  is prime\n",
      "7  is prime\n",
      "11  is prime\n",
      "13  is prime\n",
      "17  is prime\n",
      "19  is prime\n",
      "23  is prime\n",
      "29  is prime\n",
      "31  is prime\n",
      "37  is prime\n",
      "41  is prime\n",
      "43  is prime\n",
      "47  is prime\n",
      "53  is prime\n",
      "59  is prime\n",
      "61  is prime\n",
      "67  is prime\n",
      "71  is prime\n",
      "73  is prime\n",
      "79  is prime\n",
      "83  is prime\n",
      "89  is prime\n",
      "97  is prime\n",
      "Good bye!\n"
     ]
    }
   ],
   "source": [
    "i = 2\n",
    "while(i < 100):\n",
    "    j = 2\n",
    "    while(j <= (i/j)):\n",
    "        if not(i % j):\n",
    "            break\n",
    "        j = j + 1\n",
    "    if (j > i/j):\n",
    "        print(i, \" is prime\")\n",
    "    i = i + 1\n",
    "\n",
    "print(\"Good bye!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is a more robust shopping list of nested dictionaries:\n",
    "```python\n",
    "shopping_dict = {\n",
    "    'Groceries': {\n",
    "        'ben & jerrys': 5.29, 'cheese': 2.79, 'ham': 25.0, 'kale': 2.75,\n",
    "        'kefir': 4.5,'oranges': 3.64, 'tofu four-pack': 12.0,'whole milk': 3.42\n",
    "    },\n",
    "    'House supplies': {'toilet paper pack': 16.50, 'clorox spray': 6.43, 'kleenex': 2.50,},\n",
    "    'Pet supplies': {'Taste of the Wild': 65.20, 'squeaky toy': 4.50, 'duck feet': 8.45}}\n",
    "```\n",
    "\n",
    "write the nested for loops to print out each grocery list with its total\n",
    "\n",
    "_Hint_\n",
    "\n",
    "- use [this link](https://stackoverflow.com/a/45310389) for help in formatting the total to two decimal places"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions\n",
    "\n",
    "**Built-in functions** <br>\n",
    "Many useful functions are already built into Python:<br>\n",
    "\n",
    "`print()`: print the given string or variable's value<br>\n",
    "`type()`: returns the datatype of the argument<br>\n",
    "`len()`: returns the length of an array<br>\n",
    "`sum()`: returns the sum of the array's values<br>\n",
    "`min()`: returns the smallest member of an array <br>\n",
    "`max()`: returns the largest member of an array<br>\n",
    "\n",
    "\n",
    "**Writing your own functions**\n",
    "\n",
    "```python\n",
    "def sayHello():\n",
    "    print(\"Hello!\")\n",
    "```\n",
    "How do we run it?\n",
    "\n",
    "```python\n",
    "sayHello()\n",
    "```\n",
    "\n",
    "Let's talk about arguments or parameters. Let's say we want to make this function more dynamic and print out whatever we want! How would we do that?\n",
    "```python\n",
    "def shout(phrase):\n",
    "    print(phrase + \"!!!\")\n",
    "shout(\"oh hai\")\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "oh hai!!!\n"
     ]
    }
   ],
   "source": [
    "def shout(phrase):\n",
    "    print(phrase + \"!!!\")\n",
    "shout(\"oh hai\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What if we don't pass in an argument? What happens?\n",
    "Maybe we can establish a default value for the argument in case it isn't passed in.\n",
    "\n",
    "```python\n",
    "def shout(phrase = \"oh hai\"):\n",
    "    print(phrase + \"!!!\")\n",
    "\n",
    "shout()\n",
    "shout(\"bye\")\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "oh hai!!!\n",
      "bye!!!\n"
     ]
    }
   ],
   "source": [
    "def shout(phrase=\"oh hai\"):\n",
    "    print(phrase + \"!!!\")\n",
    "\n",
    "shout()\n",
    "shout(\"bye\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What if we wanted to run a function, take its output and put it in to another function?\n",
    "\n",
    "```python\n",
    "def add_one(number):\n",
    "    return number + 1\n",
    "\n",
    "def times_five(number):\n",
    "    return number * 5\n",
    "\n",
    "number_plus_one = add_one(1)\n",
    "answer = times_five(number_plus_one)\n",
    "print(answer)\n",
    "```\n",
    "\n",
    "What will the above code return?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "def add_one(number):\n",
    "    return number + 1\n",
    "\n",
    "def times_five(number):\n",
    "    return number * 5\n",
    "\n",
    "number_plus_one = add_one(1)\n",
    "answer = times_five(number_plus_one)\n",
    "print(answer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "print(times_five(add_one(1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adapt your shopping list nested for-loop to be wrapped in a function you could call on any shopping list of nested dictionaries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2  is prime\n",
      "3  is prime\n",
      "5  is prime\n",
      "7  is prime\n",
      "11  is prime\n",
      "13  is prime\n",
      "17  is prime\n",
      "19  is prime\n",
      "23  is prime\n",
      "29  is prime\n",
      "31  is prime\n",
      "37  is prime\n",
      "41  is prime\n",
      "43  is prime\n",
      "47  is prime\n",
      "53  is prime\n",
      "59  is prime\n",
      "61  is prime\n",
      "67  is prime\n",
      "71  is prime\n",
      "73  is prime\n",
      "79  is prime\n",
      "83  is prime\n",
      "89  is prime\n",
      "97  is prime\n"
     ]
    }
   ],
   "source": [
    "def prime_numbers(x=0, y=1, z=2):\n",
    "    i = 2\n",
    "    while(i < 100):\n",
    "        j = 2\n",
    "        while(j <= (i/j)):\n",
    "            if not(i % j):\n",
    "                break\n",
    "            j = j + 1\n",
    "        if (j > i/j):\n",
    "            print(i, \" is prime\")\n",
    "        i = i + 1\n",
    "        \n",
    "result = prime_numbers()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "NoneType"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mathematical Notation and Measures of Central Tendency \n",
    "\n",
    "median vs mode vs mean<br>\n",
    "What's the difference?\n",
    "\n",
    "\n",
    "```python\n",
    "samp_list = [1,1,1,1,2,2,2,3,3,10,44]\n",
    "```\n",
    "\n",
    "How could you write a for loop to calculate the mean?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "samp_list = [1, 1, 1, 1, 2, 2, 2, 3, 3, 10, 44]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6.363636363636363\n"
     ]
    }
   ],
   "source": [
    "# mean\n",
    "running_total = 0\n",
    "for samp in samp_list:\n",
    "    running_total += samp\n",
    "\n",
    "print(running_total / len(samp_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Integration\n",
    "\n",
    "adapt your function to do the following:\n",
    "- stop the nested loop if a grocery total goes over $30\n",
    "- print out the average cost of per item in your cart"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Jupyter Bonus\n",
    "\n",
    "This doesn't really fit in with the rest of Python 102, but Jupyter is incredibly flexible! Here are two examples of embedding beautiful LaTex scripting in a notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\lim\\limits_{x \\to \\infty} \\exp(-x) = 0$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%latex # this will make the entire cell LaTeX syntax\n",
    "$$\\lim\\limits_{x \\to \\infty} \\exp(-x) = 0$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Markdown Cell\n",
    "Wrap LaTeX in two dollar signs ($$) to show things in a paragraph:\n",
    "\n",
    "$$\\lim\\limits_{x \\to \\infty} \\exp(-x) = 0$$\n",
    "\n",
    "Or just one to show inline: $\\lim\\limits_{x \\to \\infty} \\exp(-x) = 0$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$F(k) = \\int_{-\\infty}^{\\infty} f(x) e^{2\\pi i k} dx$$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import Math\n",
    "# this imports a function called Math() in which you can pass in a raw string of LaTeX\n",
    "Math('F(k) = \\int_{-\\infty}^{\\infty} f(x) e^{2\\pi i k} dx')"
   ]
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}