Chapter 5 - Lists.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapter 5: Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Data Processing with Python, a course for Communication and Information Sciences*\n",
    "\n",
    "<a href=mailto:s.wubben@tilburguniversity.edu>s.wubben@tilburguniversity.edu</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-------------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables and collections"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we have learned before, variables have one value in them. When we put a new value in the variable, the old value is overwritten. \n",
    "\n",
    "In this chapter we will have a first look at collections. A collection allows us to put many values in a single 'box'.\n",
    "A collection is nice because we can carry lots of values around in one convenient package. It is very straight forward to store a list of items as a collection. Not surprisingly, we call this a list.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "friends = [ 'Johh', 'Bob', 'Mary' ]\n",
    "stuff_to_pack = [ 'socks', 'shirt', 'toothbrush' ]\n",
    "print(friends)\n",
    "print (stuff_to_pack)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Lists are surrounded by square brackets and the elements in the list are separated by commas\n",
    "* A list element can be any Python object - even another list\n",
    "* A list can be empty\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#list of integers\n",
    "print( [1, 24, 76] )\n",
    "\n",
    "#list of strings\n",
    "print( ['red', 'yellow', 'blue'] )\n",
    "\n",
    "#mixed list\n",
    "print( ['red', 24, 98.6] )\n",
    "\n",
    "#list with a list included\n",
    "print( [ 1, [5, 6], 7] )\n",
    "\n",
    "#empty list\n",
    "print( [] )\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##Looking inside lists\n",
    "\n",
    "Python has a range of functions that operate on lists. We can easily get some simple calculations done with these functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "nums = [3, 41, 12, 9, 74, 15]\n",
    "print (len(nums))\n",
    "print (max(nums))\n",
    "print (min(nums))\n",
    "print (sum(nums))\n",
    "print (sum(nums)/len(nums))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember the example below? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "for i in [5, 4, 3, 2, 1] :\n",
    "    print(i)\n",
    "print('Blastoff!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists and definite loops go really well together. That's why we sneakily used lists earlier. With a loop we can easily access all the elements in a list, one element at a time! \n",
    "\n",
    "\n",
    "Lists and loops are best friends!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "friends = [ 'John', 'Bob', 'Mary' ]\n",
    "\n",
    "for buddy in friends:\n",
    "    print(\"Happy Halloween,\", buddy)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Every item in the list has its own index number. Do you remember how Python is similar to an elevator? We start counting at 0! The index for our friends list is as follows:\n",
    "\n",
    "\n",
    "John|Bob|Mary\n",
    "---|---\n",
    "0|1|2\n",
    "\n",
    "###Mutability\n",
    "\n",
    "Lists are mutable, which means that you can change the contents of a list, just as you can change the content of a variable. We can easily replace one friend with a new one:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "friends = [ 'John', 'Bob', 'Mary' ]\n",
    "print(friends[1])\n",
    "friends[1] = 'Billy'\n",
    "print (friends)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings\n",
    "A nice feature of Python is that we can read strings just like we do with lists. There is one important difference however: strings are immutable. This means we cannot change a part of a string like we can change an element of a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "hero = 'batman'\n",
    "#print first character\n",
    "print(hero[0])\n",
    "#but we cant change it:\n",
    "hero[0] = 'c'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "sentence = \"Python's name is derived from the television series Monty Python's Flying Circus.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Words are made up of characters, and so are strings in Python, like the string stored in the variable `sentence` in the block above. For the sentence above, it might seem more natural for humans to describe it as a series of words, rather than as a series of characters. Say we want to access the first word in our sentence. If we type in:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "first_word = sentence[0]\n",
    "print(first_word)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python only prints the first *character* of our sentence. (Think about this if you do not understand why.) We can transform our sentence into a `list` of words (represented by strings) using the `split()` function as follows: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "words = sentence.split(' ')\n",
    "print(words)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make sure that you understand the syntax of this code! Here, we apply the `split()` function to the variable `sentence` and we assign the result of the function (we call this the 'return value' of the function) to the new variable `words`.\n",
    "\n",
    "By default, the split() function in Python will split strings on the spaces between consecutive words and it will returns a list of words. However, we can pass an argument to `split()` that specifies explicitly the string we would like to split on. In the code block below, we will split a string on commas, instead of spaces. Do you get the syntax?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "fruitstring = \"banana,pear,apple\"\n",
    "fruitlist = fruitstring.split(\",\")\n",
    "print(fruitlist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The reverse of the `split()` function can be accomplished with `join()`, it turns a list into a string, with a specific 'delimiter' or the string you want to use to join the items."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "fruitlist = ['banana', 'pear', 'apple']\n",
    "delimiter = \",\"\n",
    "fruitstring = delimiter.join(fruitlist)\n",
    "print(fruitstring)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Excercise:** The above four lines can be accomplished in a single line if code, can you figure out how? (Tip: replace all variables by their values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# insert your oneliner here!\n",
    "print(\",\".join(['banana', 'pear', 'apple']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ``replace()``"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `replace()` function is another function which can be called on a string. It will replace all occurrences of a specified substring with another string. Consider the lines in the code block below - and mind the order in which you pass the arguments to the function!\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "text = \"You can not compare apples and pears\"\n",
    "text2 = text.replace(\"pears\", \"oranges\")\n",
    "text = text.replace(\"not \", \"\")\n",
    "print(text)\n",
    "print (text2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has two functions for changing the case of a string. `lower()` converts a string to lowercase characters and `upper()` returns an uppercased version:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "my_string = \"AllCaps\"\n",
    "print(my_string)\n",
    "my_string_upper = my_string.upper()\n",
    "print(my_string_upper)\n",
    "my_string_lower = my_string.lower()\n",
    "print(my_string_lower)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:**\n",
    "-  Can you come up with your own sentence `my_sentence` and split it into words along spaces? Print the new list of words.\n",
    "-  You can recognize functions because they are always followed by (round brackets). Apart from the `split()` function, we already encountered other functions, also in the previous chapter. Which ones? Can you describe their functionality? Are there any differences in terms of syntax when you compare these to `split()`?\n",
    "-  Is there a difference in length between the variables `sentence` and `words`? (Use functions to find this out!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# your code goes here..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In many ways, list variables are very similar to strings. We can for example access its components using indexes and we can use slice indexes to access parts of the list. Let's try this out.\n",
    "\n",
    "Write a small program that defines a variable `first_word` and assign to it the first word of our word list `words` from above. Do the same for the fifth word, the last word and the last but one word. Also, try to extract a slice from `words` and isolate the string of words between `derived` and `Flying` (the slice should not include `derived` and `Flying`). Also, make a slice of words that is identical to the title of the television series in `words`.   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# insert your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##List operations\n",
    "\n",
    "A `list` acts like some kind of container where we can store all kinds of information. We can access a list using indexes and slices. We can also add new items to a list. For that you use the function `append()`. Let's see how that works. \n",
    "\n",
    "###``append()``\n",
    "Say we want to keep a list of all our good reads. We first declare an empty list using square brackets. Next, we add some good books to the list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# start with an empty list\n",
    "good_reads = []\n",
    "good_reads.append(\"The Hunger games\")\n",
    "print(good_reads)\n",
    "good_reads.append(\"A Clockwork Orange\")\n",
    "print(good_reads)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Do you get the syntax that goes with the ``append()`` function? The list we wish to append the item to goes first and we join the ``append()`` function to this list using a dot (`.`). In between the round brackets that go with the function name, we place the actual string that we wish to add to the list. We call such a input value an 'argument' or a 'parameter' that we 'pass' to a function. Next, the function will return a 'return value'. Make sure that you are familiar with this terminology because you will often come across such terms when you look for help online!\n",
    "\n",
    "Now, if for some reason we don't like a particular book anymore, we can change it as follows using the old item's index:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "good_reads[0] = \"Pride and Prejudice\"\n",
    "print(good_reads)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you see, it is no problem to reset or update an individual item in a list. This is different, however, for strings. Run the following code in which we try to change a single character in a string. This will raise an error: this is your computer signalling that something is wrong. This is because `strings` (and some other types) are *immutable*. That means that they cannot be changed using the index, as opposed to `list`s which *are* mutable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "name = \"Bonny\"\n",
    "print(name)\n",
    "list_chars = list(name)\n",
    "print(list_chars)\n",
    "list_chars[3] = \"t\"\n",
    "print(list_chars)\n",
    "delimiter = \"\"\n",
    "print(delimiter.join(list_chars))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Here's another small exercise! Add two new titles to the list of `good_reads`. Then, try to change the title of the second book in our good reads collection:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# insert your code here\n",
    "good_reads.append(\"A Game of Thrones\")\n",
    "good_reads[1]=\"1984\"\n",
    "print(good_reads)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists are a really powerful way of dealing with your data in Python. Let's explore some other ways in which we can manipulate lists."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ``remove()``"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's assume our good read collection has grown a lot and we would like to remove some of the books from the list. Python provides the function `remove()` that you can call on a list and which takes as argument the item we would like to remove. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "good_reads = [\"The Hunger games\", \"A Clockwork Orange\", \n",
    "             \"Pride and Prejudice\", \"Water for Elephants\", \"Illias\"]\n",
    "print(good_reads)\n",
    "good_reads.remove(\"Water for Elephants\")\n",
    "print(good_reads)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we try to remove a book that is not in our collection, Python raises an error to signal that something is wrong."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "good_reads.remove(\"White Oleander\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note, however, that `remove()` will only delete the *first* item in the list that is identical to the argument which you passed to the function. Execute the code in the block below and you will see that only the first instance of \"Pride and Prejudice\" gets deleted."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "good_reads = [\"The Hunger games\", \"A Clockwork Orange\", \n",
    "             \"Pride and Prejudice\", \"Water for Elephants\", \"Pride and Prejudice\"]\n",
    "good_reads.remove(\"Pride and Prejudice\")\n",
    "print(good_reads)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just as with strings, we can concatenate two lists using the `+` operator. Here is an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# first we specify two lists of strings:\n",
    "good_reads = [\"The Hunger games\", \"A Clockwork Orange\", \n",
    "              \"Pride and Prejudice\", \"Water for Elephants\",\n",
    "              \"The Shadow of the Wind\", \"Bel Canto\"]\n",
    "bad_reads = [\"Fifty Shades of Grey\", \"Twilight\"]\n",
    "\n",
    "# then we combine them\n",
    "all_reads = good_reads + bad_reads\n",
    "print(all_reads)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ``sort()``"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is always nice to organise your bookshelf. We can sort our collection alphabetically with the following expression:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "good_reads.append(\"lord of the rings\")\n",
    "good_reads.append(\"a clockwork orange\")\n",
    "good_reads.sort()\n",
    "print(good_reads)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### An overview of list operations\n",
    "\n",
    "There are many more operations which we can perform on lists. Here is an overview of some of them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#define some lists and variables\n",
    "a = [1,2,3]\n",
    "b = 4\n",
    "c = [5,6,7]\n",
    "x = 1\n",
    "\n",
    "#do some operations \n",
    "a.append(b)     # Add item b to the end of a\n",
    "a.extend(c)     # Add the elements of list c at the end of a\n",
    "a.insert(i,b)   # Insert item b at position i\n",
    "a.pop(i)        # Remove from a the i'th element and return it. If i is not specified, remove the last element\n",
    "a.index(x)      # Return the index of the first element of a with value x. Error if it does not exist\n",
    "a.count(x)      # Return how often value x is found in a\n",
    "a.remove(x)     # Remove from a the first element with value x. Error if it does not exist\n",
    "a.sort()        # Sort the elements of list a\n",
    "a.reverse()     # Reverses list a (no return value!)\n",
    "\n",
    "print (a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###Slicing lists\n",
    "\n",
    "You can access subsections of a list using slices. In the slice the indexes of the items you want to access are defined.\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a = ['red','green','yellow','orange','blue','pink']\n",
    "print(a)\n",
    "b = a[1:3]\n",
    "c = a[:3]\n",
    "d = a[3:]\n",
    "print(b, c, d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Nested lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A list can contain all kinds of data types, such as integers and even lists! Do you understand what is happening in the following example? Have a close look at the square brackets used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "nested_list = [[1, 2, 3, 4], [5, 6, 7, 8]]\n",
    "print(nested_list[0])\n",
    "print(nested_list[0][0])\n",
    "print(nested_list[1][2])\n",
    "print(nested_list[0][:-2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can traverse an multidimensional list by using nested loops:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "nested_list = [['dragon','troll','ogre'],['elf','dwarf','hobbit'],['wizard','witch']]\n",
    "\n",
    "for l in nested_list:\n",
    "    for i in l:\n",
    "        print (i)\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can put nested lists to use to enhance our good read collection with a score for every book we have. An entry in our collection will consist of a score within the range of `1` and `10` and the title of our book. The first element is the title; the second the score `[title, score]`. We initialize an empty list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "good_reads = []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And add two books to it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "good_reads.append([\"Pride and Prejudice\", 8])\n",
    "good_reads.append([\"A Clockwork Orange\", 9])\n",
    "print (good_reads)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##Tuples\n",
    "A data structure similar to a list is a tuple. A tuple can be used to group any number of items into a single compound value. We have already used tuples to retrieve multiple values from a function.\n",
    "Tuples consist of comma separated values and are normally enclosed in round brackets ( )."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "year_born = (\"Paris Hilton\", 1981)\n",
    "print (year_born)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can access the individual items in a tuple but other than lists, tuples are immutable!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#works fine\n",
    "print (year_born[1])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#produces error\n",
    "year_born[0] =\"Natalie Portman\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can pack and unpack variables into tuples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "b = (\"Bob\", 19, \"CS\")\n",
    "(name, age, studies) = b  \n",
    "print (name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a = 1\n",
    "b = 0\n",
    "(a,b) = (b,a)\n",
    "print (a,b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What we have learnt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To finish this section, here is an overview of the new concepts you have learnt. Go through them and make sure you understand them all.\n",
    "\n",
    "-  lists\n",
    "-  nested lists\n",
    "-  *mutable* versus *immutable*\n",
    "- string operations\n",
    "- tuples\n",
    "-  `.split()` vs. `.join()`\n",
    "-  `.append()`\n",
    "-  `.remove()`\n",
    "-  `.sort()`\n",
    "-  `.upper()` vs. `.lower()`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Exercise 1:** Update the `good_reads` collection with some of your own books and give them all a score and a publication year by nesting lists. Can you print out the score you gave to the first book in the list? And the publication year of the third item in your list? (Hint: you can pile up indexes using square brackets!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# insert your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Exercise 2:** Consider the following strings `sentence1 = \"Bert and Ernie are good friends\"` and `sentence2 = \"Bonny and Clyde are famous criminals\"`. Split these strings into words and create the following strings via list manipulation: `sentence3 = \"Bert and Ernie are famous criminals\"` and `sentence4=\"Bonny+and+Clyde+are+good+friends\"` (mind the plus signs!)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# sentences"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Exercise 3:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "text = \"It is often still possible to understand text even if all vowels are removed\"\n",
    "# insert your code here.. I suppose it's obvious what we want you to do ;-)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-----------------------------------------------------------------\n",
    "\n",
    "You've reached the end of Chapter 5! "
   ]
  }
 ],
 "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.4.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}