module-1/week-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 for loops 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",
    "\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",
    "### For loops:\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": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "items = ['cheese', 'whole milk', 'kefir', 'tofu four-pack',\n",
    "         'kale', 'oranges', 'ham', '''ben & jerry's''', \"tic-tac\"]\n",
    "cost = [2.79, 3.42, 4.50, 12.00, 2.75, 3.64, 25.00, 5.29, 0.03]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I need to buy: cheese\n",
      "I need to buy: whole milk\n",
      "I need to buy: kefir\n",
      "I need to buy: tofu four-pack\n",
      "I need to buy: kale\n",
      "I need to buy: oranges\n",
      "I need to buy: ham\n",
      "I need to buy: ben & jerry's\n"
     ]
    }
   ],
   "source": [
    "for item in items:\n",
    "    print(\"I need to buy: \" + item)"
   ]
  },
  {
   "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": 10,
   "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",
    " - [x]  whole milk\n",
    " - [ ]  kefir\n",
    " - [ ]  tofu four-pack\n",
    " - [ ]  kale\n",
    " - [ ]  oranges\n",
    " - [ ]  ham\n",
    " - [ ]  ben & jerry's"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "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": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grocery_dict = {}\n",
    "index = 0\n",
    "for item in items:\n",
    "    grocery_dict[item] = cost[index]\n",
    "    index += 1\n",
    "    \n",
    "grocery_dict\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "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": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# this time with enumerate()\n",
    "\n",
    "grocery_dict = {}\n",
    "\n",
    "for index, item in enumerate(items):\n",
    "    grocery_dict[item] = cost[index]\n",
    "    \n",
    "grocery_dict\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "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": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict(zip(items+['pretzels'], cost))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So let's now add the total grocery bill at the end:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "59.39"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(grocery_dict.values())"
   ]
  },
  {
   "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": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "i = 1\n",
    "while True:\n",
    "    if i >= 6:\n",
    "        break\n",
    "    print(i)\n",
    "    i += 1\n"
   ]
  },
  {
   "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": 39,
   "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": 40,
   "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 `breaks` in for-loops.\n",
    "\n",
    "What would we use to **stop** the for loop if the total reached $25?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'cheese': 2.79, 'whole milk': 3.42, 'kefir': 4.5, 'tofu four-pack': 12.0, 'tic-tac': 0.03}\n",
      "22.740000000000002\n"
     ]
    }
   ],
   "source": [
    "# stop at $25\n",
    "\n",
    "grocery_dict = {}\n",
    "running_total = 0\n",
    "\n",
    "for index, item in enumerate(items):\n",
    "    if running_total + cost[index] <= 25:\n",
    "        running_total += cost[index]\n",
    "        grocery_dict[item] = cost[index]\n",
    "    \n",
    "print(grocery_dict)\n",
    "print(sum(grocery_dict.values()))    "
   ]
  },
  {
   "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": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'cheese': 2.79, 'whole milk': 3.42, 'kefir': 4.5, 'kale': 2.75, 'oranges': 3.64, \"ben & jerry's\": 5.29, 'tic-tac': 0.03}\n",
      "22.42\n"
     ]
    }
   ],
   "source": [
    "# stop at $25, no items over $10\n",
    "\n",
    "grocery_dict = {}\n",
    "running_total = 0\n",
    "\n",
    "for index, item in enumerate(items):\n",
    "    if cost[index] > 10:\n",
    "        continue\n",
    "    if running_total + cost[index] <= 25:\n",
    "        running_total += cost[index]\n",
    "        grocery_dict[item] = cost[index]\n",
    "    \n",
    "print(grocery_dict)\n",
    "print(sum(grocery_dict.values())) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nested Loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "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": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "15//4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not(\"0\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4404217312\n",
      "4404217312\n"
     ]
    }
   ],
   "source": [
    "x = True\n",
    "print(id(x))\n",
    "print(id(True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(x == True)\n",
    "print(x is True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(1 is True)\n",
    "print(1 == True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "list1 = ['a', 'b']\n",
    "list2 = ['a', 'b']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1 is list2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4447001160\n",
      "4447102664\n"
     ]
    }
   ],
   "source": [
    "print(id(list1))\n",
    "print(id(list2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4404621408"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = \"hello\"\n",
    "id(0)"
   ]
  },
  {
   "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",
      "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 = {'Grocieries': \n",
    "                 {'ben & jerrys': 5.29, 'cheese': 2.79,\n",
    "                  'ham': 25.0, 'kale': 2.75,\n",
    "                  'kefir': 4.5,'oranges': 3.64,\n",
    "                  'tofu four-pack': 12.0,'whole milk': 3.42},\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://pyformat.info/#number) for help in formatting the total to two decimal places"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "shopping_dict = {'Groceries': {'ben & jerrys': 5.29, 'cheese': 2.79, 'ham': 25.0, 'kale': 2.75, 'kefir': 4.5, 'oranges': 3.64, 'tofu four-pack': 12.0, 'whole milk': 3.42},\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}}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Groceries: Total = $59.39\n",
      " - ben & jerrys\n",
      " - cheese\n",
      " - ham\n",
      " - kale\n",
      " - kefir\n",
      " - oranges\n",
      " - tofu four-pack\n",
      " - whole milk\n",
      "House supplies: Total = $25.43\n",
      " - toilet paper pack\n",
      " - clorox spray\n",
      " - kleenex\n",
      "Pet supplies: Total = $78.15\n",
      " - Taste of the Wild\n",
      " - squeaky toy\n",
      " - duck feet\n"
     ]
    }
   ],
   "source": [
    "for list_name, list_items in shopping_dict.items():\n",
    "    print(f\"{list_name}: Total = ${sum(list_items.values())}\")\n",
    "    for item in list_items:\n",
    "        print(\" - \" + item)"
   ]
  },
  {
   "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": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello!\n"
     ]
    }
   ],
   "source": [
    "def sayHello():\n",
    "    print(\"Hello!\")\n",
    "sayHello()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OH HAI!!!\n"
     ]
    }
   ],
   "source": [
    "def shout(phrase):\n",
    "    print(f\"{phrase}!!!\".upper())\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": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello!!!!\n"
     ]
    }
   ],
   "source": [
    "def shout(phrase=\"oh hai\"):\n",
    "    print(phrase + \"!!!\")\n",
    "shout(\"hello!\")"
   ]
  },
  {
   "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": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "error!\n"
     ]
    }
   ],
   "source": [
    "def add_one(number):\n",
    "    try:\n",
    "        return number + 1\n",
    "    except:\n",
    "        print(\"error!\")\n",
    "\n",
    "add_one('asdf')"
   ]
  },
  {
   "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": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Groceries: Total = $59.39\n",
      " - ben & jerrys\n",
      " - cheese\n",
      " - ham\n",
      " - kale\n",
      " - kefir\n",
      " - oranges\n",
      " - tofu four-pack\n",
      " - whole milk\n",
      "House supplies: Total = $25.43\n",
      " - toilet paper pack\n",
      " - clorox spray\n",
      " - kleenex\n",
      "Pet supplies: Total = $78.15\n",
      " - Taste of the Wild\n",
      " - squeaky toy\n",
      " - duck feet\n"
     ]
    }
   ],
   "source": [
    "def shopping_dict_to_list(shopping_list_dict):\n",
    "    for list_name, list_items in shopping_dict.items():\n",
    "        print(f\"{list_name}: Total = ${sum(list_items.values())}\")\n",
    "        for item in list_items:\n",
    "            print(\" - \" + item)\n",
    "\n",
    "shopping_dict_to_list(shopping_dict)"
   ]
  },
  {
   "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": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6.363636363636363\n"
     ]
    }
   ],
   "source": [
    "samp_list = [1, 1, 1, 1, 2, 2, 2, 3, 3, 10, 44]\n",
    "\n",
    "running_tot = 0\n",
    "for x in samp_list:\n",
    "    running_tot += x\n",
    "\n",
    "print(running_tot / 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": 116,
   "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": "code",
   "execution_count": 117,
   "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": 117,
     "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')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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
}