Class_1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Statistics with Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "Koen Plevoets\n",
    "Last modified: 2020-12-06\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Chapter 1: Data types\n",
    "  - 1.1: Numbers\n",
    "  - 1.2: Strings\n",
    "  - 1.3: Lists\n",
    "  - 1.4: Tuples\n",
    "  - 1.5: Sets\n",
    "  - 1.6: Dictionaries\n",
    "- Chapter 2: Programming tools\n",
    "  - 2.1: Functions\n",
    "  - 2.2: Control structures\n",
    "  - 2.3: Exception handling\n",
    "  - 2.4: Classes, methods and object-oriented programming\n",
    "- Chapter 3: External data\n",
    "  - 3.1: Importing modules\n",
    "  - 3.2: Reading and writing data files\n",
    "- Chapter 4: Numerical computations with NumPy\n",
    "  - 4.1: Creating NumPy arrays\n",
    "  - 4.2: Computing with NumPy arrays\n",
    "  - 4.3: Indexing with NumPy arrays\n",
    "  - 4.4: NumPy submodules\n",
    "- Chapter 5: Data handling with pandas\n",
    "  - 5.1: Working with pandas Series and DataFrames\n",
    "  - 5.2: Exploratory statistics with pandas\n",
    "  - 5.3: Reading data with pandas\n",
    "  - 5.4: Data wrangling with pandas\n",
    "  - 5.5: Aggregate statistics with GroupBy objects\n",
    "  - 5.6: Reshaping pandas DataFrames\n",
    "- Chapter 6: Visualization with Matplotlib\n",
    "  - 6.1: Creating graphs with Matplotlib\n",
    "  - 6.2: Statistical graphs with Matplotlib\n",
    "  - 6.3: Style sheets\n",
    "  - 6.4: Object-oriented approach\n",
    "  - 6.5: Graphical methods in pandas\n",
    "- Chapter 7: Statistical visualization with seaborn\n",
    "  - 7.1: Style sheets in seaborn\n",
    "  - 7.2: Visualizing relationships between variables\n",
    "  - 7.3: Visualizing categorical data\n",
    "  - 7.4: Visualizing distributions of data\n",
    "  - 7.5: Visualizing regression models\n",
    "  - 7.6: Visualizing facets\n",
    "- Chapter 8: Statistical inference with SciPy\n",
    "  - 1.1: Tests for categorical data\n",
    "  - 8.2: Tests for continuous data\n",
    "- Chapter 9: Statistical modelling with statsmodels"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chapter 1: Data types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1 Numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python can best be seen as a **sophisticated pocket calculator**: if you type in an expression and press **Enter**, then Python will print the result. In Jupyter Notebooks this comes down to selecting a code block (by clicking on it) and pressing the button **Run** above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2 + 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3 - 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3 * 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "6 / 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3 ** 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Division of two integers gives the correct solution in Python **3**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "7 / 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, Python **2** distinguishes between **integers** and **floating point numbers**. Hence, it is always safe to type in one of the numbers as a floating point number:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "7.0 / 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "7 / 4.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " The functions above are **built-in** functions. Other functions are **not** automatically available."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "log(9) # Error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You first have to **load/import** the module `math`. You always have to write the module name before the function name separated by a dot (`.`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "math.log(9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Modules contain various functions, constants, etc., which are somehow related to each other (Python has many different modules). They are not loaded automatically in order not to make Python too \"heavy\". The user chooses what he/she needs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to access the functions directly, then you can type in the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import *\n",
    "log(9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, this is considered to be a **bad practice** (because it may overwrite existing function names)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Every function in Python has a **help page** which explains the details of the function. You can access the help page of a function with the function `help()`. In-between the brackets you specify the name of your function between quotation marks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help('math.log')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also ask for the help page of a whole module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help('math')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python is **object-oriented**. That means that you can assign values to variables. You do assignment with the `=` operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mass = 30\n",
    "speed = 5\n",
    "mass * speed\n",
    "momentum = mass * speed\n",
    "momentum"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**The typography matters**: capital letters, dots, comma's etc. have to be correct!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Momentum # Error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another data type in Python are **strings**. A string is made by placing a sequence of characters **between** either **double quotes** or **single quotes**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = 'hello'\n",
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ss = \"hello\"\n",
    "ss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The difference is when your string already contains quotation marks. The rule is:\n",
    "```\n",
    "A quotation mark which differs from the surrounding two quotation marks is always possible,\n",
    "but any similar quotation mark has to be \"escaped\", i.e. preceded by a backslash (\\).\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'My dad says \"hello\".'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"My dad's words are heard.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'My dad\\'s words are \"hello\".'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"My dad's words are \\\"hello\\\".\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Backslashes can always be added. So, the following is also okay:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'My dad\\'s words are \\\"hello\\\".'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"My dad\\'s words are \\\"hello\\\".\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But this is not:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'My dad's words are \"hello\".' # Error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"My dad's words are \"hallo\".\" # Error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quotation marks **define** the sequence as a string. That is why Python prints all quotation marks, backslashes etc. when you call for the string. This is called the \"**string literal**\". If you want to have the **content** of a string, then you use the command `print()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('My dad\\'s words are \\\"hello\\\".')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are also strings defined by **triple quotation marks**: those are strings surrounded by either three single quotation marks (`'''`) or three double quotation marks (`\"\"\"`). You use triple quotation marks if your string spans **multiple lines**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sss = '''This is the first line\n",
    "and this is the second'''\n",
    "print(sss)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that the string literal erin has a `\\n` character between the two lines:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This `\\n` is the so-called \"**newline**\" (meta)character."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can perform some operations on strings (and other sequence types such as lists - see later). Two fundamental operators are `+` and `*`. `+` **concatenates** two strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'pa' + 'pa'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`*` **repeats** the string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'pa' * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'My dad says' + ' ' + 'a' * 34"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python **3** the `+` operator is not necessary anymore for concatenation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'pa' 'pa'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can **test** whether a particular character sequence **occurs in** the string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'e' in s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'z' in s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also test whether a character sequence does **not** occur in the string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'e' not in s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'z' not in s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **order** is important: Python does not test for the individual characters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'le' in s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can ask for the **smallest** or the **largest** element in the string - i.e. **in alphabetical order**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "min(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "max(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Both functions also apply to numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "min('375')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "max('375')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **numbers of characters** in a string can be found with the function `len()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **empty string** has, of course, length zero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len('')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also access the individual elements of a sequence. Python works with numbers for the positions **between** the elements of a sequence; these are the \"**indexes**\" (or \"**indices**\"). Compare the following scheme:\n",
    "```\n",
    "\t+---+---+---+---+---+\n",
    "\t| h | e | l | l | o |\n",
    "\t+---+---+---+---+---+\n",
    "\t0   1   2   3   4   5\n",
    "```\n",
    "Python treats the areas between the indexes as a **ruler**:\n",
    "- all numbers in the **first** area (i.e. from 0,0... until 0,9...) can be **rounded off** to `0`,\n",
    "- all numbers in the **second** area (i.e. from 1,0... until 1,9...) can be **rounded off** to `1`,\n",
    "- all numbers in the **third** area (i.e. from 2,0... until 2,9...) can be **rounded off** to `2`,\n",
    "- etc.\n",
    "\n",
    "As a consequence, the index of the **first** element is `0`, the index of the **second** element is `1`, the index of the **third** element is `2`, etc.\n",
    "\n",
    "In other words, indexing in Python is \"**zero-based**\" (so the last element in a sequence has index *len-1*)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[5] # Error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indexes also allow for accessing a **whole segment** of a sequence; this is a so-called **slice**, and they are defined by a `:`.  Before `:` you specify the index **from which** you want to slice, after the `:` you specify the index **until which** you want to slice.\n",
    "\n",
    "**Remark**: this means that the upper index is in fact the index of the **next** element in the sequence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[1:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[1:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also slice \"with an **increment**\". To do that, you specify a second `:` followed by the value of the increment:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[0:5:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are straightforward **default values** for slices:\n",
    "- if you omit the first index, then Python considers this as equivalent to the beginning of the sequence (index = `0`)\n",
    "- if you omit the last index, then Python considers this as equivalent to the end of the sequence (index = *len*)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[3:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That means that `s[:i] + s[i:] = s` for **every** `i`: *0* < `i` < *len(s)*!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "f you specify an **upper index** which is **too high**, then Python will **automatically reduce** it to the actual length of the sequence:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[:50]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, if you specify a **lower limit** which is **too high**, then you will get the **empty sequence**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[50:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The same happens if you **change** the **order** of the indexes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[3:1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In other words, the last two results may be possible errors!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you specify **negative** indexes, then you count from the **end** of the sequence. In other words, starting from *len* (= *5*), index `-1` accesses the **last** element, index `-2` accesses the **one but last** element, etc.\n",
    "\n",
    "**Important**: Python still counts with **positive** indexes \"behind the scene\":\n",
    "- `-1` is actually a **shorthand** for *len-1* (and equals *4* in the example of \"hello\")\n",
    "- `-2` is actually a **shorthand** for *len-2* (and equals *3* in the example of \"hello\")\n",
    "- etc.\n",
    "\n",
    "In order to make everything clear, we extend the scheme above with negative indexes:\n",
    "```\n",
    "\t+---+---+---+---+---+\n",
    "\t| h | e | l | l | o |\n",
    "\t+---+---+---+---+---+\n",
    "\t0   1   2   3   4   5\n",
    "   -5  -4  -3  -2  -1\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[-2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[-3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[-4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[-5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[-6] # Error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Index `-0` is equal to index `0` (which is in line with the implicit back-transformation of negative indexes to positive indexes):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[-0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also **slice** with **negative indexes**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[-4:-2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[:-3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[-2:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just as with positive indexes, the order has to be **from small to large** (otherwise you will again get the empty sequence)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[-2:-4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercises\n",
    "1. Compute (pay attention to decimal digits):\n",
    "  - (1000 times 3) divided by 2\n",
    "  - (minus 1000 divided by 3) times (2 to the power 5)\n",
    "  - 3000 times (5 to the power minus 20)\n",
    "  - the square root of 10000\n",
    "  - the logarithm of 3000\n",
    "  - the tangent of minus 10000\n",
    "  - the sine of 90\n",
    "  - the cosine of minus pi\n",
    "  - the tangent of (minus pi divided by 4)\n",
    "2. Compute the following:\n",
    "  - Create two variables, the first with your first name as its value and the second with your surname.\n",
    "  - Count the number of letters in both variables.\n",
    "  - Extract the first two letters in both variables and extract the last two letters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "String objects have many different \"**methods**\". Methods belong to the **object-oriented** paradigm: they are small functions which you can apply on an object of a certain type (in this case: strings)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All string methods can be found in the [Python Standard Library under String Methods](https://docs.python.org/3/library/stdtypes.html#string-methods). We will illustrate a few of them by means of the following two examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vs1 = 'what shall we do with the drunken sailor'\n",
    "vs2 = '    what shall we do with the\\tdrunken sailor    '"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The method `.count()` counts how often a certain substring occurs in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vs1.count('d')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vs1.count('dr')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can optionally also specify the **start** and **stop index** between which you want to search."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vs1.count('d', 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vs1.count('d', 10, 20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " The method `.find()` gives the **first** index where a certain substring can be found, and otherwise the result is `-1`. You can optionally specify a start and stop index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vs1.find('d')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vs1.find('dr')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vs1.find('z')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The method `.index()` does the same as `.find()` but raises an **error** if nothing is found (instead of `-1`). You can optionally specify a start and stop index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vs1.index('d')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vs1.index('dr')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vs1.index('z') # Error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are also the methods `.rfind()` and `.rindex()` which give the **last** index."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are various methods which **test** for a property of your string, e.g.:\n",
    "- `.isalnum()` is `True` if all characters in your string are alphanumeric and is `False` otherwise\n",
    "- `.isalpha()` is `True` if all characters in your string are aphabetic and is `False` otherwise\n",
    "- etc.\n",
    "\n",
    "See the full lists of methods for testing in the [String Methods](https://docs.python.org/3/library/stdtypes.html#string-methods)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vs1.isalnum() # False because of the spaces"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vs1.isalpha()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vs1.islower()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The method `.join()` uses the string to **concatenate** the sequence specified as the argument. Usually the argument is a list (see later)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'_'.join( ['h', 'e', 'l', 'l', 'o'] )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "' '.join( ['what', 'shall', 'we', 'do', 'with', 'the', 'drunken', 'sailor'] )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The methods `.ljust()`, `.center()` and `.rjust()` do **line adjustment** of a string (left, centered and right, respectively). You always have to specify the **total width** of the resulting string. Optionally you can specify the **filling character** used for padding the string (the default is one space)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vs1.ljust(50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vs1.center(50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vs1.rjust(50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The methods `.lower()` and `.upper()` **convert** the character **case** of a string (to lowercase and uppercase, respectively)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vs1.lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vs1.upper()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are also the methods `.capitalize()`, `.casefold()`, `.swapcase()` and `.title()`; see the [String Methods](https://docs.python.org/3/library/stdtypes.html#string-methods)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " The methods `.lstrip()`, `.rstrip()` and `.strip()` **remove characters** from a string: `.lstrip()` from the beginning, `.rstrip()` from the end and `.strip()` from both the beginning and the end. You can optionally specify the set of characters to remove (the default is the set of all whitespace characters)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vs2.lstrip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vs2.lstrip(' wh')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vs2.rstrip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vs2.rstrip('or ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vs2.strip()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The method `.replace()` **replaces** the occurrences of a certain substring (in your string) by another substring."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vs1.replace('a', 'o')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vs1.replace('drunken', 'sober')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can optionally specify the number of replacements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vs1.replace('a', 'o', 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The methods `.rsplit()` and `.split()` **split** your string on the occurrences of a \"**separator string**\", to be specified as the argument. You can optionally specify the maximal number of splits. `.rsplit()` starts splitting from the end of the string, `.split()` starts from the beginning of the string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vs1.rsplit(' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vs1.rsplit(' ', 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vs1.split(' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vs1.split(' ', 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note**: the methods `.split()` and `.join()` perform opposite operations, but notice the difference in syntax:\n",
    "\n",
    "`SEQUENCE = STRING.split(sep)` vs. `STRING = sep.join(SEQUENCE)`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The method `.splitlines()` **splits** your string on every **newline** character. You can optionally specify `True` to keep the newline character itself."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sss.splitlines()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sss.splitlines(True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The methods `.startswith()` and `.endswith()` **test** whether your string starts with, resp. ends with a **specified substring**. You can optionally specify the start index and stop index **between** which to search."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vs1.startswith('what')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vs1.endswith('or')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vs1.endswith('er')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The method `.zfill()` **adds zero's to the left** of your string until the resulting string has a certain **specified width**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vs1.zfill(50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numbers and strings can also be converted to one another. You can do that with the functions functies `int()` and `str()`: `int()` converts a string to a number; `str()` converts a number to a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "int('5') * 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "str(5) * 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For completeness' sake, we also mention the function `float()` with which you can convert to a floating point number:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "float('5') * 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, there is the special character `#` (viz. the hash tag). Its meaning is that everything which appears **after it** (until a newline) is **ignored**. Therefore, it is useful to add **comments** to programming code.\n",
    "\n",
    "**Important**: a `#` occurring **inside** of a string is, of course, just the `#` character itself:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'The # here is still printed' # but now not anymore."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercises\n",
    "3. Use the two string variables (with your first name and your second name) from exercise 2 for:\n",
    "  - Center both variables, left-align them and right-align them in a total string of 30 characters.\n",
    "  - Find in all those (6) variables the position of your initial (which can be done with **two** different methods).\n",
    "  - Try to do the same, counting from the **end** of the string.\n",
    "    - **Hint**: Your initial is the letter before which there is no preceding letter. (Pay attention to the fact that you want the index of the initial itself and not of the preceding character.)\n",
    "  - Remove the whitspace at the beginning of each variable, at the end and at both the beginning and the end.\n",
    "  - Join the variable with your first name and the one with your surname together into one string with a space in-between.\n",
    "  - Put all letters in that one string in uppercase and put them in lowercase.\n",
    "  - Try to put only the first letter of your first name and of your surname in uppercase (and all other letters in lowercase).\n",
    "  - Join your first name and your second name again together into one string but now with a newline in-between. This can be done in **two** ways.\n",
    "  - Display that string as intended: your first name and your second name on separate lines without the newline character."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3 Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The third major data type in Python are **lists**. A list is an ordered sequence of elements, it is created by **square brackets** and separating the elements by **comma's**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = ['morning', 'midday', 'evening', 123, math.log]\n",
    "l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like strings, lists are **sequences**. That means that many above-mentioned operations can also be applied on lists:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Concatenation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l + [456, math.sin, 789, math.cos]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Repetition:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Test for membership:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'midday' in l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "math.tan in l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'midday' not in l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "math.tan not in l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The smallest or largest element (this does not make sense for 'l', which contains different data types):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "min(['a', 'b', 'c', 'd', 'e'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "max([1, 2, 3, 4, 5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Length:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just like the empty string, the empty list has length zero:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len([])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indexing & slicing (in the same **zero-based** fashion):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l[2:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l[-3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l[-2:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The difference with strings is obvious: lists can contain elements of different types. That has to do with the **core** property of lists: they are **mutable** sequences. Strings are **immutable**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l[1] = 'noon'\n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[1] = 'a' # Error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That means that new elements can always be added at the end of a list with the following generic formula:\n",
    "\n",
    "`LIST1[len(LIST1):] = LIST2` (abbrevation of: `LIST1[len(LIST1):len(LIST1)] = LIST2`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l[len(l):] = ['dad', 'mum']\n",
    "l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is not possible with strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[len(s):] = 'hey' # Error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By consequence, you can add new elements at the **beginning** of a list with: `LIST1[:0] = LIST2` (Abbreviation of: `LIST1[0:0] = LIST2`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l[:0] = ['mother', 'father']\n",
    "l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again, this is not possible with strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[:0] = 'bye' # Error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A consequence of the mutability of lists is that lists can be **nested**: i.e. you can create lists of lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ll = [456, l, 789]\n",
    "ll"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the overarching (super)list (`ll`) the sublist (`l`) is just a single element:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(ll)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ll[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to access elements in nested lists, you can work with multiple indexes: i.e. you place the index of the sublist **immediately after** the index of the superlist."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ll[1][5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Depending on the depth of you list, you can keep on specifying indexes (between square brackets)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slicing remains similar:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lll = ll[1][2:7]\n",
    "lll"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists also have some **methods**. We will discuss them all."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The method `.append()` **adds** a specified **element** to the **end** of your list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lll.append('dawn')\n",
    "lll"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is in fact **concatenation** of the form: `lll + ['dawn']`. Hence, it is also equivalent to: `lll[len(lll):] = ['dawn']`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The method `.extend()` **adds** a **list** to the **end** of your list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lll.extend(['dawn', 'dusk'])\n",
    "lll"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is in fact **pure** concatenation: `lll + ['dawn','dusk']`. Hence, it is equivalent to: `lll[len(lll):] = ['dawn','dusk']`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The method `.count()` **counts** the number of occurrences in your list of a certain specified **element**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lll.count('morning')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The method `.copy()` creates a **copy** of your list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l_2 = lll.copy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is equivalent to `l_2 = lll[:]`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l_2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The method `.clear()` **removes all elements** from your list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l_2.clear()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is equivalent to: `l_2 = del l_2[:]`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l_2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The method `.index()` gives the **first** index of a certain specified **element** in your list (and an error if nothing is found)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lll.index(123)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The method `.insert()` **inserts** an **element** at a certain **position** (index) in the list. You specify the index as the first argument and the new element as the second argument. The element which already occupied the indexed position moves one position to the right."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lll.insert(5, 'night')\n",
    "lll"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The method `.pop()` **removes *and* prints** an **element** from your list. By default this is the last element in the list, but you can specify an index as the argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = lll.pop()\n",
    "v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lll.pop(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The method `.remove()` **removes** the **first** occurrence of a specified **element** from your list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lll.remove(123)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lll.remove('morning')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lll"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The method `.reverse()` **reverses** the **order** of the elements in your list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lll.reverse()\n",
    "lll"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The method `.sort()` **sorts** the elements in your list. By default, this is **increasing** order, but you can specify the argument `reverse = True` to get **decreasing** order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lll.sort()\n",
    "lll"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lll.sort(reverse = True)\n",
    "lll"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because lists are mutable, you can also **delete** elements or segments from a list. That is possible with the function `del()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "del (lll[1:4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is equivalent to: `lll[1:4] = []`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lll"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We come back to the `.copy()` method because it reveals a fundamental aspect of assignment in Python: when you **assign** an existing list to another list, you do **not** create a new object but only a new **name**. In other words, you create two names for the same object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l_2 = lll\n",
    "l_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l_2[1] = 'daybreak'\n",
    "l_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lll"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the `.copy()` method you create an entirely new object (which is called a \"**deep**\" copy):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l_3 = lll.copy()\n",
    "l_3[1] = 'nightfall'\n",
    "l_3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lll"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, this aspect of assignment **only** applies to lists (and other mutable sequences). If you assign an existing number object or string object to a new object, then you have two different objects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_1 = 30\n",
    "n_2 = n_1\n",
    "n_2 = 20\n",
    "n_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s_1 = 'hey'\n",
    "s_2 = s_1\n",
    "s_2 = 'bye'\n",
    "s_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s_1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercises\n",
    "4. Create the following list (copy-paste): `exList = ['shall','I','compare','thee','to','a','summer\\'s','day']` and:\n",
    "  - Create (**manually**) a **nested list** on the basis of the **indexes** in `exList` with:\n",
    "    - the words with only an `\"a\"` in one sublist (i.e. `\"shall\"`, `\"a\"` and `\"day\"`)\n",
    "    - the words which starts with an `\"s\"` in one sublist (i.e. `\"shall\"` and `\"summer's\"`)\n",
    "    - the words of a single character in one sublist (i.e. `\"I\"` and `\"a\"`)\n",
    "    - all other words as subsequent elements (i.e. `\"compare\"`, `\"thee\"` and `\"to\"`)\n",
    "  - Revert the order in every sublist.\n",
    "  - Sort every sublist.\n",
    "  - Remove from every sublist the second element. That can be done in **three** different ways, so use a different way for each of the first three sublists.\n",
    "  - Give all the ways in which you can add elements to the end of a list and illustrate them with `['rose']` and `['snow']`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}