1_python_basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Basics\n",
    "\n",
    "This is an interactive Jupyter Notebook explaining the very basics of Python that you'll need for the Machine Learning course.\n",
    "\n",
    "Please make sure you understand everything mentioned here and are able to solve the exercises in the next notebook!\n",
    "\n",
    "This is only a very brief introduction, mostly intended for people who already know a bit about computer science. If you feel this does not provide enough information for you, please consider looking at these additional references:\n",
    "- [Official Python Tutorial](https://docs.python.org/3/tutorial/)\n",
    "- [W3 School Tutorials](https://www.w3schools.com/python/default.asp)\n",
    "- [Video Tutorials on YouTube](https://www.youtube.com/playlist?list=PL-osiE80TeTt2d9bfVyTiXJA-UTHn6WwU)\n",
    "- [Beginners Computer Science & Python Course on Udacity](https://eu.udacity.com/course/intro-to-computer-science--cs101)\n",
    "\n",
    "For bonus points, also have a look at the official [**Python Code Style Guide**](https://www.python.org/dev/peps/pep-0008/). \n",
    "\n",
    "You can execute the code in the cells by clicking into a cell and pressing \"shift\"+\"enter\" or clicking the \"run\" button at the top. Feel free to experiment a bit by changing the code in the examples to see what happens. Don't worry if you get any error messages - consider them hints on how to do better ;-)\n",
    "\n",
    "Instead of just running through the examples, **it helps to first think about what you would expect the output of a code cell to be and then execute it to see if you were right**. If you weren't, please make sure you understand why and what is happening in the code!\n",
    "\n",
    "If you see a number in the square brakets next to a cell (e.g. `In [1]`), then the cell was already executed. If the brakets are empty, run the cell to execute the code in it and see the output. If you want to try out something else but not erase the given code, press the \"+\" button at the top to add a new cell below the currently selected cell. \n",
    "\n",
    "You have to execute all the cells starting at the beginning for everything to work as expected. If you change any variable names or their values, be prepared for different outcomes. You can execute cells multiple times and jump back and forth; the number next to the cell tells you the order of execution - if a cell below changes a variable used in the cell above it and you execute the cell above again, the output might be different from before as it uses the updated variable value. \n",
    "\n",
    "Should the code get stuck (`In [*]` means the cell is currently executing the code in it; in our examples this should never take more than a few seconds), click the \"stop\" button at the top or select \"Kernel > Interrupt\" from the menu bar."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using Python as a Calculator\n",
    "\n",
    "Python understands basic math - just enter an expression and execute the cell to get your result below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is a comment. It does not get executed. You can use it to explain your code.\n",
    "# These are the symbols you can use in calculations (in addition to parenthesis \"()\"):\n",
    "# +: addition\n",
    "# -: subtraction\n",
    "# *: multiplication\n",
    "# /: division\n",
    "# **: to the power of\n",
    "(2 * 5)**3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# regular division returns a decimal number\n",
    "5 / 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# with \"//\" the divison result is rounded down\n",
    "5 // 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# with the modulo operator \"%\" you get the remainder of a division\n",
    "5 % 2  # 5 = 2*2 + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variables\n",
    "\n",
    "You already know variables from math. There, a placeholder like $x$ can stand for any kind of value. In programming this is similar, you just define a name and assign it a value and then you can work with these values in a more convienient way by adressing the variables that store them. This is especially useful if you want to change a value somewhere: since it's assigned to the variable, everywhere where you use the variable it uses the new value, you don't have to copy & paste it a hundred times :)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define a \"width\" and a \"height\" variable by assigning them values with \"=\"\n",
    "width = 20\n",
    "height = 5 * 9\n",
    "# compute something with the variables instead of using the values directly\n",
    "width * height"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python only knows variables that you have previously defined;\n",
    "# if you use a name that you haven't assigned a value yet, you'll get an error\n",
    "n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# after we state what we mean by \"n\", we don't get an error anymore\n",
    "n = 5\n",
    "n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### \"Hello world!\"\n",
    "The standard example in any programming language is to have your code say \"Hello world!\". In Python this is really simple: you can output anything by just wrapping it in `print( )` like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello world!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: change the print statement below to greet yourself:\n",
    "print(\"Hello John!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# in a Jupyter notebook cell, you only get the output from the last line,\n",
    "# i.e., this will only give you back the value of height, not width:\n",
    "width\n",
    "height  # - what is the output if you switch the two?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# with print you can now output the values of multiple variables, not just the last one\n",
    "print(width)\n",
    "print(height)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Datatypes\n",
    "\n",
    "Your variables can store different kinds of data, e.g., numbers, text, or even more complex objects. Some basic datatypes are:\n",
    "- `int`: Integers are whole numbers, i.e., without a decimal point\n",
    "- `float`: Floating point numbers include the places after the decimal point\n",
    "- `str`: \"String\" is just a fancy word for text\n",
    "- `bool`: A Boolean contains either `True` or `False`, i.e. it's a binary value\n",
    "- `None`: This symbolizes a missing value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this is an int\n",
    "i = 8\n",
    "# if you're unsure what kind of data a variable contains, check it with \"type()\"\n",
    "type(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this is a float\n",
    "f = 1.6\n",
    "print(f)  # print output of the variable value\n",
    "type(f)   # regular output of the variable type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# you can explicitly transform one type of variable into another type,\n",
    "# this is called casting\n",
    "print(type(f))  # the f we defined before was a float\n",
    "g = f           # g now contains the same thing as f\n",
    "print(g)\n",
    "print(type(g))\n",
    "g = int(f)      # now g contains the integer version of f\n",
    "print(g)\n",
    "print(type(g))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Strings & String Formatting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# strings are created by putting quotes (single ' ' or double \" \") around some text:\n",
    "s = \"hello\"\n",
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# be careful, some letters have a special meaning, e.g., \"\\n\" means new line:\n",
    "s = 'C:\\some\\name'\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# you can either \"escape\" these special symbols with an additional \"\\\"\n",
    "s = 'C:\\some\\\\name'\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# or put an \"r\" in front of the string to signal that it is a \"raw\" string\n",
    "s = r'C:\\some\\name'\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# note that Python internaly also escapes some special symbols.\n",
    "# the regular output gives you the internal representation of the variable,\n",
    "# while the print statement interprets it the way you would write it out\n",
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# by the way: it is very bad style to use such short variable names\n",
    "# (like \"s\"), usually they should be a bit more descriptive. \n",
    "# but make sure to not use any special keywords for your variables,\n",
    "# i.e. don't call a variable with a string \"str\"!\n",
    "my_string = \"this is a variable with a more descriptive name\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# you can't just add numbers, but strings as well\n",
    "my_string + \" \" + \"AND HERE IS SOMETHING EXTRA\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# but Python will complain if you add variables of different data types\n",
    "my_string + 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# you could manually transform (i.e. cast) the number into a string to add them\n",
    "my_string + str(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# a nicer way to do something like this is string formatting\n",
    "# this allows you to include the values of other variables in a string\n",
    "# see here for an overview: https://zetcode.com/python/fstring/\n",
    "formatted_string = f\"This is the value of width: {width}\"\n",
    "formatted_string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this also works for multiple variables\n",
    "f\"These are the values of width: {width} and height: {height}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this works with different datatypes\n",
    "a_float = 5.896\n",
    "a_str = \"FOO\\nBAR\"\n",
    "print(a_float)\n",
    "print(a_str)\n",
    "print(f\"This is the printed output of the float a_float: {a_float} and the str a_str: {a_str}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# by using repr() you can print the internal representation of the object\n",
    "print(f\"This is the printed output of the float a_float: {repr(a_float)} and the str a_str: {repr(a_str)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# with :f, additional float formatting option can be supplied\n",
    "# by default the floats are shown with 6 places after the decimal point\n",
    "# but the output can be adapted with .x:\n",
    "print(f\"This is the default output of the float: {a_float:f}\")\n",
    "print(f\"This is the float rounded to 2 places after the decimal point: {a_float:.2f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# strings also have a bunch of methods that can be called on them to change the string\n",
    "# for a complete list check the documentation: \n",
    "# https://docs.python.org/3/library/stdtypes.html#string-methods\n",
    "a_str = \"This is a sentence. And here we have another sentence, which is longer.\"\n",
    "# everything in lower case\n",
    "print(a_str.lower())\n",
    "# calling such a method on a string returns a new string, the original variable remains unchanged\n",
    "print(a_str)\n",
    "# everything in upper case\n",
    "print(a_str.upper())\n",
    "# every word starting with a capital letter\n",
    "print(a_str.title())\n",
    "# replace spaces with underscores\n",
    "print(a_str.replace(\" \", \"_\"))\n",
    "# split the string at spaces to get a list of words\n",
    "print(a_str.split())\n",
    "# split the string at the word \"is\"\n",
    "print(a_str.split(\" is \"))  # exercise: what happens if you remove the spaces around \"is\"? try it!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Booleans & None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# booleans can be set to \"True\" or \"False\" explicitly\n",
    "a_bool = True\n",
    "print(a_bool)\n",
    "type(a_bool)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# truthvalues are also created e.g. when two things are compared\n",
    "a_bool = 5 >= 4\n",
    "print(a_bool)\n",
    "type(a_bool)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# also works with strings\n",
    "a_bool = \"HELLO\" == \"hello\"\n",
    "a_bool"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# bools can also be returned by other methods\n",
    "a_str = \"This is new.\"\n",
    "a_bool = a_str.startswith(\"This\")\n",
    "print(a_bool)\n",
    "# check if a string only contains letters\n",
    "a_bool = \"Hey There!\".isalpha() # exercise: change the string so that the boolean is True\n",
    "print(a_bool)\n",
    "# check if a string only contains numbers\n",
    "a_bool = \"110\".isnumeric()\n",
    "print(a_bool)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# None is mostly used as a placeholder\n",
    "unknown_var = None\n",
    "print(unknown_var)\n",
    "type(unknown_var)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the prefered way to check if a variable is set to None is to use the keyword \"is\", not \"==\"\n",
    "a_bool = unknown_var is None\n",
    "a_bool"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Collections\n",
    "More complex datatypes allow us to store multiple values at a time. These include:\n",
    "- `tuple`: A tuple contains multiple elements separated by `,`. Usually, these elements are grouped by `()`. A tuple is an immutable datatype, i.e., once it's been defined, the values in a tuple can't be changed anymore.\n",
    "- `list`: A list is very similar to a tuple but with `[]` surrounding the items and the elements in a list can be changed after its creation.\n",
    "- `set`: In a set, every item occurs only once and the elements are not in a specific order.\n",
    "- `dict`: A dictionary (similar to a hash table in other programming languages) contains a mapping between keys and values. While the values can be arbitrarily complex datatypes, the keys have to be something \"hashable\", like an int, string, or tuple.\n",
    "\n",
    "Check the [official documentation](https://docs.python.org/3/tutorial/datastructures.html) for more details, e.g., functions you can call on lists etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# a list can contain arbitrary elements, e.g., numbers, strings, or previously defined variables\n",
    "a_list = [\"hello\", 14, 0.054, a_bool]\n",
    "a_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# by indexing the list you can get specific elements from it\n",
    "# note: Python starts counting at 0!\n",
    "a_list[0]  # get the first element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_list[1]  # get the second element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_list[-1] # get the last element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_list[-2] # what will this return?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# with : you can specify a range of elements to be selected\n",
    "a_list[1:] # get all elements starting with the second one until the end of the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_list[1:3] # the end point is exclusive, i.e. this gives you a_list[1] and a_list[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_list[:2] # up to, but not including the 3rd element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_list[0:4:2] # select from the first till the last element every other element (shorthand: [::2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# check how many elements a list contains\n",
    "len(a_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# add an element to a list\n",
    "a_list.append(15)\n",
    "a_list  # the list was changed in place"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# add a list to the list (also in place)\n",
    "a_list.extend([16, 17, 18])\n",
    "a_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# lists can also be added together, but this is not done in place but returns a new list\n",
    "a_list + [19, 20]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the original a_list is still without the two new elements\n",
    "a_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the variable needs to be explicitly updated to contain the new elements\n",
    "a_list += [19, 20]  # += is shorthand for a_list = a_list + [19, 20]\n",
    "a_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# you can also change elements in the list by selectively replacing them\n",
    "a_list[0] = \"HELLO\"\n",
    "a_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# multiple values can be replaced by a new list\n",
    "a_list[-3:] = [0, 0, 0]\n",
    "a_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# check if an element is in a list with the keyword \"in\"\n",
    "print(14 in a_list) # bool\n",
    "# if the element is in the list, you can also ask for its index (the first occurence if it's in there multiple times)\n",
    "print(a_list.index(14)) # int: --> a_list[a_list.index(14)] gives you 14!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# a lot of operations on lists also work on strings.\n",
    "# basically you can think of a string as a list of characters\n",
    "a_str = \"oh, hello world!\"\n",
    "# for example, the \"in\" check works\n",
    "print(\"hello\" in a_str)\n",
    "# index gives you the starting position of the substring in the string\n",
    "i = a_str.index(\"hello\")\n",
    "print(i)\n",
    "# just like list indexing, you can also select parts of a string\n",
    "print(a_str[i:i+len(\"hello\")]) # what is happening here?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# count how often an element occurs in a list\n",
    "print(['a', 'b', 'r', 'a', 'c', 'a', 'd', 'a', 'b', 'r', 'a'].count(\"a\"))\n",
    "# count how often a substring occurs in a string\n",
    "print(\"abracadabrababababa\".count(\"aba\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# tuples are really similar to lists but written without [] (usually with () for clarity)\n",
    "a_tuple = (1, 2, \"hey\")\n",
    "a_tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# you can also select elements\n",
    "a_tuple[1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# but you can't change them!\n",
    "a_tuple[0] = 15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# python supports assigning values to multiple variables at once\n",
    "var0 = 8, \"hey\"        # var0 is a tuple with both values\n",
    "print(\"var0:\", var0)\n",
    "var1, var2 = var0  # the 2 values are unpacked into the two variables\n",
    "print(f\"var1: {var1},   var2: {var2}\")\n",
    "# this is really handy for switching the values of 2 variables, as you don't need a temp variable\n",
    "var1, var2 = var2, var1 + 1\n",
    "print(f\"var1: {var1}, var2: {var2}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the defining characteristic of sets is that they contain every element only once\n",
    "# and the elements don't have a guaranteed order\n",
    "# you can create a set from a list or with {}\n",
    "a_set = set(['HELLO', 14, 0.054, True, 15, 16, 17, 0, 0, 0])\n",
    "a_set  # the multiple 0 are removed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# intersections, unions, and differences can be computed on sets (remember math?)\n",
    "b_set = {16, 17, 18}\n",
    "print(a_set.union(b_set))        # all elements from a + b\n",
    "print(a_set.intersection(b_set)) # all elements in both a and b\n",
    "print(a_set.difference(b_set))   # all elements in a, but not b\n",
    "print(a_set)  # these operations always returned new sets; the original a_set is unchanged"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dictionaries map from arbitrary (hashable, i.e., \"simple\") elements (the \"key\") to anything else (the \"value\")\n",
    "# the keys have to be unique!\n",
    "a_dict = {\"key\": [1, 2, 4], 15: 16, 4: \"ho\", (0, \"a\"): 42}\n",
    "a_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# instead of indexing a dict with positions, you use the keys to get the values\n",
    "a_dict[4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_dict[(0, \"a\")]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# check if a key is in the dict (does not work for values!)\n",
    "print(42 in a_dict)\n",
    "# you'll get an error if you try to get an element for a non-existing key\n",
    "a_dict[42]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# instead of asking with a key directly with [], you can also use .get()\n",
    "# this allows you to specify a default value that is returned instead\n",
    "# if the key was not found (otherwise you get None instead of an error)\n",
    "print(a_dict.get(4))    # key exists\n",
    "print(a_dict.get(42))   # key doesn't exist\n",
    "print(a_dict.get(42, \"Key not found\"))  # return default value instead"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# with a_dict.keys(), .values(), or .items() you get all the keys, values, or key-value-pairs in the dict\n",
    "print(a_dict.keys())\n",
    "print(a_dict.values())\n",
    "print(a_dict.items())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# by accessing a dict with a key, the associated value can also be updated\n",
    "print(a_dict[4])\n",
    "a_dict[4] = \"ha\"\n",
    "print(a_dict[4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# just like for the other collections, len() gives you the number of key-value pairs in the dict\n",
    "len(a_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# you can add new elements by specifying a new key and the associated value\n",
    "a_dict[\"new key\"] = \"hello world!\"\n",
    "len(a_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### range and zip\n",
    "\n",
    "`range()` is a shortcut to get a list of integers. As we'll see later, it's optimized for iteration (e.g. used in a for-loop), but right now we'll just use it to create an example list.\n",
    "\n",
    "`zip()` merges two lists and can be used as a shortcut to create a dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# use range to get 10 numbers, from 0 to 9\n",
    "# if you want the numbers as a list, you need to cast it explicitly\n",
    "# otherwise it's just something that can be iterated over\n",
    "numbers_list = list(range(10))\n",
    "numbers_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# you can also specify start and (exclusive) end points\n",
    "list(range(5, 16))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# you can also skip numbers, e.g., take every 5th number\n",
    "list(range(0, 16, 5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# zip is a shortcut to create dictionaries by merging two lists\n",
    "# cast it into a dict to use it as a dictionary\n",
    "list1 = list(range(6))      # numbers from 0 to 5\n",
    "list2 = list(range(5, 11))  # numbers from 5 to 10\n",
    "a_dict = dict(zip(list1, list2))  # mapping from 0 to 5, 1 to 6 etc\n",
    "a_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### min, max, and sorting\n",
    "\n",
    "`min()` and `max()` are builtin functions to give you the smallest or largest element from a collection.\n",
    "`sorted()` returns a sorted list from the given collection. There needs to be a meaningful way to compare the elements in the collection for this to work, i.e., all elements need to be of the same datatype."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the functions do what you would expect...\n",
    "max(-10, 15, 8.3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "max(-10, \"hey\", 15, 8.3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# they also work directly on collections\n",
    "a_list = list(range(11))            # numbers from 0 to 10\n",
    "print(min(a_list))                  # smallest element in a_list\n",
    "print(max(a_list))                  # largest element in a_list\n",
    "print(sorted(a_list))               # list sorted from smallest to largest\n",
    "print(sorted(a_list, reverse=True)) # list sorted from largest to smallest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# similar for strings (output is always a list though!)\n",
    "print(sorted(\"This is a string. HELLO!\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sorted words by first splitting the string at \" \"\n",
    "print(sorted(\"This is a string. HELLO!\".split()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a dictionary mapping from numbers to strings\n",
    "a_dict = dict(zip(range(5), [\"hello\", \"oh\", \"world\", \"John\", \"john\"]))\n",
    "a_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(max(a_dict))                 # get the largest key\n",
    "print(max(a_dict.values()))        # get the largest value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(sorted(a_dict))              # sorted keys\n",
    "print(sorted(a_dict.values()))     # sorted values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# when calling the min/max/sorted functions with a collection, you can pass another function\n",
    "# as the \"key\" argument, which is then called and evaluated on every element from the collection\n",
    "# and instead of using the elements themselves to determine the largest or smallest element,\n",
    "# whatever is returned by the given \"key\" function for each element is used instead\n",
    "# (more on this later when we discuss functions).\n",
    "# you have already learned that a_dict.get() gives the value in the dict for a specific key.\n",
    "# we can use this here to sort the keys in a dictionary based on their values:\n",
    "print(max(a_dict, key=a_dict.get))     # get the key associated with the largest value\n",
    "print(sorted(a_dict, key=a_dict.get))  # keys sorted by values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### join\n",
    "\n",
    "`join()` is a shortcut to concatenate strings in a list into a full string with arbitrary text between the given strings. It is the counter part to `split()`, which creates a list from a string by removing pieces of text in the string to split it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_of_strs = [\"hello\", \"oh\", \"world\", \"John\", \"john\"]\n",
    "# join the strings in the list with nothing in between\n",
    "\"\".join(list_of_strs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# join sorted strings with newline and more text\n",
    "new_str = \"\\nWORD \".join(sorted(list_of_strs))\n",
    "# notice how the additional text is only placed in between the elements of the list,\n",
    "# not at the beginning or end\n",
    "print(new_str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loops & Conditionals\n",
    "\n",
    "So far we have only created and manipulated individual variables. Now we're taking a step towards actual programming by using loops (`for`, `while`) and conditionals (`if`/`else`).\n",
    "\n",
    "As you have already noticed, multiple lines of code get executed sequentially from top to bottom. Loops can be used as shortcuts to execute the same code multiple times. Conditional statements add additional flexibility by allowing us to exectue some code only if certain conditions are met.\n",
    "\n",
    "The syntax of loops and conditional statements is really simple, you just need to make sure you don't forget the `:` at the end of the statement and then indent the following code by 4 spaces.\n",
    "\n",
    "`for`-loops are used to iterate over a predefined list of elements and in each iteration you have access to the current element.\n",
    "```python\n",
    "for XXX in YYY:\n",
    "    # do something with the current XXX\n",
    "# whatever you write outside of the indentation is executed after the loop is finished.\n",
    "```\n",
    "\n",
    "`while`-loops are less common; they are used if you don't know in advance when you'll be done with whatever you're computing in the loop.\n",
    "```python\n",
    "while ZZZ:\n",
    "    # you land and stay inside here if ZZZ evaluates to True.\n",
    "    # make sure that some point in the code you change something so that ZZZ\n",
    "    # will eventually evaluate to False so you can exit the loop again and finish.\n",
    "```\n",
    "\n",
    "Conditional statements always need an `if` part (first check), then they can contain multiple `elif` (\"else if\") statements with other checks (if the first check has failed), and finally they can have an `else` statement, which catches all other cases. The `elif` and `else` statements are optional, but `else` always has to come last.\n",
    "```python\n",
    "if AAA:\n",
    "    # do something if AAA evaluates to True\n",
    "elif BBB:\n",
    "    # if AAA was False but BBB is True, do something here\n",
    "elif CCC:\n",
    "    # if AAA and BBB were False but CCC is True, do something here\n",
    "else:\n",
    "    # if AAA, BBB, and CCC were False, you end up here\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `for` loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_list = [\"hello\", 14, 0.054, False]\n",
    "# iterate over the elements in the list with a for loop\n",
    "for elem in a_list:\n",
    "    # just print out the element\n",
    "    print(elem)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_dict = {1: \"hello\", 2: 14, 3: 0.054, 4: False}\n",
    "# when you iterate over a dict, you iterate over the keys\n",
    "for key in a_dict:\n",
    "    # print out the key and its associated value\n",
    "    print(f\"key: {key}; value: {a_dict[key]}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the range() function is really handy if you want to execute some code X times\n",
    "fib_numbers = [0, 1]\n",
    "for i in range(10):\n",
    "    fib_numbers.append(fib_numbers[-2] + fib_numbers[-1])\n",
    "# do you know what we did here?\n",
    "print(fib_numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# another handy shortcut for for-loops is the enumerate() function\n",
    "# with it you get both the element of a list as well as the index of this element in the list\n",
    "for i, elem in enumerate(a_list):\n",
    "    # i contains the index of elem\n",
    "    print(f\"Element {i}: {elem}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `while` loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# you can do the same thing with while loops as with for loops\n",
    "# e.g. iterate through a list\n",
    "i = 0\n",
    "# you stop if i is larger than the last index of the list\n",
    "while i < len(a_list):\n",
    "    print(f\"Element {i}: {a_list[i]}\")\n",
    "    # don't forget to increase i, otherwise you would print the same line until the end of times!\n",
    "    i += 1  # shortcut for  i = i + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `if` (/`elif`/`else`) statements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# exercise: set i to different values and see what happens\n",
    "i = 42\n",
    "if i < 10:\n",
    "    print(f\"{i} is less than 10\")\n",
    "elif i <= 100:\n",
    "    print(f\"{i} is between 10 and 100\")\n",
    "else:\n",
    "    print(f\"{i} is greater than 100\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# with if/elif/else blocks, only one of the code pieces is exectued\n",
    "# (the first one where the condition is satisfied).\n",
    "# if you have multiple if (instead of elif) statements below each other (without additional indentation),\n",
    "# they all get checked sequentially and possibly executed.\n",
    "i = 4\n",
    "if i < 10:\n",
    "    print(f\"{i} is less than 10\")\n",
    "if i < 100:\n",
    "    print(f\"{i} is less than 100\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `and`, `or`, `not`, and nothing\n",
    "\n",
    "As we have seen with `while` loops and `if` statements, booleans (i.e. anything that evaluates to `True` or `False`) critically determine the flow of our code. \n",
    "\n",
    "With `and` and `or` we can construct even more complex expressions by checking for multiple conditions at once. \n",
    "\n",
    "`not` is a keyword to invert the value of a boolean.\n",
    "\n",
    "Furthermore, checks at `while` loops and `if` statement also work on variables directly, e.g., an empty list (`[]`), and empty string (`\"\"`), the number `0`, or `None` all implicitly evalue to `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 24\n",
    "# \"AAA and BBB\" is only True if both AAA and BBB evaluate to True\n",
    "if i >= 10 and i <= 100:\n",
    "    print(f\"{i} is between 10 and 100\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# \"AAA or BBB\" is True if either AAA, BBB, or both AAA and BBB evaluate to True\n",
    "if i < 10 or i > 100:\n",
    "    # no print output means we didn't get inside here\n",
    "    print(f\"{i} is either smaller than 10 or greater than 100\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# \"not\" can make your code more readable\n",
    "stop = False\n",
    "i = 0\n",
    "while not stop:\n",
    "    i += 1\n",
    "    if i > 10:\n",
    "        stop = True\n",
    "# what value does i have? (remove the # before the print statement to see if you're right)\n",
    "# print(i)\n",
    "# exercise: put the line with i += 1 after the if block - what is the value of i then?\n",
    "# (careful with indentation! *after*, not *inside* the if block...)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_list = list(range(10))\n",
    "# a non-empty list implicitly evaluates to True\n",
    "while a_list:\n",
    "    # pop removes and returns the last element\n",
    "    elem = a_list.pop()\n",
    "    print(\"Popped\", elem)\n",
    "print(a_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_list = []\n",
    "i = 1\n",
    "while len(a_list) < 10:\n",
    "    # \"i % 2\" returns the remainder if you divide the variable i by 2.\n",
    "    # since the number 0 also evalues to False we enter the if block\n",
    "    # if i is a number that is divisible without rest by 2\n",
    "    if not (i % 2):\n",
    "        a_list.append(i)\n",
    "    i += 1\n",
    "# which numbers does a_list contain and how many?\n",
    "# print(a_list)\n",
    "# print(len(a_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `any` and `all`\n",
    "\n",
    "`any()` and `all()` are functions that can be applied to a list and work similar to `and` and `or`:\n",
    "\n",
    "`any(a_list)` evaluates to `True` if any of the elements in `a_list` evaluate to `True`\n",
    "\n",
    "`all(a_list)` evaluates to `True` if all the elements evaluate to `True`, i.e., the list does not contain e.g. `0`, `False`, `None`, `\"\"`, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_list = [10, \"hey\", -0.2, True]\n",
    "print(\"original list all:\", all(a_list))\n",
    "print(\"original list any:\", any(a_list))\n",
    "a_list.append(None)  # exercise: try something else here\n",
    "print(\"modified list all:\", all(a_list))\n",
    "print(\"modified list any:\", any(a_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `break` and `continue`\n",
    "\n",
    "`break` and `continue` are special keywords that can be used inside loops to stop the computation early (`break`) or skip the computation for an iteration (`continue`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# before you execute this: what do you expect the output to be?\n",
    "for i in range(15):\n",
    "    if i >= 10:\n",
    "        break\n",
    "    if i % 2:\n",
    "        continue\n",
    "    print(i)\n",
    "print(\"Done with the loop!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Comprehensions\n",
    "\n",
    "List (and dictionary) comprehensions are a really neat way to quickly generate a list or dictionary in a single line. It's also more efficient than appending elements to a list or dictionary in a loop (due to the way memory is allocated). It might look a bit complicated at first, but once you get it you'll use it all the time!\n",
    "\n",
    "The key to understanding list comprehensions is to think about what they would look like as ordinary for loops. They always have the structure:\n",
    "```\n",
    "[(expression) (for loops and if statements)]\n",
    "```\n",
    "Which is the same as\n",
    "```\n",
    "for loops and if statements:\n",
    "    expression\n",
    "```\n",
    "i.e., the for loops and if statements are always in the same order, only that normally they are spread out over multiple lines with indentation, while in a list comprehension they are in a single line one after another and without a `:` between them. The expression that is normally inside one or multiple loops is at the beginning of the list comprehension.\n",
    "\n",
    "Check out the [documentation](https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions) for more complex examples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# simple example:\n",
    "a_list1 = [i**2 for i in range(10)]\n",
    "print(a_list1)\n",
    "\n",
    "# the same in a for loop\n",
    "a_list2 = []\n",
    "for i in range(10):\n",
    "    a_list2.append(i**2)\n",
    "print(a_list2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# you can also include if statements to filter the elements\n",
    "a_list1 = [i**2 for i in range(10) if i % 2]\n",
    "print(a_list1)\n",
    "\n",
    "# the same in a for loop\n",
    "a_list2 = []\n",
    "for i in range(10):\n",
    "    if i % 2:\n",
    "        a_list2.append(i**2)\n",
    "print(a_list2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# or use multiple for loops\n",
    "[(x, y) for x in [1, 2, 3] for y in [1, 2, 3] if x != y]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_of_lists = [range(5), range(14), range(7), range(22)]\n",
    "\n",
    "# a more complicated example that combines multiple for loops and if statements\n",
    "a_list1 = [x for inside_list in list_of_lists if len(inside_list) > 5 for x in inside_list if x > 10]\n",
    "print(a_list1)\n",
    "\n",
    "a_list2 = []\n",
    "# go through the list of lists\n",
    "for inside_list in list_of_lists:\n",
    "    # continue only if the inside list has more than 5 elements\n",
    "    if len(inside_list) > 5:\n",
    "        # go through the elements of the inside list\n",
    "        for x in inside_list:\n",
    "            # continue only if the element is larger than 10\n",
    "            if x > 10:\n",
    "                a_list2.append(x)\n",
    "print(a_list2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dictionary comprehensions work the same, you just use {} instead of []\n",
    "# and map key to values with k: v\n",
    "a_dict = {i: i**2 for i in range(10)}\n",
    "print(a_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Error handeling\n",
    "\n",
    "As you've seen before, sometimes our code can throw an error, which stops the computation right then and there and the code exits with this error. Often, this is good, since it shows us that we didn't think of something and should go back and improve our code. Other times though, errors are expected behavior and we don't want them to cause our program to come to a complete halt. Instead, we can wrap code that might throw an error at some point (e.g. a request to a website that can be temporarily unavailable) in a `try`-`except`-block:\n",
    "```python\n",
    "try:\n",
    "    # code that might throw an error\n",
    "except:\n",
    "    # the error has occured! what now?\n",
    "```\n",
    "Above is the simplest way of handeling all errors that might occur. Usually you want to be more specific, e.g., if you expect a specific type of error to be thrown in the `try` part, then only catch this kind error. This way you still might notice ways to improve your code since you still get all the unexpected error messages that signal that you missed something.\n",
    "\n",
    "If you write\n",
    "```python\n",
    "except:\n",
    "    pass\n",
    "```\n",
    "the error will simply be ignored and we move on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sentence = \"this is a string with many words some words occur many times this this is is is a a a a a\"\n",
    "# count how often each word occurs in the string above\n",
    "# the dict should contain a mapping with {word: count}\n",
    "count_dict = {}\n",
    "for word in sentence.split():\n",
    "    # for each word in the sentence we want to increase its count by one\n",
    "    try:\n",
    "        count_dict[word] += 1\n",
    "    # you already know that we get a KeyError if we try to access or manipulate\n",
    "    # the value associated with a key that doesn't exist yet.\n",
    "    # here we can use this to initialize the count for this word in these cases\n",
    "    except KeyError:\n",
    "        count_dict[word] = 1\n",
    "# we're done counting! create some nice output by printing the words with decreasing frequency\n",
    "for word in sorted(count_dict, key=count_dict.get, reverse=True):\n",
    "    # :10 is similar to :.2f: we tell the string how many spaces it should take up\n",
    "    print(f\"{word:10}: {count_dict[word]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions\n",
    "\n",
    "Functions are great to organize your code to avoid copy & paste of frequently used computations and reuse code in other projects. A function should always have a single clear purpose and be self-contained.\n",
    "\n",
    "A function consists of at least two lines: the function signature, specifying the name of the function and its arguments, i.e., values you give the function based on which it computes something, and a return value, typically the result of the computation:\n",
    "```python\n",
    "def name_of_function(argument1, argument2, arg_with_default1=10, arg_with_default2=\"hey\"):\n",
    "    # some code\n",
    "    return \"Hello World!\"\n",
    "```\n",
    "When you call a function, the order of the arguments matters (or you have to specify the argument names) and you have to provide at least as many values as there are arguments without default values. E.g., the above function could be called with:\n",
    "```python\n",
    "new_var = name_of_function(13, 5.7, arg_with_default2=\"ha\")\n",
    "```\n",
    "Since we're leaving `arg_with_default1` at it's default value 10, we need to specify the name of the following argument to give it a new value, otherwise the function would just go by the ordering of the arguments and \"ha\" would be assigned to `arg_with_default1` instead.\n",
    "\n",
    "`new_var` now contains the result of the function, i.e., whatever was returned (in this case just always the string \"Hello World!\", no matter what you had passed as arguments). A function can also return multiple values, in this case just catch the results with multiple variables:\n",
    "```python\n",
    "var1, var2 = function_with_2_return_values()\n",
    "```\n",
    "\n",
    "Careful: when you write a function, only access variables in that function that you have either defined in the function itself or passed as arguments. While it doesn't give you an error here in the notebook, normally (i.e. in regular scripts), the code inside a function does not know about any variables defined in the surrounding code. This also makes your code easier to debug."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# a simple function to add 2 numbers\n",
    "def add_numbers(a, b=10):\n",
    "    print(f\"[add_numbers] a is {a}, b is {b}\")\n",
    "    return a + b\n",
    "\n",
    "c = add_numbers(5, 9)\n",
    "print(c)\n",
    "# without the second argument we just add the default value to the given first value\n",
    "d = add_numbers(5.5)\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# not specifiying enough arguments produces an error\n",
    "e = add_numbers()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def square(x):\n",
    "    return x**2\n",
    "\n",
    "# functions can be used in many places, e.g., when sorting a dictionary, we have already seen that\n",
    "# we can sort the keys by the values. With custom functions, we can sort by anything!\n",
    "a_list = [0, 7, -5, 19, -6, 89, -100]\n",
    "# sort the list based on the return values of the square function\n",
    "# i.e., compute square(i) for every i in the list and then use these values to sort the original values\n",
    "sorted(a_list, key=square)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# functions can also have multiple return statements - the first one that is encountered will be taken\n",
    "def is_greater_than_10(a_number):\n",
    "    if a_number > 10:\n",
    "        # if it's greater than 10, we enter the block and exit the function early\n",
    "        return True\n",
    "    # otherwise we end up here and can return something else\n",
    "    print(\"[is_greater_than_10] skipped the if block!\")\n",
    "    return False\n",
    "\n",
    "print(\"return value for -5:\", is_greater_than_10(-5))\n",
    "print(\"return value for 10:\", is_greater_than_10(10))\n",
    "print(\"return value for 11:\", is_greater_than_10(11))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Lambda functions\n",
    "\n",
    "Lambda functions are anonymous functions, i.e., they are not defined by name and instead of the keyword `def`, they are defined with `lambda`. Usually, they are very short (one liners!) and straightforward, and therefore often used to define functions that are passed as arguments to other functions such as `sorted()` or `max()`.\n",
    "\n",
    "For example, in the cell above, we sorted `a_list` by passing the `square()` function to the `key` argument to sort the values in the list based on their squared values. This can be done in a more concise way by using a lambda function instead of defining a separate function (especially if this function is not used anywhere else in the code):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# x is the argument that is passed to the function and what comes after the : is the return value\n",
    "# (also works with multiple arguments, i.e., could also define, e.g., lambda x, y: x + y)\n",
    "sorted(a_list, key=lambda x: x**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Classes\n",
    "\n",
    "Classes, the cornerstone of \"object-oriented programming\", are very useful to collect a bunch of variables (in this case refered to as \"attributes\") and functions (here called \"methods\") that belong together in a meaningful way. After having defined a class, we can then create instances of this class, which are variables that are of the type of the class and on which we can call the methods that we have defined for this class. \n",
    "\n",
    "In the end, classes are not much different from the data types that you have already encounterd. For example, lists and strings also come with pre-defined methods that can only be called on variables of this type (e.g. `a_str.split()`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# code to define a simple class\n",
    "\n",
    "class Rectangle():\n",
    "    \n",
    "    def __init__(self, side1, side2=10):\n",
    "        # this function is called automatically when you create a new\n",
    "        # instance of the class Rectangle. You need to pass the respective \n",
    "        # values if no defaults are specified for the arguments.\n",
    "        # \"self\" is a special argument that references the object itself and is passed implicitly.\n",
    "        # when initializing a new object, you save the values that were passed \n",
    "        # and thereby create attributes of the object\n",
    "        self.side1 = side1\n",
    "        self.side2 = side2\n",
    "        \n",
    "    def get_area(self):\n",
    "        # this is a method that can be called on every instance of the class Rectangle\n",
    "        # since it only has \"self\" as an argument, you don't need to pass any values when calling it\n",
    "        return self.side1 * self.side2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create an instance of the class defined above\n",
    "rect = Rectangle(20)\n",
    "# its type is the class that we defined\n",
    "print(type(rect))\n",
    "# we can access the object's attributes\n",
    "print(rect.side1, rect.side2)\n",
    "# and call the get_area method on the object\n",
    "print(rect.get_area())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# you can create as many instances of the class as you want\n",
    "rect_new = Rectangle(4, 5)\n",
    "print(rect_new.side1, rect_new.side2)\n",
    "print(rect_new.get_area())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accessing code defined outside this notebook\n",
    "\n",
    "The great thing about Python is that a lot of other people have written a lot of very useful code that you can use for your own projects. However, by default, your code only knows the variables and functions that you have defined here yourself (together with some very basic standard functions like `len()` and `max()`). To get access to all the other great code, you need to **import** it, so your code knows how to call on it.\n",
    "\n",
    "These are the standard ways to import code:\n",
    "```python\n",
    "import some_library\n",
    "# you can now access all the functions, classes, etc. defined in some_library\n",
    "# by calling some_library.function_that_i_need()\n",
    "\n",
    "# with \"as\" you can define a shortcut name on which you can call the functions of the library\n",
    "import some_library_with_a_very_long_name as long_lib\n",
    "# so instead of calling \"some_library_with_a_very_long_name.function_that_i_need()\"\n",
    "# you can just call \"long_lib.function_that_i_need()\"\n",
    "\n",
    "# sometimes you only need a very specific function or class from a library\n",
    "# then you can also import it directly\n",
    "from some_library import function_that_i_need\n",
    "# now instead of calling \"some_library.function_that_i_need()\"\n",
    "# you just call \"function_that_i_need()\" directly, i.e., as if you had defined it in your own code here\n",
    "\n",
    "# sometimes the functions that you need are in a submodule of the library\n",
    "# this is accessed with a \".\". Also, multiple things that you want to import\n",
    "# from a (sub)module can be separated by commas:\n",
    "from some_library.submodule_name import another_function, Some_Class\n",
    "# you can now call \"another_function()\" and \"Some_Class()\" directly\n",
    "\n",
    "# Never do this:\n",
    "from some_library import *\n",
    "# this would import all the functions, classes, variables etc. from some_library, \n",
    "# but now it can easily happen that you accidentally call something from the library\n",
    "# even though you wanted to access something else by the same name, but you didn't\n",
    "# know that you had imported it with the wildcard *\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import the date submodule from the datatime library:\n",
    "from datetime import date\n",
    "\n",
    "# call a function on what you have imported \n",
    "date.today()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Importing your own code\n",
    "\n",
    "If you write some functions or classes that you would like to use in other projects, you can copy them to a text file that you save with a .py ending (e.g. `my_script.py`) and then you can put this file in the same folder as your project notebook and then in the notebook import the functions or classes that you want to use from your script\n",
    "```python\n",
    "from my_script import my_function\n",
    "```\n",
    "By storing general purpose code outside of the notebook, it is easier to reuse and makes your notebook more readable by reducing the code to the essentials."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## You're done!\n",
    "#### Go check out the exercises!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}