Class_2.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-07\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Class 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has some other data types such as tuples, sets and dictionaries."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.4 Tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A **tuple** is an **immutable** sequence of elements. They can be created with **round brackets**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = (1, 2, 3)\n",
    "t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, the round brackets are not necessary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tt = 1, 2, 3\n",
    "tt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since tuples are sequences, you can perform any sequence operation on them: concatenation, repetition, membership testing, indexing, slicing, minimum, maximum and len(gth)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In contrast to lists, tuples are immutable (in that regard, tuples are more like strings):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t[1] = 4 # Error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nonetheless, tuples can contain (nested) elements which themselves are mutable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ttt = (1,2,['mummy','daddy'])\n",
    "ttt[2].append('baby')\n",
    "ttt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The major use of tuples is to have ordered sequences of elements which cannot be changed anymore."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.5 Sets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A **set** is an **unordered** collection of **unique elements**. That means that sets do not exhibit a sequence, not do they contain repeated values. They can be created with the function `set()`, which always extracts the unique elements from a sequence:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = set('baby')\n",
    "v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vv = set([1,2,3,2,3])\n",
    "vv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first example shows that sets have no ordering. Hence, indexes/slices are not applicable to sets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v[1] # Error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vv[1] # Error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sets do have a length, this is their \"**cardinal number**\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(vv)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also **test for membership** in a set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'y' in v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 not in vv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course, sets allow for all the usual set-theoretical operations. In order to illustrate them, we create some examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v1 = set(['father', 'mother', 'son', 'daughter'])\n",
    "v2 = set(['daddy', 'mummy', 'son', 'daughter'])\n",
    "v3 = set(['father', 'son'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Union:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v1 | v2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v1.union(v2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Intersection:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v1 & v2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v1.intersection(v2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Difference:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v1 - v2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v1.difference(v2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Symmetric difference (\"Exclusion\"):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v1 ^ v2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v1.symmetric_difference(v2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Furthermore, there are various **tests** (next to the above-mentioned test for membership):"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Test for disjunction:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v1.isdisjoint(v2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(v1 & v2).isdisjoint(v1 ^ v2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(v1 ^ v2).isdisjoint(v1 & v2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Test for subset:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v3 <= v1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v3.issubset(v1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  - There is also a test for a **proper** (or **strict**) subset:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v1 <= v1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v1 < v1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v3 < v1 # PROPER subset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Test for superset:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v1 >= v3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v1.issuperset(v3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- There is also a test for a **proper** (or **strict**) superset:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v1 >= v1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v1 > v1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v1 > v3 # PROPER superset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, there are some operations:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Update:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v1 |= set(['uncle', 'aunt'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v1.update(set(['uncle', 'aunt']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Intersection update:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v1 &= set(['mother', 'daughter', 'uncle', 'aunt', 'nephew', 'niece'])\n",
    "v1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v1.intersection_update(set(['mother', 'daughter', 'uncle', 'aunt', 'nephew', 'niece']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " - Difference update:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v1 -= set(['son', 'daughter', 'nephew', 'niece'])\n",
    "v1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v1.difference_update(set(['son', 'daughter', 'nephew', 'niece']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Exclusion update:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v1 ^= set(['uncle', 'aunt', 'brother', 'sister'])\n",
    "v1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v1.symmetric_difference_update(set(['uncle', 'aunt', 'brother', 'sister']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Important**: this is of course another data set!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Copy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v4 = v2.copy()\n",
    "v4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Add:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v2.add('bro')\n",
    "v2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Remove:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v2.remove('daddy')\n",
    "v2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v2.remove('aunt') # Error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Remove (without Error):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v2.discard('aunt')\n",
    "v2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v2.discard('son')\n",
    "v2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Remove **random** element:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v2.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Empty set:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v2.clear()\n",
    "v2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(v2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.6 Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another important data type in Python are **dictionaries**. The core property of a dictionary is that every element in it is accessed by a **name** instead of an index (that also means that dictionaries are **unordered**).\n",
    "\n",
    "Such a name is called the \"**key**\", and Python allows any immutable sequence as a key. The elements themselves of a dictionary are called the \"**values**\", and every pair of key and value is called an \"**item**\".\n",
    "\n",
    "The quickest way to create a dictionary is with **curly braces** (`{` en `}`) and every pair of key and value is separated by a `:`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {'subject1' : 'John', 'subject2' : 'Mark', 'object' : ['apples', 'oranges', 'pears', 'fish'], 'price' : 12345 }\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can access the value of any items by specifying the **key** between **square brackets**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d['price']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d['subject500'] # Error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also **assign** items to a dictionary (in other words, dictionaries are mutable):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d['subject3'] = 'Bart'\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can remove an item from a dictionary with the well-known function `del()`. Again, you specify the key between square brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "del d['subject2']\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can **test for membership** in a dictionary by testing on a **key**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'subject1' in d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'subject2' not in d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'John' in d # False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The number of items in a dictionary is found with the function `len()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionaries also have some **methods**. We discuss all of them. First we create an example dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vd0 = {'key1' : 'value1', 'key2' : 'value2', 'key3' : 'value3'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The method `.clear()` **removes all items** from your dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vd0.clear()\n",
    "vd0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(vd0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The method `.copy()` creates a **copy** of your dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vd0 = d.copy()\n",
    "vd0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The method `.fromkeys()` creates a **new dictionary** based on a **list** of the **keys** of an old dictionary. The list keys in question are specified as the argument. You can also specify a list of values as the second argument (but the default in `None`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d.fromkeys(['subject1', 'price', 'subject500'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d.fromkeys(['subject1', 'price', 'subject500'], ['pineapple', 'peach', 'prune'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The method `.get()` gives the **value** of the **key** which you specify as the first argument. If the dictionary does not contain the key, then the value specified as the second argument is returned (the default is `None`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d.get('subject1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d.get('subject500')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d.get('subject500', 'noway')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d.get('subject1', 'noway')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The method `.items()` gives a **list** of all **items** (i.e. pairs of keys and values) in your dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d.items()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Important**: the list is not alphabetically ordered. That reflects the fact that the dictionary is an unordered data type."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The method `.keys()` gives a **list** of all **keys** in your dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d.keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It can sometimes be convenient to sort the keys:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorted(d.keys())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The method `.pop()` **prints *and* removes** the item with the key which you specify as an argument. f your dictionary does not contain the key, then you have the specify a value as the second argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d.pop('subject1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d.pop('subject500') # Error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d.pop('subject500', 'noway')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The method `.popitem()` prints and removes a **random** item from your dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d.popitem()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The method `.setdefault()` gives the **value** for the **key** which you specify as an argument. If your dictionary does not contain the key, then a new item will be **assigned** to your dictionary with the value specified as the second argument (the default is `None`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d.setdefault('subject500') # None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d.setdefault('subject501', 'William Wordsworth')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d.setdefault('subject501')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The method `.update()` **adds** the **items** from the dictionary specified as the argument to your dictionary. Existing items with the same key are overwritten."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d.update({'subject1' : 'John', 'subject3' : 'Bart', 'subject501' : 'Samuel Taylor Coleridge',\n",
    "          'object' : ['pineapple', 'peach', 'prune'], 'price' : 98765})\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The method `.values()` gives a **list** of all **values** in your dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d.values()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again, you can sort this list, but you can also test for membership:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'Samuel Taylor Coleridge' in d.values()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercises\n",
    "5. Create a dict `PythonBooks` with the following items:\n",
    "\n",
    "\n",
    "  |         KEY               |              VALUE                    |\n",
    "  |:-------------------------:|:-------------------------------------:|\n",
    "  | Mckinney, Wes             |   Python for Data Analysis            |\n",
    "  | Matthes, Eric             |   Python Crash Course                 |\n",
    "  | Saha, Amit                |   Doing Math with Python              |\n",
    "  | Sweigart, Al              |   Automate Boring Stuff with Python   |\n",
    "  | VanderPlas, Jake          |   Python Data Science Handbook        |\n",
    "  | Venkitachalam, Mahesh     |   Python Playground                   |\n",
    "\n",
    "\n",
    "  - Print the keys of `PythonBooks` in alphabetical order.\n",
    "  - Print the values of `PythonBooks` in alphabetical order.\n",
    "  - Print the items of `PythonBooks` in alphabetical order.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chapter 2: Programming tools"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1 Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because Python is a programming language, you can also create your own **functions** (next to Python's built-in functions). To recapitulate, a function is an operation which gives a certain output value on the basis of input values, e.g.:\n",
    "\n",
    "```\n",
    "f(x) = 3x + 1\n",
    "```\n",
    "\n",
    "In Python you can create this function the `def` operator as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x):\n",
    "    print(3*x + 1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After the `def` you specify the **name** of the function (which is `f` in this case, but you have the freedom to choose), and **in-between brackets** you specify the **arguments** of your function (the argument is `x` here, but you can choose both the number of arguments as well as their names).\n",
    "\n",
    "Immediately after the enclosing brackets there **has to be** a `:` and an **enter**, otherwise Python will give an error. On the next line(s) you give the actual **function definition** (i.e. what your function will do).\n",
    "\n",
    "It is important that all the lines of the function definition are **indented**, otherwise Python will give an error. Many Python-related tools now indent automatically, otherwise you have to do it yourself. Indentation with a **tab** will work, but the convention nowadays is **four spaces** (or you can set your tab to be four spaces).\n",
    "\n",
    "Finally, the function definition has to end with an **empty line**, otherwise Python will give an error. (The empty line is how Python finds out where the function definition **terminates**.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you have done that, then you can use the function to perform computations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f(-50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f(7.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions are not restricted to numbers, you can define function for any data type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def g(x):\n",
    "    print('Shall I compare thee to '+ x +'?')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g(\"a summer's day\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g(\"bananas\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can assign **default values** to your **arguments** in the function definition. Such default values will then be used unless other values are explicitly specified (i.e. the default values are \"overridden\")."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def h(x = \"a winter's breeze\"):\n",
    "    print('Shall I compare thee to '+ x +'?')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "h()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "h('mangoes')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are a few restrictions to be kept in mind. The first one is that the **order of the arguments** is important when many of them have default values. The second one is that you **cannot assign more than one value** to an argument. For the rest, there is great liberty, as is exemplified by the next function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hey(subject = 'John', object1 = 'Marc', object2 = \"a winter's breeze\"):\n",
    "    print('Shall ' + subject + ' compare ' + object1 + ' to ' + object2 + '?')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hey()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hey(object1 = 'Bart')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hey(object1 = 'Bart', subject = 'you')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**But**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hey('Bart', 'you')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hey('Bart', 'you', \"a summer's day\", object2 = 'mangoes') # Error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **result** of a function can also be **assigned** to an object. For that you need to replace the `print()` command by `return`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def i(x = \"a winter's night\"):\n",
    "    return 'Shall I compare thee to '+ x +'?'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = h('mangoes')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y # (Nothing)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = i('mangoes')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also use the object which you want to modify as one of your **arguments**. (Arguments without default values always have to appear before argument with default values.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def j(y, x = \"a winter's night\"):\n",
    "    y.append('Shall I compare thee to '+ x +'?')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y=[]\n",
    "j(y, 'mangoes')\n",
    "j(y, 'bananas')\n",
    "j(y, 'apples')\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next to the `def` statement you can also create (small) functions with a `lambda` statement: After the `lambda` operator you specify the arguments and after a `:` you specify the computation. Lambda statements have to be all on one line (which is why they usually are quite simple functions):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "j_alt = lambda y, x: y.append('Shall I compare thee to '+ x +'?')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "j_alt(y, 'pears')\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lambda statements are useful when you need to perform quick computations on the fly. Applications of `NumPy` and/or `pandas` contain many examples of lambda statements."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2 Control structures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another programming feature of Python are the **control structures** `if`, `for` and `while`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An `if` statement tests whether a certain condition is `True` before executing an operation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x1 = 'bananas'\n",
    "if len(x1) > 4:\n",
    "    print(x1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x2 = 'fish'\n",
    "if len(x2) > 4:\n",
    "    print(x2)\n",
    "\n",
    "# (Nothing)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note** how the syntax is similar to the syntax of function definitions:\n",
    "\n",
    "- The first line (with the actual control structure) ends on a `:` and an **enter**\n",
    "- The second line (with the executable commands) is indented\n",
    "- The last line is a blank line\n",
    "\n",
    "This syntax also holds for `for` and `while`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `if` statement can be combined with `elif` or `else` statements in order to control what happens if the condition is `False`. An `elif` stement tests for another condition, an `else` condition specifies what happens if all previous conditions are `False`. Hence, `elif` statements can appear multiple times, but the final statement has to be `else`. (MIND the `:`!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x3 = 'apples'\n",
    "if len(x3) > 8:\n",
    "    print('nine or more')\n",
    "elif len(x3) > 6:\n",
    "    print('seven or more')\n",
    "elif len(x3) > 4:\n",
    "    print('five or  more')\n",
    "else:\n",
    "    print('four or less')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x4 = 'fish'\n",
    "if len(x4) > 4:\n",
    "    print('more than four')\n",
    "else:\n",
    "    print('four or less')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A `for` statement loops over the individual elements in a sequence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for x in ['apples', 'oranges', 'pears', 'fish']:\n",
    "    print(x)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes you have to loop over the **indexes** of a sequence. To that end you can use the function `range()` which returns a (zero-based) sequence of integers until a certain value. That is to say, `range()` returns a so-called range object, which itself can be converted to a sequence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "range(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(range(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looping over the indexes can then be done by specifying the **length** of your sequence as the argument to `range()`. The previous `for` loop can therefore also be run as follows (the `for` statement automatically converts the range object to a list):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xList = ['apples', 'oranges', 'pears', 'fish']\n",
    "for x in range(len(xList)):\n",
    "    print(xList[x])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For completeness' sake, we mention that you can also specify `range()` with a **start value** as well as with an **increment**. It is even possible to work with **negative indexes**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(range(5,10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(range(0,10,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(range(-10,0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(range(-10,0,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(range(0,-10,-2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes you need to loop over **both** the indexes and elements of a sequence. For that you can use the function `enumerate()` (which returns both indexes and elements):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i, x in enumerate(xList):\n",
    "    print(i, x)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes you need to loop over **two or more** sequences. Then you can use the function `zip()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for x, y in zip(xList, y):\n",
    "    print('Food in the morning: ' + x + ', fruit at 4pm: ' + y)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A `while` statement keeps on executing a certain operation as long as a certain condition is fulfilled."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "while len(xList) > 0:\n",
    "    print(xList.pop())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In other words, a `while` loop can be seen as a combination of a `for` loop and an `if` statement."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The logical tests (in `if` or `while`) make use of the following **logical operators** (which are all specified with left-hand side and a right-hand side):\n",
    "\n",
    "| Operator   |  Meaning                       |\n",
    "|-----------:|:-------------------------------|\n",
    "|   `==`     |  is equal to                   |\n",
    "|   `!=`     |  is not equal to               |\n",
    "|   `<`      |  is smaller than               |\n",
    "|   `<=`     |  is smaller than or equal to   |\n",
    "|   `>`      |  is larger than                |\n",
    "|   `>=`     |  is larger than or equal to    |\n",
    "|   `is`     |  is the same object as         |\n",
    "|   `is not` |  is not the same object as     |\n",
    "\n",
    "The outcome of any logical test is either `True` or `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x2 is x4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3 > 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3 >= 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'e' < 'o'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'e' >= 'o'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note** the difference between `==` (logical comparison) and `=` (assignment)!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Logical tests can be combined to complex expressions by means of the **Boolean operators** `and`, `or` and `not`. In the following descriptions, the symbols `P` and `Q` stand for any logical expression."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Boolean operator `and` returns `True` if **both** logical expressions are `True` and returns `False` otherwise:\n",
    "\n",
    " |  `P`    |  `Q`    | `P and Q` |\n",
    " |:-------:|:-------:|:---------:|\n",
    " | `True`  | `True`  | `True`    |\n",
    " | `True`  | `False` | `False`   |\n",
    " | `False` | `True`  | `False`   |\n",
    " | `False` | `False` | `False`   |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3 < 4 and 'c' < 'e'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3 < 4 and 'c' >= 'e'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Boolean operator `or` returns `True` if **one** of the logical expressions is `True` and returns `False` otherwise:\n",
    "\n",
    " |  `P`    |  `Q`    | `P or Q`  |\n",
    " |:-------:|:-------:|:---------:|\n",
    " | `True`  | `True`  | `True`    |\n",
    " | `True`  | `False` | `True`    |\n",
    " | `False` | `True`  | `True`    |\n",
    " | `False` | `False` | `False`   |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3 > 4 or 'c' < 'e'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3 > 4 or 'c' >= 'e'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Boolean operator `not` returns `True` if the logical expression `False` and returns `False` otherwise:\n",
    "\n",
    " |   `P`    | `not P`   |\n",
    " |:--------:|:---------:|\n",
    " |  `True`  |  `False`  |\n",
    " |  `False` |  `True`   |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "not 3 < 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "not 3 >= 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A **convenient** feature in Python is that logical expressions are processed in **consecutive order** (from left to right). That means that **superfluous** expressions are **not evaluated**, e.g.:\n",
    "\n",
    "- If the left-hand side of `and` is `False`, then the result is always `False` no matter what the right-hand side is.\n",
    "- If the left-hand side of `or` is `True`, then the result is always `True` no matter what the right-hand side is."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x5 == 'hoi' # Error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if 3 > 4 and x5 == 'hoi':\n",
    "    print('hello')\n",
    "\n",
    "# No error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if 3 < 4 or x5 == 'hoi':\n",
    "    print('hello')\n",
    "\n",
    "# No error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are also some special cases of data types which Python considers as equivalent to `False`:\n",
    "\n",
    "- `None`\n",
    "- `0` (i.e. the number zero, also in the floating-point version: `0.0`)\n",
    "- `''` (i.e. the empty string)\n",
    "- `[]` (i.e. the empty list)\n",
    "- `()` (i.e. the empty tuple)\n",
    "- `{}` (i.e. the empty dictionary)\n",
    "\n",
    "To illustrate this, we ask for the \"truth value\" of any object in Python with the built-in function `bool()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bool(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bool('z')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bool([3, 'hello'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bool()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bool(None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bool(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bool(0.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bool('')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bool([])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bool({})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a consequence, you can use **short-hand** notations for logical tests:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xCopy = ['apples', 'oranges', 'pears', 'fish']\n",
    "while xCopy: # becomes False when xCopy becomes the empty list [].\n",
    "    print(xCopy.pop())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The full extent of Python's programming possibilities reside in **combining** control structures with function definitions. As an example, we will count how many times each element in a list occurs and store the results in a dictionary. In order to do that, we first define a function which updates the (frequency) values for the keys:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def updateFreq(d, k):\n",
    "    if k in d.keys():\n",
    "        d[k] += 1\n",
    "    else:\n",
    "        d[k] = 1\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The symbol `+=` is a **short-hand** operator for: `x = x + 1`. This means that the value of an existing key gets incremented by 1. Any new key is created with value 1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vbD = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "updateFreq(vbD, 'Marc')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vbD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "updateFreq(vbD, 'Marc')\n",
    "vbD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "updateFreq(vbD, 'Bart')\n",
    "vbD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "updateFreq(vbD, 'Bart')\n",
    "updateFreq(vbD, 'John')\n",
    "vbD"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note the indentation**: the `if` statement is itself indented, so any conditional command has to be indented twice. Similarly, more complex (nested) control structures lead to further indentation. The **indentation has meaning in Python**: it is the way to control for the \"**level**\" of your computations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next step is to extend our function in order to loop over the elements in a sequence:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def countFreqs(d, l):\n",
    "    for i in l:\n",
    "        if i in d.keys():\n",
    "            d[i] += 1\n",
    "        else:\n",
    "            d[i] = 1\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that **within** the `for` loop the code remains the same as in our function `updateFreq()`. Because we have already defined that function, we can also use it in the definition of `countFreqs()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def countFreqs_alt(d, l):\n",
    "    for i in l:\n",
    "        updateFreq(d, i)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We create an example list in order to show some results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vbL = ['banana', 'apple', 'pear', 'apple', 'banana', 'apple', 'prune', 'pear', 'apple', 'peach', 'pear']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vbD = {}\n",
    "countFreqs(vbD, vbL)\n",
    "vbD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vbD_alt = {}\n",
    "countFreqs_alt(vbD_alt, vbL)\n",
    "vbD_alt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vb2 = [7, 8, 9, 2, 10, 9, 9, 9, 9, 4, 5, 6, 1, 5, 6, 7, 8, 6, 1, 10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vbD = {}\n",
    "countFreqs(vbD, vb2)\n",
    "vbD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vbD = {}\n",
    "countFreqs_alt(vbD, vb2)\n",
    "vbD"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An **extra example** is counting the words in a string. In order to do that we need to split the string into a list. We also make use of string methods to \"clean up\" the string:\n",
    "\n",
    "- Converting to lowercase\n",
    "- Removing punctuation\n",
    "\n",
    "Incidentally, we do not specify the output dictionary as an argument, but we let the function produce it itself:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def countWords(s):\n",
    "    s = s.lower()\n",
    "    l = s.split(' ')\n",
    "    outD = {}\n",
    "    for i in l:\n",
    "        i = i.strip('.,:;?!')\n",
    "        if i in outD.keys():\n",
    "            outD[i] += 1\n",
    "        else:\n",
    "            outD[i] = 1\n",
    "    return outD\n",
    "\n",
    "vbS = 'A rose is a rose is a rose.'\n",
    "countWords(vbS)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercises\n",
    "6. Define the following functions:\n",
    "  - A function `triLinear(a, b, c)` which gives the result `3a + 5b + 4c + 11`. The results should be able to be stored in an object.\n",
    "  - A function `capRepeat(l, s, x)` which repeats a string `s` a number of `x` times in capital letters and adds that to a list `l`. The default number of repetitions should be five.\n",
    "  - A function `myAverage(l)` which computes the mean of list `l` of numbers, i.e. the sum of the numbers in `l` divided by the size. The results should be able to be stored in an object. Apply the function to the list `vb2`.\n",
    "  - **(Optional:)** A function `myVariance(l)` which computes the variance of `l`, i.e. the sum of the squared differences to the mean divided by size minus one. The results should be able to be stored in an object. Apply the function to the list `vb2`.\n",
    "  - **(Optional:)** A function `myMode(l)` which computes the mode of `l`, i.e. the most common element in `l`. Use the function `countFreqs()` for that. The results should be able to be stored in an object. Apply the function to the list `vb2`."
   ]
  },
  {
   "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
}