Lab1_Python_for_MBA.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "language_info": {
      "name": "python"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/anmolchaure/advanced_analytics/blob/main/Lab1_Python_for_MBA.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Chapter 1: Getting started"
      ],
      "metadata": {
        "id": "23brZgAud068"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "40T1F5lxd06_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Ready, set, GO!\")"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ready, set, GO!\n"
          ]
        }
      ],
      "metadata": {
        "id": "w36UWFCJd06_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8f186a5e-077c-4389-a252-aa86f79a00ec"
      },
      "execution_count": 1
    },
    {
      "cell_type": "markdown",
      "source": [
        "Everyone can learn how to program and the best way to learn is by doing.\n",
        "\n",
        "\n",
        " Click any block of code in this tutorial, such as the one above, and press ctrl+enter to run it.\n",
        "\n",
        "\n",
        "\n",
        " Let's begin right away and write our first little program!  "
      ],
      "metadata": {
        "id": "h4jU0ivEd07A"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "----------"
      ],
      "metadata": {
        "id": "MGoMwsP5d07A"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "####Quiz!"
      ],
      "metadata": {
        "id": "Cm2g3QGNd07A"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "In the code box below, write a simple program that calculates how many minutes there are in seven weeks."
      ],
      "metadata": {
        "id": "08aytlX4d07A"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# insert your code here"
      ],
      "outputs": [],
      "metadata": {
        "id": "lglemUMhd07A"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "-----------"
      ],
      "metadata": {
        "id": "sGTC6OPZd07B"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Great! You have written your first little program and you've done it without any help! So, can we now go beyond using our programming language as a simple calculator? Before we ask you to write another program, we will first have to explain something about `assignment'.\n",
        "\n",
        "We can assign values to variables using the `=` operator. A variable is just a name we give to a particular value, you can imagine it as a box you put a certain value into, and on which you write a name with a black marker. The following code block contains two operations. First, we assign the value 2 to the name `x`. After that `x` will hold the value 2. You might say Python stored the value 2 in `x`. Finally we print the value using the `print()` command."
      ],
      "metadata": {
        "id": "k7rDoiJmd07B"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = 2\n",
        "print(x)"
      ],
      "outputs": [],
      "metadata": {
        "id": "odRYIBPMd07B"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now that we stored the value 2 in `x`, we can use the variable `x` to do things like the following:"
      ],
      "metadata": {
        "id": "ZaRuqKFbd07B"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(x * x)\n",
        "print(x == x)\n",
        "print(x > 6)"
      ],
      "outputs": [],
      "metadata": {
        "id": "0hEEW3Odd07B"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "Can you figure out what is happening here?\n",
        "\n",
        "Variables are not just numbers. They can also be text. These are called strings. For example:"
      ],
      "metadata": {
        "id": "EmCXVkvZd07B"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "book = \"The Lord of the Flies\"\n",
        "print(book)"
      ],
      "outputs": [],
      "metadata": {
        "id": "-Ipu-w-2d07B"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "A string in Python must be enclosed with quotes (either single or double quotes). Without those quotes Python thinks its dealing with variables that have been defined earlier. `book` is a variable to which we assign the string `\"The Lord of the Flies\"`, but that same string is not a variable but a value!\n",
        "\n",
        "Variable names can be chosen arbitrarily. *We* give a certain value a name, and we are free to pick one to our liking. It is, however, recommended to use senseful names as we will use the variable names in our code directly and not the values they hold."
      ],
      "metadata": {
        "id": "5r19brz4d07B"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# not recommended...\n",
        "banana = \"The Lord of the Flies\"\n",
        "print(banana)"
      ],
      "outputs": [],
      "metadata": {
        "id": "DXHltGsCd07B"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "You are free to use the name `banana` to hold the title `\"The Lord of the Flies\"` but you will agree that this naming is not transparent.\n",
        "\n",
        "Variables can vary and we can update our variables. Say we have counted how many books we have in our office:"
      ],
      "metadata": {
        "id": "0ITq70nzd07B"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "number_of_books = 100"
      ],
      "outputs": [],
      "metadata": {
        "id": "wWJ5tODAd07B"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "Then, when we obtain a new book, we can update the number of books accordingly:"
      ],
      "metadata": {
        "id": "QKFcXf5Xd07B"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "number_of_books = number_of_books + 1\n",
        "print(number_of_books)"
      ],
      "outputs": [],
      "metadata": {
        "id": "Z1VW9D3Sd07B"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "Updates like these happen a lot. Python therefore provides a shortcut and you can write the same thing using `+=`:"
      ],
      "metadata": {
        "id": "aBuIzursd07B"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "number_of_books += 5\n",
        "print(number_of_books)"
      ],
      "outputs": [],
      "metadata": {
        "id": "wINoWr1Od07B"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "For now the final interesting thing we would like to mention about variables is that we can assign the value of one variable to another variable. We will explain more about this later on, but here you just need to understand the basic mechanism. Before you evaluate the following code block, can you predict what Python will print?"
      ],
      "metadata": {
        "id": "-0rQgzQSd07C"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "book = \"The Lord of the Flies\"\n",
        "reading = book\n",
        "print(reading)"
      ],
      "outputs": [],
      "metadata": {
        "id": "DINqLq6yd07C"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "----------"
      ],
      "metadata": {
        "id": "gibF10y2d07C"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "####Quiz!"
      ],
      "metadata": {
        "id": "YisFkkDwd07C"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now that you understand all about assigning values to variables, it is time for our second programming quiz. We want you to write some code that defines a variable, *name*, and assign to it a string that is your name. If your first name is shorter than 5 characters, use your last name. If your last name is also shorter than 5 characters, use the combination of you first and last name."
      ],
      "metadata": {
        "id": "3s752PUsd07C"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# insert your code here\n",
        "print(name)"
      ],
      "outputs": [],
      "metadata": {
        "id": "QZ69z8Ygd07C"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "--------------"
      ],
      "metadata": {
        "id": "jwEUPwdvd07C"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#####What we have learnt"
      ],
      "metadata": {
        "id": "VgscNNZkd07C"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "To finish this section, here is an overview of the concepts you have learnt. Go through the list and make sure you understand all the concepts.\n",
        "\n",
        "-  variable\n",
        "-  value\n",
        "-  assignment to variables\n",
        "-  difference between variables and values\n",
        "-  strings\n",
        "-  integers\n",
        "-  varying variables"
      ],
      "metadata": {
        "id": "0asFmP0Jd07C"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "------"
      ],
      "metadata": {
        "id": "YxmRwkmNd07C"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##String manipulation"
      ],
      "metadata": {
        "id": "mI02gnZWd07C"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Many disciplines within the humanities work on texts. Quite naturally programming for the humanities will focus a lot on manipulating texts. In the last quiz you were asked to define a variable that points to a string that represents your name. We have already seen some basic arithmetic in our very first calculation. Not only numbers, but also strings can be added, or, more precisely, *concatenated*, together as well:"
      ],
      "metadata": {
        "id": "d056TNled07C"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "book = \"The Lord of the Flies\"\n",
        "print(name + \" likes \" + book + \"?\")"
      ],
      "outputs": [],
      "metadata": {
        "id": "iN2VJszAd07D"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "This string consists of a number of characters. We can access the individual characters with the help of `indexing`. For example, to find only the first letter of your name, you can type in:"
      ],
      "metadata": {
        "id": "p5Mcgovnd07D"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "first_letter = name[0]\n",
        "print(first_letter)"
      ],
      "outputs": [],
      "metadata": {
        "id": "DZkjKQBtd07D"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "Notice that to access the first letter, we use the index `0`. This might seem odd, but just remember that indexes in Python start at zero."
      ],
      "metadata": {
        "id": "MJe68jAsd07D"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "----------"
      ],
      "metadata": {
        "id": "czKKA4Vld07D"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "####Quiz!"
      ],
      "metadata": {
        "id": "TzfYfWZ-d07D"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now, if you know the length of your name you can ask for the last letter of your name:"
      ],
      "metadata": {
        "id": "aDfBV9g7d07D"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "last_letter = name[# fill in the last index of your name (tip indexes start at 0)]\n",
        "print(last_letter)"
      ],
      "outputs": [],
      "metadata": {
        "id": "awBJUXLgd07D"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "---------"
      ],
      "metadata": {
        "id": "JPqFM4hId07D"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "It is rather inconvenient having to know how long our strings are if we want to find out what its last letter is. Python provides a simple way of accessing a string from the rear:"
      ],
      "metadata": {
        "id": "ittcLhfed07D"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "last_letter = name[-1]\n",
        "print(last_letter)"
      ],
      "outputs": [],
      "metadata": {
        "id": "LR1Jjxl8d07D"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "Alternatively, there is the function `len()` which returns the length of a string:"
      ],
      "metadata": {
        "id": "nenNzz7Ud07D"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(len(name))"
      ],
      "outputs": [],
      "metadata": {
        "id": "E0aeTufCd07E"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "Do you understand the following?"
      ],
      "metadata": {
        "id": "yEOdy2SLd07E"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(name[len(name)-1])"
      ],
      "outputs": [],
      "metadata": {
        "id": "Vk3Ti275d07E"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "---------"
      ],
      "metadata": {
        "id": "XvBqLI6Ud07E"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "####Quiz!"
      ],
      "metadata": {
        "id": "NRtJVqzhd07E"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now can you write some code that defines a variable `but_last_letter` and assign to it the second-to-last letter of your name?"
      ],
      "metadata": {
        "id": "RBzj0QaXd07E"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "but_last_letter = # insert your code here\n",
        "print(but_last_letter)"
      ],
      "outputs": [],
      "metadata": {
        "id": "61zkMzAzd07E"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "------"
      ],
      "metadata": {
        "id": "suplCNdhd07E"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "You're starting to become a real expert in indexing strings. Now what if we would like to find out what the last two or three letters of our name are? In Python we can use so-called slice-indexes or slices for short. To find the first two letters of our name we type in:"
      ],
      "metadata": {
        "id": "e5QiRTiud07E"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "first_two_letters = name[0:2]\n",
        "print(first_two_letters)"
      ],
      "outputs": [],
      "metadata": {
        "id": "B4h-pZWCd07E"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `0` index is optional, so we could just as well type in `name[:2]`. This says take all characters of name until you reach index 2. We can also start at index 2 and leave the end index unspecified:"
      ],
      "metadata": {
        "id": "EbhRVgiHd07F"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "without_first_two_letters = name[2:]"
      ],
      "outputs": [],
      "metadata": {
        "id": "TiaUg4Hfd07F"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "Because we did not specify the end index, Python continues until it reaches the end of our string. If we would like to find out what the last two letters of our name are, we can type in:"
      ],
      "metadata": {
        "id": "sXBwiTJmd07F"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "last_two_letters = name[-2:]\n",
        "print(last_two_letters)"
      ],
      "outputs": [],
      "metadata": {
        "id": "hQ5_Rrtbd07F"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "Take a look at the following picture. Do you fully understand it?\n",
        "<div style=\"float: center;\"><img style=\"float: center;\" src=\"http://www.nltk.org/images/string-slicing.png\" align=center /></div>"
      ],
      "metadata": {
        "id": "k7GeAcY4d07F"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "-------"
      ],
      "metadata": {
        "id": "dh744Ajhd07F"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "####Quiz!"
      ],
      "metadata": {
        "id": "RgMAF4_Td07F"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Can you define a variable `middle_letters` and assign to it all letters of your name except for the first two and the last two?"
      ],
      "metadata": {
        "id": "C5-yOwYcd07F"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "middle_letters = # insert your code here\n",
        "print(middle_letters)"
      ],
      "outputs": [],
      "metadata": {
        "id": "EmxYGHz-d07F"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "Given the following two words, can you write code that prints out the word *humanities* using only slicing and concatenation? (So, no quotes are allowed in your code.)"
      ],
      "metadata": {
        "id": "AJLlgg1Id07F"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "word1 = \"human\"\n",
        "word2 = \"opportunities\"\n",
        "# insert your code here"
      ],
      "outputs": [],
      "metadata": {
        "id": "q_K2noyKd07G"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "----------"
      ],
      "metadata": {
        "id": "7nHAX8-wd07G"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#####What we have learnt"
      ],
      "metadata": {
        "id": "CknRy6-Sd07G"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "To finish this section, here is an overview of what we have learnt. Go through the list and make sure you understand all the concepts.\n",
        "\n",
        "-  concatenation (e.g. addition of strings)\n",
        "-  indexing\n",
        "-  slicing\n",
        "-  `len()`"
      ],
      "metadata": {
        "id": "6_KSgP_Cd07G"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "-------"
      ],
      "metadata": {
        "id": "ljDsTQhPd07G"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Lists"
      ],
      "metadata": {
        "id": "8lu5DMmtd07G"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Consider the sentence below:"
      ],
      "metadata": {
        "id": "bzVBhowMd07G"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sentence = \"Python's name is derived from the television series Monty Python's Flying Circus.\""
      ],
      "outputs": [],
      "metadata": {
        "id": "-KQbpCtid07G"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "Words are made up of characters, and so are string objects in Python. As we will see, it is always to be prefered to represent our data as naturally as possible. Now for the sentence above, it seems more natural to describe it in terms of words than in terms of characters. Say we want to access the first word in our sentence. If we type in:"
      ],
      "metadata": {
        "id": "qI0ehaX_d07H"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "first_word = sentence[0]\n",
        "print(first_word)"
      ],
      "outputs": [],
      "metadata": {
        "id": "VqlvbXded07H"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "Python only prints the first letter 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:"
      ],
      "metadata": {
        "id": "6Wfpsfl9d07H"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "words = sentence.split()\n",
        "print(words)"
      ],
      "outputs": [],
      "metadata": {
        "id": "x9gwPx2Pd07H"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "By issuing the function split on our sentence, Python splits the sentence on spaces and returns a list of words. In many ways a list functions like a string. We can access all of its components using indexes and we can use slice indexes to access parts of the list. Let's try it!"
      ],
      "metadata": {
        "id": "WbX6A9wTd07H"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "--------"
      ],
      "metadata": {
        "id": "3D0eA24vd07H"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "####Quiz!"
      ],
      "metadata": {
        "id": "tiWiZFmyd07H"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Write a small program that defines a variable `first_word` and assign to it the first word of our word list. Play around a little with the indexes to see if you really understand how it works."
      ],
      "metadata": {
        "id": "XNlculOWd07H"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "first_word = # insert your code here\n",
        "print(first_word)"
      ],
      "outputs": [],
      "metadata": {
        "id": "jmZHUwDUd07H"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "---------------"
      ],
      "metadata": {
        "id": "_K3KLdDmd07H"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "A `list` acts like a 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 method `append`. Let's see how it works. Say we want to keep a list of all our good reads. We start with an empty list and we will add some good books to it:"
      ],
      "metadata": {
        "id": "i9Tef8l7d07I"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#start with an empty list\n",
        "good_reads = []\n",
        "good_reads.append(\"The Hunger games\")\n",
        "good_reads.append(\"A Clockwork Orange\")\n",
        "print(good_reads)"
      ],
      "outputs": [],
      "metadata": {
        "id": "Qi_vfA0Md07I"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now, if for some reason we don't like a particular book anymore, we can change it as follows:"
      ],
      "metadata": {
        "id": "wiNJHewRd07I"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "good_reads[0] = \"Pride and Prejudice\"\n",
        "print(good_reads)"
      ],
      "outputs": [],
      "metadata": {
        "id": "JIwMxso1d07I"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "--------"
      ],
      "metadata": {
        "id": "hJIBdPxed07I"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "####Quiz!"
      ],
      "metadata": {
        "id": "RavPWrO4d07I"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Here's another small Quiz! Try to change the title of the second book in our good reads collection."
      ],
      "metadata": {
        "id": "MyiqxiFzd07J"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# insert your code here\n",
        "print(good_reads)"
      ],
      "outputs": [],
      "metadata": {
        "id": "WUbY41-Dd07J"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "-----------"
      ],
      "metadata": {
        "id": "2OPulnFld07J"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "We just changed one element in a list. Note that if you do the same thing for a string, you will get an error:"
      ],
      "metadata": {
        "id": "Xut4fM7Wd07J"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "name = \"Pythen\"\n",
        "name[4] = \"o\""
      ],
      "outputs": [],
      "metadata": {
        "id": "_Yb0ppHmd07J"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "This is because `strings` (and some other types) are *immutable*. That is, they cannot be changed, as opposed to `lists` which *are* mutable. Let's explore some other ways in which we can manipulate lists."
      ],
      "metadata": {
        "id": "9fOXBkN1d07J"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "####remove()"
      ],
      "metadata": {
        "id": "zjjwPM-_d07J"
      }
    },
    {
      "cell_type": "markdown",
      "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 method `remove` that acts upon a list and takes as its argument the items we would like to remove."
      ],
      "metadata": {
        "id": "lsa9S1XZd07J"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "good_reads = [\"The Hunger games\", \"A Clockwork Orange\",\n",
        "              \"Pride and Prejudice\", \"Water for Elephants\",\n",
        "              \"The Shadow of the Wind\", \"Bel Canto\"]\n",
        "\n",
        "good_reads.remove(\"Water for Elephants\")\n",
        "\n",
        "print(good_reads)"
      ],
      "outputs": [],
      "metadata": {
        "id": "2nX4z_cCd07K"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "If we try to remove a book that is not in our collection, Python raises an error (don't be afraid, your computer won't break ;-))"
      ],
      "metadata": {
        "id": "A1kNMf-kd07K"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "good_reads.remove(\"White Oleander\")"
      ],
      "outputs": [],
      "metadata": {
        "id": "qI58LQCod07K"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "--------"
      ],
      "metadata": {
        "id": "8otS_KHTd07K"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "####Quiz!"
      ],
      "metadata": {
        "id": "188hhRQWd07K"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Define a variable `good_reads` as an empty list. Now add some of your favorite books to it (at least three) and print the last two books you added."
      ],
      "metadata": {
        "id": "yJDiTT9Xd07K"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# insert your code here"
      ],
      "outputs": [],
      "metadata": {
        "id": "GfZnrHDVd07K"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "------"
      ],
      "metadata": {
        "id": "Z8M9pYITd07K"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Just as with strings, we can concatenate two lists. Here is an example:"
      ],
      "metadata": {
        "id": "47ugpyuRd07K"
      }
    },
    {
      "cell_type": "code",
      "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",
        "\n",
        "bad_reads = [\"Fifty Shades of Grey\", \"Twilight\"]\n",
        "\n",
        "all_reads = good_reads + bad_reads\n",
        "print(all_reads)"
      ],
      "outputs": [],
      "metadata": {
        "id": "9vsbipofd07K"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "####sort()"
      ],
      "metadata": {
        "id": "U1s-cxF6d07K"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "It is always nice to organise your bookshelf. We can sort our collection with the following expression:"
      ],
      "metadata": {
        "id": "Wmq5w5rgd07L"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "good_reads.sort()\n",
        "print(good_reads)"
      ],
      "outputs": [],
      "metadata": {
        "id": "E6v7v_V7d07L"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "####nested lists"
      ],
      "metadata": {
        "id": "V187Iy2Kd07L"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Up to this point, our lists only have consisted of strings. However, 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?"
      ],
      "metadata": {
        "id": "p-JJPbx8d07L"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "nested_list = [[1, 2, 3, 4], [5, 6, 7, 8]]\n",
        "print(nested_list[0])\n",
        "print(nested_list[0][0])"
      ],
      "outputs": [],
      "metadata": {
        "id": "R2jPD9Hcd07L"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can put this 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:"
      ],
      "metadata": {
        "id": "05JiggRTd07L"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "good_reads = []"
      ],
      "outputs": [],
      "metadata": {
        "id": "3iT_nZ__d07L"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "And add two books to it:"
      ],
      "metadata": {
        "id": "bFG7jkk2d07L"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "good_reads.append([\"Pride and Prejudice\", 8])\n",
        "good_reads.append([\"A Clockwork Orange\", 9])"
      ],
      "outputs": [],
      "metadata": {
        "id": "QdvcqnB8d07L"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "---------"
      ],
      "metadata": {
        "id": "YaMVawC3d07L"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "####Quiz!"
      ],
      "metadata": {
        "id": "pY44FCY4d07L"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Update the `good_reads` collection with some of your own books and give them all a score. Can you print out the score you gave to the first book in the list? (Tip: you can pile up indexes)"
      ],
      "metadata": {
        "id": "mYHOVnjod07L"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# insert your code here"
      ],
      "outputs": [],
      "metadata": {
        "id": "aa23SFNTd07L"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "-----------"
      ],
      "metadata": {
        "id": "8iEcuv7gd07L"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#####What we have learnt"
      ],
      "metadata": {
        "id": "ZqFVyvkPd07L"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "To finish this section, here is an overview of the new concepts and functions you have learnt. Go through them and make sure you understand them all.\n",
        "\n",
        "-  list\n",
        "-  *mutable* versus *immutable*\n",
        "-  `.split()`\n",
        "-  `.append()`\n",
        "-  nested lists\n",
        "-  `.remove()`\n",
        "-  `.sort()`"
      ],
      "metadata": {
        "id": "fNO-KzHUd07L"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "-------------"
      ],
      "metadata": {
        "id": "N01F7p9Id07L"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Dictionaries"
      ],
      "metadata": {
        "id": "xnDiNozmd07L"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Our little good reads collection is starting to look good and we can perform all kinds of manipulations on it. Now, imagine that our list is large and we would like to look up the score we gave to a particular book. How are we going to find that book? For this purpose Python provides another more appropriate data structure, named `dictionary`. A `dictionary` is similar to the dictionaries you have at home. It consists of entries, or keys, that hold a value. Let's define one:"
      ],
      "metadata": {
        "id": "isXushTYd07L"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_dict = {\"book\": \"physical objects consisting of a number of pages bound together\",\n",
        "           \"sword\": \"a cutting or thrusting weapon that has a long metal blade\",\n",
        "           \"pie\": \"dish baked in pastry-lined pan often with a pastry top\"}"
      ],
      "outputs": [],
      "metadata": {
        "id": "75zsb872d07L"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "Take a close look at the new syntax. Notice the curly brackets and the colons. Keys are located at the left side of the colon; values at the right side. To look up the value of a given key, we 'index' the dictionary using that key:"
      ],
      "metadata": {
        "id": "bkjEitLRd07L"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "description = my_dict[\"sword\"]\n",
        "print(description)"
      ],
      "outputs": [],
      "metadata": {
        "id": "sZZTSXoqd07L"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "We say 'index', because we use the same syntax with square brackets when indexing lists or strings. The differences is that we don't use a position number to index a dictionary, but a key. Like lists, dictionaries are mutable which means we can add and remove entries from it. Let's define an empty dictionary and add some books to it. The titles will be our keys and the scores their values. Watch the syntax to add a new entry:"
      ],
      "metadata": {
        "id": "HieHJvP4d07M"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "good_reads = {}\n",
        "good_reads[\"Pride and Prejudice\"] = 8\n",
        "good_reads[\"A Clockwork Orange\"] = 9"
      ],
      "outputs": [],
      "metadata": {
        "id": "Pb6JnKe7d07M"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "In a way this is similar to what we have seen before when we altered our book `list`. There we indexed the list using a integer to access a particular book. Here we directly use the title of the book. Can you imagine why this is so useful?"
      ],
      "metadata": {
        "id": "xUvijwrUd07M"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "--------"
      ],
      "metadata": {
        "id": "iMyaY8_5d07M"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "####Quiz!"
      ],
      "metadata": {
        "id": "_2lL1LdBd07M"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Update the new good reads datastructure with your own books. Try to print out the score you gave for one of the books."
      ],
      "metadata": {
        "id": "AyS6HYODd07M"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# insert your code here"
      ],
      "outputs": [],
      "metadata": {
        "id": "CJ5veMc_d07M"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "----------"
      ],
      "metadata": {
        "id": "ieE6mMIfd07M"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "####keys(), values()"
      ],
      "metadata": {
        "id": "7bHNmryyd07M"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "To retrieve a list of all the books we have in our collection, we can ask the dictionary to return its keys as a list:"
      ],
      "metadata": {
        "id": "AlJ4jTORd07N"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "good_reads.keys()"
      ],
      "outputs": [],
      "metadata": {
        "id": "Zw_Td0FZd07N"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "Similarly we can ask for the values:"
      ],
      "metadata": {
        "id": "lZaq0rfMd07N"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "good_reads.values()"
      ],
      "outputs": [],
      "metadata": {
        "id": "HrX5uZYTd07N"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "---------"
      ],
      "metadata": {
        "id": "rjRU0yPYd07N"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#####What we have learnt"
      ],
      "metadata": {
        "id": "UL8j47TQd07N"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "To finish this section, here is an overview of the new concepts and functions you have learnt. Make sure you understand them all.\n",
        "\n",
        "-  dictionary\n",
        "-  indexing or accessing keys of dictionaries\n",
        "-  adding items to a dictionary\n",
        "-  `.keys()`\n",
        "-  `.values()`"
      ],
      "metadata": {
        "id": "FIx-zElwd07N"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "--------"
      ],
      "metadata": {
        "id": "KY_U6RvNd07N"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Conditions"
      ],
      "metadata": {
        "id": "hbvRLsbud07N"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Simple conditions"
      ],
      "metadata": {
        "id": "5PEs4wyNd07N"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "A lot of programming has to do with executing a certain piece of code if a particular condition holds. We have already seen two conditions at the very beginning of the chapter. Here we give a brief overview. Can you figure our what all of the conditions do?"
      ],
      "metadata": {
        "id": "-bU79UmPd07N"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"2 < 5 =\", 2 < 5)\n",
        "print(\"3 > 7 =\", 3 >= 7)\n",
        "print(\"3 == 4 =\", 3 == 4)\n",
        "print(\"school == homework =\", \"school\" == \"homework\")\n",
        "print(\"Python != perl =\", \"Python\" != \"perl\")"
      ],
      "outputs": [],
      "metadata": {
        "id": "VJI6fG8ud07N"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "###if, elif and else"
      ],
      "metadata": {
        "id": "HbXB0Wdfd07N"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The dictionary is a much better data structure for our good reads collections. However, even with dictionaries we might forget which books we added to the collection. What happens if we try to get the score of a book that is not in our collection (and hopefully never will be...)?"
      ],
      "metadata": {
        "id": "LKdHKRhzd07N"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "good_reads[\"Folgert's awesomeness\"]"
      ],
      "outputs": [],
      "metadata": {
        "id": "WP5w8kbYd07N"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "We get an error. A `KeyError`, which basically means \"the key you asked me to look up is not in the dictionary\". We will learn a lot more about error handling later, but for now we would like to prevent our program from giving it in the first place. Let's write a little program that prints \"X is in the collection\" if a particular book is in the collection and \"X is NOT in the collection\" if it is not."
      ],
      "metadata": {
        "id": "5GTlO5BPd07N"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "book = \"A Clockwork Orange\"\n",
        "if book in good_reads:\n",
        "    print(book + \" is in the collection\")\n",
        "    print(\"A lot more\")\n",
        "    print(\"Still more to come\")\n",
        "else:\n",
        "    print(book + \" is NOT in the collection\")"
      ],
      "outputs": [],
      "metadata": {
        "id": "E1RZsKiqd07N"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "A lot of new syntax here. Let's go through it step by step. First we ask if the value we assigned to `book` is in our collection. The part after `if` evaluates to either `True` or to `False`. Let's type that in:"
      ],
      "metadata": {
        "id": "5btN69E3d07O"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "book in good_reads"
      ],
      "outputs": [],
      "metadata": {
        "id": "m1azSHYtd07P"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "Because our book is not in the collection, Python returns `False`. Let's do the same thing for a book that we know is in the collection:"
      ],
      "metadata": {
        "id": "8PG3rkMYd07P"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\"A Clockwork Orange\" in good_reads"
      ],
      "outputs": [],
      "metadata": {
        "id": "X6HYcI22d07P"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "Indeed, it is in the collection. Back to our `if` statement. If the expression after `if` evaluates to `True`, our program will go on to the next line and print `book + \" is in the collection\"`. Let's try that as well:"
      ],
      "metadata": {
        "id": "Gk20AGiyd07P"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "if \"A Clockwork Orange\" in good_reads:\n",
        "    print(\"Found it!\")"
      ],
      "outputs": [],
      "metadata": {
        "id": "3sCgM8eLd07P"
      },
      "execution_count": null
    },
    {
      "cell_type": "code",
      "source": [
        "if book in good_reads:\n",
        "    print(\"Found it!\")"
      ],
      "outputs": [],
      "metadata": {
        "id": "dCfaN6f-d07P"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "Notice that the print statement in the last code block is not executed. That is because the value we assigned to `book` is not in our collection and thus the part after `if` did not evaluate to `True`. In our little program above we used another statement besides `if`, namely `else`. It shouldn't be too hard to figure out what's going on here. The part after `else` will be executed if the `if` statement evaluated to `False`. In English: if the book is not in the collection, print that it is not."
      ],
      "metadata": {
        "id": "XrMynGiyd07P"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "####Indentation!"
      ],
      "metadata": {
        "id": "YFF2U1k3d07P"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Before we continue, we must first explain to you that the layout of our code is not optional. Unlike in other languages, Python does not make use of curly braces to mark the start and end of expressions. The only delimiter is a colon (`:`) and the indentation of the code. This indentation must be used consistently throughout your code. The convention is to use 4 spaces as indentation. This means that after you have used a colon (such as in our `if` statement) the next line should be indented by four spaces more than the previous line."
      ],
      "metadata": {
        "id": "fwfGRgQfd07P"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Sometimes we have various conditions that should all evaluate to something different. For that Python provides the `elif` statement. We use it similar to `if` and `else`. Note however that you can only use `elif` after an `if` statement! Above we asked whether a book was in the collection. We can do the same thing for parts of strings or for items in a list. For example we could test whether the letter *a* is in the word *banana*:"
      ],
      "metadata": {
        "id": "q0w2JEEKd07P"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\"a\" in \"banana\""
      ],
      "outputs": [],
      "metadata": {
        "id": "bR56wv-Ud07P"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "Likewise the following evaluates to `False`:"
      ],
      "metadata": {
        "id": "Fy1-xj6sd07P"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\"z\" in \"banana\""
      ],
      "outputs": [],
      "metadata": {
        "id": "OcVWolO7d07Q"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "Let's use this in an `if-elif-else` combination:"
      ],
      "metadata": {
        "id": "tqtaRGGyd07Q"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "word = \"rocket science\"\n",
        "if \"a\" in word:\n",
        "    print(word + \" contains the letter a\")\n",
        "elif \"s\" in word:\n",
        "    print(word + \" contains the letter s\")\n",
        "else:\n",
        "    print(\"What a weird word!\")"
      ],
      "outputs": [],
      "metadata": {
        "id": "SySkYHLud07Q"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "--------"
      ],
      "metadata": {
        "id": "Z-9xnV2Pd07Q"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "####Quiz!"
      ],
      "metadata": {
        "id": "DV_xeQc_d07Q"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Let's practice our new condition skills a little. Write a small program that defines a variable `weight`. If the weight is > 50 pounds, print \"There is a $25 charge for luggage that heavy.\" If it is not, print: \"Thank you for your business.\" Change the value of weight to see both statements. (Tip: make use of the `<` or `>` operators)"
      ],
      "metadata": {
        "id": "S0SUxiJYd07Q"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# insert your code here"
      ],
      "outputs": [],
      "metadata": {
        "id": "mbMjj5qCd07Q"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "-------"
      ],
      "metadata": {
        "id": "rYjBomlad07Q"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "###and, or, not"
      ],
      "metadata": {
        "id": "s5df147Ed07Q"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Up to this point, our conditions have consisted of single expresssions. However, quite often we would like to test for multiple conditions and then execute a particular piece of code. Python provides a number of ways to do that. The first is with the `and` statement. `and` allows us to juxtapose two expressions that need to be true in order to make the entire expression evaluate to `True`. Let's see how that works:"
      ],
      "metadata": {
        "id": "qyY8G4Wdd07Q"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "word = \"banana\"\n",
        "if \"a\" in word and \"b\" in word:\n",
        "    print(\"Both a and b are in \" + word)"
      ],
      "outputs": [],
      "metadata": {
        "id": "ioPiKTeAd07Q"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "If one of the expressions evaluates to False, nothing will be printed:"
      ],
      "metadata": {
        "id": "K40638UQd07R"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "if \"a\" in word and \"z\" in word:\n",
        "    print(\"Both a and z are in \" + word)"
      ],
      "outputs": [],
      "metadata": {
        "id": "Pt2TnWMhd07R"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "-------"
      ],
      "metadata": {
        "id": "4prLB_o4d07R"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "####Quiz!"
      ],
      "metadata": {
        "id": "pZ8EubYTd07R"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Replace `and` with `or` in the `if` statement below. What happens?"
      ],
      "metadata": {
        "id": "nY8deOtxd07R"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "word = \"banana\"\n",
        "if \"a\" in word and \"z\" in word:\n",
        "    print(\"Both a and b are in \" + word)"
      ],
      "outputs": [],
      "metadata": {
        "id": "aRWrCSbXd07R"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "In the code block below, can you add an `else` statement that prints that none of the letters were found?"
      ],
      "metadata": {
        "id": "tAbLOq95d07R"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "if \"a\" in word and \"z\" in word:\n",
        "    print(\"Both a and z are in \" + word)\n",
        "# insert your code here"
      ],
      "outputs": [],
      "metadata": {
        "id": "IjRFcUAod07R"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "----------"
      ],
      "metadata": {
        "id": "PkNmtTq9d07R"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Finally we can use `not` to test for conditions that are not true."
      ],
      "metadata": {
        "id": "szGcljpCd07R"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "if \"z\" not in word:\n",
        "    print(\"z is not in \" + word)"
      ],
      "outputs": [],
      "metadata": {
        "id": "L1KBAhQld07R"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "Objects, such as strings or integers of lists are `True` because they exist. Empty strings, lists, dictionaries etc on the other hand are `False` because in a way they do *not* exist. We can use this principle to, for example, only execute a piece of code if a certain list contains any values:"
      ],
      "metadata": {
        "id": "-q971JXhd07R"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "numbers = [1, 2, 3, 4]\n",
        "if numbers:\n",
        "    print(\"I found some numbers!\")"
      ],
      "outputs": [],
      "metadata": {
        "id": "jW_X9Fl0d07R"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now if our list were empty, Python wouldn't print anything:"
      ],
      "metadata": {
        "id": "d_wltZqpd07R"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "numbers = []\n",
        "if numbers:\n",
        "    print(\"I found some numbers!\")"
      ],
      "outputs": [],
      "metadata": {
        "id": "GnrQPGOHd07R"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "--------"
      ],
      "metadata": {
        "id": "TupWGZbsd07S"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "####Quiz!"
      ],
      "metadata": {
        "id": "OrlJRsCbd07S"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Can you write code that prints \"This is an empty list\" if the provided list does not contain any values?"
      ],
      "metadata": {
        "id": "0uJM3tlBd07S"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "numbers = []\n",
        "# insert your code here"
      ],
      "outputs": [],
      "metadata": {
        "id": "HeSa5tD6d07S"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "Can you do the same thing, but this time using the function `len()`?"
      ],
      "metadata": {
        "id": "Bg86wM-4d07S"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "numbers = []\n",
        "# insert your code here"
      ],
      "outputs": [],
      "metadata": {
        "id": "JcDuVOCyd07S"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "-----------"
      ],
      "metadata": {
        "id": "Nd16iWB1d07S"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#####What we have learnt"
      ],
      "metadata": {
        "id": "V76xD0rPd07S"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "To finish this section, here is an overview of the new functions, statements and concepts we have learnt. Go through them and make sure you understand what their purpose is and how they are used.\n",
        "\n",
        "-  conditions\n",
        "-  indentation\n",
        "-  `if`\n",
        "-  `elif`\n",
        "-  `else`\n",
        "-  `True`\n",
        "-  `False`\n",
        "-  empty objects are false\n",
        "-  `not`\n",
        "-  `in`\n",
        "-  `and`\n",
        "-  `or`\n",
        "-  multiple conditions\n",
        "-  `==`\n",
        "-  `<`\n",
        "-  `>`\n",
        "-  `!=`\n",
        "-  `KeyError`"
      ],
      "metadata": {
        "id": "DEmXzCShd07S"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---------"
      ],
      "metadata": {
        "id": "KcaZ0SKId07T"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Loops"
      ],
      "metadata": {
        "id": "gSfUHH7bd07T"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Programming is most useful if we can perform a certain action on a range of different elements. For example, given a list of words, we would like to know the length of all words, not just one. Now you *could* do this by going through all the indexes of a list of words and print the length of the words one at a time, taking up as many lines of code as you have indices. Needless to say, this is rather cumbersome.\n",
        "\n",
        "Python provides the so-called `for`-statements that allow us to iterate through any iterable object and perform actions on its elements. The basic format of a `for`-statement is:\n",
        "\n",
        "    for X in iterable:\n",
        "\n",
        "That reads almost like English. We can print all letters of the word *banana* as follows:"
      ],
      "metadata": {
        "id": "wrD4bJSGd07T"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for letter in \"banana\":\n",
        "    print(letter)"
      ],
      "outputs": [],
      "metadata": {
        "id": "RuuRlTbJd07T"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "The code in the loop is executed as many times as their are letters, with a different value for the variable `letter` at each iteration. Read the previous sentence again."
      ],
      "metadata": {
        "id": "PUuuK20Ld07T"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Likewise we can print all the items that are contained in a list:"
      ],
      "metadata": {
        "id": "pW3x4cjzd07T"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "colors = [\"yellow\", \"red\", \"green\", \"blue\", \"purple\"]\n",
        "for whatever in colors:\n",
        "    print(\"This is color \" + whatever)"
      ],
      "outputs": [],
      "metadata": {
        "id": "B5Rh1Jrmd07T"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "Since dictionaries are iterable objects as well, we can iterate through our good reads collection as well. This will iterate over the *keys* of a dictionary:"
      ],
      "metadata": {
        "id": "MYuAJzrMd07T"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for book in good_reads:\n",
        "    print(book)"
      ],
      "outputs": [],
      "metadata": {
        "id": "99QMNPD3d07T"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can also iterate over both the keys and the values of a dictionary, this is done as follows:"
      ],
      "metadata": {
        "id": "O6Z26Qhsd07T"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "good_reads.items()"
      ],
      "outputs": [],
      "metadata": {
        "id": "I-T-cyBZd07T"
      },
      "execution_count": null
    },
    {
      "cell_type": "code",
      "source": [
        "for x, y in good_reads.items():\n",
        "    print(x + \" has score \" + str(y))"
      ],
      "outputs": [],
      "metadata": {
        "id": "d0pXBJjtd07T"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "Using `items()` will, at each iteration, return a nice pair of the key and the value. In the example above the variable `book` will loop over the keys of the dictionary, and the variable `score` loops over the respective values.\n",
        "\n",
        "The above way is the most elegant way of looping over dictionaries, but try to see if you understand the following alternative as well:"
      ],
      "metadata": {
        "id": "qtoalAfZd07T"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for book in good_reads:\n",
        "    print(book, \"has score\", good_reads[book])"
      ],
      "outputs": [],
      "metadata": {
        "id": "XpmQF1NId07U"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "-------"
      ],
      "metadata": {
        "id": "pBju9pLCd07U"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "####Quiz!"
      ],
      "metadata": {
        "id": "LCnhCAK_d07U"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The function `len()` returns the length of an iterable item:"
      ],
      "metadata": {
        "id": "VWY5a51vd07U"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "len(\"banana\")"
      ],
      "outputs": [],
      "metadata": {
        "id": "ZJuikODed07U"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can use this function to print the length of each word in the color list. Write your code in the box below:"
      ],
      "metadata": {
        "id": "uA2fo5D-d07U"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "colors = [\"yellow\", \"red\", \"green\", \"blue\", \"purple\"]\n",
        "# insert your code here"
      ],
      "outputs": [],
      "metadata": {
        "id": "mto_f_H6d07U"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now write a small program that iterates through the list `colors` and `appends` all colors that contain the letter *r* to the list `colors_with_r`. (Tip: use `colors_with_r.append`)"
      ],
      "metadata": {
        "id": "MqvFKtl6d07U"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "colors = [\"yellow\", \"red\", \"green\", \"blue\", \"purple\"]\n",
        "colors_with_r = []\n",
        "# insert you code here"
      ],
      "outputs": [],
      "metadata": {
        "id": "7NZqhXMid07U"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "-----------"
      ],
      "metadata": {
        "id": "zdKj58FUd07U"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#####What we have learnt"
      ],
      "metadata": {
        "id": "IxpgwvoMd07U"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Here is an overview of the new concepts, statements and functions we have learnt in this section. Again, go through the list and make sure you understand them all.\n",
        "\n",
        "-  loop\n",
        "-  `for` statement\n",
        "-  iterable objects\n",
        "-  variable assignment in a `for` loop"
      ],
      "metadata": {
        "id": "Uh1IYLZKd07U"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "--------"
      ],
      "metadata": {
        "id": "erE0rQvzd07U"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "####Final Quiz!"
      ],
      "metadata": {
        "id": "7cPtWDLqd07V"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "We have covered a lot of ground. Now it is time to put all what we learned together. The following quiz might be quite hard and we would be very impressed if you get it right!\n",
        "\n",
        "What we want you to do is write code that counts the number of word tokens in which the letter *a* is present in a small corpus. You need to do this on the basis of a frequency distribution of words that is represented by a dictionary. In this dictionary `frequency_distribution`, keys are words and values are the frequencies. Assign your value to the variable `number_of_as`."
      ],
      "metadata": {
        "id": "H3TlUltRd07V"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "frequency_distribution = {\"Beg\": 1, \"Goddard's\": 1, \"I\": 3, \"them\": 2, \"absent\": 1, \"already\": 1,\n",
        "                          \"alteration\": 1, \"amazement\": 2, \"appeared\": 1, \"apprehensively\": 1,\n",
        "                          \"associations\": 1, 'clever': 1, 'clock': 1, 'composedly': 1,\n",
        "                          'deeply': 7, 'do': 7, 'encouragement': 1, 'entrapped': 1,\n",
        "                          'expressed': 1, 'flatterers': 1, 'following': 12, 'gone': 9,\n",
        "                          'happening': 4, 'hero': 2, 'housekeeper': 1, 'ingratitude': 1,\n",
        "                          'like': 1, 'marriage': 15, 'not': 25, 'opportunities': 1,\n",
        "                          'outgrown': 1, 'playfully': 2, 'remain': 1, 'required': 2,\n",
        "                          'ripening': 1, 'slippery': 1, 'touch': 1, 'twenty-five': 1,\n",
        "                          'ungracious': 2, 'unwell': 1, 'verses': 1, 'yards': 5}\n",
        "number_of_as = 0\n",
        "# insert your code here"
      ],
      "outputs": [],
      "metadata": {
        "id": "_Xm2QZ-nd07V"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "-------"
      ],
      "metadata": {
        "id": "joSJzhvVd07V"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "You've reached the end of the chapter. Ignore the code below, it's just here to make the page pretty:"
      ],
      "metadata": {
        "id": "HOv9zmf6d07V"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from IPython.core.display import HTML\n",
        "def css_styling():\n",
        "    styles = open(\"styles/custom.css\", \"r\").read()\n",
        "    return HTML(styles)\n",
        "css_styling()"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {},
          "metadata": {},
          "execution_count": 2
        }
      ],
      "metadata": {
        "id": "wFjprG4od07V",
        "outputId": "f76e0bef-4a76-4510-97f6-0c5074bd50da"
      },
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "dKvTE5aXd07V"
      }
    }
  ]
}