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

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![python logo](https://www.python.org/static/community_logos/python-logo-master-v3-TM.png)\n",
    "\n",
    "\n",
    "\n",
    "# Python has a lot of great [documentation](https://www.python.org/about/gettingstarted/)\n",
    "\n",
    "\n",
    "Today as a first step we want you to be able to:\n",
    "- Make use of assigning variables\n",
    "- Classify and explain integers, float, strings, boolean, list, dictionary, and tuple\n",
    "- Identify the comparators and boolean operators\n",
    "- Make use of a `list`: indexing, ranges, appending\n",
    "- Make use of a `dict`: identifying, creating, navigating\n",
    "- Apply a for loop to lists and dictionaries\n",
    "\n",
    "\n",
    "### To do all that, we are going to code up versions of a bento box:\n",
    "\n",
    "<img src=\"https://images.pexels.com/photos/884596/pexels-photo-884596.jpeg?auto=compress&cs=tinysrgb&dpr=2&h=750&w=1260\" width=550 />\n",
    "\n",
    "\n",
    "### Bento boxes can have multiple ingredients and choices\n",
    "\n",
    "We want to write a script that can combine everyone's bento order into one data collection and print each item for the restaurant. \n",
    "\n",
    "#### Variable assignment \n",
    "\n",
    "Let's start with our first bento oder:\n",
    "\n",
    "```python\n",
    "main = \"rice\"\n",
    "protein = \"salmon\"\n",
    "ozofprotein = 4.5\n",
    "number_of_sides = 3\n",
    "side1 = 'seaweed'\n",
    "side2 = 'tempura'\n",
    "side2 =  'turnip pickle'\n",
    "greatbento = True\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "main = \"rice\"\n",
    "protein = \"salmon\"\n",
    "ozofprotein = 4.5\n",
    "number_of_sides = 3\n",
    "side1 = 'seaweed'\n",
    "side2 = 'tempura'\n",
    "side2 = 'turnip pickle'\n",
    "greatbento = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'salmon'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "protein"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, if we wanted to change our protein to ginger chicken, how would we do that?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "protein = 'ginger chicken'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ginger chicken'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "protein"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can reassign variable values easily.\n",
    "\n",
    "Now, we assigned those variables one at a time. We also can assign multiple values at once:\n",
    "\n",
    "`side1, side2, side3 = \"carrots\", \"kimchi\", \"mushrooms\"`\n",
    "\n",
    "Update your side order to match your preference. \n",
    "\n",
    "Then use `print()` to confirm the variable change"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "side1, side2, side3 = \"carrots\", \"kimchi\", \"mushrooms\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'kimchi'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "side2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Variable Types\n",
    "\n",
    "Each variable in our bento box has a `type`. \n",
    "\n",
    "```\n",
    "type(side1)\n",
    "str\n",
    "```\n",
    "Run `type()` on the remaining variables to explore the type options."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(greatbento)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Conditionals\n",
    "\n",
    "Now what if you have food allergies, or want to be able to evaluate a variable before changing it?\n",
    "\n",
    "Well you're in luck, cause we have if statements and conditionals and control flow operators.\n",
    "\n",
    "\n",
    "\n",
    "Control flow operators are:\n",
    "```\n",
    "==\n",
    "!=\n",
    ">\n",
    "<\n",
    "<=\n",
    ">=\n",
    "```\n",
    "\n",
    "\n",
    "Decision Making is like this:\n",
    "```python\n",
    "if protein == 'salmon':\n",
    "    print(\"I love salmon!\")\n",
    "```\n",
    "\n",
    "![how conditional works](images/decision_making.jpg)\n",
    "\n",
    "\n",
    "Will I like this bento box?\n",
    "```python\n",
    "if main == 'rice':\n",
    "    print(\"no carbs, please!\")\n",
    "elif ozofprotein >= 2.5:\n",
    "    print(\"too much!\")\n",
    "else:\n",
    "    print(\"I have no problems with this order\")\n",
    "```\n",
    "\n",
    "\n",
    "The [tools](https://docs.python.org/3/tutorial/controlflow.html)  used in conditionals are `if`, `elif`, and `else`\n",
    "\n",
    "Update the above code example, but rather than `print` set `greatbento` equal to `True` or `False` depending on the values of the bento box ingredients."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I love salmon!\n"
     ]
    }
   ],
   "source": [
    "if protein == 'salmon':\n",
    "    print(\"I love salmon!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "protein = 'salmon'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "no carbs, please!\n",
      "too much!\n"
     ]
    }
   ],
   "source": [
    "if main == 'rice':\n",
    "    print(\"no carbs, please!\")    \n",
    "if ozofprotein >= 2.5:\n",
    "    print(\"too much!\")\n",
    "else:\n",
    "    print(\"I have no problems with this order\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Using Lists: Indexing, ranges, appending"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Lists\n",
    "\n",
    "Writing out all those ingredients individually is a pain, let's put them in a list!\n",
    "\n",
    "![dog-to-do-list](https://media.giphy.com/media/xTiTnuhyBF54B852nK/giphy.gif)\n",
    "\n",
    "\n",
    "```python\n",
    "bento_box_list = [\"rice\", \"chicken teriyaki\", \"tempura\", \"soy sauce\", \"ginger\", \"seaweed\"]\n",
    "bento_box_list[2]\n",
    "\n",
    "# Output: tempura\n",
    "\n",
    "numbers[0:2]\n",
    "\n",
    "# Output: [\"rice\", \"chicken teriyaki\"]\n",
    "```\n",
    "To append to a list:\n",
    "\n",
    "```python\n",
    "bento_box_list = [\"rice\", \"chicken teriyaki\", \"tempura\", \"soy sauce\", \"ginger\", \"seaweed\"]\n",
    "bento_box_list.append(\"wasabi\")\n",
    "print(bento_box_list)\n",
    "\n",
    "# Output: [\"rice\", \"chicken teriyaki\", \"tempura\", \"soy sauce\", \"ginger\", \"seaweed\", \"wasabi\"]\n",
    "```\n",
    "\n",
    "Now, let's put our order in a readable format using `join`\n",
    "\n",
    "\n",
    "```python\n",
    "print(\"I'd like my bento box to contain: \" + \n",
    "      \",\".join(bento_box_list[:-1] + \n",
    "      \", and \" + bento_box_list[-1])\n",
    "```\n",
    "\n",
    "Make a list of your bento box ingredients!  Have it print out in a legible sentence!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "bento_box_list = [\"rice\", \"chicken teriyaki\", \"tempura\", \"soy sauce\", \"ginger\", \"seaweed\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['rice', 'chicken teriyaki', 'tempura', 'soy sauce', 'ginger', 'seaweed']"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bento_box_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['rice', 'chicken teriyaki', 'tempura', 'soy sauce', 'ginger', 'seaweed']"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bento_box_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bento_box_list.count('rice')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(bento_box_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['rice',\n",
       " 'chicken teriyaki',\n",
       " 'tempura',\n",
       " 'soy sauce',\n",
       " 'ginger',\n",
       " 'seaweed',\n",
       " 'rice cake',\n",
       " 'rice cake',\n",
       " 'rice cake']"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bento_box_list.append('rice cake')\n",
    "bento_box_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'rice cake'"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bento_box_list.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['rice',\n",
       " 'chicken teriyaki',\n",
       " 'tempura',\n",
       " 'soy sauce',\n",
       " 'ginger',\n",
       " 'seaweed',\n",
       " 'rice cake',\n",
       " 'rice cake']"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bento_box_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "bento_box_list.append(['miso soup', 'ginger'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['rice',\n",
       " 'chicken teriyaki',\n",
       " 'tempura',\n",
       " 'soy sauce',\n",
       " 'ginger',\n",
       " 'seaweed',\n",
       " 'rice cake',\n",
       " 'rice cake',\n",
       " 'miso soup',\n",
       " 'ginger',\n",
       " ['miso soup', 'ginger']]"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bento_box_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['rice',\n",
       " 'chicken teriyaki',\n",
       " 'tempura',\n",
       " 'soy sauce',\n",
       " 'ginger',\n",
       " 'seaweed',\n",
       " 'rice cake',\n",
       " 'rice cake',\n",
       " 'miso soup',\n",
       " 'ginger',\n",
       " ['miso soup', 'ginger'],\n",
       " 'rice',\n",
       " 'chicken teriyaki',\n",
       " 'tempura',\n",
       " 'soy sauce',\n",
       " 'ginger',\n",
       " 'seaweed',\n",
       " 'rice cake',\n",
       " 'rice cake',\n",
       " 'miso soup',\n",
       " 'ginger',\n",
       " ['miso soup', 'ginger']]"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bento_box_list.extend(bento_box_list)\n",
    "bento_box_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "bento_box_list[1:3] + bento_box_list[8:9]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dictionaries\n",
    "\n",
    "<img src=\"https://images.pexels.com/photos/270233/pexels-photo-270233.jpeg?auto=compress&cs=tinysrgb&dpr=2&w=500\" width=550 >\n",
    "\n",
    "No, not that kind! \n",
    "\n",
    "With your list above, someone would need to tell you that \"rice\" is the main and \"chicken\" is the protein. \n",
    "\n",
    "Dictionaries let you assign **key** and **value** pairs. \n",
    "\n",
    "Rather than using **indexing** you use **keys** to return values.\n",
    "\n",
    "```python\n",
    "bento_box_dict = {'ingredient1': 'rice', 'ingredient2': 'unagi', 'ingredient3': 'miso soup'}\n",
    "```\n",
    "To get an element in the dictionary:\n",
    "```python\n",
    "print(bento_box_dict['ingredient2'])\n",
    "```\n",
    "\n",
    "Update your bento_box_list to be a dictionary. Make sure to run `type()` on your dictionary to confirm it is successful."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "bento_box_dict = {'ingredient1': 'rice', 'ingredient2': 'unagi', 'ingredient3': 'miso soup'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "bento_box_dict['ingredient4'] = 'wasabi'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'wasabi'"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bento_box_dict['ingredient4']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([('ingredient1', 'rice'), ('ingredient2', 'unagi'), ('ingredient3', 'miso soup'), ('ingredient4', 'wasabi')])"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bento_box_dict.items()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'unagi'"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bento_box_dict.get('ingredient2', 'miss')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, to make it even better, you can nest **DICTIONARIES** INSIDE of **LISTS**\n",
    "\n",
    "```python\n",
    "group_lunch = [\n",
    "    {'ingredient1': 'rice', 'ingredient2': 'unagi', 'ingredient3': 'miso soup'},\n",
    "    {'ingredient1': 'seaweed', 'ingredient2': 'tempura', 'ingredient3': 'miso soup'},\n",
    "    {'ingredient1': 'hamburger', 'ingredient2': 'french fries', 'ingredient3': 'milkshake'}\n",
    "]\n",
    "```\n",
    "\n",
    "try calling elements of group lunch and see what you get!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Talk with your neighbors to get a few different bento box orders into a group order. Please limit each order to 5 ingredients. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "group_lunch = [\n",
    "    {'ingredient1': 'rice', 'ingredient2': 'unagi', 'ingredient3': 'miso soup'},\n",
    "    {'ingredient1': 'seaweed', 'ingredient2': 'tempura', 'ingredient3': 'miso soup'},\n",
    "    {'ingredient1': 'hamburger', 'ingredient2': 'french fries', 'ingredient3': 'milkshake'}\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'tempura'"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "group_lunch[1]['ingredient2']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'french fries'"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "group_lunch[2].get('ingredient2')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### For loops\n",
    "\n",
    "Okay, is anyone confused about for-loops? \n",
    "\n",
    "(if so - ask me about laundry)\n",
    "\n",
    "If NOT:\n",
    "\n",
    "```python\n",
    "group_lunch = [\n",
    "    {'ingredient1': 'rice', 'ingredient2': 'unagi', 'ingredient3': 'miso soup'},\n",
    "    {'ingredient1': 'seaweed', 'ingredient2': 'tempura', 'ingredient3': 'miso soup'},\n",
    "    {'ingredient1': 'hamburger', 'ingredient2': 'french fries', 'ingredient3': 'milkshake'}\n",
    "]\n",
    "```\n",
    "\n",
    "write a loop to print first ingredient in everyone's bento order.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The first ingredient is RICE\n",
      "The first ingredient is SEAWEED\n",
      "The first ingredient is HAMBURGER\n"
     ]
    }
   ],
   "source": [
    "for order in group_lunch:\n",
    "    print(f\"The first ingredient is {order.get('ingredient1').upper()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Integration\n",
    "\n",
    "Write a for loop that will go through and print all the orders as a readable sentences. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Order 1 has rice, unagi, and miso soup\n",
      "Order 2 has seaweed, tempura, and miso soup\n",
      "Order 3 has hamburger, french fries, and milkshake\n"
     ]
    }
   ],
   "source": [
    "# Order 1 has rice, unagi, and miso soup\n",
    "# Order 2 has seaweed, tempura, and miso soup\n",
    "# Order 3 has hamburger, french fries, and milkshake\n",
    "\n",
    "for i, order in enumerate(group_lunch, 1):\n",
    "    ingredient1 = order.get('ingredient1')\n",
    "    ingredient2 = order.get('ingredient2')\n",
    "    ingredient3 = order.get('ingredient3')\n",
    "    print(f\"Order {i} has {ingredient1}, {ingredient2}, and {ingredient3}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reflection:\n",
    "\n",
    "What's an situation where you could use lists and loops to automate a process?\n"
   ]
  },
  {
   "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}