part-4.ipynb

{
 "metadata": {
  "name": "",
  "signature": "sha256:c41c7b2462d1eccc5d63748331ca0f9ee5635e45f1f51c325d9a923cc48cc7ad"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Let's learn more cool Python stuff."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## List Comprehensions\n",
      "\n",
      "Now we're going to learn about list comprehensions.\n",
      "\n",
      "A list comprehension is kind of like a reverse for-loop.  It makes it easy to do operations on elements in a list and return a new list."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Say we have a list of numbers:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "my_favorite_numbers = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Now let's make a new list that contains a square of every number in our list."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "squared_numbers = []\n",
      "for n in my_favorite_numbers:\n",
      "    squared_numbers.append(n * n)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "squared_numbers"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "**Stop for questions?:** Does this look familiar?  Any questions about this?"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Now let's do the same thing by using a list comprehension instead:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "squared_numbers = [n * n for n in my_favorite_numbers]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "squared_numbers"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Note how our list comprehension is written within the brackets: The for-loop statement is written at the end whereas the action inside of the for-loop is written first: n * n"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Let's revisit a problem we've already solved in Danny's lecture on list:\n",
      "\n",
      "Pick every name from a list that begins with a vowel.\n",
      "\n",
      "We started with a list of names first:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "names = [\"Danny\", \"Audrey\", \"Rise\", \"Alain\"]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Then we filtered names like this:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "vowel_names = []\n",
      "for name in names:\n",
      "    if name[0] in \"AEIOU\":\n",
      "        vowel_names.append(name)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "vowel_names"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Here's another way to grab all names starting with a vowel, using list comprehensions:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "vowel_names = [name for name in names if name[0] in \"AEIOU\"]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "vowel_names"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Dictionaries\n",
      "\n",
      "Unlike lists, dictionaries are indexed by keys.  Dictionaries can be used to represent unordered key-value pairs.  Keys are unique and are used for looking up values assigned to them.\n",
      "\n",
      "Let's make a Spanish to English translator.  We'll ignore grammar and just translate word-by-word for now."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "words = {\n",
      "    'gato': \"cat\",\n",
      "    'casa': \"house\",\n",
      "    'esta': \"is\",\n",
      "    'en': \"in\",\n",
      "    'el': \"the\",\n",
      "    'la': \"the\",\n",
      "}"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "words['gato']"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Similar to lists and strings, you can check whether a dictionary contains a given key."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "'gato' in words"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "We can also check how many key-value pairs are in our dictionary:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "len(words)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Strings have a split method which we can use to split strings with spaces into a list of words."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "sentence = \"el gato esta en la casa\"\n",
      "sentence_words = sentence.split()\n",
      "sentence_words"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Let's translate each word and save them in the list called translated_words. We'll generate this list by using a list comprehension."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "translated_words = [print(words[spanish_word]) for spanish_word in sentence_words]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "translated_words"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "We've almost made a translated sentence!  Let's join our new list of words back together with spaces in between each word."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "translated_sentence = \" \".join(translated_words)\n",
      "translated_sentence"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Let's put this all together into a function:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "words = {\n",
      "    'gato': \"cat\",\n",
      "    'perro': \"dog\",\n",
      "    'casa': \"house\",\n",
      "    'burrito': \"burrito\",\n",
      "    'verde': \"green\",\n",
      "    'comio': \"ate\",\n",
      "    'esta': \"is\",\n",
      "    'en': \"in\",\n",
      "    'el': \"the\",\n",
      "    'la': \"the\",\n",
      "}\n",
      "\n",
      "def translate(sentence):\n",
      "    spanish_words = sentence.split()\n",
      "    english_words = []\n",
      "    for w in spanish_words:\n",
      "        english_words.append(words[w])\n",
      "    return \" \".join(english_words)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 2
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "translate(\"el perro comio el burrito verde\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "translate(\"el burrito comio el perro verde\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "translate(\"el gato comio la casa\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Now let's make the words dictionary a Spain Spanish and Mexican Spanish to English dictionary.  We'll start by adding a few keys and values."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "words['patatas'] = 'potatoes'\n",
      "words['papas'] = 'potatoes'\n",
      "words['zumo'] = 'juice'\n",
      "words['jugo'] = 'juice'\n",
      "words['y'] = 'and'\n",
      "words['comio'] = 'ate'\n",
      "words['bebi\u00f3'] = 'drank'\n",
      "words['las'] = 'the'\n",
      "words['galletas'] = 'cookies'\n",
      "words['papas-fritas'] = 'french fries'\n",
      "words['patatas-fritas'] = 'french fries'"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 17
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Mexican Spanish to English translation:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "translate(\"el perro bebi\u00f3 el jugo y comio las papas\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 8,
       "text": [
        "'the dog drank the juice and ate the potatoes'"
       ]
      }
     ],
     "prompt_number": 8
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Spain Spanish to English translation:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "translate(\"el perro bebi\u00f3 el zumo y comio las patatas\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 11,
       "text": [
        "'the dog drank the juice and ate the potatoes'"
       ]
      }
     ],
     "prompt_number": 11
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "To illustrate a few more dictionary concepts, let's convert our dictionary to Span Spanish to British English."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#remove the Mexican Spanish key, values:\n",
      "del words['papas']\n",
      "del words['jugo']\n",
      "del words['papas-fritas']"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 18
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#change the values from English to British English:\n",
      "words['galletas'] = 'bisquits'\n",
      "words['patatas-fritas'] = 'chips'"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 22
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "translate(\"el perro bebi\u00f3 el zumo y comio las patatas-fritas y las galletas\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 25,
       "text": [
        "'the dog drank the juice and ate the chips and the bisquits'"
       ]
      }
     ],
     "prompt_number": 25
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "It's also possible to loop through the keys and values of a dictionary using the items method.\n",
      "Let's loop through the words dictionary and see how this works:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for key, value in words.items():\n",
      "    print(key, value)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "**Extra Credit:** Try using a list comprehension in the translate function.\n",
      "\n",
      "**Note:** Typing out the exercises for the next section, \"Sets\",  is optional. If your brain is melting, feel free to sit back, relax, and enjoy the rest of the lecture."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Sets\n",
      "\n",
      "Sets are unordered collections of distinct items.  Lists can have duplicates of the same item, but sets only store one copy.\n",
      "\n",
      "Let's say we want to make a roster of people who have RSVPed to our birthday party.  If someone RSVPs twice we don't want them to show up in our roster twice.  Let's use a set!"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "party_roster = {\"Jessica\", \"Tom\", \"Alice\"}\n",
      "party_roster"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Notice how we used curly braces around our set (just like we did for dictionaries)?  What happens if we want to represent an empty set?"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "empty_dictionary = {}\n",
      "type(empty_dictionary)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "empty_set = set()\n",
      "type(empty_set)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Our friend Jeremy just RSVPed, let's add him to our set too:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "party_roster.add(\"Jeremy\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "We can check for size and membership of sets and loop over them just like with sets, strings, and dictionaries."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\"Jessica\" in party_roster"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\"Bill\" in party_roster"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "len(party_roster)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Our party is a potluck.  Everyone is supposed to bring a dinner dish or a dessert.  Let's make sets for everyone bringing a dish and everyone bringing a dessert."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "bringing_dish = {\"Jessica\", \"Jeremy\"}\n",
      "bringing_dessert = {\"Alice\", \"Jeremy\"}"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Sets allow us to use set operations from math to find the union, intersection, difference, and symmetric difference between sets.  Let's try it out:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "bringing_dish_or_dessert = bringing_dish.union(bringing_dessert)\n",
      "bringing_dish_and_dessert = bringing_dish.intersection(bringing_dessert)\n",
      "bringing_just_one_item = bringing_dish.symmetric_difference(bringing_dessert)\n",
      "not_bringing_food = party_roster.difference(bringing_dish_or_dessert)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(bringing_dish_or_dessert)\n",
      "print(bringing_dish_and_dessert)\n",
      "print(bringing_just_one_item)\n",
      "print(not_bringing_food)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    }
   ],
   "metadata": {}
  }
 ]
}