Python3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python 3\n",
    "\n",
    "## Data types and operators\n",
    "\n",
    "### Arithmetic Operators\n",
    "+ Addition\n",
    "- Subtraction\n",
    "* Multiplication\n",
    "/ Division\n",
    "% Mod (the remainder after dividing)\n",
    "** Exponentiation (note that ^ does not do this operation, as you might have seen in other languages)\n",
    "// Divides and rounds down to the nearest integer\n",
    "\n",
    "## Variables\n",
    "Pythonic to use snake case...go figure\n",
    "my_variable = 'Gilbert'\n",
    "\n",
    "use PEP8 Guidelines.\n",
    "PEP8 Python Linter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "x = int(4.7) # x is now 4\n",
    "y = float(4) # y is now 4.0\n",
    "print(type(x))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print(0.1 + 0.1 + 0.1 == 3) \n",
    "#False because in Python 0.1 is slight more than 0.1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Booleans, Comparison Operators, and Logical Operators\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Logical Operation\n",
    "5 < 3 and 5 == 5 #\tFalse\tand - Evaluates if all provided statements are True\n",
    "5 < 3 or 5 == 5 #\tTrue\tor - Evaluates if at least one of many statements is True\n",
    "not 5 < 3#\tTrue\tnot - Flips the Bool Value\n",
    "\n",
    "# comparison operators \n",
    "# you usual > < >= == <= !="
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings\n",
    "- immutable, ordered\n",
    "\n",
    "Like many other popular programming languages, strings in Python are arrays of bytes representing unicode characters.\n",
    "However, Python does not have a character data type, a single character is simply a string with a length of 1.\n",
    "Square brackets can be used to access elements of the string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ll\n",
      "orl\n",
      "!dlroW ,olleH\n",
      "Hello\n"
     ]
    }
   ],
   "source": [
    "b = \"Hello, World!\"\n",
    "print(b[2:4]) # lower index is inclusive and upper is exclusive\n",
    "print(b[-5:-2]) # starting from end of the string, get characters from 5 to 1\n",
    "print(b[::-1]) # reverse string\n",
    "print(b[:5]) # up to 5-1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Methods\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You can format string for Gilbert Gotora, number of 'os' = 2 starting at index 9 like this.\n",
      "Format Gilbert Gotora with 2 'o's \n"
     ]
    }
   ],
   "source": [
    "#A method is function called using dot notation\n",
    "my_string = \"gilbert gotora\"\n",
    "my_string.find('o') # 9\n",
    "my_string.count('o') # 2\n",
    "my_string.islower()\n",
    "print('You can format string for {}, number of \\'os\\' = {} starting at index {} like this.'.format(my_string.title(), my_string.count('o'), my_string.find('o')))\n",
    "\n",
    "# can get complicated instead of f-string\n",
    "print(f\"Format {my_string.title()} with {my_string.count('o')} 'o's \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### split() method\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['The', 'cow', 'jumped', 'over', 'the', 'moon.']"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_str = \"The cow jumped over the moon.\"\n",
    "new_str.split()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['The', 'cow', 'jumped', 'over the moon.']"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_str.split(' ', 3) # syntax string.split(separator, maxsplit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Structures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List\n",
    "\n",
    "- **mutable, ordered**\n",
    "\n",
    "    Mutable means an object can change once its created\n",
    "    Ordered means position of an element in the object can be used to access the element \n",
    "    \n",
    "- most common data structure in Python\n",
    "- lists in Python can contain any mix and match of data types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "list_of_random_things = [1, 3.4, 'a string', True]\n",
    "print(list_of_random_things[3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**in or not in**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 in list_of_random_things"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'frank' not in list_of_random_things"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Identity Operators (is and is not) versus Comparison Operators ( == and !=)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n",
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3]\n",
    "b = a\n",
    "c = [1, 2, 3]\n",
    "\n",
    "print(a == b)\n",
    "print(a is b)\n",
    "print(a is not b)\n",
    "print(a == c)\n",
    "print(a is c)\n",
    "print(a is not c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Slicing lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['November 13, 2012', 'March 20, 2015', 'March 9, 2016']\n",
      "['November 23, 2003', 'March 29, 2006', 'August 1, 2008', 'July 22, 2009', 'July 11, 2010', 'November 13, 2012', 'March 20, 2015', 'March 9, 2016']\n",
      "November 13, 2012\n",
      "March 29, 2006\n",
      "reversed list ['March 9, 2016', 'March 20, 2015', 'November 13, 2012', 'July 11, 2010', 'July 22, 2009', 'August 1, 2008', 'March 29, 2006', 'November 23, 2003', 'December 4, 2002', 'June 21, 2001']\n"
     ]
    }
   ],
   "source": [
    "eclipse_dates = ['June 21, 2001', 'December 4, 2002', 'November 23, 2003',\n",
    "                 'March 29, 2006', 'August 1, 2008', 'July 22, 2009',\n",
    "                 'July 11, 2010', 'November 13, 2012', 'March 20, 2015',\n",
    "                 'March 9, 2016']\n",
    "print(eclipse_dates[-3:]) # prints the last three elements of a list4\n",
    "print(eclipse_dates[2:])\n",
    "print(eclipse_dates[-3]) # prints third from last\n",
    "print(eclipse_dates[3]) # because of 0 indexing 3 is the fourth element....on the money backwards\n",
    "print('reversed list', eclipse_dates[::-1]) # reversed list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Methods\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "November 23, 2003\n",
      "August 1, 2008\n",
      "['August 1, 2008', 'December 4, 2002', 'July 11, 2010', 'July 22, 2009', 'June 21, 2001', 'March 20, 2015', 'March 29, 2006', 'March 9, 2016', 'November 13, 2012', 'November 23, 2003']\n"
     ]
    }
   ],
   "source": [
    "# some handy methods\n",
    "\n",
    "print(len(eclipse_dates)) # how many elements in the list\n",
    "print(max(eclipse_dates)) # return the greatest element of the list depending on data type\n",
    "#greatest  number for ints and maximun of strings if sorted alphabetically...\n",
    "# print(max([3, '4'])) will give error because of mixed data types..max function is defined in terms of the greater than comparison operator. \n",
    "print(min(eclipse_dates))\n",
    "print(sorted(eclipse_dates)) # returns a copy of a list in order from smallest to largest, leaving the list unchanged."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Join() method**\n",
    "\n",
    "Join is a string method that takes a list of strings as an argument, and returns a string consisting of the list elements joined by a separator string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this\n",
      "on\n",
      "new\n",
      "line\n"
     ]
    }
   ],
   "source": [
    "new_str = \"\\n\".join(['this', 'on', 'new', 'line'])\n",
    "print(new_str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gilbert-Gotora\n"
     ]
    }
   ],
   "source": [
    "name = \"-\".join(['Gilbert', 'Gotora'])\n",
    "print(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**append() method**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'c', 'd', 'z']\n"
     ]
    }
   ],
   "source": [
    "letters = ['a', 'b', 'c', 'd']\n",
    "letters.append('z')\n",
    "print(letters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**uses**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Albert & Ben & Carol & Donna\n"
     ]
    }
   ],
   "source": [
    "names = [\"Carol\", \"Albert\", \"Ben\", \"Donna\"]\n",
    "print(\" & \".join(sorted(names)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuples\n",
    "\n",
    "- **immutable and ordered** sequences of elements. \n",
    "- They are often used to store related pieces of information.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Latitude: 13.4125\n",
      "Longitude: 103.866667\n"
     ]
    }
   ],
   "source": [
    "# example\n",
    "location = (13.4125, 103.866667)\n",
    "print(\"Latitude:\", location[0])\n",
    "print(\"Longitude:\", location[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Tuples can also be used to assign multiple variables in a compact way**\n",
    "\n",
    "**tuple unpacking****"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The dimensions are 52 x 40 x 100\n",
      "The dimensions are 52 x 40 x 100\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "dimensions = 52, 40, 100\n",
    "length, width, height = dimensions\n",
    "print(\"The dimensions are {} x {} x {}\".format(length, width, height))\n",
    "#The parentheses are optional when defining tuples, and programmers \n",
    "#frequently omit them if parentheses don't clarify the code.\n",
    "\n",
    "#directly without the dimensions variable\n",
    "length, width, height = 52, 40, 100\n",
    "print(\"The dimensions are {} x {} x {}\".format(length, width, height))\n",
    "\n",
    "tuple_a = 1, 2\n",
    "tuple_b = (1,2)\n",
    "print(tuple_a == tuple_b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sets\n",
    "\n",
    "**mutable and unordered**\n",
    "- one application of sets is remove duplicates from a list\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 6}\n"
     ]
    }
   ],
   "source": [
    "numbers = [1, 2, 6, 3, 1, 1, 6]\n",
    "unique_nums = set(numbers)\n",
    "print(unique_nums)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Support **in** operator\n",
    "use **add** to add items to sets  \n",
    "**pop** to remove similar to lists although in sets a random element is removed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "{'watermelon', 'banana', 'orange', 'grapefruit', 'apple'}\n",
      "watermelon\n",
      "{'banana', 'orange', 'grapefruit', 'apple'}\n"
     ]
    }
   ],
   "source": [
    "fruit = {\"apple\", \"banana\", \"orange\", \"grapefruit\"}  # define a set\n",
    "\n",
    "print(\"watermelon\" in fruit)  # check for element\n",
    "\n",
    "fruit.add(\"watermelon\")  # add an element\n",
    "print(fruit)\n",
    "\n",
    "print(fruit.pop())  # remove a random element\n",
    "print(fruit)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries\n",
    "\n",
    "A dictionary is a mutable data type that stores mappings of unique keys to values. Here's a dictionary that stores elements and their atomic numbers.\n",
    "- Dictionaries can have keys of any immutable type, like integers or tuples, not just strings. It's not even necessary for every key to have the same type! We can look up values or insert new values in the dictionary using square brackets that enclose the key.\n",
    "\n",
    "#### Identity Operators \n",
    "**is**\tevaluates if both sides have the same identity  \n",
    "**is not**\tevaluates if both sides have different identities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "elements = {\"hydrogen\": 1, \"helium\": 2, \"carbon\": 6}\n",
    "print(elements['helium'])\n",
    "print('carbon' in elements)\n",
    "print('calcium' in elements)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### get() Method\n",
    "looks up values in a dictionary, but unlike looking up values with   square brackets, get() returns None (or a default value of your choice) if the key isn't found. If you expect lookups to sometimes fail, get() might be a better "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test = elements.get('hydro', 0)\n",
    "type(test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Compound Data Stuctures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.00794\n",
      "1.00794\n"
     ]
    }
   ],
   "source": [
    "elements = {\"hydrogen\": {\"number\": 1,\n",
    "                         \"weight\": 1.00794,\n",
    "                         \"symbol\": \"H\"},\n",
    "              \"helium\": {\"number\": 2,\n",
    "                         \"weight\": 4.002602,\n",
    "                         \"symbol\": \"He\"}}\n",
    "print(elements['hydrogen']['weight'])\n",
    "print(elements.get('hydrogen').get('weight')) # wonder if thats legal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### add key values to dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'hydrogen': {'number': 1, 'weight': 1.00794, 'symbol': 'H', 'is_noble_gas': False}, 'helium': {'number': 2, 'weight': 4.002602, 'symbol': 'He', 'is_noble_gas': True}}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1.00794"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "elements['hydrogen']['is_noble_gas'] = False\n",
    "elements['helium']['is_noble_gas'] = True\n",
    "print(elements)\n",
    "elements.get('hydrogen').get('weight')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Control Flow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter weight :100\n",
      "Enter height :168\n",
      "Dude do some sit ups\n"
     ]
    }
   ],
   "source": [
    "weight = int(input('Enter weight :'))\n",
    "height = int(input('Enter height :'))\n",
    "if 18.5 <= weight / height**2 < 25:\n",
    "    print(\"BMI is considered 'normal'\")\n",
    "else:\n",
    "    print('Dude do some sit ups')\n",
    "\n",
    "# if is_raining and is_sunny:\n",
    "#     print(\"Is there a rainbow?\")\n",
    "\n",
    "# if (not unsubscribed) and (location == \"USA\" or location == \"CAN\"):\n",
    "#     print(\"send email\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For Loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['joey_tribbiani', 'monica_geller', 'chandler_bing', 'phoebe_buffay']\n"
     ]
    }
   ],
   "source": [
    "names = [\"Joey Tribbiani\", \"Monica Geller\", \"Chandler Bing\", \"Phoebe Buffay\"]\n",
    "usernames = []\n",
    "\n",
    "# write your for loop here#\n",
    "\n",
    "for name in names:\n",
    "    usernames.append(name.lower().replace(' ', '_'))\n",
    "print(usernames)\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quiz\n",
    "\n",
    "Write a for loop that iterates over a list of strings, tokens, and counts how many of them are XML tags. XML is a data language similar to HTML. You can tell if a string is an XML tag if it begins with a left angle bracket \"<\" and ends with a right angle bracket \">\". Keep track of the number of tags using the variable count."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "tokens = ['<greeting>', 'Hello World!', '</greeting>']\n",
    "count = 0\n",
    "\n",
    "# write your for loop here\n",
    "for token in tokens:\n",
    "    if token[-1] == '>' and token[0] == '<':\n",
    "        count += 1\n",
    "print(count)\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quiz: Create an HTML List\n",
    "\n",
    "    Write some code, including a for loop, that iterates over a list of strings and creates a single string, html_str, which is an HTML list. For example, if the list is items = ['first string', 'second string'], printing html_str should output:\n",
    "\n",
    "    <ul>\n",
    "        <li>first string</li>\n",
    "        <li>second string</li>\n",
    "    </ul>\n",
    "    That is, the string's first line should be the opening tag <ul>. Following that is one line per element in the source list, surrounded by  <li> and </li> tags. The final line of the string should be the closing tag </ul>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<ul>\n",
      "<li>first string </li>\n",
      "<li>second string </li>\n",
      "</ul>\n"
     ]
    }
   ],
   "source": [
    "items = ['first string', 'second string']\n",
    "html_str = \"<ul>\\n\"  # \"\\ n\" is the character that marks the end of the line, it does\n",
    "                     # the characters that are after it in html_str are on the next line\n",
    "\n",
    "# write your code here\n",
    "for item in items:\n",
    "    html_str += '<li>{} </li>\\n'.format(item)\n",
    "html_str += '</ul>'\n",
    "    \n",
    "\n",
    "\n",
    "\n",
    "print(html_str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Word counter using for loops and dictionaries\n",
    "\n",
    "**Method 1**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'great': 2, 'expectations': 1, 'the': 2, 'adventures': 2, 'of': 2, 'sherlock': 1, 'holmes': 1, 'gasby': 1, 'hamlet': 1, 'huckleberry': 1, 'fin': 1}\n"
     ]
    }
   ],
   "source": [
    "book_title =  ['great', 'expectations','the', 'adventures', 'of', 'sherlock','holmes','the','great','gasby','hamlet','adventures','of','huckleberry','fin']\n",
    "\n",
    "word_counter = {}\n",
    "\n",
    "for word in book_title:\n",
    "    if word not in word_counter:\n",
    "        word_counter[word] = 1\n",
    "    else:\n",
    "        word_counter[word] += 1\n",
    "        \n",
    "print(word_counter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Method 2**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'great': 2, 'expectations': 1, 'the': 2, 'adventures': 2, 'of': 2, 'sherlock': 1, 'holmes': 1, 'gasby': 1, 'hamlet': 1, 'huckleberry': 1, 'fin': 1}\n"
     ]
    }
   ],
   "source": [
    "another_book_title =  ['great', 'expectations','the', 'adventures', 'of', 'sherlock','holmes','the','great','gasby','hamlet','adventures','of','huckleberry','fin']\n",
    "\n",
    "word_count = {}\n",
    "for word in another_book_title:\n",
    "    if word in word_count:\n",
    "        word_count[word] += 1\n",
    "    else:\n",
    "        word_count[word] = 1\n",
    "print(word_count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For loops **key** and **values** using **items()**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Actor: Jerry Seinfeld    Role: Jerry Seinfeld\n",
      "Actor: Julia Louis-Dreyfus    Role: Elaine Benes\n",
      "Actor: Jason Alexander    Role: George Costanza\n",
      "Actor: Michael Richards    Role: Cosmo Kramer\n"
     ]
    }
   ],
   "source": [
    "cast = {\n",
    "           \"Jerry Seinfeld\": \"Jerry Seinfeld\",\n",
    "           \"Julia Louis-Dreyfus\": \"Elaine Benes\",\n",
    "           \"Jason Alexander\": \"George Costanza\",\n",
    "           \"Michael Richards\": \"Cosmo Kramer\"\n",
    "       }\n",
    "for key, value in cast.items():\n",
    "    print(\"Actor: {}    Role: {}\".format(key, value))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Quiz: Fruit Basket - Task 1\n",
    "You would like to count the number of fruits in your basket. In order to do this, you have the following dictionary and list of fruits. Use the dictionary and list to count the total number of fruits, but you do not want to count the other items in your basket."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23\n"
     ]
    }
   ],
   "source": [
    "# You would like to count the number of fruits in your basket. \n",
    "# In order to do this, you have the following dictionary and list of\n",
    "# fruits.  Use the dictionary and list to count the total number\n",
    "# of fruits, but you do not want to count the other items in your basket.\n",
    "\n",
    "result = 0\n",
    "basket_items = {'apples': 4, 'oranges': 19, 'kites': 3, 'sandwiches': 8}\n",
    "fruits = ['apples', 'oranges', 'pears', 'peaches', 'grapes', 'bananas']\n",
    "\n",
    "#Iterate through the dictionary\n",
    "for item, count in basket_items.items():\n",
    "#if the key is in the list of fruits, add the value (number of fruits) to result\n",
    "    if item in fruits:\n",
    "        result += count\n",
    "\n",
    "print(result)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### while loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 8]\n"
     ]
    }
   ],
   "source": [
    "card_deck = [4, 11, 8, 5, 13, 2, 8, 10]\n",
    "hand = []\n",
    "\n",
    "# adds the last element of the card_deck list to the hand list\n",
    "# until the values in hand add up to 17 or more\n",
    "while sum(hand)  < 17:\n",
    "    hand.append(card_deck.pop())\n",
    "print(hand)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "720\n"
     ]
    }
   ],
   "source": [
    "#Factorial\n",
    "# number to find the factorial of\n",
    "number = 6   \n",
    "\n",
    "# start with our product equal to one\n",
    "product = 1\n",
    "\n",
    "# track the current number being multiplied\n",
    "current = 1\n",
    "\n",
    "# write your while loop here\n",
    "while current <= number:\n",
    "    # multiply the product so far by the current number\n",
    "    product *=  current\n",
    "    current += 1;\n",
    "    \n",
    "    # increment current with each iteration until it reaches number\n",
    "\n",
    "\n",
    "\n",
    "# print the factorial of number\n",
    "print(product)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### break and continue\n",
    "\n",
    "Notice method 1 breaks after loading 120 from \"machine\" which exceeds the limit...Method 2  fixes the issue with \n",
    "a continue \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "METHOD 1\n",
      "current weight: 0\n",
      "  adding bananas (15)\n",
      "current weight: 15\n",
      "  adding mattresses (24)\n",
      "current weight: 39\n",
      "  adding dog kennels (42)\n",
      "current weight: 81\n",
      "  adding machine (120)\n",
      "current weight: 201\n",
      "  breaking loop now!\n",
      "\n",
      "Final Weight: 201\n",
      "Final Items: ['bananas', 'mattresses', 'dog kennels', 'machine']\n",
      "\n",
      "METHOD 2\n",
      "current weight: 0\n",
      "  adding bananas (15)\n",
      "current weight: 15\n",
      "  adding mattresses (24)\n",
      "current weight: 39\n",
      "  adding dog kennels (42)\n",
      "current weight: 81\n",
      "  skipping machine (120)\n",
      "current weight: 81\n",
      "  adding cheeses (5)\n",
      "\n",
      "Final Weight: 86\n",
      "Final Items: ['bananas', 'mattresses', 'dog kennels', 'cheeses']\n"
     ]
    }
   ],
   "source": [
    "manifest = [(\"bananas\", 15), (\"mattresses\", 24), (\"dog kennels\", 42), (\"machine\", 120), (\"cheeses\", 5)]\n",
    "\n",
    "# the code breaks the loop when weight exceeds or reaches the limit\n",
    "print(\"METHOD 1\")\n",
    "weight = 0\n",
    "items = []\n",
    "for cargo_name, cargo_weight in manifest:\n",
    "    print(\"current weight: {}\".format(weight))\n",
    "    if weight >= 100:\n",
    "        print(\"  breaking loop now!\")\n",
    "        break\n",
    "    else:\n",
    "        print(\"  adding {} ({})\".format(cargo_name, cargo_weight))\n",
    "        items.append(cargo_name)\n",
    "        weight += cargo_weight\n",
    "\n",
    "print(\"\\nFinal Weight: {}\".format(weight))\n",
    "print(\"Final Items: {}\".format(items))\n",
    "\n",
    "# skips an iteration when adding an item would exceed the limit\n",
    "# breaks the loop if weight is exactly the value of the limit\n",
    "print(\"\\nMETHOD 2\")\n",
    "weight = 0\n",
    "items = []\n",
    "for cargo_name, cargo_weight in manifest:\n",
    "    print(\"current weight: {}\".format(weight))\n",
    "    if weight >= 100:\n",
    "        print(\"  breaking from the loop now!\")\n",
    "        break\n",
    "    elif weight + cargo_weight > 100:\n",
    "        print(\"  skipping {} ({})\".format(cargo_name, cargo_weight))\n",
    "        continue\n",
    "    else:\n",
    "        print(\"  adding {} ({})\".format(cargo_name, cargo_weight))\n",
    "        items.append(cargo_name)\n",
    "        weight += cargo_weight\n",
    "\n",
    "print(\"\\nFinal Weight: {}\".format(weight))\n",
    "print(\"Final Items: {}\".format(items))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    Quiz: Break the String\n",
    "Write a loop with a break statement to create a string, news_ticker, that is exactly 140 characters long. You should create the news ticker by adding headlines from the headlines list, inserting a space in between each headline. If necessary, truncate the last headline in the middle so that news_ticker is exactly 140 characters long.\n",
    "\n",
    "Remember that break works in both for and while loops. Use whichever loop seems most appropriate. Consider adding print statements to your code to help you resolve bugs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Local Bear Eaten by Man Legislature Announces New Laws Peasant Discovers Violence Inherent in System Cat Rescues Fireman Stuck in Tree Brave\n"
     ]
    }
   ],
   "source": [
    " #INT: modify the headlines list to verify your loop works with different inputs\n",
    "headlines = [\"Local Bear Eaten by Man\",\n",
    "             \"Legislature Announces New Laws\",\n",
    "             \"Peasant Discovers Violence Inherent in System\",\n",
    "             \"Cat Rescues Fireman Stuck in Tree\",\n",
    "             \"Brave Knight Runs Away\",\n",
    "             \"Papperbok Review: Totally Triffic\"]\n",
    "\n",
    "news_ticker = \"\"\n",
    "for headline in headlines:\n",
    "    news_ticker += headline + \" \"\n",
    "    if len(news_ticker) >= 140:\n",
    "        news_ticker = news_ticker[:140]\n",
    "\n",
    "print(news_ticker)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Quiz: Check for Prime Numbers\n",
    "    Prime numbers are whole numbers that have only two factors: 1 and the number itself. The first few prime numbers are 2, 3, 5, 7.\n",
    "\n",
    "    For instance, 6 has four factors: 1, 2, 3, 6.\n",
    "    1 X 6 = 6\n",
    "    2 X 3 = 6\n",
    "    So we know 6 is not a prime number.\n",
    "\n",
    "    In the following coding environment, write code to check if the numbers provided in the list check_prime are prime numbers.\n",
    "\n",
    "    If the numbers are prime, the code should print \"[number] is a prime number.\"\n",
    "    If the number is NOT a prime number, it should print \"[number] is not a prime number\", and a factor of that number, other than 1 and the number itself: \"[factor] is a factor of [number]\".\n",
    "    Example output:\n",
    "\n",
    "    7 IS a prime number\n",
    "    26 is NOT a prime number, because 2 is a factor of 26"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7 IS a prime number \n",
      "26 is not a factorial being divisible by 2\n",
      "39 is not a factorial being divisible by 3\n",
      "51 is not a factorial being divisible by 3\n",
      "53 IS a prime number \n",
      "57 is not a factorial being divisible by 3\n",
      "79 IS a prime number \n",
      "85 is not a factorial being divisible by 5\n"
     ]
    }
   ],
   "source": [
    "## Your code should check if each number in the list is a prime number\n",
    "check_prime = [7,26, 39, 51, 53, 57, 79, 85]\n",
    "\n",
    "for num in check_prime:\n",
    "    for i in range(2, num):\n",
    "        if (num % i) == 0:\n",
    "            print(f\"{num} is not a factorial being divisible by {i}\")\n",
    "            break\n",
    "        if i == num - 1:\n",
    "            print(f\"{num} IS a prime number \")\n",
    "            \n",
    "            \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### zip and enumerate\n",
    "\n",
    "**zip**  returns an iterator that combine multiple iterables intp one sequence of **tuples**\n",
    "Each tuple contains the elements in that position from all the iterables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('a', 1), ('b', 2), ('c', 3)]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Example\n",
    "list(zip(['a', 'b', 'c'], [1, 2, 3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**You could unpack eack tuple in a for loop**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a: 1\n",
      "b: 2\n",
      "c: 3\n"
     ]
    }
   ],
   "source": [
    "letters = ['a', 'b', 'c']\n",
    "nums = [1, 2, 3]\n",
    "\n",
    "for letter, num in zip(letters, nums):\n",
    "    print(\"{}: {}\".format(letter, num))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### You can also unzip a list into tuples using an asterisk"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "some_list = [('one', 1), ('two', 2), ('three', 3)]\n",
    "letters, numbers = zip(*some_list)\n",
    "print(numbers)\n",
    "print(letters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**enumerate** is a built in function that returns an iterator of tuples containing indices and values of a list.\n",
    "You will often use this when you want the index along with each element in a loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 a\n",
      "1 b\n",
      "2 c\n",
      "3 d\n",
      "4 e\n"
     ]
    }
   ],
   "source": [
    "letters = [\"a\", \"b\", \"c\", \"d\", \"e\"]\n",
    "for i, letter in enumerate(letters):\n",
    "    print(i, letter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Quiz zip Coordinates\n",
    "\n",
    "Use zip to write a for loop that creates a string specifying the label and coordinates of each point and appends it to the list points. Each string should be formatted as label: x, y, z. For example, the string for the first coordinate should be F: 23, 677, 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "F: 23, 677, 4\n",
      "J: 53, 233, 16\n",
      "A: 2, 405, -6\n",
      "Q: -12, 433, -42\n",
      "Y: 95, 905, 3\n",
      "B: 103, 376, -6\n",
      "W: 14, 432, 23\n",
      "X: -5, 445, -1\n"
     ]
    }
   ],
   "source": [
    "x_coord = [23, 53, 2, -12, 95, 103, 14, -5]\n",
    "y_coord = [677, 233, 405, 433, 905, 376, 432, 445]\n",
    "z_coord = [4, 16, -6, -42, 3, -6, 23, -1]\n",
    "labels = [\"F\", \"J\", \"A\", \"Q\", \"Y\", \"B\", \"W\", \"X\"]\n",
    "\n",
    "points = []\n",
    "for label, x, y, z in zip(labels, x_coord, y_coord, z_coord):\n",
    "    points.append(\"{}: {}, {}, {}\".format(label, x, y, z))\n",
    "\n",
    "for point in points:\n",
    "    print(point)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Quiz: Unzip Tuples**\n",
    "Unzip the cast tuple into two names and heights tuples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Barney', 'Robin', 'Ted', 'Lily', 'Marshall')\n",
      "(72, 68, 72, 66, 76)\n"
     ]
    }
   ],
   "source": [
    "cast = ((\"Barney\", 72), (\"Robin\", 68), (\"Ted\", 72), (\"Lily\", 66), (\"Marshall\", 76))\n",
    "\n",
    "# define names and heights here\n",
    "names, heights = zip(*cast)\n",
    "print(names)\n",
    "print(heights)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quiz: Transpose with Zip  \n",
    "Use zip to transpose data from a **4-by-3 matrix** to a **3-by-4 matrix.** "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "((0, 3, 6, 9), (1, 4, 7, 10), (2, 5, 8, 11))\n"
     ]
    }
   ],
   "source": [
    "data = ((0, 1, 2), (3, 4, 5), (6, 7, 8), (9, 10, 11))\n",
    "\n",
    "data_transpose = tuple(zip(*data))\n",
    "print(data_transpose)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Quiz: Enumerate\n",
    "Use enumerate to modify the cast list so that each element contains the name followed by the character's corresponding height. For example, the first element of cast should change from \"Barney Stinson\" to \"Barney Stinson 72\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Barney Stinson 72', 'Robin Scherbatsky 68', 'Ted Mosby 72', 'Lily Aldrin 66', 'Marshall Eriksen 76']\n"
     ]
    }
   ],
   "source": [
    "cast = [\"Barney Stinson\", \"Robin Scherbatsky\", \"Ted Mosby\", \"Lily Aldrin\", \"Marshall Eriksen\"]\n",
    "heights = [72, 68, 72, 66, 76]\n",
    "\n",
    "# write your for loop here\n",
    "for i, name in enumerate(cast):\n",
    "    cast[i] = name + \" \" + str(heights[i])\n",
    "\n",
    "print(cast)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Comprehension\n",
    "\n",
    "- create list quickly an d concisely\n",
    "- its about creating lists lists lists lists\n",
    "\n",
    "##  Turning this "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Dallas', 'Houston', 'Austin', 'San Antonio']\n"
     ]
    }
   ],
   "source": [
    "cities = ['dallas', 'houston', 'austin', 'san antonio']\n",
    "capitalized_cities = []\n",
    "for city in cities:\n",
    "    capitalized_cities.append(city.title())\n",
    "print(capitalized_cities)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Into this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Dallas', 'Houston', 'Austin', 'San Antonio']\n"
     ]
    }
   ],
   "source": [
    "capitalized_cities = [city.title() for city in cities]\n",
    "print(capitalized_cities)\n",
    "# [] creates list...calls city,title() for each city in cities"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Conditionals in List Comprehension\n",
    "\n",
    "- after iterable you can use if....no else after if please"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "squares = [x**2 for x in range(9) if x % 2 == 0]\n",
    "print(squares)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To add if...else....move conditionals to the beginning of\n",
    "listcomp, right after the expression "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 4, 4, 6, 16, 8, 36, 10, 64]\n"
     ]
    }
   ],
   "source": [
    "squares = [x**2 if x % 2 == 0 else x + 3 for x in range(9)]\n",
    "print(squares)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Quiz: Extract First Names\n",
    "Use a list comprehension to create a new list first_names containing just the first names in names in lowercase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Rick', 'Morty', 'Summer', 'Jerry', 'Beth']\n"
     ]
    }
   ],
   "source": [
    "names = [\"Rick Sanchez\", \"Morty Smith\", \"Summer Smith\", \"Jerry Smith\", \"Beth Smith\"]\n",
    "\n",
    "first_names = [name.split()[0] for name in names] # write your list comprehension here\n",
    "print(first_names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Quiz: Multiples of Three\n",
    "Use a list comprehension to create a list multiples_3 containing the first 20 multiples of 3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, 54, 57, 60]\n",
      "20\n"
     ]
    }
   ],
   "source": [
    "multiples_3 = [num * 3 for num in range(1, 21)]# write your list comprehension here\n",
    "print(multiples_3)\n",
    "print(len(multiples_3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Quiz: Filter Names by Scores\n",
    "Use a list comprehension to create a list of names passed that only include those that scored at least 65."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Rick Sanchez', 'Summer Smith', 'Beth Smith']\n"
     ]
    }
   ],
   "source": [
    "scores = {\n",
    "             \"Rick Sanchez\": 70,\n",
    "             \"Morty Smith\": 35,\n",
    "             \"Summer Smith\": 82,\n",
    "             \"Jerry Smith\": 23,\n",
    "             \"Beth Smith\": 98\n",
    "          }\n",
    "\n",
    "passed = [name for name, score in scores.items() if score > 65]\n",
    "print(passed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Practice Questions\n",
    "Question 1.\n",
    "A. Create a dictionary that includes the count of Oscar nominations for each director in the nominations list.\n",
    "\n",
    "B. Provide a dictionary with the count of Oscar wins for each director in the winners list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nom_count_dict = {'Norman Taurog': 2, 'Wesley Ruggles': 1, 'Clarence Brown': 4, 'Lewis Milestone': 1, 'Josef Von Sternberg': 2, 'Frank Borzage': 1, 'King Vidor': 3, 'Frank Lloyd': 2, 'Frank Capra': 6, 'George Cukor': 5, 'Victor Schertzinger': 1, 'W. S. Van Dyke': 2, 'John Ford': 5, 'Michael Curtiz': 5, 'Henry Hathaway': 1, 'William Wyler': 12, 'Robert Z. Leonard': 1, 'Gregory La Cava': 2, 'Leo McCarey': 3, 'Sidney Franklin': 1, 'William Dieterle': 1, 'William Wellman': 2, 'Sam Wood': 3, 'Victor Fleming': 1, 'Alfred Hitchcock': 5, 'Orson Welles': 1, 'Alexander Hall': 1, 'Howard Hawks': 1, 'Mervyn LeRoy': 1, 'John Farrow': 1, 'Ernst Lubitsch': 1, 'George Stevens': 5, 'Henry King': 2, 'Billy Wilder': 8, 'Otto Preminger': 2, 'Jean Renoir': 1, 'David Lean': 7, 'Robert Siodmak': 1, 'Elia Kazan': 5, 'Henry Koster': 1, 'Edward Dmytryk': 1, 'John Huston': 5, 'Laurence Olivier': 1, 'Jean Negulesco': 1, 'Fred Zinnemann': 7, 'Anatole Litvak': 1, 'Joseph L. Mankiewicz': 4, 'Robert Rossen': 2, 'William A. Wellman': 1, 'Carol Reed': 3, 'Vincente Minnelli': 2, 'Cecil B. DeMille': 1, 'Charles Walters': 1, 'George Seaton': 1, 'Delbert Mann': 1, 'John Sturges': 1, 'Joshua Logan': 2, 'Michael Anderson': 1, 'Walter Lang': 1, 'Mark Robson': 2, 'Sidney Lumet': 4, 'Richard Brooks': 3, 'Stanley Kramer': 3, 'Robert Wise': 3, 'Jack Clayton': 1, 'Jules Dassin': 1, 'Jack Cardiff': 1, 'J. Lee Thompson': 1, 'Federico Fellini': 4, 'Jerome Robbins': 1, 'Frank Perry': 1, 'Pietro Germi': 1, 'Arthur Penn': 3, 'Robert Mulligan': 1, 'Martin Ritt': 1, 'Tony Richardson': 1, 'Peter Glenville': 1, 'Stanley Kubrick': 4, 'Robert Stevenson': 1, 'Michael Cacoyannis': 1, 'John Schlesinger': 3, 'Hiroshi Teshigahara': 1, 'Michelangelo Antonioni': 1, 'Claude Lelouch': 1, 'Mike Nichols': 4, 'Norman Jewison': 3, 'Gillo Pontecorvo': 1, 'Anthony Harvey': 1, 'Franco Zeffirelli': 1, 'George Roy Hill': 2, 'Sydney Pollack': 3, 'Costa-Gavras': 1, 'Franklin J. Schaffner': 1, 'Arthur Hiller': 1, 'Robert Altman': 5, 'Ken Russell': 1, 'Peter Bogdanovich': 1, 'William Friedkin': 2, 'Bob Fosse': 3, 'John Boorman': 2, 'Jan Troell': 1, 'Francis Ford Coppola': 3, 'George Lucas': 2, 'Ingmar Bergman': 3, 'Bernardo Bertolucci': 2, 'Roman Polanski': 3, 'Francois Truffaut': 1, 'John Cassavetes': 1, 'Milos Forman': 3, 'Alan J. Pakula': 1, 'Lina Wertmuller': 1, 'John G. Avildsen': 1, 'Steven Spielberg': 6, 'Herbert Ross': 1, 'Woody Allen': 6, 'Hal Ashby': 1, 'Warren Beatty': 2, 'Buck Henry': 1, 'Alan Parker': 2, 'Michael Cimino': 1, 'Francis Coppola': 1, 'Peter Yates': 2, 'Edouard Molinaro': 1, 'Robert Benton': 2, 'David Lynch': 3, 'Martin Scorsese': 6, 'Richard Rush': 1, 'Robert Redford': 2, 'Louis Malle': 1, 'Hugh Hudson': 1, 'Mark Rydell': 1, 'Wolfgang Petersen': 1, 'Richard Attenborough': 1, 'Bruce Beresford': 1, 'James L. Brooks': 1, 'Roland Joffe': 2, 'Hector Babenco': 1, 'Akira Kurosawa': 1, 'Peter Weir': 4, 'James Ivory': 3, 'Oliver Stone': 3, 'Adrian Lyne': 1, 'Lasse Hallstrom': 2, 'Barry Levinson': 2, 'Charles Crichton': 1, 'Kenneth Branagh': 1, 'Jim Sheridan': 2, 'Stephen Frears': 2, 'Barbet Schroeder': 1, 'Kevin Costner': 1, 'John Singleton': 1, 'Ridley Scott': 3, 'Jonathan Demme': 1, 'Clint Eastwood': 4, 'Neil Jordan': 1, 'Martin Brest': 1, 'Jane Campion': 1, 'Quentin Tarantino': 2, 'Krzysztof Kieslowski': 1, 'Robert Zemeckis': 1, 'Chris Noonan': 1, 'Tim Robbins': 1, 'Mike Figgis': 1, 'Michael Radford': 1, 'Mel Gibson': 1, 'Anthony Minghella': 1, 'Joel Coen': 3, 'Mike Leigh': 2, 'Scott Hicks': 1, 'Peter Cattaneo': 1, 'Gus Van Sant': 2, 'Curtis Hanson': 1, 'Atom Egoyan': 1, 'James Cameron': 2, 'Roberto Benigni': 1, 'John Madden': 1, 'Terrence Malick': 1, 'Spike Jonze': 1, 'Michael Mann': 1, 'M. Night Shyamalan': 1, 'Sam Mendes': 1, 'Stephen Daldry': 3, 'Ang Lee': 2, 'Steven Soderbergh': 2, 'Peter Jackson': 2, 'Ron Howard': 2, 'Rob Marshall': 1, 'Pedro Almodovar': 1, 'Fernando Meirelles': 1, 'Sofia Coppola': 1, 'Taylor Hackford': 1, 'Alexander Payne': 1, 'Bennett Miller': 1, 'Paul Haggis': 1, 'George Clooney': 1, 'Alejandro Gonzaalez Inarritu': 1, 'Paul Greengrass': 1, 'Julian Schnabel': 1, 'Jason Reitman': 2, 'Tony Gilroy': 1, 'Paul Thomas Anderson': 1, 'Ethan Coen': 2, 'David Fincher': 2, 'Danny Boyle': 1, 'Lee Daniels': 1, 'Kathryn Bigelow': 1, 'Darren Aronofsky': 1, 'David O. Russell': 1, 'Tom Hooper': 1}\n",
      "\n",
      "win_count_dict = {'Norman Taurog': 1, 'Frank Borzage': 1, 'Frank Lloyd': 1, 'Frank Capra': 3, 'John Ford': 4, 'Leo McCarey': 2, 'Victor Fleming': 1, 'William Wyler': 3, 'Michael Curtiz': 1, 'Billy Wilder': 2, 'Elia Kazan': 2, 'John Huston': 1, 'Joseph L. Mankiewicz': 2, 'George Stevens': 2, 'Fred Zinnemann': 2, 'Delbert Mann': 1, 'David Lean': 2, 'Vincente Minnelli': 1, 'Jerome Robbins': 1, 'Robert Wise': 2, 'Tony Richardson': 1, 'George Cukor': 1, 'Mike Nichols': 1, 'Carol Reed': 1, 'John Schlesinger': 1, 'Franklin J. Schaffner': 1, 'William Friedkin': 1, 'Bob Fosse': 1, 'George Roy Hill': 1, 'Francis Ford Coppola': 1, 'Milos Forman': 2, 'John G. Avildsen': 1, 'Woody Allen': 1, 'Michael Cimino': 1, 'Robert Benton': 1, 'Robert Redford': 1, 'Warren Beatty': 1, 'Richard Attenborough': 1, 'James L. Brooks': 1, 'Sydney Pollack': 1, 'Oliver Stone': 2, 'Bernardo Bertolucci': 1, 'Barry Levinson': 1, 'Kevin Costner': 1, 'Jonathan Demme': 1, 'Clint Eastwood': 2, 'Steven Spielberg': 2, 'Robert Zemeckis': 1, 'Mel Gibson': 1, 'Anthony Minghella': 1, 'James Cameron': 1, 'Sam Mendes': 1, 'Steven Soderbergh': 1, 'Ron Howard': 1, 'Roman Polanski': 1, 'Peter Jackson': 1, 'Ang Lee': 1, 'Martin Scorsese': 1, 'Ethan Coen': 1, 'Joel Coen': 1, 'Danny Boyle': 1, 'Kathryn Bigelow': 1, 'Tom Hooper': 1}\n"
     ]
    }
   ],
   "source": [
    "nominated = {1931: ['Norman Taurog', 'Wesley Ruggles', 'Clarence Brown', 'Lewis Milestone', 'Josef Von Sternberg'], 1932: ['Frank Borzage', 'King Vidor', 'Josef Von Sternberg'], 1933: ['Frank Lloyd', 'Frank Capra', 'George Cukor'], 1934: ['Frank Capra', 'Victor Schertzinger', 'W. S. Van Dyke'], 1935: ['John Ford', 'Michael Curtiz', 'Henry Hathaway', 'Frank Lloyd'], 1936: ['Frank Capra', 'William Wyler', 'Robert Z. Leonard', 'Gregory La Cava', 'W. S. Van Dyke'], 1937: ['Leo McCarey', 'Sidney Franklin', 'William Dieterle', 'Gregory La Cava', 'William Wellman'], 1938: ['Frank Capra', 'Michael Curtiz', 'Norman Taurog', 'King Vidor', 'Michael Curtiz'], 1939: ['Sam Wood', 'Frank Capra', 'John Ford', 'William Wyler', 'Victor Fleming'], 1940: ['John Ford', 'Sam Wood', 'William Wyler', 'George Cukor', 'Alfred Hitchcock'], 1941: ['John Ford', 'Orson Welles', 'Alexander Hall', 'William Wyler', 'Howard Hawks'], 1942: ['Sam Wood', 'Mervyn LeRoy', 'John Farrow', 'Michael Curtiz', 'William Wyler'], 1943: ['Michael Curtiz', 'Ernst Lubitsch', 'Clarence Brown', 'George Stevens', 'Henry King'], 1944: ['Leo McCarey', 'Billy Wilder', 'Otto Preminger', 'Alfred Hitchcock', 'Henry King'], 1945: ['Billy Wilder', 'Leo McCarey', 'Clarence Brown', 'Jean Renoir', 'Alfred Hitchcock'], 1946: ['David Lean', 'Frank Capra', 'Robert Siodmak', 'Clarence Brown', 'William Wyler'], 1947: ['Elia Kazan', 'Henry Koster', 'Edward Dmytryk', 'George Cukor', 'David Lean'], 1948: ['John Huston', 'Laurence Olivier', 'Jean Negulesco', 'Fred Zinnemann', 'Anatole Litvak'], 1949: ['Joseph L. Mankiewicz', 'Robert Rossen', 'William A. Wellman', 'Carol Reed', 'William Wyler'], 1950: ['Joseph L. Mankiewicz', 'John Huston', 'George Cukor', 'Billy Wilder', 'Carol Reed'], 1951: ['George Stevens', 'John Huston', 'Vincente Minnelli', 'William Wyler', 'Elia Kazan'], 1952: ['John Ford', 'Joseph L. Mankiewicz', 'Cecil B. DeMille', 'Fred Zinnemann', 'John Huston'], 1953: ['Fred Zinnemann', 'Charles Walters', 'William Wyler', 'George Stevens', 'Billy Wilder'], 1954: ['Elia Kazan', 'George Seaton', 'William Wellman', 'Alfred Hitchcock', 'Billy Wilder'], 1955: ['Delbert Mann', 'John Sturges', 'Elia Kazan', 'Joshua Logan', 'David Lean'], 1956: ['George Stevens', 'Michael Anderson', 'William Wyler', 'Walter Lang', 'King Vidor'], 1957: ['David Lean', 'Mark Robson', 'Joshua Logan', 'Sidney Lumet', 'Billy Wilder'], 1958: ['Richard Brooks', 'Stanley Kramer', 'Robert Wise', 'Mark Robson', 'Vincente Minnelli'], 1959: ['George Stevens', 'Fred Zinnemann', 'Jack Clayton', 'Billy Wilder', 'William Wyler'], 1960: ['Billy Wilder', 'Jules Dassin', 'Alfred Hitchcock', 'Jack Cardiff', 'Fred Zinnemann'], 1961: ['J. Lee Thompson', 'Robert Rossen', 'Stanley Kramer', 'Federico Fellini', 'Robert Wise', 'Jerome Robbins'], 1962: ['David Lean', 'Frank Perry', 'Pietro Germi', 'Arthur Penn', 'Robert Mulligan'], 1963: ['Elia Kazan', 'Otto Preminger', 'Federico Fellini', 'Martin Ritt', 'Tony Richardson'], 1964: ['George Cukor', 'Peter Glenville', 'Stanley Kubrick', 'Robert Stevenson', 'Michael Cacoyannis'], 1965: ['William Wyler', 'John Schlesinger', 'David Lean', 'Hiroshi Teshigahara', 'Robert Wise'], 1966: ['Fred Zinnemann', 'Michelangelo Antonioni', 'Claude Lelouch', 'Richard Brooks', 'Mike Nichols'], 1967: ['Arthur Penn', 'Stanley Kramer', 'Richard Brooks', 'Norman Jewison', 'Mike Nichols'], 1968: ['Carol Reed', 'Gillo Pontecorvo', 'Anthony Harvey', 'Franco Zeffirelli', 'Stanley Kubrick'], 1969: ['John Schlesinger', 'Arthur Penn', 'George Roy Hill', 'Sydney Pollack', 'Costa-Gavras'], 1970: ['Franklin J. Schaffner', 'Federico Fellini', 'Arthur Hiller', 'Robert Altman', 'Ken Russell'], 1971: ['Stanley Kubrick', 'Norman Jewison', 'Peter Bogdanovich', 'John Schlesinger', 'William Friedkin'], 1972: ['Bob Fosse', 'John Boorman', 'Jan Troell', 'Francis Ford Coppola', 'Joseph L. Mankiewicz'], 1973: ['George Roy Hill', 'George Lucas', 'Ingmar Bergman', 'William Friedkin', 'Bernardo Bertolucci'], 1974: ['Francis Ford Coppola', 'Roman Polanski', 'Francois Truffaut', 'Bob Fosse', 'John Cassavetes'], 1975: ['Federico Fellini', 'Stanley Kubrick', 'Sidney Lumet', 'Robert Altman', 'Milos Forman'], 1976: ['Alan J. Pakula', 'Ingmar Bergman', 'Sidney Lumet', 'Lina Wertmuller', 'John G. Avildsen'], 1977: ['Steven Spielberg', 'Fred Zinnemann', 'George Lucas', 'Herbert Ross', 'Woody Allen'], 1978: ['Hal Ashby', 'Warren Beatty', 'Buck Henry', 'Woody Allen', 'Alan Parker', 'Michael Cimino'], 1979: ['Bob Fosse', 'Francis Coppola', 'Peter Yates', 'Edouard Molinaro', 'Robert Benton'], 1980: ['David Lynch', 'Martin Scorsese', 'Richard Rush', 'Roman Polanski', 'Robert Redford'], 1981: ['Louis Malle', 'Hugh Hudson', 'Mark Rydell', 'Steven Spielberg', 'Warren Beatty'], 1982: ['Wolfgang Petersen', 'Steven Spielberg', 'Sydney Pollack', 'Sidney Lumet', 'Richard Attenborough'], 1983: ['Peter Yates', 'Ingmar Bergman', 'Mike Nichols', 'Bruce Beresford', 'James L. Brooks'], 1984: ['Woody Allen', 'Roland Joffe', 'David Lean', 'Robert Benton', 'Milos Forman'], 1985: ['Hector Babenco', 'John Huston', 'Akira Kurosawa', 'Peter Weir', 'Sydney Pollack'], 1986: ['David Lynch', 'Woody Allen', 'Roland Joffe', 'James Ivory', 'Oliver Stone'], 1987: ['Bernardo Bertolucci', 'Adrian Lyne', 'John Boorman', 'Norman Jewison', 'Lasse Hallstrom'], 1988: ['Barry Levinson', 'Charles Crichton', 'Martin Scorsese', 'Alan Parker', 'Mike Nichols'], 1989: ['Woody Allen', 'Peter Weir', 'Kenneth Branagh', 'Jim Sheridan', 'Oliver Stone'], 1990: ['Francis Ford Coppola', 'Martin Scorsese', 'Stephen Frears', 'Barbet Schroeder', 'Kevin Costner'], 1991: ['John Singleton', 'Barry Levinson', 'Oliver Stone', 'Ridley Scott', 'Jonathan Demme'], 1992: ['Clint Eastwood', 'Neil Jordan', 'James Ivory', 'Robert Altman', 'Martin Brest'], 1993: ['Jim Sheridan', 'Jane Campion', 'James Ivory', 'Robert Altman', 'Steven Spielberg'], 1994: ['Woody Allen', 'Quentin Tarantino', 'Robert Redford', 'Krzysztof Kieslowski', 'Robert Zemeckis'], 1995: ['Chris Noonan', 'Tim Robbins', 'Mike Figgis', 'Michael Radford', 'Mel Gibson'], 1996: ['Anthony Minghella', 'Joel Coen', 'Milos Forman', 'Mike Leigh', 'Scott Hicks'], 1997: ['Peter Cattaneo', 'Gus Van Sant', 'Curtis Hanson', 'Atom Egoyan', 'James Cameron'], 1998: ['Roberto Benigni', 'John Madden', 'Terrence Malick', 'Peter Weir', 'Steven Spielberg'], 1999: ['Spike Jonze', 'Lasse Hallstrom', 'Michael Mann', 'M. Night Shyamalan', 'Sam Mendes'], 2000: ['Stephen Daldry', 'Ang Lee', 'Steven Soderbergh', 'Ridley Scott', 'Steven Soderbergh'], 2001: ['Ridley Scott', 'Robert Altman', 'Peter Jackson', 'David Lynch', 'Ron Howard'], 2002: ['Rob Marshall', 'Martin Scorsese', 'Stephen Daldry', 'Pedro Almodovar', 'Roman Polanski'], 2003: ['Fernando Meirelles', 'Sofia Coppola', 'Peter Weir', 'Clint Eastwood', 'Peter Jackson'], 2004: ['Martin Scorsese', 'Taylor Hackford', 'Alexander Payne', 'Mike Leigh', 'Clint Eastwood'], 2005: ['Ang Lee', 'Bennett Miller', 'Paul Haggis', 'George Clooney', 'Steven Spielberg'], 2006: ['Alejandro Gonzaalez Inarritu', 'Clint Eastwood', 'Stephen Frears', 'Paul Greengrass', 'Martin Scorsese'], 2007: ['Julian Schnabel', 'Jason Reitman', 'Tony Gilroy', 'Paul Thomas Anderson', 'Joel Coen', 'Ethan Coen'], 2008: ['David Fincher', 'Ron Howard', 'Gus Van Sant', 'Stephen Daldry', 'Danny Boyle'], 2009: ['James Cameron', 'Quentin Tarantino', 'Lee Daniels', 'Jason Reitman', 'Kathryn Bigelow'], 2010: ['Darren Aronofsky', 'David O. Russell', 'David Fincher', 'Ethan Coen', 'Joel Coen', 'Tom Hooper']}\n",
    "winners = {1931: ['Norman Taurog'], 1932: ['Frank Borzage'], 1933: ['Frank Lloyd'], 1934: ['Frank Capra'], 1935: ['John Ford'], 1936: ['Frank Capra'], 1937: ['Leo McCarey'], 1938: ['Frank Capra'], 1939: ['Victor Fleming'], 1940: ['John Ford'], 1941: ['John Ford'], 1942: ['William Wyler'], 1943: ['Michael Curtiz'], 1944: ['Leo McCarey'], 1945: ['Billy Wilder'], 1946: ['William Wyler'], 1947: ['Elia Kazan'], 1948: ['John Huston'], 1949: ['Joseph L. Mankiewicz'], 1950: ['Joseph L. Mankiewicz'], 1951: ['George Stevens'], 1952: ['John Ford'], 1953: ['Fred Zinnemann'], 1954: ['Elia Kazan'], 1955: ['Delbert Mann'], 1956: ['George Stevens'], 1957: ['David Lean'], 1958: ['Vincente Minnelli'], 1959: ['William Wyler'], 1960: ['Billy Wilder'], 1961: ['Jerome Robbins', 'Robert Wise'], 1962: ['David Lean'], 1963: ['Tony Richardson'], 1964: ['George Cukor'], 1965: ['Robert Wise'], 1966: ['Fred Zinnemann'], 1967: ['Mike Nichols'], 1968: ['Carol Reed'], 1969: ['John Schlesinger'], 1970: ['Franklin J. Schaffner'], 1971: ['William Friedkin'], 1972: ['Bob Fosse'], 1973: ['George Roy Hill'], 1974: ['Francis Ford Coppola'], 1975: ['Milos Forman'], 1976: ['John G. Avildsen'], 1977: ['Woody Allen'], 1978: ['Michael Cimino'], 1979: ['Robert Benton'], 1980: ['Robert Redford'], 1981: ['Warren Beatty'], 1982: ['Richard Attenborough'], 1983: ['James L. Brooks'], 1984: ['Milos Forman'], 1985: ['Sydney Pollack'], 1986: ['Oliver Stone'], 1987: ['Bernardo Bertolucci'], 1988: ['Barry Levinson'], 1989: ['Oliver Stone'], 1990: ['Kevin Costner'], 1991: ['Jonathan Demme'], 1992: ['Clint Eastwood'], 1993: ['Steven Spielberg'], 1994: ['Robert Zemeckis'], 1995: ['Mel Gibson'], 1996: ['Anthony Minghella'], 1997: ['James Cameron'], 1998: ['Steven Spielberg'], 1999: ['Sam Mendes'], 2000: ['Steven Soderbergh'], 2001: ['Ron Howard'], 2002: ['Roman Polanski'], 2003: ['Peter Jackson'], 2004: ['Clint Eastwood'], 2005: ['Ang Lee'], 2006: ['Martin Scorsese'], 2007: ['Ethan Coen', 'Joel Coen'], 2008: ['Danny Boyle'], 2009: ['Kathryn Bigelow'], 2010: ['Tom Hooper']}\n",
    "\n",
    "### 1A: Create dictionary with the count of Oscar nominations for each director \n",
    "nom_count_dict = {}\n",
    "# Add your code here\n",
    "for year, nominees in nominated.items():\n",
    "    for nominee in nominees:\n",
    "        if nominee not in nom_count_dict:\n",
    "            nom_count_dict[nominee] = 1\n",
    "        else:\n",
    "            nom_count_dict[nominee] += 1\n",
    "    \n",
    "\n",
    "\n",
    "\n",
    "print(\"nom_count_dict = {}\\n\".format(nom_count_dict))\n",
    "\n",
    "\n",
    "### 1B: Create dictionary with the count of Oscar wins for each director\n",
    "win_count_dict = {}\n",
    "# Add your code here\n",
    "for year, winner_list in winners.items():\n",
    "    for winner in winner_list:\n",
    "        win_count_dict[winner] = win_count_dict.get(winner, 0) +1\n",
    "    \n",
    "        \n",
    "# win_count_dict = {}\n",
    "# for year, winnerlist in winners.items():\n",
    "#     for winner in winnerlist:\n",
    "#         win_count_dict[winner] = win_count_dict.get(winner, 0) + 1\n",
    "\n",
    "\n",
    "print(\"win_count_dict = {}\".format(win_count_dict))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Provide a list with the name(s) of the director(s) with the most Oscar wins. We are asking for a list because there could be more than 1 director tied for the most Oscar wins."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "most_win_director = ['John Ford']\n"
     ]
    }
   ],
   "source": [
    "winners = {1931: ['Norman Taurog'], 1932: ['Frank Borzage'], 1933: ['Frank Lloyd'], 1934: ['Frank Capra'], 1935: ['John Ford'], 1936: ['Frank Capra'], 1937: ['Leo McCarey'], 1938: ['Frank Capra'], 1939: ['Victor Fleming'], 1940: ['John Ford'], 1941: ['John Ford'], 1942: ['William Wyler'], 1943: ['Michael Curtiz'], 1944: ['Leo McCarey'], 1945: ['Billy Wilder'], 1946: ['William Wyler'], 1947: ['Elia Kazan'], 1948: ['John Huston'], 1949: ['Joseph L. Mankiewicz'], 1950: ['Joseph L. Mankiewicz'], 1951: ['George Stevens'], 1952: ['John Ford'], 1953: ['Fred Zinnemann'], 1954: ['Elia Kazan'], 1955: ['Delbert Mann'], 1956: ['George Stevens'], 1957: ['David Lean'], 1958: ['Vincente Minnelli'], 1959: ['William Wyler'], 1960: ['Billy Wilder'], 1961: ['Jerome Robbins', 'Robert Wise'], 1962: ['David Lean'], 1963: ['Tony Richardson'], 1964: ['George Cukor'], 1965: ['Robert Wise'], 1966: ['Fred Zinnemann'], 1967: ['Mike Nichols'], 1968: ['Carol Reed'], 1969: ['John Schlesinger'], 1970: ['Franklin J. Schaffner'], 1971: ['William Friedkin'], 1972: ['Bob Fosse'], 1973: ['George Roy Hill'], 1974: ['Francis Ford Coppola'], 1975: ['Milos Forman'], 1976: ['John G. Avildsen'], 1977: ['Woody Allen'], 1978: ['Michael Cimino'], 1979: ['Robert Benton'], 1980: ['Robert Redford'], 1981: ['Warren Beatty'], 1982: ['Richard Attenborough'], 1983: ['James L. Brooks'], 1984: ['Milos Forman'], 1985: ['Sydney Pollack'], 1986: ['Oliver Stone'], 1987: ['Bernardo Bertolucci'], 1988: ['Barry Levinson'], 1989: ['Oliver Stone'], 1990: ['Kevin Costner'], 1991: ['Jonathan Demme'], 1992: ['Clint Eastwood'], 1993: ['Steven Spielberg'], 1994: ['Robert Zemeckis'], 1995: ['Mel Gibson'], 1996: ['Anthony Minghella'], 1997: ['James Cameron'], 1998: ['Steven Spielberg'], 1999: ['Sam Mendes'], 2000: ['Steven Soderbergh'], 2001: ['Ron Howard'], 2002: ['Roman Polanski'], 2003: ['Peter Jackson'], 2004: ['Clint Eastwood'], 2005: ['Ang Lee'], 2006: ['Martin Scorsese'], 2007: ['Ethan Coen', 'Joel Coen'], 2008: ['Danny Boyle'], 2009: ['Kathryn Bigelow'], 2010: ['Tom Hooper']}\n",
    "\n",
    "\n",
    "### For Question 2: Please provide a list with the name(s) of the director(s) with \n",
    "### the most Oscar wins. The list can hold the names of multiple directors,\n",
    "### since there can be more than 1 director tied with the most Oscar wins.\n",
    "\n",
    "most_win_director = []\n",
    "# Add your code here\n",
    "win_count_dict = {}\n",
    "for year, winnerlist in winners.items():\n",
    "    for winner in winnerlist:\n",
    "        win_count_dict[winner] = win_count_dict.get(winner, 0) + 1\n",
    "\n",
    "highest_count = max(win_count_dict.values())\n",
    "\n",
    "most_win_director = [key for key, value in win_count_dict.items() if value == highest_count]\n",
    "\n",
    "print(\"most_win_director = {}\".format(most_win_director))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "#default argument\n",
    "def cylinder_volume(height, radius=5):\n",
    "    pi = 3.14159\n",
    "    return height * pi * radius ** 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Variable Scope"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fin\n"
     ]
    }
   ],
   "source": [
    "# A variable created inside a function belongs to the local scope of that function, \n",
    "#and can only be used inside that function.\n",
    "# This will result in an error\n",
    "def some_function():\n",
    "    word = \"hello\"\n",
    "\n",
    "print(word)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "ename": "UnboundLocalError",
     "evalue": "local variable 'egg_count' referenced before assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mUnboundLocalError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-58-32dca0f4d031>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0megg_count\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m12\u001b[0m \u001b[0;31m# purchase a dozen eggs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mbuy_eggs\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;32m<ipython-input-58-32dca0f4d031>\u001b[0m in \u001b[0;36mbuy_eggs\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mbuy_eggs\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[0;32m----> 4\u001b[0;31m     \u001b[0megg_count\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m12\u001b[0m \u001b[0;31m# purchase a dozen eggs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0mbuy_eggs\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[0;31mUnboundLocalError\u001b[0m: local variable 'egg_count' referenced before assignment"
     ]
    }
   ],
   "source": [
    "egg_count = 0\n",
    "\n",
    "def buy_eggs():\n",
    "    egg_count += 12 # purchase a dozen eggs\n",
    "\n",
    "buy_eggs()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This code causes an UnboundLocalError, because the variable egg_count in the first line has global scope. Note that it is not passed as an argument into the function, so the function assumes the egg_count being referred to is the global variable.\n",
    "\n",
    "W can print a global variable's value successfully without an error. This works because we were simply accessing the value of the variable. If we try to change or reassign this global variable, however, as we do in this code, we get an error. Python doesn't allow functions to modify variables that aren't in the function's scope. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Nested functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6900\n"
     ]
    }
   ],
   "source": [
    "def myfunc():\n",
    "  x = 300\n",
    "  def myinnerfunc():\n",
    "    return x * 23\n",
    "  return myinnerfunc()\n",
    "\n",
    "print(myfunc())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Documentation\n",
    "\n",
    "Docstring - a type of comment used to explain the purpose of a function and how it should be used\n",
    "\n",
    "#### Single line docstring"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Single line docstring\n",
    "\n",
    "def population_density(population, land_area):\n",
    "    \"\"\"Calculate the population density of an area. \"\"\"\n",
    "    return population / land_area"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### for more complicated functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for more complicated functions\n",
    "\n",
    "def population_density(population, land_area):\n",
    "    \"\"\"Calculate the population density of an area.\n",
    "\n",
    "    INPUT:\n",
    "    population: int. The population of that area\n",
    "    land_area: int or float. This function is unit-agnostic, if you pass in values in terms\n",
    "    of square km or square miles the function will return a density in those units.\n",
    "\n",
    "    OUTPUT: \n",
    "    population_density: population / land_area. The population density of a particular area.\n",
    "    \"\"\"\n",
    "    return population / land_area"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lambda Expressions\n",
    "\n",
    "- used to create anonymous functions and in higher order functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This function \n",
    "def multiply(x, y):\n",
    "    return x * y\n",
    "\n",
    "# Is reduced to this\n",
    "multiply = lambda x, y: x * y # note the lambda keyword used to indicate this is a lambda expression"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Components of a Lambda Function\n",
    "1. The lambda keyword is used to indicate that this is a lambda expression.\n",
    "2. Following lambda are one or more arguments for the anonymous function separated by commas, followed by a colon :. Similar to functions, the way the arguments are named in a lambda expression is arbitrary.\n",
    "3. Last is an expression that is evaluated and returned in this function. This is a lot like an expression you might see as a return statement in a function.\n",
    "\n",
    "With this structure, lambda expressions aren’t ideal for complex functions, but can be very useful for short, simple functions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quiz: Lambda with Map\n",
    "**map()** is a higher-order built-in function that takes a function and iterable as inputs, and returns an iterator that applies the function to each element of the iterable. The code below uses map() to find the mean of each list in numbers to create the list averages. Give it a test run to see what happens.\n",
    "\n",
    "Rewrite this code to be more concise by replacing the mean function with a lambda expression defined within the call to map()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[57.0, 58.2, 50.6, 27.2]\n"
     ]
    }
   ],
   "source": [
    "numbers = [\n",
    "              [34, 63, 88, 71, 29],\n",
    "              [90, 78, 51, 27, 45],\n",
    "              [63, 37, 85, 46, 22],\n",
    "              [51, 22, 34, 11, 18]\n",
    "           ]\n",
    "\n",
    "# def mean(num_list):\n",
    "#     return sum(num_list) / len(num_list)\n",
    "\n",
    "averages = list(map(lambda x: sum(x) / len(x) , numbers))\n",
    "print(averages)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quiz: Lambda with Filter\n",
    "**filter()** is a higher-order built-in function that takes a function and iterable as inputs and returns an iterator with the elements from the iterable for which the function returns True. The code below uses filter() to get the names in cities that are fewer than 10 characters long to create the list short_cities. Give it a test run to see what happens.\n",
    "\n",
    "Rewrite this code to be more concise by replacing the is_short function with a lambda expression defined within the call to filter()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cities = [\"New York City\", \"Los Angeles\", \"Chicago\", \"Mountain View\", \"Denver\", \"Boston\"]\n",
    "\n",
    "# def is_short(name):\n",
    "#     return len(name) < 10\n",
    "\n",
    "short_cities = list(filter(lambda x: len(x) < 10, cities))\n",
    "print(short_cities)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Raw Input\n",
    "\n",
    "#### input and eval  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a name Gil\n",
      "Gil\n",
      "Enter a number 3\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "name = input(\"Enter a name \") # takes user input as a string\n",
    "print(name)\n",
    "\n",
    "number = int(input('Enter a number ')) # wrap in int or float if you want a number\n",
    "print(number)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter an expression 4\n",
      "4\n",
      "Enter another 3\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "# eval evaluates a string as a line of Python\n",
    "x = eval(input('Enter an expression '))\n",
    "print(x)\n",
    "y = eval(input('Enter another '))\n",
    "print(x % y)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quiz: Generate Messages\n",
    "Imagine you're a teacher who needs to send a message to each of your students reminding them of their missing assignments and grade in the class. You have each of their names, number of missing assignments, and grades on a spreadsheet and just have to insert them into placeholders in this message you came up with:\n",
    "\n",
    "    Hi [insert student name],\n",
    "\n",
    "    This is a reminder that you have [insert number of missing assignments] assignments left to submit before you can graduate. Your current grade is [insert current grade] and can increase to [insert potential grade] if you submit all assignments before the due date.\n",
    "\n",
    "You can just copy and paste this message to each student and manually insert the appropriate values each time, but instead you're going to write a program that does this for you.\n",
    "\n",
    "Write a script that does the following:\n",
    "\n",
    "1. Ask for user input 3 times. Once for a list of names, once for a list of missing assignment counts, and once for a list of grades. Use this input to create lists for names, assignments, and grades.\n",
    "2. Use a loop to print the message for each student with the correct values. The potential grade is simply the current grade added to two times the number of missing assignments.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-1-0cafca056a75>, line 3)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-1-0cafca056a75>\"\u001b[0;36m, line \u001b[0;32m3\u001b[0m\n\u001b[0;31m    names =  # get and process input for a list of names\u001b[0m\n\u001b[0m                                                        ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "#Template code for your script:\n",
    "\n",
    "names =  # get and process input for a list of names\n",
    "assignments =  # get and process input for a list of the number of assignments\n",
    "grades =  # get and process input for a list of grades\n",
    "\n",
    "# message string to be used for each student\n",
    "# HINT: use .format() with this string in your for loop\n",
    "message = \"Hi {},\\n\\nThis is a reminder that you have {} assignments left to \\\n",
    "submit before you can graduate. You're current grade is {} and can increase \\\n",
    "to {} if you submit all assignments before the due date.\\n\\n\"\n",
    "\n",
    "# write a for loop that iterates through each set of names, assignments, and grades to print each student's message\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution\n",
    "\n",
    "names = input(\"Enter names separated by commas: \").title().split(\",\")\n",
    "assignments = input(\"Enter assignment counts separated by commas: \").split(\",\")\n",
    "grades = input(\"Enter grades separated by commas: \").split(\",\")\n",
    "\n",
    "message = \"Hi {},\\n\\nThis is a reminder that you have {} assignments left to \\\n",
    "submit before you can graduate. You're current grade is {} and can increase \\\n",
    "to {} if you submit all assignments before the due date.\\n\\n\"\n",
    "\n",
    "for name, assignment, grade in zip(names, assignments, grades):\n",
    "    print(message.format(name, assignment, grade, int(grade) + int(assignment)*2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Errors and Exceptions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Syntax errors \n",
    "occur when Python can’t interpret our code, since we didn’t follow the correct syntax for Python. These are errors you’re likely to get when you make a typo, or you’re first starting to learn Python.\n",
    "eg. Missing quotation mark etc\n",
    "- Can be detected before runtime\n",
    "\n",
    "### Exceptions occur \n",
    "when unexpected things happen during execution of a program, even if the code is syntactically correct. There are different types of built-in exceptions in Python, and you can see which exception is thrown in the error message.\n",
    "ValueError...NameError...undefined variable etc..occurs during runtim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Handling Error\n",
    "\n",
    "#### Try Statement\n",
    "We can use try statements to handle exceptions. There are four clauses you can use (one more in addition to those shown in the video).\n",
    "\n",
    "- **try**: This is the only mandatory clause in a try statement. The code in this block is the first thing that Python runs in a try statement.\n",
    "- **except:** If Python runs into an exception while running the try block, it will jump to the except block that handles that exception.\n",
    "- **else:** If Python runs into no exceptions while running the try block, it will run the code in this block after running the try block.\n",
    "- **finally:** Before Python leaves this try statement, it will run the code in this finally block under any conditions, even if it's ending the program. E.g., if Python ran into an error while running code in the except or else block, this finally block will still be executed before stopping the program."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number 3\n",
      "\n",
      "Attempted Input\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    x = int(input('Enter a number '))\n",
    "except:\n",
    "    print('That\\s not a valid number')\n",
    "print('\\nAttempted Input')# goes onto next line after print error msg"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want user to keep entering until correct input.. use while loop and break when successful"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: r\n",
      "That\\s not a valid number\n",
      "\n",
      " attempted input\n",
      "Enter a number: 4\n"
     ]
    }
   ],
   "source": [
    "while True:\n",
    "    try:\n",
    "        x = int(input('Enter a number: '))\n",
    "        break\n",
    "    except:\n",
    "        print('That\\s not a valid number')\n",
    "    print('\\n attempted input') # won't print if good-try pun intended "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To always print something at end we use finally\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: r\n",
      "That\\s not a valid number\n",
      "\n",
      " attempted input\n",
      "Enter a number: 5\n",
      "\n",
      " attempted input\n"
     ]
    }
   ],
   "source": [
    "while True:\n",
    "    try:\n",
    "        x = int(input('Enter a number: '))\n",
    "        break\n",
    "    except:\n",
    "        print('That\\s not a valid number')\n",
    "    finally:\n",
    "        print('\\n attempted input') "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Specifying Exceptions\n",
    "We can actually specify which error we want to handle in an except block like this:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    # some code\n",
    "except ValueError:\n",
    "    # some code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, it catches the ValueError exception, but not other exceptions. If we want this handler to address more than one type of exception, we can include a parenthesized tuple after the except with the exceptions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    # some code\n",
    "except (ValueError, KeyboardInterrupt):\n",
    "    # some code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or, if we want to execute different blocks of code depending on the exception, you can have multiple except blocks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    # some code\n",
    "except ValueError:\n",
    "    # some code\n",
    "except KeyboardInterrupt:\n",
    "    # some code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accessing Error Messages\n",
    "When you handle an exception, you can still access its error message like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    # some code\n",
    "except ZeroDivisionError as e:\n",
    "   # some code\n",
    "   print(\"ZeroDivisionError occurred: {}\".format(e))\n",
    "    \n",
    "# print - ZeroDivisionError occurred: integer division or modulo by zero"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So you can still access error messages, even if you handle them to keep your program from crashing!\n",
    "\n",
    "If you don't have a specific error you're handling, you can still access the message like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    # some code\n",
    "except Exception as e:\n",
    "   # some code\n",
    "   print(\"Exception occurred: {}\".format(e))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reading and Writing files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Reading a file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello!!\n",
      "\n",
      "You've read the contents of this file!\n",
      "\n"
     ]
    }
   ],
   "source": [
    "f = open('my_text_file.txt', 'r') # I created a text file in the same folder..default mode if r = read only\n",
    "file_data = f.read()\n",
    "f.close()\n",
    "print(file_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### writing to a file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = open('my_text_file.txt', 'w')\n",
    "f.write(\"Hello there!\")\n",
    "f.close()\n",
    "## once open a file in write mode, anything it previoussly contained will be deleted\n",
    "## Use append if you want to add information to a file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## with\n",
    "\n",
    "Python provides a special syntax that auto-closes a file for you once you're finished using it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('my_path/my_file.txt', 'r') as f:\n",
    "    file_data = f.read()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This with keyword allows you to open a file, do operations on it, and automatically close it after the indented code is executed, in this case, reading from the file. Now, we don’t have to call f.close()! You can only access the file object, f, within this indented block."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calling the read Method with an Integer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the code you saw earlier, the call to f.read() had no arguments passed to it. This defaults to reading all the remainder of the file from its current position - the whole file. If you pass the read method an integer argument, it will read up to that number of characters, output all of them, and keep the 'window' at that position ready to read on."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**camelot.txt contains the following**\n",
    "\n",
    "We're the knights of the round table\n",
    "We dance whenever we're able"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We\n",
      "re the k\n",
      "nights of the round table We dance whenever we're able'\n",
      "\n"
     ]
    }
   ],
   "source": [
    "with open(\"camelot.txt\") as song:\n",
    "    print(song.read(2))\n",
    "    print(song.read(8))\n",
    "    print(song.read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each time we called read on the file with an integer argument, it read up to that number of characters, outputted them, and kept the 'window' at that position for the next call to read. This makes moving around in the open file a little tricky, as there aren't many landmarks to navigate by."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reading Line by Line\n",
    "\\ns in blocks of text are newline characters. The newline character marks the end of a line, and tells a program (such as a text editor) to go down to the next line. However, looking at the stream of characters in the file, \\n is just another character.\n",
    "\n",
    "Fortunately, Python knows that these are special characters and you can ask it to read one line at a time. Let's try it!\n",
    "\n",
    "readline()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Conveniently, Python will loop over the lines of a file using the syntax for line in file. I can use this to create a list of lines in the file. Because each line still has its newline character attached, I remove this using .strip()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[\"Were the knights of the round table We dance whenever we're able'\"]\n"
     ]
    }
   ],
   "source": [
    "camelot_lines = []\n",
    "with open(\"camelot.txt\") as f:\n",
    "    for line in f:\n",
    "        camelot_lines.append(line.strip())\n",
    "\n",
    "print(camelot_lines)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quiz: Flying Circus Cast List\n",
    "You're going to create a list of the actors who appeared in the television programme Monty Python's Flying Circus.\n",
    "\n",
    "Write a function called create_cast_list that takes a filename as input and returns a list of actors' names. It will be run on the file flying_circus_cast.txt (this information was collected from imdb.com). Each line of that file consists of an actor's name, a comma, and then some (messy) information about roles they played in the programme. You'll need to extract only the name and add it to a list. You might use the .split() method to process each line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Graham Chapman\n",
      "Eric Idle\n",
      "Terry Jones\n",
      "Michael Palin\n",
      "Terry Gilliam\n",
      "John Cleese\n",
      "Carol Cleveland\n",
      "Ian Davidson\n",
      "John Hughman\n",
      "The Fred Tomlinson Singers\n",
      "Connie Booth\n",
      "Bob Raymond\n",
      "Lyn Ashley\n",
      "Rita Davies\n",
      "Stanley Mason\n",
      "David Ballantyne\n",
      "Donna Reading\n",
      "Peter Brett\n",
      "Maureen Flanagan\n",
      "Katya Wyeth\n",
      "Frank Lester\n",
      "Neil Innes\n",
      "Dick Vosburgh\n",
      "Sandra Richards\n",
      "Julia Breck\n",
      "Nicki Howorth\n",
      "Jimmy Hill\n",
      "Barry Cryer\n",
      "Jeannette Wild\n",
      "Marjorie Wilde\n",
      "Marie Anderson\n",
      "Caron Gardner\n",
      "Nosher Powell\n",
      "Carolae Donoghue\n",
      "Vincent Wong\n",
      "Helena Clayton\n",
      "Nigel Jones\n",
      "Roy Gunson\n",
      "Daphne Davey\n",
      "Stenson Falke\n",
      "Alexander Curry\n",
      "Frank Williams\n",
      "Ralph Wood\n",
      "Rosalind Bailey\n",
      "Marion Mould\n",
      "Sheila Sands\n",
      "Richard Baker\n",
      "Douglas Adams\n",
      "Ewa Aulin\n",
      "Reginald Bosanquet\n",
      "Barbara Lindley\n",
      "Roy Brent\n",
      "Jonas Card\n",
      "Tony Christopher\n",
      "Beulah Hughes\n",
      "Peter Kodak\n",
      "Lulu\n",
      "Jay Neill\n",
      "Graham Skidmore\n",
      "Ringo Starr\n",
      "Fred Tomlinson\n",
      "David Hamilton\n",
      "Suzy Mandel\n",
      "Peter Woods\n"
     ]
    }
   ],
   "source": [
    "def create_cast_list(filename):\n",
    "    cast_list = []\n",
    "    #use with to open the file filename\n",
    "    #use the for loop syntax to process each line\n",
    "    #and add the actor name to cast_list\n",
    "    with open(filename) as f:\n",
    "        for line in f:\n",
    "            cast_list.append(line.split(\",\")[0])\n",
    "\n",
    "    return cast_list\n",
    "\n",
    "cast_list = create_cast_list('flying_circus_cast.txt')\n",
    "for actor in cast_list:\n",
    "    print(actor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Importing Local Scripts\n",
    "\n",
    "We can actually import Python code from other scripts, which is helpful if you are working on a bigger project where you want to organize your code into multiple files and reuse code in those files. If the Python script you want to import is in the same directory as your current script, you just type import followed by the name of the file, without the .py extension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import useful_functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's the standard convention for import statements to be written at the top of a Python script, each one on a separate line. This import statement creates a module object called useful_functions. Modules are just Python files that contain definitions and statements. To access objects from an imported module, you need to use dot notation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import useful_functions\n",
    "useful_functions.add_five([1, 2, 3, 4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using a main block\n",
    "\n",
    "To avoid running executable statements in a script when it's imported as a module in another script, include these lines in an if __name__ == \"__main__\" block. Or alternatively, include them in a function called main() and call this in the if main block.\n",
    "\n",
    "Whenever we run a script like this, Python actually sets a special built-in variable called __name__ for any module. When we run a script, Python recognizes this module as the main program, and sets the __name__ variable for this module to the string \"__main__\". For any modules that are imported in this script, this built-in __name__ variable is just set to the name of that module. Therefore, the condition if __name__ == \"__main__\"is just checking whether this module is the main program.\n",
    "\n",
    "Try It Out!\n",
    "\n",
    " Create these scripts in the same directory and run them in your terminal! Experiment with the if main block and accessing objects from the imported module!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Scores: [88, 92, 79, 93, 85]\n",
      "Original Mean: 87.4  New Mean: 92.4\n",
      "__main__\n",
      "useful_functions\n"
     ]
    }
   ],
   "source": [
    "# demo.py\n",
    "\n",
    "import useful_functions as uf\n",
    "\n",
    "scores = [88, 92, 79, 93, 85]\n",
    "\n",
    "mean = uf.mean(scores)\n",
    "curved = uf.add_five(scores)\n",
    "\n",
    "mean_c = uf.mean(curved)\n",
    "\n",
    "print(\"Scores:\", scores)\n",
    "print(\"Original Mean:\", mean, \" New Mean:\", mean_c)\n",
    "\n",
    "print(__name__)\n",
    "print(uf.__name__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# useful_functions.py\n",
    "\n",
    "def mean(num_list):\n",
    "    return sum(num_list) / len(num_list)\n",
    "\n",
    "def add_five(num_list):\n",
    "    return [n + 5 for n in num_list]\n",
    "\n",
    "def main():\n",
    "    print(\"Testing mean function\")\n",
    "    n_list = [34, 44, 23, 46, 12, 24]\n",
    "    correct_mean = 30.5\n",
    "    assert(mean(n_list) == correct_mean)\n",
    "\n",
    "    print(\"Testing add_five function\")\n",
    "    correct_list = [39, 49, 28, 51, 17, 29]\n",
    "    assert(add_five(n_list) == correct_list)\n",
    "\n",
    "    print(\"All tests passed!\")\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Standard Library\n",
    "\n",
    "Organised into modules which are simply files created by other people to make me into a very powerful programmer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24\n"
     ]
    }
   ],
   "source": [
    "## math\n",
    "import math\n",
    "print(math.factorial(4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Quiz: Password Generator\n",
    "Write a function called generate_password that selects three random words from the list of words word_list and concatenates them into a single string. Your function should not accept any arguments and should reference the global variab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "withoutwithoutvery\n"
     ]
    }
   ],
   "source": [
    "# Use an import statement at the top\n",
    "import random\n",
    "\n",
    "word_file = \"words.txt\"\n",
    "word_list = []\n",
    "\n",
    "#fill up the word_list\n",
    "with open(word_file,'r') as words:\n",
    "\tfor line in words:\n",
    "\t\t# remove white space and make everything lowercase\n",
    "\t\tword = line.strip().lower()\n",
    "\t\t# don't include words that are too long or too short\n",
    "\t\tif 3 < len(word) < 8:\n",
    "\t\t\tword_list.append(word)\n",
    "\n",
    "# Add your function generate_password here\n",
    "# It should return a string consisting of three random words \n",
    "# concatenated together without spaces\n",
    "def generate_password():\n",
    "    return random.choice(word_list) + random.choice(word_list) + random.choice(word_list)\n",
    "\n",
    "\n",
    "# test your function\n",
    "print(generate_password())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Techniques for Importing Modules\n",
    "\n",
    "There are other variants of import statements that are useful in different situations.\n",
    "\n",
    "1. To import an individual function or class from a module:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from module_name import object_name\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2. To import multiple individual objects from a module:\n",
    "To import multiple individual objects from a module:\n",
    "# 3. To rename a module:\n",
    "import module_name as new_name\n",
    "# 4. To import an object from a module and rename it:\n",
    "from module_name import object_name as new_name\n",
    "# 5. To import every object individually from a module (DO NOT DO THIS):\n",
    "from module_name import *\n",
    "# If you really want to use all of the objects from a module, use the standard import module_name statement instead and access each of the objects with the dot notation.\n",
    "# import module_name\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modules, Packages, and Names"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to manage the code better, modules in the Python Standard Library are split down into sub-modules that are contained within a package. A package is simply a module that contains sub-modules. A sub-module is specified with the usual dot notation.\n",
    "\n",
    "Modules that are submodules are specified by the package name and then the submodule name separated by a dot. You can import the submodule like this.\n",
    "\n",
    "import package_name.submodule_name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iterators And Generators\n",
    "\n",
    "Iterables are objects that can return one of their elements at a time, such as a list. Many of the built-in functions we’ve used so far, like 'enumerate,' return an iterator.\n",
    "\n",
    "An iterator is an object that represents a stream of data. This is different from a list, which is also an iterable, but is not an iterator because it is not a stream of data.\n",
    "\n",
    "Generators are a simple way to create iterators using functions. You can also define iterators using classes.\n",
    "\n",
    "Here is an example of a generator function called my_range, which produces an iterator that is a stream of numbers from 0 to (x - 1)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_range(x):\n",
    "    i = 0\n",
    "    while i < x:\n",
    "        yield i\n",
    "        i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that instead of using the return keyword, it uses yield. This allows the function to return values one at a time, and start where it left off each time it’s called. This yield keyword is what differentiates a generator from a typical function.\n",
    "\n",
    "Remember, since this returns an iterator, we can convert it to a list or iterate through it in a loop to view its contents. For example, this code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for x in my_range(5):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Why Generators?\n",
    "You may be wondering why we'd use generators over lists. Here’s an excerpt from a stack overflow page that addresses this:\n",
    "\n",
    "Generators are a lazy way to build iterables. They are useful when the fully realized list would not fit in memory, or when the cost to calculate each list element is high and you want to do it as late as possible. But they can only be iterated over once."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quiz: Implement my_enumerate\n",
    "Write your own generator function that works like the built-in function enumerate.\n",
    "\n",
    "Calling the function like this:\n",
    "\n",
    "lessons = [\"Why Python Programming\", \"Data Types and Operators\", \"Control Flow\", \"Functions\", \"Scripting\"]\n",
    "\n",
    "    for i, lesson in my_enumerate(lessons, 1):\n",
    "        print(\"Lesson {}: {}\".format(i, lesson))\n",
    "should output:\n",
    "\n",
    "    Lesson 1: Why Python Programming\n",
    "    Lesson 2: Data Types and Operators\n",
    "    Lesson 3: Control Flow\n",
    "    Lesson 4: Functions\n",
    "    Lesson 5: Scripting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lesson 1: Why Python Programming\n",
      "Lesson 2: Data Types and Operators\n",
      "Lesson 3: Control Flow\n",
      "Lesson 4: Functions\n",
      "Lesson 5: Scripting\n"
     ]
    }
   ],
   "source": [
    "lessons = [\"Why Python Programming\", \"Data Types and Operators\", \"Control Flow\", \"Functions\", \"Scripting\"]\n",
    "\n",
    "def my_enumerate(iterable, start=0):\n",
    "    count = start\n",
    "    for element in iterable:\n",
    "        yield count, element\n",
    "        count += 1\n",
    "\n",
    "for i, lesson in my_enumerate(lessons, 1):\n",
    "    print(\"Lesson {}: {}\".format(i, lesson))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quiz: Chunker\n",
    "If you have an iterable that is too large to fit in memory in full (e.g., when dealing with large files), being able to take and use chunks of it at a time can be very valuable.\n",
    "\n",
    "Implement a generator function, chunker, that takes in an iterable and yields a chunk of a specified size at a time.\n",
    "\n",
    "Calling the function like this:\n",
    "\n",
    "    for chunk in chunker(range(25), 4):\n",
    "        print(list(chunk))\n",
    "    should output:\n",
    "\n",
    "    [0, 1, 2, 3]\n",
    "    [4, 5, 6, 7]\n",
    "    [8, 9, 10, 11]\n",
    "    [12, 13, 14, 15]\n",
    "    [16, 17, 18, 19]\n",
    "    [20, 21, 22, 23]\n",
    "    [24]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3]\n",
      "[4, 5, 6, 7]\n",
      "[8, 9, 10, 11]\n",
      "[12, 13, 14, 15]\n",
      "[16, 17, 18, 19]\n",
      "[20, 21, 22, 23]\n",
      "[24]\n"
     ]
    }
   ],
   "source": [
    "def chunker(iterable, size):\n",
    "    \"\"\"Yield successive chunks from iterable of length size.\"\"\"\n",
    "    for i in range(0, len(iterable), size):\n",
    "        yield iterable[i:i + size]\n",
    "\n",
    "for chunk in chunker(range(25), 4):\n",
    "    print(list(chunk))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generator Expressions\n",
    "Here's a cool concept that combines generators and list comprehensions! You can actually create a generator in the same way you'd normally write a list comprehension, except with parentheses instead of square brackets. For example:\n",
    "\n",
    "sq_list = [x**2 for x in range(10)]  # this produces a list of squares\n",
    "\n",
    "sq_iterator = (x**2 for x in range(10))  # this produces an iterator of squares\n",
    "This can help you save time and create efficient code!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "sq_list = [x**2 for x in range(10)]  # this produces a list of squares\n",
    "\n",
    "sq_iterator = (x**2 for x in range(10))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The End"
   ]
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}