2_Fundamentals.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "284b591f-c876-44a0-b703-ffba7a0db6e9",
   "metadata": {},
   "source": [
    "<img src=\"images/bwHPC_Logo_cmyk.svg\" width=\"200\" /> <img src=\"images/HochschuleEsslingen_Logo_RGB_DE.png\" width=\"200\" /> <img src=\"images/Konstanz_Logo.svg\" width=\"200\" /> <img src=\"images/KIT_Logo.png\" width=\"200\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e122d0f-7821-4cee-bd9d-1848cc7702c5",
   "metadata": {},
   "source": [
    "## Python Grundlagen\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ee0c7d2-9831-472d-8855-a290ed6d4b7b",
   "metadata": {},
   "source": [
    "* [Datentypen](#Datentypen)\n",
    "    * [str](#str)\n",
    "    * [int](#int)\n",
    "    * [float](#float)\n",
    "    * [complex](#complex)\n",
    "    * [list](#list)\n",
    "    * [tuple](#tuple)\n",
    "    * [range](#range)\n",
    "    * [dict](#dict)\n",
    "    * [set](#set)\n",
    "    * [frozenset](#frozenset)\n",
    "    * [bool](#bool)\n",
    "    * [bytes](#bytes)\n",
    "    * [bytearray](#bytearray)\n",
    "    * [memoryview](#memoryview)\n",
    "* [Explizite Typumwandlung](#Explizite-Typumwandlung)\n",
    "* [Verschachtelte Datentypen](#Verschachtelte-Datentypen)\n",
    "* [Multiple Names und mutable](#Multiple-Names-und-mutable)\n",
    "* [Scopes: nonlocal und global](#Scopes:-nonlocal-und-global)\n",
    "* [Operatoren](#Operatoren)\n",
    "    * [Arithmetische Operatoren](#Arithmetische-Operatoren)\n",
    "    * [Bitweise Operatoren](#Bitweise-Operatoren)\n",
    "    * [Zuweisungen](#Zuweisungen)\n",
    "* [Kontrollstrukturen](#Kontrollstrukturen)\n",
    "    * [if, elif und else](#if,-elif-und-else)\n",
    "    * [Vergleichsoperatoren](#Vergleichsoperatoren)\n",
    "        * [Inhaltsvergleich](#Inhaltsvergleich)\n",
    "        * [Adressvergleich](#Adressvergleich)\n",
    "        * [Vergleichsoperatoren für Aufzählungen](#Vergleichsoperatoren-für-Aufzählungen)\n",
    "        * [Boolsche Operatoren](#Boolsche-Operatoren)\n",
    "        * [Vergleich von Datentypen](#Vergleich-von-Datentypen)\n",
    "    * [Schleifen](#Schleifen)\n",
    "        * [while](#while)\n",
    "        * [for](#for)\n",
    "* [Index und Slice](#Index-und-Slice)\n",
    "* [Funktionen](#Funktionen)\n",
    "    * [ohne Parameter und Return-Wert](#ohne-Parameter-und-Return-Wert)\n",
    "    * [Parameter](#Parameter)\n",
    "    * [default-Parameter](#default-Parameter)\n",
    "    * [variable Parameter Anzahl](#variable-Parameter-Anzahl)\n",
    "    * [Return-Wert](#Return-Wert)\n",
    "    * [Funktion im Scope einer Funktion](#Funktion-im-Scope-einer-Funktion)\n",
    "    * [Funktion als Variable](#Funktion-als-Variable)\n",
    "    * [Funktion als Parameter](#Funktion-als-Parameter)\n",
    "    * [Keyword Arguments](#Keyword-Arguments)\n",
    "    * [variable Keyword Parameter Anzahl](#variable-Keyword-Parameter-Anzahl)\n",
    "    * [variable Parameter und Keyword Parameter Anzahl](#variable-Parameter-und-Keyword-Parameter-Anzahl)\n",
    "    * [Typ Annotation](#Typ-Annotation)\n",
    "    * [Funktionen und mutable Parameter](#Funktionen-und-mutable-Parameter)\n",
    "    * [Generator Funktionen](#Generator-Funktionen)\n",
    "    * [Decorator Funktionen](#Decorator-Funktionen)\n",
    "    * [Lambda Funktionen](#Lambda-Funktionen)\n",
    "* [Klassen](#Klassen)\n",
    "    * [Klassen-Variablen](#Klassen-Variablen)\n",
    "    * [Instanz-Variablen](#Instanz-Variablen)\n",
    "    * [Sichtbarkeit von Klassen- und Instanz-Variablen](#Sichtbarkeit-von-Klassen--und-Instanz-Variablen)\n",
    "    * [Methoden](#Methoden)\n",
    "    * [Sichtbarkeit von Methoden](#Sichtbarkeit-von-Methoden)\n",
    "    * [Vererbung](#Vererbung)\n",
    "    * [vordefinierte Methoden-Namen](#vordefinierte-Methoden-Namen)\n",
    "    * [Ändern von Klassen/Objekten zur Laufzeit](#Ändern-von-Klassen/Objekten-zur-Laufzeit)\n",
    "    * [Iterators](#Iterators)\n",
    "* [Exceptions](#Exceptions)\n",
    "* [With, \\_\\_enter\\_\\_, \\_\\_exit\\_\\_ und yield](#With,-__enter__,-__exit__-und-contextmanager)\n",
    "* [Module und import](#Module-und-import)\n",
    "* [Environment erstellen](#Environment-erstellen)\n",
    "* [Environment für folgende Übungen](#Environment-für-folgende-Übungen)\n",
    "* [Hinweise zu Jupyter](#Hinweise-zu-Jupyter)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2bf831fb-009c-4427-8f82-4197d68299ee",
   "metadata": {},
   "source": [
    "### Data types\n",
    "\n",
    "Python provides several built-in data types. These include complex data structures such as key value mappings, sets and lists. These built-in data types are shown in the following table together with certain attributes:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4faae9d-94b1-4cdf-b68a-38ac15a3679b",
   "metadata": {},
   "source": [
    "| Category        | Python built-in data type    | mutable   | Sequence    |\n",
    "|-----------------|------------------------------|-----------|-------------|\n",
    "| Text            | str                          |           | ordered     |\n",
    "| Numeric         | int, float, complex          |           |             |\n",
    "| Sequences       | list, tuple, range           | list      | ordered     |\n",
    "| Mappings        | dict                         | dict      | unordered   |\n",
    "| Sets            | set, frozenset               | set       | unordered   |\n",
    "| Booleans        | bool                         |           |             |\n",
    "| Binaries        | bytes, bytearray, memoryview | bytearray | ordered     |\n",
    "| None            | NoneType                     |           |             |\n",
    "\n",
    "Data types in Python are implicitedly set upon assigning a value to a variable. This allows a variable to change data types. In the following examples, all of the built-in datatypes listed above are created by assigning a corresponding value. However, always the same variable named \"x\" will be used. It's data type thereforechanges from assignment to assignment\n",
    "\n",
    "Actually, this behaviour of data type by assignment is somewhat simplified. We will examine the actual behaviour later on in section [Multiple Names und mutable](#Multiple-Names-und-mutable)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08018c7b-b3e4-431a-84e8-289373b7bd4b",
   "metadata": {},
   "source": [
    "#### str\n",
    "\n",
    "Python implements text strings as built-in data type str as an immutable sequence of Unicode characters. This means, that any changes of the text (e.g. to concated multiple strings) will create new objects of data type str as well. To stress the fact: as Unicode is used, non-ASCII characters are inherently supported.\n",
    "\n",
    "For methods available for string objects, see  https://docs.python.org/3/library/stdtypes.html#string-methods.\n",
    "\n",
    "If a mutable, modifiable character string is required, please use bytearray. A bytearray object however is a sequence of single bytes (see below [bytearray](#bytearray)).\n",
    "Therefore, a str object is not easily encodable as bytearray and vice-versa as the encoding has to match (ASCII, utf-8, utf-16, etc.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "808e1893-a0bd-4824-afca-aa7c24d51ec0",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "x = \"This is a short text\" # a str is immutable\n",
    "print(str(type(x)) + \": \" + x)\n",
    "print(\"Object ID (in CPython the memory address): \" + str(id(x)))\n",
    "# The following attempt to change this str object will lead to an error:\n",
    "#x[4] = \"_\"\n",
    "\n",
    "y = x + \" with addendum\" # this creates another str object\n",
    "print(str(type(y)) + \": \" + y)\n",
    "print(\"Objekt ID (in CPython the memory address): \" + str(id(y)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f64a476-2c72-407c-ae30-f5fd7ca1ba2a",
   "metadata": {},
   "source": [
    "In the example above, the output of print() will create another str object by concatenation of multiple strings. Alternatively, a new string may be created using place holders:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "51b9d679-e072-4198-9b14-3d9ab68a6bf2",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "x = \"This is a short text\"\n",
    "y = f\"{x} with addendum\" # using the statement \"f\" prior to the string, all variables in the curly braces will be substituted \n",
    "print(f\"{type(y)}: {y}\")\n",
    "print(\"{type(y)}: {y}\") # without the \"f\", the curly braces are not interpreted, but are literally printed as part of the text\n",
    "print(f\"{type(y)}: {{{y}}}\") # double curly braces may be used to \"escape\" braces (to show them in the output)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2cb851f3-1b22-4f9e-82cc-bc58588eede0",
   "metadata": {},
   "source": [
    "Line breaks in a str may be inserted using the character string \"\\n\". Alternatively, you may declare the str starting and ending with triple quote signs -- such a str may contain multiple line breaks in source."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2b58d678-ac48-4beb-8857-243776b77dd9",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "x = \"A short text\\nwith a line break.\"\n",
    "print(x)\n",
    "x = \"A Text\\n\\\n",
    "with line break.\" # the last backslash \"\\\" after the line break \"\\n\" masks the \"true\" line break at the end of the line\n",
    "print(x)\n",
    "x = \"\"\"A longer text\n",
    "with multiple\n",
    "line breaks.\"\"\"\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84ea50b2-43d5-4b4a-a85f-dc124bcdf96d",
   "metadata": {},
   "source": [
    "#### int\n",
    "\n",
    "The data type int stores integers. In contrast to languages like C/C++ and Java, there's no upper limit for the numbers representable with a Python 3 int. The largest representable integer depends only on available memory. Therefore, silent overflows are not possible, either."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "af83ab54-d93e-437f-af25-d96a146b4e0d",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "\n",
    "x = 1\n",
    "print(str(type(x)) + \": \" + str(x))\n",
    "\n",
    "print(sys.int_info) # see https://docs.python.org/3/library/sys.html"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e72065b-c33c-477b-9d7e-6f8bdbd51f2c",
   "metadata": {},
   "source": [
    "#### float\n",
    "\n",
    "Floating point numbers are stored in the built-in data type float."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4c518c1c-c1bb-44be-b486-8ea8606c0dce",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "\n",
    "x = 1.1\n",
    "print(str(type(x)) + \": \" + str(x))\n",
    "\n",
    "print(sys.float_info) # see https://docs.python.org/3/library/sys.html"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ac18d28-7fd0-4a8e-bd03-4f4fab5cee72",
   "metadata": {},
   "source": [
    "#### complex\n",
    "\n",
    "Complex numbers are first-class citizens in Python. The imaginary unit is not marked using i, but rather j as is usual in Electronics. The package cmath offers many methods to deal with complex numbers and convert between other data types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0bc220aa-7389-4439-b7e1-855ae0d397b4",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "x = 2+1j\n",
    "x = complex(2, 1) # is an equivalent assignment\n",
    "print(str(type(x)) + \": \" + str(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "348de807-d66b-4eeb-8c63-626fb499196d",
   "metadata": {},
   "source": [
    "#### list\n",
    "\n",
    "The list datatype is avaiable for sorted and modifiable enumerations of objects. A list may be composed of objects of different data types.\n",
    "\n",
    "For an introduction and a list of methods, please see https://www.w3schools.com/python/python_ref_list.asp."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a37416aa-3f6f-4831-9e34-e8d7e0c5d0c3",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "x = [\"1\", 1, 1.0] # a list ist mutable: it may be modified after assignment\n",
    "print(str(type(x)) + \": \" + str(x))\n",
    "x[2] = 2\n",
    "x.append(1.0)\n",
    "print(str(type(x)) + \": \" + str(x))\n",
    "x.remove(\"1\")\n",
    "print(str(type(x)) + \": \" + str(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0044b71-971e-47cb-a841-26ba92cd977f",
   "metadata": {},
   "source": [
    "#### tuple\n",
    "\n",
    "In contrast to a list, a variable of data type tuple is ordered, but not modifiable.\n",
    "\n",
    "For a description and a list of methods, please see https://www.w3schools.com/python/python_ref_tuple.asp."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6a4bbbaa-2a22-4e91-8bad-fa81e2703118",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "x = (\"1\", 1, 1.0) # A tuple is immutable: after assignment, it may not be modified\n",
    "                  # (therefore is hashable and may be used as key in a dict, see below)\n",
    "print(str(type(x)) + \": \" + str(x))\n",
    "# The following modification will result in error\n",
    "#x[2] = 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "675e9a3e-f3fd-4c2a-9b04-9e4488c4d417",
   "metadata": {},
   "source": [
    "#### range\n",
    "\n",
    "Ranges of numbers may be expressed using the range function. The function range() takes one to three arguments. If passed only one argument `n`, it creates an integer range starting at 0 with up to `n-1` (step size 1). Passing two arguments `n` and `m` will lead to a integer range of `n`, `n+1` up to `m-1` with a step size of 1. Passing three arguments, one may pass the step size (apart from 0). Therefore it is possible to even count down from large to small integers.\n",
    "\n",
    "Using range, one may easily define large ranges, without manually having to write down the whole range as would have been the case with a list or a tuple. This is specifically useful for counter variables in loops (see [for](#for))."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dd42a230-0af3-423c-9705-4b274f47bf08",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "x = range(5) # all integers starting with zero up to but excluding five: (0, 1, 2, 3, 4)\n",
    "print(str(type(x)) + \": \" + str(x))\n",
    "for n in x:\n",
    "    print(n)\n",
    "\n",
    "x = range(2,5) # all integers starting from two up to but excluding five: (2, 3, 4)\n",
    "print(str(type(x)) + \": \" + str(x))\n",
    "for n in x:\n",
    "    print(n)\n",
    "\n",
    "x = range(4,-1,-2) # Attention: All integers starting from four counting down in steps of -2 up to but excluding -1: (4, 2, 0)\n",
    "print(str(type(x)) + \": \" + str(x))\n",
    "for n in x:\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4987efd4-664e-4912-ad2f-066b9e4b0042",
   "metadata": {},
   "source": [
    "#### dict\n",
    "\n",
    "A `dict` contains the enumeration of key-value pairs. The `dict` is mutable and unordered (starting with Python 3.7 a dict is ordered). The syntax when creating a dict is similar to the JSON Syntax. As keys one may use any Python obects (immutable and mutable), as long as they are hashable (see https://docs.python.org/3/glossary.html#term-hashable). Access to single elements in a `dict` is accomplished by passing the Key in square brackets or using the `dict`'s methods  such as `get()` or `values()`.\n",
    "\n",
    "For a description of the available methods, please see https://www.w3schools.com/python/python_ref_dictionary.asp."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "65269414-0661-4428-8dbd-ddf19ddf35eb",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "x = {\"key1\": \"value1\", \"key2\": 5, \"key3\": [5, 4, \"test\"], 2: \"test1\", (5, 3): \"test2\"}\n",
    "print(str(type(x)) + \": \" + str(x))\n",
    "x[\"key2\"] = 7\n",
    "print(str(type(x)) + \": \" + str(x))\n",
    "x[2] = 2\n",
    "print(str(type(x)) + \": \" + str(x))\n",
    "x[(5, 3)] = \"test3\"\n",
    "print(str(type(x)) + \": \" + str(x))\n",
    "x.pop(\"key3\")\n",
    "print(str(type(x)) + \": \" + str(x))\n",
    "x[\"new_key\"] = \"new_value\"\n",
    "print(str(type(x)) + \": \" + str(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42a03754-15dc-4c9c-99f7-7ba9738e4c2f",
   "metadata": {},
   "source": [
    "#### set\n",
    "\n",
    "Sets are created using the set data type. A set is mutable and unordered. A certain element may only exist once in a set.\n",
    "\n",
    "For a description an a list of methods, please see https://www.w3schools.com/python/python_ref_set.asp."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c7c66735-5862-4f42-aa66-5c2c3672aa5b",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "x = {\"one\", \"two\", \"three\"}\n",
    "print(str(type(x)) + \": \" + str(x))\n",
    "x.add(\"four\")\n",
    "print(str(type(x)) + \": \" + str(x))\n",
    "x.add(\"one\")                 # A set may contain one element only once!\n",
    "print(str(type(x)) + \": \" + str(x))\n",
    "x.remove(\"one\")              # now it's gone\n",
    "print(str(type(x)) + \": \" + str(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2b32e6d-5adc-4281-861d-e306efa33255",
   "metadata": {},
   "source": [
    "#### frozenset\n",
    "\n",
    "This is the immutable (non-modifiable) alternative to a `set`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1ab9a247-8826-477f-9404-e0479701a0bc",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "x = frozenset({1, 2, 3}) # immutable set\n",
    "# Any attempts to modifiy a frozenset will lead to errors:\n",
    "#x.add(4)  # actually, these methods are not available\n",
    "#x.add(1)\n",
    "print(str(type(x)) + \": \" + str(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4216feb0-7bb5-49bc-8c39-a8aa882ed43c",
   "metadata": {},
   "source": [
    "#### bool\n",
    "\n",
    "A single binary value (either `True` or `False`) is best represented using the base data type `bool`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c4bba3e6-d910-4940-a042-4c8ac8d45dcb",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "x = True         # please note the capital letter\n",
    "print(str(type(x)) + \": \" + str(x))\n",
    "x = False        # please note the capital letter\n",
    "print(str(type(x)) + \": \" + str(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da1d7011-17ad-4c10-abc0-0660ec1b929f",
   "metadata": {},
   "source": [
    "#### bytes\n",
    "\n",
    "An ordered and immutable sequence of Bytes which may defined with the `bytes()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f8d6ddf8-6304-4646-98a2-4a9148824bc8",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = bytes(5)          # five Bytes initialized with the value 0\n",
    "print(str(type(x)) + \": \" + str(x))\n",
    "x = b\"This is a text\" # immutable initialization of a byte sequence\n",
    "print(str(type(x)) + \": \" + str(x))\n",
    "# The following modification leads to an error\n",
    "#x[4] = b\"_\"\n",
    "x = x.decode(\"utf-8\") # interpreting the bytes as utf-8 characters, converting to a str\n",
    "print(str(type(x)) + \": \" + str(x))\n",
    "x = x.encode(\"utf-8\") # converting back from str to Bytes\n",
    "print(str(type(x)) + \": \" + str(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8d96a77-ff6d-4b64-bc69-2424dc85ab9b",
   "metadata": {},
   "source": [
    "#### bytearray\n",
    "\n",
    "An ordered and mutable sequence of Bytes, which may be defined using the `bytearray()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e5dc0222-ac7b-40a5-8bef-f9f40bd03c1b",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "x = bytearray(5)      # five Bytes initialized with the value 0\n",
    "print(str(type(x)) + \": \" + str(x))\n",
    "x = bytearray(\"This is a text\", \"utf-8\") # text as mutable array\n",
    "print(str(type(x)) + \": \" + str(x))\n",
    "x[4] = 95             # which equates to ASCII \"_\" character\n",
    "print(str(type(x)) + \": \" + str(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9183e6a-3033-45f0-9810-6d82f3525871",
   "metadata": {},
   "source": [
    "#### memoryview\n",
    "\n",
    "Using the `memoryview()` function, Python offers access to internal data of an object. To do so, the corresponding object must support Python's buffer protocol (e.g. bytes or bytearray object). In this case, the function `memoryview()` creates a new object from the passed object without copying, offering fast access to extract data.\n",
    "\n",
    "More about the buffer protocol, please see https://docs.python.org/3/c-api/buffer.html."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "67bfbced-90f2-4f10-857f-7ecf7ffa765f",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "x = memoryview(bytearray(\"This is a text\", \"utf-8\"))\n",
    "\n",
    "print(str(type(x)) + \": \" + str(x))\n",
    "\n",
    "print(x[0])       # ASCII value of \"T\" ist 84"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ccdaf3fd-a4fe-4bd2-ac5e-f410bd2e3dbb",
   "metadata": {},
   "source": [
    "### Explicit Type conversion\n",
    "\n",
    "A data type may be chosen explicitely, by casting the type upon assignment of the value. In the following example, each built-in datatype is cast explicitely:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a2c55245-08a4-430d-af6f-f26f43b8a1d8",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "x = str(\"This is a text\")\n",
    "x = int(1)\n",
    "x = float(1.1)\n",
    "x = complex(2, 1j)\n",
    "x = list((\"1\", 1, 1.0))     # Explicit cast of a tuple to a list\n",
    "x = tuple((\"1\", 1, 1.0))\n",
    "x = range(5)\n",
    "# For function calls, keyword arguments may only contain valid identifier:\n",
    "# A dict with keys such as 2 or (5,3) may not be created:\n",
    "# x = dict(key1=\"value1\", key2=5, key3=[5, 4, \"test\"], 2=\"test1\", (5, 3)=\"test2\")\n",
    "x = dict(key1=\"value1\", key2=5, key3=[5, 4, \"test\"])\n",
    "x = {\"key1\": \"value1\", \"key2\": 5, \"key3\": [5, 4, \"test\"], 2: \"test1\", (5, 3): \"test2\"}\n",
    "x = dict(x)    # Alternative for keys such as 2 and (5, 3): first create a dict then cast to a dict\n",
    "x = set((\"one\", \"two\", \"three\")) # Cast from tuple to list\n",
    "x = frozenset((1, 2, 3)) # Cast from tuple to set\n",
    "x = bool(True)\n",
    "x = bytes(b\"This is a text\")\n",
    "x = bytearray(b\"This is a text\")\n",
    "x = memoryview(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d24cc24d-1658-4bd7-b19c-f2d5909f619f",
   "metadata": {},
   "source": [
    "### Nested Data types\n",
    "\n",
    "Sets, lists and dicts may as well be used as elements of sets, lists and dicts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1a86fa71-1cf1-47ed-9ca5-ee730ad1a200",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "x = {\"list_of_list\": [[2,3,4],[2,4,6],[[\"test1\", \"test2\"],[\"test3\", \"test4\"]]]}\n",
    "print(str(type(x)) + \": \" + str(x))\n",
    "\n",
    "x = x[\"list_of_list\"][2]\n",
    "print(str(type(x)) + \": \" + str(x))\n",
    "\n",
    "x = x[1][0]\n",
    "print(str(type(x)) + \": \" + str(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c321bc60-ec6a-4541-96a0-dc8cd38d4f1a",
   "metadata": {},
   "source": [
    "### Multiple Names und mutable\n",
    "\n",
    "In Python, variables (sometimes called names) are always pointers/references to an object (sometimes called value). A variable is defined within a scope and only visible in this scope. The object itselve is stored in global memory and therefore visible outside of the scope it was created in. For this to work, it needs to be passed to another scope (e.g. as parameter of a function call). By assignment, multiple variables may point to the same object. An object is preserved, until the last reference to this object is deleted (e.g. the scope of all variables has exited, or it has been explicitely deleted using the `del` function)\n",
    "\n",
    "This is realised in Python by storing Variables as references to objects on the Stack, while the objects are stored in the Heap memory.\n",
    "\n",
    "Variables do not have a data type, the data type is stored with the object. Technically, a variable therefore cannot change it's data type. But by assignment, the variable may point to another data type.\n",
    "\n",
    "![image](images/Python_Variables.svg)\n",
    "\n",
    "If multiple names point to an immutable object, an assignment of a new object to a one of the names, just this variable references the new object. Since the original object us immutable, an assignment cannot change the object itselve. Instead, the affected name references the new object, while all other names still point to the original object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "111d0a60-a833-43d4-946c-b0f85cf074fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1\n",
    "# Assignment creates a new immutable object of type int\n",
    "# carrying the value 1, and let's x reference this object\n",
    "y = x\n",
    "# Assignment lets the name y point to the same object as x\n",
    "x = 2\n",
    "# Since int is immutable, this assignment creates a new\n",
    "# object of type int with value 2, and let's x reference\n",
    "# this new object.\n",
    "# The name y still points to the original object with value 1\n",
    "print(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ecd2a418-18b7-48e3-a9c9-f556e1c706d7",
   "metadata": {},
   "source": [
    "For a mutable object, the content of the object may not be changed without creating a new object and switching references. Therefore, a change by assignment of such a mutable object will change the value for all names, that reference the same object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ef253b14-cf74-4197-99d3-26324e413cd1",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [1]\n",
    "# Assignment creates a new mutable object of type list\n",
    "# with one element of type int with a value of 1; and\n",
    "# lets the name x reference the list object.\n",
    "y = x\n",
    "# Assignment lets the name y reference the same object\n",
    "# as name x\n",
    "x = [2]\n",
    "# We do not change the original mutable object, but rather\n",
    "# create a new object of type list with one element of\n",
    "# type int with a value of 2; assigns the name x the\n",
    "# reference to the new list object.\n",
    "# y still points to the original list object.\n",
    "\n",
    "print(x)\n",
    "print(y)\n",
    "\n",
    "x = [1]\n",
    "y = x\n",
    "x[0] = 2\n",
    "# HERE we change the content of the mutable list object\n",
    "# Therefore, no new object is created, x and y point to\n",
    "# the same object. This now contains a new value for both names.\n",
    "\n",
    "print(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cbe17b0c-a5f4-40a1-9fb9-240b2f392732",
   "metadata": {},
   "source": [
    "Relationship between data types, name and value:\n",
    "\n",
    "- Names (Variables) have a Scope (the extent of validity of the name) but not a type,\n",
    "- Values (Objekte) have a data type but not a scope.\n",
    "\n",
    "Therefore\n",
    "- Passing parameters to functions/methods is always done by reference \n",
    "- the crucial difference is, whether the parameter (to which the reference points) is mutable or ímmutable\n",
    "- \"primitive\" data types (such as int, float, complex, str and bool) are immutable\n",
    "- Data is not deleted upon exiting a Scope, but rather when the last reference to the data is gone (name is out of scope or is explicitely deleted using the function `del`)\n",
    "- large objects should, as soon as they are not required anymore, explicitely deleted using the `del` function\n",
    "\n",
    "More information on: https://nedbatchelder.com/text/names.html"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53973848-f627-48ed-843b-e82fc9b6c5ca",
   "metadata": {},
   "source": [
    "### Scopes: nonlocal and global\n",
    "\n",
    "Using the Python keyword nonlocal and global, names / variables may be references from the surrounding (nonlocal) or the global Scoope. The global scope here is the actual module, but not a class within the module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "32558a20-8c22-4b12-b5d5-4a74113e0333",
   "metadata": {},
   "outputs": [],
   "source": [
    "def scope_changes():\n",
    "    def local_change():\n",
    "        z = \"strictly local change\" # a new variable z is created in local Scope and reference a new object of type str, which is filled\n",
    "\n",
    "    def nonlocal_change():\n",
    "        nonlocal z\n",
    "        z = \"nonlocal change\" # the variable z from the surrounding (nonlocal) scope references a new object of type str and filled\n",
    "\n",
    "    def global_change():\n",
    "        global z\n",
    "        z = \"global change\" # the variable z from global Scope references another new object of type str and filled\n",
    "\n",
    "    z = \"orignal value\"\n",
    "    local_change()\n",
    "    print(\"after local_change:    \" + z) # changes in local scope have no effect outside of their scope\n",
    "    nonlocal_change()\n",
    "    print(\"after nonlocal_change: \" + z) # changes in the respective scope access via nonlocal keyword the variable in surrounding scope\n",
    "    global_change()\n",
    "    print(\"after global_change:   \" + z) # changes in the respective scope access via global keywod the variable in the global scope\n",
    "\n",
    "scope_changes()\n",
    "print(\"In global Scope:    \" + z)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58b62805-ab60-4e66-bbac-5bf2e6ce1fef",
   "metadata": {},
   "source": [
    "### Operators\n",
    "\n",
    "Opreators for comparison are presented in a later chapter on control structures: [Vergleichsoperatoren](#Vergleichsoperatoren)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89a33942-c3c4-4e1f-8c5a-02719ee9f8ac",
   "metadata": {},
   "source": [
    "#### Arithmetic Operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a6d5e4e-5541-457e-8127-5cfa5e494494",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Addition:                5 + 5 = \" + str(5 + 5))\n",
    "\n",
    "print(\"Subtraction:             5 - 5 = \" + str(5 - 5))\n",
    "\n",
    "print(\"Multiplication:          5 * 5 = \" + str(5 * 5))\n",
    "\n",
    "print(\"Division:                5 / 5 = \" + str(5 / 5))\n",
    "\n",
    "print(\"Division (rounding):     5 / 2 = \" + str(5 / 2))\n",
    "\n",
    "print(\"Modulo:                 12 % 5 = \" + str(12 % 5))\n",
    "\n",
    "print(\"Exponentiation:         2 ** 3 = \" + str(2 ** 3))\n",
    "\n",
    "print(\"Division w/o remainder: 5 // 2 = \" + str(5 // 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa85711f-a248-4722-8034-57c886726fb3",
   "metadata": {},
   "source": [
    "#### Bitwise Operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fb21310d-79bd-4746-b118-6ec307b9845b",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"AND:                  3 & 1 = \" + str(3 & 1))     # 0001 = 0011 & 0001\n",
    "\n",
    "print(\"OR:                   3 | 1 = \" + str(3 | 1))     # 0011 = 0011 | 0001\n",
    "\n",
    "print(\"XOR:                  3 ^ 1 = \" + str(3 ^ 1))     # 0010 = 0011 | 0001\n",
    "\n",
    "print(\"NOT:                  ~3 = \" + str(~3))           # 1100 = ~0011 (sign bit is set; negative values start at -1)\n",
    "\n",
    "print(\"Zero fill left shift: 1 << 2 = \" + str(1 << 2))   # 0100 = 0001 << 2\n",
    "\n",
    "print(\"Zero fill left shift: -1 << 2 = \" + str(-1 << 2)) # 0100 = 0001 << 2 (sign bit not shifted)\n",
    "\n",
    "print(\"Signed right shift:   4 >> 1 = \" + str(4 >> 1))   # 0010 = 0100 >> 1\n",
    "\n",
    "print(\"Signed right shift:   -4 >> 1 = \" + str(-4 >> 1)) # 0010 = 0100 >> 1 (sign bit not shifted)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1740e13-405b-4a76-9636-ca57ed6fdebe",
   "metadata": {},
   "source": [
    "#### Assignments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1a9475fd-d41d-461e-b555-b5c6cbe815ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 5\n",
    "print(\"x = 5: x = \" + str(x))\n",
    "\n",
    "x, y = (5, 7) # Amount of variables to the left of the assignment must match the number of values assigned on the right\n",
    "print(\"x, y = (5, 7): x = \" + str(x) + \", y = \" + str(y))\n",
    "\n",
    "x, y, z = [7, 8, 9] # Again the amount of variables must mathc the number of values on the right of the assignment\n",
    "print(\"x, y, z = [7, 8, 9]: x = \" + str(x) + \", y = \" + str(y) + \", z = \" + str(z))\n",
    "\n",
    "x += 7 # short for: x = x + 7\n",
    "print(\"x += 7: x = \" + str(x))\n",
    "\n",
    "x -= 4 # short for: x = x - 4\n",
    "print(\"x -= 4: x = \" + str(x))\n",
    "\n",
    "x *= 2 # short for: x = x * 2\n",
    "print(\"x *= 2: x = \" + str(x))\n",
    "\n",
    "x /= 5 # short for: x = x / 5\n",
    "print(\"x /= 5: x = \" + str(x)) # Division automatically changes the data type to float\n",
    "\n",
    "x %= 3 # short for: x = x % 3\n",
    "print(\"x %= 3: x = \" + str(x))\n",
    "\n",
    "x //= 0.3 # short for: x = x // 0.3\n",
    "print(\"x //= 0.3: x = \" + str(x))\n",
    "\n",
    "x **= 2 # short for: x = x ** 2\n",
    "print(\"x **= 2: x = \" + str(x))\n",
    "\n",
    "y &= 9 # short for: y = y & 9; 1000 = 1000 & 1001\n",
    "print(\"y &= 9: y = \" + str(y))\n",
    "\n",
    "y |= 9 # short for: y = y | 9; 1001 = 1000 | 1001\n",
    "print(\"y |= 9: y = \" + str(y))\n",
    "\n",
    "y ^= 8 # short for: y = y ^ 8; 0001 = 1001 ^ 1000\n",
    "print(\"y ^= 8: y = \" + str(y))\n",
    "\n",
    "y <<= 2 # short for: y = y << 2; 0100 = 0001 << 2\n",
    "print(\"y <<= 2: y = \" + str(y))\n",
    "\n",
    "y >>= 1 # short for: y = y >> 1; 0100 = 0010 >> 1\n",
    "print(\"y >>= 1: y = \" + str(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7007f4c6-b4fe-4260-8654-cb6194a4b22b",
   "metadata": {},
   "source": [
    "### Control structures\n",
    "\n",
    "Python uses new lines and indentation as part of the Syntax! New code-blocks / scopes are started after an instruction followed by a colon \":\". Every instruction wthin the corresponding block/scope is indeted by one level. Indentation may be a tab character or spaces."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6ee0fa1-598f-45c7-957f-55848d7a0e04",
   "metadata": {},
   "source": [
    "#### if, elif and else"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1516559e-e2c9-4c6e-acff-8c63199bfc57",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 1\n",
    "b = 2\n",
    "\n",
    "if a < b:\n",
    "    print(\"a is smaller than b\")\n",
    "    print(\"anther output dependant on this if-statement\")\n",
    "elif a == b:\n",
    "    print(\"a is equal to b\")\n",
    "else:\n",
    "    print(\"a is larger than b\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ee6176a-090e-4958-a5c2-1c082bf70816",
   "metadata": {},
   "source": [
    "#### Comparison operators"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85d96a39-9475-4128-aaf4-3125236c94ef",
   "metadata": {},
   "source": [
    "##### Comparing content\n",
    "\n",
    "Operators for comparison of the content of variables always compare the de-refenced content, never the address referenced.\n",
    "\n",
    "| Operator |                  |\n",
    "|----------|------------------|\n",
    "| <        | smaller than     |\n",
    "| <=       | smaller or equal |\n",
    "| \\>       | larger than      |\n",
    "| \\>=      | larger or equal  |\n",
    "| ==       | equal            |\n",
    "| !=       | unequal          |"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9819c325-81fb-4087-a784-d8dcadd9626a",
   "metadata": {},
   "source": [
    "##### Address comparison\n",
    "\n",
    "Comparison of the referenced address (object-pointer):\n",
    "\n",
    "|Operator |                             |\n",
    "|---------|-----------------------------|\n",
    "| is      | is memory reference equal   |\n",
    "| is not  | is memory reference unequal |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "42e0413a-6b49-440a-aba5-3b646dfa521d",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1, 2]\n",
    "b = [1, 2]\n",
    "c = a\n",
    "\n",
    "if a is b:\n",
    "    print(\"a and b reference the same memory\")\n",
    "elif a == b:\n",
    "    print(\"a and b have the same content\")\n",
    "else:\n",
    "    print(\"a and b have different content\")\n",
    "\n",
    "if a is c:\n",
    "    print(\"a and c reference the same memory\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46c530ae-82c0-473f-94ee-ff020d433848",
   "metadata": {},
   "source": [
    "##### Comparison operators for sequences\n",
    "\n",
    "Operators to check whether elements ore part of a sequence (set, list or tuples):\n",
    "\n",
    "| Operator |                                         |\n",
    "|----------|-----------------------------------------|\n",
    "| in       | whether element is part of sequence     |\n",
    "| not in   | whether element is not part of sequence |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2bd7ad55-727a-4b9e-be00-344d4b8434cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "some_list = ['a','b','c']\n",
    "some_item = \"a\"\n",
    "\n",
    "if some_item in some_list:\n",
    "    print(\"a is part of some_list\")\n",
    "else:\n",
    "    print(\"a is not part of some_list\")\n",
    "\n",
    "if \"d\" not in some_list:\n",
    "    print(\"d is not part of some_list\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c79b37ee-4d8b-4335-b52a-e2431e590b35",
   "metadata": {},
   "source": [
    "The following examples show, how the in Operator may be used on for-loops based generators and the functions `any()` and `all()` to check for existence of multiple elements within a sequence.\n",
    "\n",
    "For loops as well as Generators will be covered later:\n",
    "\n",
    "[More information on for loops](#for)\n",
    "\n",
    "[More information on generators](#Generator-Funktionen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a69c8249-a6d0-4a51-94c3-9d9c5b23b316",
   "metadata": {},
   "outputs": [],
   "source": [
    "some_list = ['a','b','c']\n",
    "\n",
    "for i in (i for i in ('a', 'b')): # for loop as generator, used in the outer loop\n",
    "    print(i)\n",
    "\n",
    "if all(i in some_list for i in ('a', 'b')):\n",
    "    print(\"a and b are part of some_list\")\n",
    "\n",
    "if all(i in some_list for i in ('a', 'c')):\n",
    "    print(\"a and c are part of some_list\")\n",
    "\n",
    "if all(i in some_list for i in ('a', 'd')): # d is NOT in some_list: i in some_list is for 'b' False => all will return False\n",
    "    print(\"a and d are not part of some_list\")\n",
    "\n",
    "if any(i in some_list for i in ('a', 'd')): # a is part of some_list, therefore any() returns True in generator as soon as one element is found\n",
    "    print(\"a or d is part of some_list\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78fa6d3a-5a44-419f-9b1f-51713e4c3cc8",
   "metadata": {},
   "source": [
    "##### Boolean Operator\n",
    "\n",
    "| Operator |                                    |\n",
    "|----------|------------------------------------|\n",
    "| not      | negates a boolean value            |\n",
    "| and      | True if both values are True       |\n",
    "| or       | True if at least one value is True |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7d07c22c-af62-4a7d-83d1-68066308412a",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1, 2]\n",
    "b = [1, 2]\n",
    "\n",
    "if not(a < b) and not(a > b):\n",
    "    print(\"a is equal to b\")\n",
    "elif a == 0 or a < b:\n",
    "    print(\"a is 0 or smaller than b\")\n",
    "\n",
    "a = 0\n",
    "\n",
    "# a is int, b is a list => Comparison is not valied:\n",
    "#if not(a < b) and not(a > b):\n",
    "#    print(\"a is equal to b\")\n",
    "#elif a == 0 or a < b:\n",
    "#    print(\"a is 0 or smaller than b\")\n",
    "\n",
    "b = -1\n",
    "\n",
    "if not(a < b) and not(a > b):\n",
    "    print(\"a is equal to b\")\n",
    "elif a == 0 or a < b:\n",
    "    print(\"a is 0 or smaller than b\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2754cf4-c3f3-42e1-bb14-7e6c4d7f5924",
   "metadata": {},
   "source": [
    "##### Comparison of data types\n",
    "\n",
    "Comparison of objects using `type()`, `isinstance()` and `issubclass()`:\n",
    "\n",
    "The function `type()` returns the data type of the object. A comparison of two objects using `type()` checks whether two objects have equal data type with discerning inheritance or classes. To check whether an object is of a certain class or part of a derived class, `type()` is not the proper tool. In this case `isinstance()` checks whether an object is of a certain class A or a from A derived class B. Using the function `issubclass()` one may compare two classes withouth having to create an object of either class; instead it checks whether a class is derived from the other.\n",
    "\n",
    "Classes are handled later: [More information on classes](#Klassen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e5e97d55-437d-4758-93f2-02d5a53472c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "class base1:\n",
    "    pass\n",
    "class base2:\n",
    "    pass\n",
    "class sub(base1):\n",
    "    pass\n",
    "\n",
    "a = base1()\n",
    "b = base2()\n",
    "c = sub()\n",
    "\n",
    "if type(a) is base1:\n",
    "    print(\"a is of type base1\")\n",
    "if type(c) is base1:\n",
    "    print(\"c is of type base1\")\n",
    "if isinstance(c, base1):\n",
    "    print(\"c is of class type base1 or derived from base1\")\n",
    "if isinstance(b, (base1, base2)):\n",
    "    print(\"b is of class type base1, of class type base2 or of a class type derived from base1 or base2\")\n",
    "if issubclass(sub, base1):\n",
    "    print(\"sub is derived from class type base1\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f0299e5-cf87-4308-96b3-3b7a4baef5e6",
   "metadata": {},
   "source": [
    "#### Loops\n",
    "\n",
    "Python defines two types of loops: while and for."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cad14fe7-7bf3-4945-b098-02a07dd94591",
   "metadata": {},
   "source": [
    "##### while\n",
    "\n",
    "The while loops repeat a code block as long as the condition evaluates to True. As soon as the condition evaluates to False, the optional else-branch is executed. A single iteration may be skipped using the keyword continue. After skipping this iteration the condition is checked again and the cycle repeats. Using the keyword break, the complete loop may be aborted. In this case the condition is not checked -- and therefore the option else-branch will not be executed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aac8bceb-e747-4520-8ab1-af2741beddba",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 0\n",
    "while x < 10:\n",
    "#    if x == 1:\n",
    "#        x += 1\n",
    "#        continue\n",
    "#    elif x == 8:\n",
    "#        break\n",
    "    print(x)\n",
    "    x += 1\n",
    "else:\n",
    "    print(\"x == 10, may not be executed in case the break has issued abort the loop\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8af8393-5c64-43fb-930c-705158a78924",
   "metadata": {},
   "source": [
    "##### for\n",
    "\n",
    "The for-loops execute a code block for every element in the sequence or in a set. As soon as the inner code block has been executed for every element, the optional else-branch is executed and the loop exited afterwards. Like with while-loops the loop-body may be skipped using the keyword continue to skip to the next element in the sequence -- or exit the loop if the sequence is depleted. Using the break keyword, the loop's body will be aborted -- the optional else-branch will not be executed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9bb22b18-1a41-4ee3-8663-a17cccbb153e",
   "metadata": {},
   "outputs": [],
   "source": [
    "seq = ['a','b','c']\n",
    "for item in seq:\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a1cfdb4a-de0c-4299-aa21-fe078ae8a077",
   "metadata": {},
   "outputs": [],
   "source": [
    "for n in range(2):\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7606444a-2023-4b84-874b-a11f1980dcab",
   "metadata": {},
   "outputs": [],
   "source": [
    "for n in range(5,7):\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bdf631d6-ea4f-46d2-9a9a-f70191814af4",
   "metadata": {},
   "outputs": [],
   "source": [
    "for n in range(0,5,2):\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bff35908-9ebf-4ebe-93a8-6c51548e2b63",
   "metadata": {},
   "outputs": [],
   "source": [
    "for n in range(4,-1,-2):\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ff0af65a-74a0-475d-b2ee-985cd6e051a3",
   "metadata": {},
   "outputs": [],
   "source": [
    "seq = ['a','b','c']\n",
    "for i, item in enumerate(seq):\n",
    "    print(\"{}: {}\".format(i, item))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6e687eb3-8640-48b4-9d41-56b8755a3b46",
   "metadata": {},
   "outputs": [],
   "source": [
    "seq = ['a','b','c']\n",
    "for i, item in enumerate(seq, start=1):\n",
    "    print(\"{}: {}\".format(i, item))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e4b7a724-5883-4f04-bb1a-b0c5f694290a",
   "metadata": {},
   "outputs": [],
   "source": [
    "seq = ['a','b','c']\n",
    "values = [97, 98, 99]\n",
    "for ascii_char, code in zip(seq, values):\n",
    "    print(\"{}: {}\".format(ascii_char, code))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ce867a57-b986-4e1a-873c-0af0c2df2859",
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(4):\n",
    "    print(i)\n",
    "else:\n",
    "    print(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "12b64d9a-ddda-463d-b658-e6df1c263a59",
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(4):\n",
    "    print(i)\n",
    "    if i == 3:\n",
    "        break\n",
    "else:\n",
    "    print(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4a08575-1e56-4567-8e23-089268adfef5",
   "metadata": {},
   "source": [
    "### Index and Slice\n",
    "\n",
    "Using a positive index, any element starting form the first element -- or using a negative index any element relative to the last element -- may be accessed. Please check the following table.\n",
    "\n",
    "Instead of single elements, whole slices referenced by a start- and an end-index may be selected. If these slices refer to mutable objects, this slice may be used to update or change elements within the slice. The amount of changed data does not have to equal the amount of elements in the original data.\n",
    "\n",
    "Apart from start- and end-index, one may also supply a step size, to select every n-th element within the slice. An update of a slice with step size unequals to one is however only possible, if the number of new / changes elements match exactly the number of selected elements."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f964f2cf-199f-4ddc-96c2-71c7c4c20834",
   "metadata": {},
   "source": [
    "| Sequence (list, tuple, range) or text (str) |t |e |s |t |\n",
    "|-------------------------------------------------|--|--|--|--|\n",
    "| Index relative to first Element                 | 0| 1| 2| 3|\n",
    "| Index relative to the last Element              |-4|-3|-2|-1|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "19bf624e-c152-4a7c-8dbd-5e9765737489",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = \"test\"\n",
    "print(\"Index 1 references the second Element: \" + str(x[1]))\n",
    "print(\"Index -2 references the second to last Element: \" + str(x[-2]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a30f37e9-fdf9-41eb-9b06-e93e2793da3b",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = (\"t\",\"e\",\"s\",\"t\")\n",
    "print(\"Index 1 references the seoncd Element: \" + str(x[1]))\n",
    "print(\"Index -2 references the second to last Element: \" + str(x[-2]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "288d68e5-6d44-43dc-b5b1-8417a280e730",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = (\"t\",\"e\",\"s\",\"t\")\n",
    "# Access out of the valid area will lead to runtime errors\n",
    "#x = x[4]   # 0 to 3 is valid\n",
    "#x = x[-5]  # -1 to -4 is valid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8469e17e-ac90-4820-9657-519aa3141310",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [\"t\",\"e\",\"s\",\"t\"] # is mutable\n",
    "print(x)\n",
    "x[0] = \"r\"\n",
    "print(x)\n",
    "x[-1] = \"u\"\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0fd4457c-c06e-4910-800d-e3420dff0268",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = \"this is a long text\"\n",
    "print(\"Slice starting from the beginning up to (excluding) index 4: \" + x[:4])\n",
    "print(\"Slice starting from infrec 5 up to (exclusing) index 8: \" + x[5:8])\n",
    "print(\"Slice starting from index 9 up to (exclusing) index -5: \" + x[9:-5])\n",
    "print(\"Slice starting from index -4 up to the end: \" + x[-4:])\n",
    "print(\"Slice from the beginning to the end, only every other element: \" + x[::2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fa3eaa55-2c12-4795-9554-23400764693b",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = \"this is a test\"\n",
    "# a slice outside of the valid range will lead empty sets:\n",
    "print(\"Invalid slice [13:20]: \" + x[13:20])\n",
    "print(\"Invalid slice [20:25]]: \" + x[20:25])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e8a32c41-4223-4897-90dc-6d0a0b03d957",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = bytearray(b\"this is a Test\") # we need a mutable object\n",
    "\n",
    "x[0:2] = b\"This\"\n",
    "print(x)\n",
    "\n",
    "x[-4:] = b\"automobil\"\n",
    "print(x)\n",
    "\n",
    "x[11:11] = b\"n\"\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "54859cbd-c4a4-4b42-93fb-1759bc6280cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [1,2,3,4,5,6,7] # we need a mutable object\n",
    "\n",
    "x[-2:] = (8,9,10)\n",
    "print(x)\n",
    "\n",
    "x[:] = []\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "60a48ecc-c7e0-426e-83e3-ca1049d19bf5",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = (1,2,3,4,5,6,7)\n",
    "s = slice(None,None,2)\n",
    "\n",
    "print(x[s])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f16da50f-a0dc-4ac8-8314-9c9ff72ea28f",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [1,2,3,4,5,6,7] # we need a mutable object\n",
    "s = slice(None,None,2)\n",
    "\n",
    "x[s] = (9,9,9,9) # an \"extended\" slice requires the correct amount of elements to replace\n",
    "#x[s] = (9,9) # Error, since only two instead of four elements to replace\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8fbfc185-30e7-4a9a-90a9-1e036ea471f0",
   "metadata": {},
   "source": [
    "### Functions\n",
    "\n",
    "Functiosn in Pythons are defined without datatype for parameters or the return valued. The data type is defined at runtime by the passed objects and may be checked then.\n",
    "\n",
    "Instead of proper checking, often programmers rely on the runtime environment: if the object passed to the function provides all the operators and the called object methods, then the object may be properly processed. If however an inappropriate object is passed, the corresponding error is thrown as soon as an non-existing operation or method is supposed to be executed. Therefore functions may cope with different datatypes in the parameters (see Duck Typing below)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79ce7bb6-bfce-4054-828c-6d9221a810eb",
   "metadata": {},
   "source": [
    "#### Without parameter and without return value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c2a64d0c-e3a5-4136-9647-7eabe8966fe6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_something():\n",
    "    print(\"something\")\n",
    "\n",
    "print_something() # calling the function defined above"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef7bf043-4f5f-4c58-9715-7bf9bbfd589d",
   "metadata": {},
   "source": [
    "#### Parameter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e89c0238-e0ba-4025-8c7a-641bc9cca9a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_value(i):\n",
    "    print(\"value: \" + str(i))\n",
    "\n",
    "# Duck Typing: \"If it looks like a duck and quacks like a duck, it’s a duck\"\n",
    "#\n",
    "# every variable and every object may be passed to function print_value,\n",
    "# as long as the function str() is valid for the passed parameter\n",
    "#\n",
    "# => the datatype of the function does not matter as long as the methods and operators work with them\n",
    "print_value(2)\n",
    "print_value(2.0)\n",
    "print_value(\"2\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49ef98f8-d4b3-4aca-8905-ba1530bc9c76",
   "metadata": {},
   "source": [
    "#### default parameter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a5d5a4be-43d4-4ca5-a89d-19151690d64f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_default(i = 10): # please note the default value\n",
    "    print(\"value: \" + str(i))\n",
    "\n",
    "print_default(2)\n",
    "print_default()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40708baa-42b6-4e46-8487-0e80e1baa743",
   "metadata": {},
   "source": [
    "#### Variable number of parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "59c3350e-9362-4bcf-b252-2bef4ed90b70",
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_multiple_values(*values): # please note the *\n",
    "    for v in values:\n",
    "        print(v)\n",
    "\n",
    "print_multiple_values(1, 2, 3, 4, \"finish\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55993d92-dc64-419b-aab2-61306ac2e496",
   "metadata": {},
   "source": [
    "#### Return values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "28dd1579-71eb-4b5e-82fd-471d4a756212",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_string(i):\n",
    "    return \"value: \" + str(i)\n",
    "\n",
    "print(get_string(42))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e71b9e52-722c-4053-810e-3e7f28ca1c2f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_multiple_values(i):\n",
    "    return i, \"value: \" + str(i) # creates a tuple (i, \"value: \" + str(i)) and returns these\n",
    "\n",
    "i = get_multiple_values(42) # assigns the tuple to the variable\n",
    "print(i)\n",
    "\n",
    "i, s = get_multiple_values(42) # assigns the elements of the tuple to corresponding variables (first to i, second to s)\n",
    "print(i)\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c6b164e-5cd8-4bc1-bd79-bf04942039da",
   "metadata": {},
   "source": [
    "#### Function in the scope of another function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "947dc959-cd16-4926-a7b5-85ced6aea2f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def outer(i):\n",
    "    def inner(i):\n",
    "        print(\"value: \" + str(i))\n",
    "    inner(i)\n",
    "\n",
    "outer(42)\n",
    "#inner(42) # in this scope function inner() is not known and will lead to a runtime error"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d208b73-7d37-4158-bd45-ffdec77b4b55",
   "metadata": {},
   "source": [
    "#### Function as a variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eaabc16d-5583-4b99-be91-9d98bcbf924e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def function(i):\n",
    "    print(\"value: \" + str(i))\n",
    "\n",
    "f = function\n",
    "f(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f34b68f5-e771-4d43-ab89-5f3575ed2901",
   "metadata": {},
   "source": [
    "#### Function as a parameter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fe03c2db-bb48-431d-81cb-faa4aee666ce",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_string(i):\n",
    "    return \"value: \" + str(i)\n",
    "\n",
    "def call_other_function(func, param):\n",
    "    print(\"return \" + func(param))\n",
    "\n",
    "call_other_function(get_string, 42)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b7a802f-0b6b-49a4-baf2-f7de035ad4cc",
   "metadata": {},
   "source": [
    "#### Keyword Arguments\n",
    "\n",
    "Keyword arguments allow an arbitrary order of parameters and together with default values (see above) another possibility to make functions more readable and extensible without having to change existing callers. For example, the following function call may still be used if `call_other_function` has been amended by another parameter with a default value, such as in `call_other_function(func, repeat=1, param)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d2dc5f8a-6fed-44ad-ab91-8964d57876ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_string(i):\n",
    "    return \"value: \" + str(i)\n",
    "\n",
    "def call_other_function(func, param):\n",
    "    print(\"return \" + func(param))\n",
    "\n",
    "call_other_function(param=42, func=get_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "688cd26f-638d-48f4-bacd-ce128e99fbe4",
   "metadata": {},
   "source": [
    "#### Variable number of keyword parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ead7a12c-0392-43bc-ba92-ddbf441997f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_multiple_values(**values): # please note the **\n",
    "    for v in values:\n",
    "        print(str(v) + \": \" + str(values[v]))\n",
    "\n",
    "print_multiple_values(a = 1, b = 2, c = 3, d = 4, e = \"finish\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5bad3520-9c11-4381-b3ad-a2dd65b00c2c",
   "metadata": {},
   "source": [
    "#### Variable number of parameters and keyword parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "60fecbda-981b-4bfa-b9e7-b4c202757e35",
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_multiple_values(*values, **kwvalues):  # please note the * and the **\n",
    "    for v in values:\n",
    "        print(v)\n",
    "    for v in kwvalues:\n",
    "        print(str(v) + \": \" + str(kwvalues[v]))\n",
    "\n",
    "print_multiple_values(1, 2, \"test\", a = 1, b = 2, c = 3, d = 4, e = \"finish\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41c928aa-c882-4b1c-bd68-4f37c7517ef9",
   "metadata": {},
   "source": [
    "#### Type Annotation\n",
    "\n",
    "Type annotation in the function's declaration provides a hint to the developper, however otherwise will not have any implication upon execution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a33ac98b-9745-4219-8f35-01ce376e40dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "def call_with_type_annotation(a:int, b:int) -> int:\n",
    "    return a + b\n",
    "\n",
    "print(call_with_type_annotation(1, 2))\n",
    "print(call_with_type_annotation(1.1, 2.0)) # Attention: Type annotation is just a hint to the developper (does not have any other implication)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c611cc55-2693-4382-a6db-15a2c21ea264",
   "metadata": {},
   "source": [
    "#### Functions and mutable parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "48509731-a3b4-4c7a-a08c-22cf7beb579b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def mutable_param(some_list):\n",
    "    some_list[0] = 42\n",
    "\n",
    "some_list = [7]\n",
    "print(some_list)\n",
    "\n",
    "mutable_param(some_list)\n",
    "print(some_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ea16a93-b964-4633-933c-477811db37c3",
   "metadata": {},
   "source": [
    "#### Generator Functions\n",
    "\n",
    "Generator functions create sequences of values. These sequence will not be return as one object (e.g. as a list) by the function, but rather every call of this function will yield the next value in the sequence. This is denoted with the keyword `yield`.\n",
    "\n",
    "Generator functions may be used in for-loops: the loop iterates over every value returned by the Generator function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eab899dd-fdb8-4933-ac6c-da5972e6a934",
   "metadata": {},
   "outputs": [],
   "source": [
    "def generator_function():\n",
    "    i = 0\n",
    "    \n",
    "    while i < 10:\n",
    "        yield 2 ** i # keyword yield elevates this function to a generator function:\n",
    "                     # returns 2 ** i (or 2^i in LaTeX Terms) and restarts from the last returned value\n",
    "        i = i + 1\n",
    "\n",
    "for n in generator_function():\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ea27444-57aa-4457-9c59-56b8889f09df",
   "metadata": {},
   "source": [
    "Simple generator functions of course may be re-written as a nested for loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a51bef9e-3d8f-41f4-beb5-ff42856197c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A for-loop is a generator by itselve: (2 ** i for i in range(10))\n",
    "for n in (2 ** i for i in range(10)):\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ca01523-0e4f-43b3-bc90-dde33de052c8",
   "metadata": {},
   "source": [
    "#### Decorator Functions\n",
    "\n",
    "A decorator function receives a function as parameter and returns this together with further instructions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b8b4e638-f48b-42cc-a4bf-babf6fa323a3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sum_up(*items): # a function with variable number of arguments\n",
    "    ret = 0\n",
    "    for i in items:\n",
    "        if ret == 0:\n",
    "            ret = i # the first parameter will set the data type\n",
    "        else:\n",
    "            ret = ret + i\n",
    "    return ret\n",
    "\n",
    "def add(a, b): # a function with two parameters, these may optionally be be passed using keywords\n",
    "    return a + b\n",
    "\n",
    "abs_2 = abs # a built-in Function with just one Argument (we use a variable referencing this function in order not to change it)\n",
    "\n",
    "# The decorator function:\n",
    "def decorator_debug(func): # Extend the passed function by DEBUG-Output of the function name and the passed parameters\n",
    "    def inner(*args, **kwargs): # Passed function supports any parameters and keyword parameters\n",
    "        print(\"DEBUG in \" + str(func))\n",
    "        for p in args:\n",
    "            print(\"DEBUG     param: \" + str(p))\n",
    "        for p in kwargs:\n",
    "            print(\"DEBUG     key: \" + str(p) + \" param: \" + str(kwargs[p]))\n",
    "        return func(*args, **kwargs)\n",
    "    return inner\n",
    "\n",
    "print(sum_up(0,1,2,3,4,5,6,7,8,9))\n",
    "sum_up = decorator_debug(sum_up)\n",
    "print(sum_up(0,1,2,3,4,5,6,7,8,9))\n",
    "\n",
    "print(add(a = 7, b = 7))\n",
    "add = decorator_debug(add)\n",
    "print(add(a = 7, b = 7))\n",
    "\n",
    "print(abs_2(-10))\n",
    "abs_2 = decorator_debug(abs_2)\n",
    "print(abs_2(-10))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c3fb3ed-f106-4ccc-92b8-a82c2299873c",
   "metadata": {},
   "source": [
    "Instead of directly calling the decorator function, Python offers an annotation of the decorated function using the symbol `@`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2a105853-36ea-455b-88c3-23295dfd6b0a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def decorator_debug(func):\n",
    "    def inner(*args, **kwargs):\n",
    "        print(\"DEBUG in \" + str(func))\n",
    "        for p in args:\n",
    "            print(\"DEBUG     param: \" + str(p))\n",
    "        for p in kwargs:\n",
    "            print(\"DEBUG     key: \" + str(p) + \" param: \" + str(kwargs[p]))\n",
    "        return func(*args, **kwargs)\n",
    "    return inner\n",
    "\n",
    "@decorator_debug # identical with: add = decorator_debug(add)\n",
    "def add(a, b):\n",
    "    return a + b\n",
    "\n",
    "print(add(a = 1, b = 2)) # shows output of function, function name, memory address and parameters."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5027a0c0-d586-4ec2-8976-71a769521054",
   "metadata": {},
   "source": [
    "The return values of generator functions may be extended using decorator functions. For this purpose, the decorator function must call the generator function in a for-loop and yield the manipulated return value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "97399ad3-1395-4d93-afcb-fb741a198ae2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def generator_function():\n",
    "    i = 0\n",
    "    while i < 10:\n",
    "        yield i\n",
    "        i = i + 1\n",
    "\n",
    "def decorator_add_one(func):\n",
    "    def inner(): # new internal function, which uses the passed function as generator and passes the value itselve again using yield:\n",
    "        for l in func():\n",
    "            yield l + 1\n",
    "    return inner\n",
    "\n",
    "generator_function = decorator_add_one(generator_function)\n",
    "for n in generator_function():\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f70d031-41b3-489e-a2d4-fd7fbda1e848",
   "metadata": {},
   "source": [
    "Decorator functions may employ the same function multiple times (which will lead to nested function calls):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fd032e85-b373-4adf-acd0-7068e24b0a84",
   "metadata": {},
   "outputs": [],
   "source": [
    "def decorator_add_one(func):\n",
    "    def inner():\n",
    "        for l in func():\n",
    "            yield l + 1\n",
    "    return inner\n",
    "\n",
    "@decorator_add_one # replaces: generator_function = decorator_add_one(generator_function)\n",
    "@decorator_add_one # in case we want to nest this generator twice\n",
    "def generator_function():\n",
    "    i = 0\n",
    "    while i < 10:\n",
    "        yield i\n",
    "        i = i + 1\n",
    "\n",
    "for n in generator_function():\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2ebd20f-1960-44c3-814d-db1d8f352b82",
   "metadata": {},
   "source": [
    "Decorator functions may use their own parameters. However, this requires another function, which will provide a correspondingly parametrised Decorator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a5a812ab-c605-46f2-944b-bca17eb7422a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def generator_function():\n",
    "    i = 0\n",
    "    while i < 10:\n",
    "        yield i\n",
    "        i = i + 1\n",
    "\n",
    "def create_decorator_add(n): # creates Decorator with parameter\n",
    "    def decorator_add(func): # the actual decorator\n",
    "        def inner():\n",
    "            for l in func():\n",
    "                yield l + n\n",
    "        return inner\n",
    "    return decorator_add\n",
    "\n",
    "# first the function will be called, which creates a parametrised decoratorm\n",
    "# which then will be used to extend a provided function.\n",
    "generator_function = (create_decorator_add(4))(generator_function)\n",
    "\n",
    "for n in generator_function():\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4806404-b351-41a9-b58f-f373c3908d85",
   "metadata": {},
   "source": [
    "A parametrised decorator may be used with @ as well:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f6a6f0cd-fd34-4d9d-8520-a4fee6c128ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_decorator_add(n):\n",
    "    def decorator_add(func):\n",
    "        def inner():\n",
    "            for l in func():\n",
    "                yield l + n\n",
    "        return inner\n",
    "    return decorator_add\n",
    "\n",
    "@create_decorator_add(4)\n",
    "def generator_function():\n",
    "    i = 0\n",
    "    while i < 10:\n",
    "        yield i\n",
    "        i = i + 1\n",
    "\n",
    "for n in generator_function():\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38665ebe-2e99-4801-ad7f-e041f78bc271",
   "metadata": {},
   "source": [
    "Finaly an example for timing function calls using decorators:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e66511ec-ba65-4235-9ae5-bed3b3b9c27a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "def measure_time(func):\n",
    "    def inner(*args, **kwargs):\n",
    "        t = time.time()\n",
    "        ret = func(*args, **kwargs)\n",
    "        t = time.time() - t\n",
    "        print(\"time used to call \" + str(func) + \": \" + str(t))\n",
    "        return ret\n",
    "    return inner\n",
    "\n",
    "@measure_time\n",
    "def add(a, b):\n",
    "    return a + b\n",
    "\n",
    "print(add(20, 5))\n",
    "\n",
    "@measure_time\n",
    "def print_str(s):\n",
    "    print(\"A str: \" + s)\n",
    "    \n",
    "print_str(\"Test string\")\n",
    "\n",
    "@measure_time\n",
    "def generator_function():\n",
    "    i = 0\n",
    "    while i < 10:\n",
    "        yield i # here is a problem: the implementation of yield will result in the decorator being called only once.\n",
    "        i = i + 1\n",
    "\n",
    "for n in generator_function():\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44de5b9d-9e8d-49fb-bcc0-ef28e53d0a0e",
   "metadata": {},
   "source": [
    "#### Lambda Functions\n",
    "\n",
    "Lambda functions are small, anonymous functions. They may not be called by name, but rather be used via a variable / a reference."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "69e88e2e-c15b-47f7-88e3-428f70ac453b",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = lambda a : a + 42\n",
    "print(x(5))\n",
    "\n",
    "x = lambda a, b : a + b\n",
    "print(x(40, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "49e31e34-247c-49dc-a9df-df0a2ec45b53",
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_exponential(e):\n",
    "    return lambda n : n ** e\n",
    "\n",
    "exp_1 = create_exponential(1)\n",
    "exp_2 = create_exponential(2)\n",
    "exp_3 = create_exponential(3)\n",
    "\n",
    "print(exp_1(2))\n",
    "print(exp_2(2))\n",
    "print(exp_3(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e0037b0-0311-4e80-96ba-03ef0b1e1a7b",
   "metadata": {},
   "source": [
    "### Classes\n",
    "\n",
    "Classes in Python are defined using the keyword `class`. This keyword is followed by the name of this class and a colon \":\". In the code blockl after the colon, variables and methods of this class may be defined. The position of the variable defines whether this varaieble is a [Class Variable](#Klassen-Variablen) or a [Instance variable](#Instanz-Variablen).\n",
    "\n",
    "After defining a class, instances of this class may be created. These operate just like built-in data types with mutable properties (see also [Multiple names and mutable](#Multiple-Names-und-mutable)), since variables in Python always are references to objects (aka instances). Therefore technically, there is no difference between \"primitive\" data types and class objects when being passed as parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9d561885-bae6-494f-922d-4a42fc2721d5",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Car:\n",
    "    pass # die Definition einer Klasse darf nicht leer sein: das pass Statement löst dieses Problem\n",
    "\n",
    "x = Car() # erstellt ein Objekt vom Typ Car und speichert eine Referenz (Instanz) in der Variable x\n",
    "print(str(type(x)) + \": \" + str(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c6667b70-4950-48e5-bf14-de93d3f3389f",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Car:\n",
    "    pass\n",
    "\n",
    "x = Car # fehlende Klammern: wir erstellen kein Objekt aus der Klasse, sondern nutzen die Klasse direkt\n",
    "del x\n",
    "#print(x) # ergibt einen Fehler, da der Name bzw. die Variable nicht mehr existiert\n",
    "          # evlt. ist hier auch das Objekt bereits gelöscht, da die einzige Variable,\n",
    "          # die das Objekt referenziert hat nicht mehr existiert und damit der\n",
    "          # Garbage Collector aktive werden konnte"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e661d8bd-cc10-4745-b9a4-e906cded26bd",
   "metadata": {},
   "source": [
    "#### Class Variables\n",
    "\n",
    "Variables, which are not within a method, but rather defined within the method are class variables. These class variables exist as just once per class. All instances of this class share this variable. If one instance changes the value of a class variable, all other instances of this class will see the changed value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f94ee2ee-ff6b-4f73-8817-728fc22f50c1",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Car:\n",
    "    wheels = 4\n",
    "    doors = 5\n",
    "\n",
    "x = Car\n",
    "print(str(type(x)) + \": \" + str(x))\n",
    "print(x.wheels)\n",
    "print(x.doors)\n",
    "\n",
    "y = Car\n",
    "y.wheels = 6 # changes the value of the class value: x.wheels now sees value 6, too!\n",
    "y.doors = 3\n",
    "print(x.wheels)\n",
    "print(x.doors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8160ef42-31e7-489e-98e8-1799414de35f",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Car:\n",
    "    wheels = 4\n",
    "    doors = 5\n",
    "\n",
    "x = Car\n",
    "\n",
    "del x.wheels\n",
    "#print(x.wheels) # Will lead to an runtime error, as x.wheels is not available anymore."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d836be0b-5ef7-4d6c-9339-db81a8e24118",
   "metadata": {},
   "source": [
    "#### Instance variables\n",
    "\n",
    "If variables are defined within a method (e.g. within the constructor), this will create an instance variable. These are created in every instance; changing its value in one instance will not change the value in another instance of this class.\n",
    "\n",
    "If a class contains a class variable and an instance variable of the same name, the type of access defines which variable is referenced: if accessing via the class, the class variable is used, otherwise the instance variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "630e4350-a83e-445c-9d7e-77b440aaa8d1",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Car:\n",
    "    def __init__(self, wheels, doors): # self is not a keyword.\n",
    "                                       # The first parameter is the reference to the instance (the object)\n",
    "                                       # It may be named in any way, however self is a good convention...\n",
    "        self.wheels = wheels\n",
    "        self.doors = doors\n",
    "\n",
    "#x = Car() # Error, since arguemnts are missing\n",
    "x = Car(4,5)\n",
    "print(x.wheels)\n",
    "print(x.doors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fa81d53e-b6a0-42c8-93ca-51901989cc89",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Car:\n",
    "    def __init__(self, wheels = 4, doors = 5): # with default values\n",
    "        self.wheels = wheels\n",
    "        self.doors = doors\n",
    "\n",
    "x = Car()\n",
    "y = Car(6,3)\n",
    "print(x.wheels) # was not overwritten with 6: it's an instance variable\n",
    "print(x.doors)\n",
    "print(y.wheels)\n",
    "print(y.doors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3d1d4e2a-0e39-467b-a991-acded4260267",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Car:\n",
    "    wheels = 6\n",
    "    def __init__(self, wheels = 4):\n",
    "        self.wheels = wheels # does not access the class variable, but rather creates a new instance variable!\n",
    "        #Car.wheels = wheels # via the class name, the class variable may be accessed!\n",
    "\n",
    "x = Car()\n",
    "print(x.wheels)   # accessing the instance variable\n",
    "print(Car.wheels) # accessing the class variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fba8af1c-a46b-4227-880c-272611aa29fe",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Car:\n",
    "    def __init__(self, wheels = 4):\n",
    "        self.wheels = wheels\n",
    "    \n",
    "    def get_wheels(self):\n",
    "        #return wheels # one cannot access the class/instance variable only by name \n",
    "                       # one must alway use the class name or the passed name to the object\n",
    "        return self.wheels\n",
    "\n",
    "x = Car()\n",
    "print(x.get_wheels())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9fd20cc5-c5e6-41d8-a0be-c15fa2e0ce43",
   "metadata": {},
   "source": [
    "#### Visibility of Class and Instance Variables\n",
    "\n",
    "Python does not differentiate between private, public and protected like C++ or Java. All variables are public by default (and therefore mutable from outside of the class). However, there are conventions that signal to users of the class, wgether a variable must only be used from within the class.\n",
    "\n",
    "The same is true for [Visibility of methods](#Sichtbarkeit-von-Methoden)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "621e2367-3d84-47df-86e8-54d0cd746217",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Car:\n",
    "    _wheels = 4 # One underscore: Variable should not be changed by users of this class (although it's technically possible)\n",
    "    __doors = 5 # double underscore: Python changes the name of the variable: direct access therefore is not possible!\n",
    "                # (The variable is prepended with a clean class name and a leading underscore, which will NOT make the\n",
    "                # variable private. However, it will resolve naming conflicts.)\n",
    "    __test1_ = 1 # One additional underscore as suffix: will change the name of the variable\n",
    "    __test2__ = 2 # More than one additional underscore as suffix will prohibit changing the name\n",
    "\n",
    "x = Car # missing parentheses: we do not create an instance, but rather reference the class iteselve\n",
    "print(str(type(x)) + \": \" + str(x))\n",
    "\n",
    "print(x._wheels)\n",
    "x._wheels = 6\n",
    "print(x._wheels)\n",
    "\n",
    "#print(x.__doors) # leads to an error, since __doors is not available (it's been renamed)\n",
    "print(x.__dict__) # Shows the complete content of an instance / of the class\n",
    "print(x._Car__doors) # Using this name, we may access the value of the \"hidden\" variable\n",
    "\n",
    "# Once again, however, completely automated\n",
    "d = x.__dict__\n",
    "for key in d:\n",
    "    if key.endswith(\"__doors\"):\n",
    "        print(d[key])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e683639d-e2a5-452d-b5a1-c81fa80afb38",
   "metadata": {},
   "source": [
    "#### Methods\n",
    "\n",
    "Functions that are defined within a class are called it's methods. Methods may either only be called through a object or through the object and class (classmethod/staticmethod). Their first parameter is either a referene to the object, the class (classmethod), or neither (staticmethod). The reference to the object or class is passed automatically when the method is called; it does not have to be listed manually in the parameter list.\n",
    "\n",
    "Python Methods are virtual by default, i.e. methods of the same name of a base class are always overloaded (see [Vererbung](#Vererbung)). Therefore a method of a base class that calls another method defined in the same base class may end up calling a method of a derived class that overloads it (if called from a derived class)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "531346e2-f25a-4c07-a8ba-96da6dce82be",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Car:\n",
    "    def __init__(self, wheels = 4, doors = 5):\n",
    "        self.wheels = wheels\n",
    "        self.doors = doors\n",
    "    \n",
    "    def print(self): # a simple Method: first parameter is always a reference to the object, from where the method was called\n",
    "        print(\"A car with \" + str(self.wheels) + \" wheels \" + str(self.doors) + \" doors.\")\n",
    "    \n",
    "    @classmethod\n",
    "    def print_class(cls): # a class method: first parameter is always the class\n",
    "        print(\"Class: \" + str(cls))\n",
    "    \n",
    "    @staticmethod\n",
    "    def print_static(): # a static method: neither object nor class is passed in\n",
    "        print(\"Static text\")\n",
    "\n",
    "x = Car()\n",
    "x.print()\n",
    "x.print_class()\n",
    "Car.print_class()\n",
    "x.print_static()\n",
    "Car.print_static()\n",
    "\n",
    "x = Car(6,3)\n",
    "x.print()\n",
    "x.print_class()\n",
    "Car.print_class()\n",
    "x.print_static()\n",
    "Car.print_static()\n",
    "\n",
    "#Car.print() # returns a runtime error: calling the method missing the required positional argument self \n",
    "Car.print(x) # Now, the function has the reference to a proper object\n",
    "             # => This is identical to calling x.print()!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "df3901d6-f309-476c-ab31-7d2b136922d1",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Car:\n",
    "    def __init__(self, wheels = 4, doors = 5):\n",
    "        self.wheels = wheels\n",
    "        self.doors = doors\n",
    "    \n",
    "    def print(self, number): # After the reference to self, further parameters may follow\n",
    "        print(str(number) + \": A car with \" + str(self.wheels) + \" wheels and \" + str(self.doors) + \" doors.\")\n",
    "    \n",
    "    @classmethod\n",
    "    def print_class(cls, number): # Also after the reference to the class, further parameters may follow\n",
    "        print(str(number) + \": Class: \" + str(cls))\n",
    "    \n",
    "    @staticmethod\n",
    "    def print_static(number):\n",
    "        print(str(number) + \": Static text\")\n",
    "\n",
    "x = Car(6,3)\n",
    "x.print(1)\n",
    "x.print_class(2)\n",
    "Car.print_class(3)\n",
    "x.print_static(4)\n",
    "Car.print_static(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e2429cb0-1218-48ac-bc19-fbfd172a689b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_wheel(self):\n",
    "    self.wheels += 1\n",
    "\n",
    "class Car:\n",
    "    def __init__(self, wheels = 4, doors = 5):\n",
    "        self.wheels = wheels\n",
    "        self.doors = doors\n",
    "    \n",
    "    add_wheel = add_wheel # A method does not have to be defined within the class.\n",
    "                          # An attribute with a reference suffices.\n",
    "                          # However, this is frowned upon as it's confusing.\n",
    "    \n",
    "    def add_axle(self):\n",
    "        self.add_wheel() # We may call methods from other methods\n",
    "        self.add_wheel() # the calls is by reference.\n",
    "\n",
    "x = Car()\n",
    "print(x.wheels)\n",
    "x.add_wheel()\n",
    "print(x.wheels)\n",
    "x.add_axle()\n",
    "print(x.wheels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5cb1ea31-5cf0-49a3-8e76-52f8b5835377",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Test:\n",
    "    def test_method(self):\n",
    "        print(\"test\")\n",
    "\n",
    "x = Test()\n",
    "test_method = x.test_method\n",
    "\n",
    "test_method()\n",
    "print(test_method.__self__) # Using the reference to an method, we may access the method:\n",
    "test_method.__self__.test_method()\n",
    "print(test_method.__func__) # Using the reference to a method, we may access the function within a class\n",
    "test_method.__func__(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf65f676-84a4-420e-b49a-56bcb2ff4d3b",
   "metadata": {},
   "source": [
    "#### Visibility of Methods\n",
    "\n",
    "As with variables, the same applies to methods: they are generally visible from outside a class or object. This can only be restricted by conventions.\n",
    "\n",
    "See [Visibility of Class- and Instance-variables](#Sichtbarkeit-von-Klassen--und-Instanz-Variablen)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8d6dc316-1358-46b6-bc9d-4fc35cc10b07",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Test:\n",
    "    def __init__(self, i):\n",
    "        #self.add(i)\n",
    "        self.__add(i)\n",
    "    \n",
    "    def add(self, i):\n",
    "        self.i = i\n",
    "    \n",
    "    def __str__(self):\n",
    "        return str(self.i)\n",
    "    \n",
    "    __add = add # private copy with a new name may use __init__, this will show up in the dict below as _Test__add!\n",
    "\n",
    "class Sub_Test(Test):\n",
    "    def add(self, number, i): # Overload the add method with an additional parameter, but not the __add() method!\n",
    "        self.i = str(number) + \": \" + str(i)\n",
    "\n",
    "x = Sub_Test(2)\n",
    "print(Test.__dict__)\n",
    "print(Sub_Test.__dict__) # Please not the difference in the methods, __add is still visible via x._Test__add()\n",
    "print(x.__dict__)\n",
    "print(x)\n",
    "x.add(2, 42)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57822975-c745-405d-a727-37d04593f1c7",
   "metadata": {},
   "source": [
    "#### Inheritence\n",
    "\n",
    "Python supports single and multiple base class inheritance. Since instance variables may be defined inside of methods within a class, overloading of methods may remove instance variables (which other methods might erroneously try to access, leading to runtime errors). The class name of the base class or super functions may be used to call the method of the base class from a overloaded method.\n",
    "\n",
    "When using multiple base classes the name of a variable or a method may already be defined in more than one base class. Resolving the name is done in the order of the base-classes when the derived class was defined. The first class containing the name in question will be referenced. All base classes are subject to depth-first, left-to-right search (not searching twice in the same class where there is an overlap in the inheritance hierarchy).\n",
    "\n",
    "See [Python 3 docu on Multiple Inheritance.](https://docs.python.org/3/tutorial/classes.html#multiple-inheritance)\n",
    "\n",
    "The built-in data types may be used as base classes, themselves."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7d9f11b5-b199-401b-b6e1-a3f3523c271b",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Car:\n",
    "    def __init__(self, wheels=4, doors=5):\n",
    "        self.wheels = wheels\n",
    "        self.doors = doors\n",
    "    \n",
    "    def print(self):\n",
    "        print(\"A car with \" + str(self.wheels) + \" wheels and \" + str(self.doors) + \" doors.\")\n",
    "\n",
    "class Bus(Car): # Bus is derived from car an inherits all methods and variables.\n",
    "    seats = 20\n",
    "\n",
    "x = Bus()\n",
    "print(str(type(x)) + \": \" + str(x))\n",
    "\n",
    "x.print()\n",
    "print(x.seats)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "843cc237-3bcf-423c-8814-94c382cdb5fb",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Car:\n",
    "    def __init__(self, wheels=4, doors=5):\n",
    "        self.wheels = wheels\n",
    "        self.doors = doors\n",
    "    \n",
    "    def print(self):\n",
    "        print(\"A car with \" + str(self.wheels) + \" wheels and \" + str(self.doors) + \" doors.\")\n",
    "\n",
    "class Bus(Car):\n",
    "    def __init__(self, seats=20): # overwrites the init-Methode of the base class (Car)\n",
    "        self.seats = seats\n",
    "\n",
    "x = Bus()\n",
    "\n",
    "x.print() # leasds to an error, since wheels and doors only defined in the init-Methode of the base class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6a744b99-9ef4-4a17-be47-ca77b6c30829",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Car:\n",
    "    def __init__(self, wheels=4, doors=5):\n",
    "        self.wheels = wheels\n",
    "        self.doors = doors\n",
    "    \n",
    "    def print(self):\n",
    "        print(\"A car with \" + str(self.wheels) + \" wheels and \" + str(self.doors) + \" doors.\")\n",
    "\n",
    "class Bus(Car):\n",
    "    def __init__(self, wheels=4, doors=5, seats=20):\n",
    "        self.seats = seats\n",
    "        #Car.__init__(self, wheels, doors) # calls the init method of the base class\n",
    "        super().__init__(wheels, doors) # Better: calls the init method of the bsae class without having to repeat the base-class name.\n",
    "\n",
    "x = Bus()\n",
    "\n",
    "x.print() # Now, all teh required variables are initialized (but since Car doesn't know anything about seats, this information is lost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4624f0cf-7365-49fd-ae39-6cb41d8d7f09",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Car:\n",
    "    def __init__(self, wheels=4, doors=5):\n",
    "        self.wheels = wheels\n",
    "        self.doors = doors\n",
    "    \n",
    "    def print(self):\n",
    "        print(\"A car with \" + str(self.wheels) + \" wheels and \" + str(self.doors) + \" doors.\")\n",
    "\n",
    "class Bus(Car):\n",
    "    def __init__(self, wheels=4, doors=5, seats=20):\n",
    "        self.seats = seats\n",
    "        super().__init__(wheels, doors)\n",
    "\n",
    "class Test1:\n",
    "    def print(self):\n",
    "        print(\"This is a Test\")\n",
    "\n",
    "class Test2:\n",
    "    pass\n",
    "\n",
    "for o in Car(4,5), Bus(6,3), Test1():\n",
    "    o.print() # Duck Typing: print may be called for Car, Bus and Test1, but not Test2\n",
    "              # Even though Car, Bus and Test1 do not share the same base class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "39453a8f-72e3-4d00-8395-806c558d4dd2",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Car:\n",
    "    def __init__(self, wheels=4, doors=5):\n",
    "        self.wheels = wheels\n",
    "        self.doors = doors\n",
    "    \n",
    "    def print(self):\n",
    "        print(\"A car with \" + str(self.wheels) + \" wheels and \" + str(self.doors) + \" doors.\")\n",
    "\n",
    "class Bus(Car):\n",
    "    def __init__(self, wheels=6, doors=3, seats=20):\n",
    "        self.seats = seats\n",
    "        super().__init__(wheels, doors)\n",
    "\n",
    "class Test1:\n",
    "    def print(self):\n",
    "        print(\"This is a test\")\n",
    "\n",
    "class Multi(Bus, Test1): # The order does matter (see below)\n",
    "    pass\n",
    "\n",
    "x = Multi()\n",
    "\n",
    "x.print() # Using the rules above, multiple inheritence is deterministic, even though there are multiple instance of print:\n",
    "          # the order in which Multi derived from its base classes determines, which print function is called.\n",
    "          # Here Multi derives from Bus, which  inherits print() from Car,\n",
    "          # and since Bus is inherited earlier than Test1 -- however the initialization of values happens in Bus' init()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6e513a1f-a46c-4842-a08b-d8c1b5f8125b",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Number(int):\n",
    "    def __str__(self):\n",
    "        return \"Number \" + super().__str__()\n",
    "\n",
    "x = Number()\n",
    "print(Number.__dict__)\n",
    "print(x.__dict__)\n",
    "print(x)\n",
    "\n",
    "x = Number(2)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d0abbe2-c291-4705-8578-f67b787a20c6",
   "metadata": {},
   "source": [
    "#### Predefined method names\n",
    "\n",
    "Python provides several predefined method names. Implementing methods carrying this name influences the behaviour of instances created out of such classes. For example using \\_\\_init\\_\\_ one may define a constructor, while \\_\\_eq\\_\\_ defines the behaviour of the == operator.\n",
    "\n",
    "The following examples present a few of the predefined methods:\n",
    "\n",
    "Further method names, which directly influence the behaviour are listed in https://docs.python.org/3/reference/datamodel.html#basic-customization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aace62d5-f540-4a73-b9a0-0070f481609e",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Test:\n",
    "    def __new__(cls): # creates a new object, but does not initialize it\n",
    "        print(\"in new\")\n",
    "        return super().__new__(cls) # has to return the new object (only then __init__ will be called next)\n",
    "    \n",
    "    def __init__(self): # initializes a new object (and may only return None)\n",
    "        print(\"in init\")\n",
    "    \n",
    "    def __del__(self): # Once the Garbage Collector frees this object it calls __del__\n",
    "        print(\"in del\")\n",
    "    \n",
    "    def __str__(self): # This method is called by str(), format() and print() to return a descriptive text of this object\n",
    "        return \"Just a test\"\n",
    "\n",
    "x = Test()\n",
    "\n",
    "print(x)\n",
    "\n",
    "del x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5125dbd4-aece-43a0-9518-5cb0e2ecca77",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Bus():\n",
    "    def __init__(self, seats):\n",
    "        self.seats = seats\n",
    "    \n",
    "    def __eq__(self, other): # Called as == operator\n",
    "        if self.seats == other.seats:\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "    \n",
    "    def __lt__(self, other): # called as < operator\n",
    "        if self.seats < other.seats:\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "\n",
    "a = Bus(10)\n",
    "b = Bus(20)\n",
    "\n",
    "if a == b:\n",
    "    print(\"Bus a and b have the same number of seats\")\n",
    "elif a < b:\n",
    "    print(\"Bus a has less seats than b\")\n",
    "else:\n",
    "    print(\"Bus a hat more seats than b\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7502a62-508f-46b3-8d67-4bd0b8f1c94a",
   "metadata": {},
   "source": [
    "#### Changing classes / objects at runtime\n",
    "\n",
    "In Python classes and object may be changed at runtime. Any attributes (Classes, instance variables, even methods) may be changed, added or removed at runtime."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a4d2ceb-866b-4627-81e2-286889915955",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Test:\n",
    "    a = 3\n",
    "    \n",
    "    def __init__(self, b = 3):\n",
    "        self.b = b\n",
    "    \n",
    "    def get_value(self):\n",
    "        return self.a * self.b\n",
    "\n",
    "x = Test()\n",
    "print(Test.__dict__)\n",
    "print(x.__dict__)\n",
    "print(\"x.a * x.b = \" + str(x.get_value()))\n",
    "\n",
    "print()\n",
    "print(\"Going to remove classvariable a and instance variable b:\")\n",
    "del Test.a # In order to use del, the name of the variable to be deleted has to be known at the time of writing this source\n",
    "del x.b\n",
    "print(Test.__dict__)\n",
    "print(x.__dict__)\n",
    "\n",
    "print()\n",
    "print(\"Going to add a class variable a and an instance variable b:\")\n",
    "Test.a = 5\n",
    "x.b = 5\n",
    "print(Test.__dict__)\n",
    "print(x.__dict__)\n",
    "\n",
    "print()\n",
    "print(\"Going to remove class variable a and an instance variable b using delattr:\")\n",
    "delattr(Test, \"a\") # delattr's first parameter is a string, i.e. the name of the variable may be generated at run-time\n",
    "delattr(x, \"b\")\n",
    "print(Test.__dict__)\n",
    "print(x.__dict__)\n",
    "\n",
    "print()\n",
    "print(\"Going to add a class variable a and an instance Vvariable b using setattr:\")\n",
    "setattr(Test, \"a\", 7)\n",
    "setattr(x, \"b\", 7)\n",
    "print(Test.__dict__)\n",
    "print(x.__dict__)\n",
    "\n",
    "print()\n",
    "print(\"Going to remove a method:\")\n",
    "#del x.get_value # Methods of a Class may only be removed from the class\n",
    "                 # (which changes all objects instantiated from this class),\n",
    "                 # but cannot be removed from single objects.\n",
    "del Test.get_value\n",
    "print(Test.__dict__)\n",
    "print(x.__dict__)\n",
    "\n",
    "print()\n",
    "print(\"Going to add methods:\")\n",
    "Test.get_value = lambda self : self.a + self.b # instead of a lambda and already defined function would work, too\n",
    "x.get_value_from_instance = (lambda self : self.a / self.b).__get__(x)  # In order to have \"self\" being passed to the method\n",
    "                                                                        # this method has to be bound to the object\n",
    "                                                                        # (which is accomplished using __get__)\n",
    "print(Test.__dict__)\n",
    "print(x.__dict__)\n",
    "\n",
    "print(\"x.a + x.b = \" + str(x.get_value()))\n",
    "print(\"x.a / x.b = \" + str(x.get_value_from_instance()))\n",
    "\n",
    "print()\n",
    "print(\"Going to remove methods using delattr:\")\n",
    "delattr(x, \"get_value_from_instance\") # Methods bound to an object\n",
    "                                      # may be removed from this object\n",
    "delattr(Test, \"get_value\")\n",
    "print(Test.__dict__)\n",
    "print(x.__dict__)\n",
    "\n",
    "print()\n",
    "print(\"Going to add method using setattr:\")\n",
    "def add_in_class_method(self):\n",
    "    return \"in Class: \" + str(self.a + self.b)\n",
    "def add_in_instance_method(self):\n",
    "    return \"in instance: \" + str(self.a + self.b)\n",
    "setattr(Test, \"add_in_class_method\", add_in_class_method)\n",
    "setattr(x, \"add_in_instance_method\", add_in_instance_method.__get__(x))\n",
    "print(Test.__dict__)\n",
    "print(x.__dict__)\n",
    "\n",
    "print(x.add_in_class_method())\n",
    "print(x.add_in_instance_method())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63672a11-f3e0-4ca8-9fc1-65afe8a66933",
   "metadata": {},
   "source": [
    "### Iterators\n",
    "\n",
    "For loops iterate over sequences of elements or over generators. This is implemented by the \\_\\_iter\\_\\_ method inherent to any sequence and generator.\n",
    "This method returns an object, which itselv provides the \\_\\_next\\_\\_ method, which may be calles using `next()`, providing the next element in the sequence or generator. If there is no further element, the exception `StopIteration` is thrown and the loop terminates.\n",
    "\n",
    "The methods \\_\\_iter\\_\\_ and \\_\\_next\\_\\_ may be used to employ ones classes in for loops."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2a23d429-b14e-4f09-ba51-fe71b2fae62b",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Every_nth_element:\n",
    "    def __init__(self, n, list):\n",
    "        self._n = n\n",
    "        self._list = list\n",
    "        self._pos = -1\n",
    "        self._len = len(list)\n",
    "    \n",
    "    def __iter__(self):\n",
    "        return self\n",
    "    \n",
    "    def __next__(self):\n",
    "        self._pos += self._n\n",
    "        if (self._pos >= self._len):\n",
    "            raise StopIteration\n",
    "        return self._list[self._pos]\n",
    "\n",
    "x = (1, 2, 3, 4, 5, 6, 7)\n",
    "for i in Every_nth_element(2, x):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6772fd34-1761-469c-9310-82e943e1d765",
   "metadata": {},
   "outputs": [],
   "source": [
    "def every_nth_element(n, list): # often generators may be used instead of iterator\n",
    "    for i in list[1::n]:\n",
    "        yield i # every call to next executes the yield until the StopIteration Exception is thrown\n",
    "\n",
    "x = (1, 2, 3, 4, 5, 6, 7)\n",
    "for i in every_nth_element(2, x): # Generator automatically provides __iter__ and __next__\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "231c3afb-7398-4871-a129-b6dacbb9625e",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = (1, 2, 3, 4, 5, 6, 7)\n",
    "for i in x[1::2]: # of course, in this particular instance the above slice operation may be used directly\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "acfef584-0b12-443b-a17c-db825ab2000b",
   "metadata": {},
   "source": [
    "### Exceptions\n",
    "\n",
    "Python provides the keywords `try`, `except` and `raise` to support error handling.\n",
    "\n",
    "With `raise` one may throw an error. This error may be fetched with a surrounding try-block. If the error is not caught, it will be written to the console and the program terminated.\n",
    "\n",
    "If an instruction within the try-block throws direclty or indirectly (e.g. via a called function) another error, this may be fetched using one or multiple except-blocks after the try-block. Each except-instruction is checked and the first exception instruction fitting the raised error (see `isinstance` in [Comparison of data types](#Vergleich-von-Datentypen)) is executed. In case an instruction within the exception instruction throws yet another error, another try-block is required surrounding this try-block.\n",
    "\n",
    "After the except instruction a try-block may have two additional instructions: `else` and `finally`. The else block is only executed if the try-block finished without error. The finally block will always be executed, independent of whether an exception was thrown, or whether it was caught.\n",
    "\n",
    "One may derive new Error/Exceptions based on existing Error classes. See [Built-In Exceptions](https://pythonbasics.org/try-except/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "350d4b47-c371-472e-a228-ebb146ecc6bc",
   "metadata": {},
   "outputs": [],
   "source": [
    "raise TypeError() # creates an error object of type TypeError and throws"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d089349f-10c2-4601-b08f-d0b2181a4a07",
   "metadata": {},
   "outputs": [],
   "source": [
    "raise TypeError # short form for raise TypeError()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cb7acdc0-537c-4147-824b-d8ecf23c99f4",
   "metadata": {},
   "outputs": [],
   "source": [
    "raise TypeError(\"Parameter x hase wrong value y\") # throws the TypeError with additional Argument"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53d3c05d-f833-48ef-aaae-ae59ef388c23",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [0, 1]\n",
    "b = 5\n",
    "\n",
    "try:\n",
    "    if a < b:\n",
    "        print(\"unreachable due to Exception\")\n",
    "except Exception as e: # catches all objects of type Exception and Objectes, whose type is derived from Exception\n",
    "    print(str(type(e)) + \": \" + str(e))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6bb4be75-08a2-4d92-98e6-f2fdb0f02348",
   "metadata": {},
   "outputs": [],
   "source": [
    "def throw_exception(i):\n",
    "    if type(i) != int:\n",
    "        raise TypeError(\"Parameter is not of type int\")\n",
    "    if i < 0 or i > 10:\n",
    "        raise ValueError(\"Parameter is not within the range 0-10\")\n",
    "    if i < 6:\n",
    "        raise Exception(\"Error happened\")\n",
    "\n",
    "try:\n",
    "    #throw_exception(\"test\")\n",
    "    #throw_exception(11)\n",
    "    #throw_exception(5)\n",
    "    throw_exception(6)\n",
    "except TypeError as te:\n",
    "    print(\"TypeError was raised: \" + str(te))\n",
    "except ValueError as ve:\n",
    "    print(\"ValueError was raised: \" + str(ve))\n",
    "except: # catches all errors, but does not provide the error as instance\n",
    "    print(\"Unknown error\")\n",
    "else:\n",
    "    print(\"No error happened\")\n",
    "finally:\n",
    "    print(\"Will always be executed\")\n",
    "    # break, continue or return within the finally-Block prevents raising of unknown errors\n",
    "    # If both try- and the finally block contain a return, only the one from finally will be executed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4208aad4-d996-4c70-9e0e-286ebef27d6f",
   "metadata": {},
   "outputs": [],
   "source": [
    "class TestException(Exception):\n",
    "    pass\n",
    "\n",
    "raise TestException(\"Just a test\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "11771f14-a450-4070-a618-195810c91258",
   "metadata": {},
   "outputs": [],
   "source": [
    "class TestException(Exception):\n",
    "    pass\n",
    "\n",
    "for e in (TypeError(\"Parameter is not of type int\"), ValueError(\"Parameter is not in range 0-10\"), TestException(\"Just a Test\")):\n",
    "    try:\n",
    "        raise e\n",
    "    except (TypeError, ValueError) as e: # There may be more than one error class caught by this except instruction\n",
    "        print(\"Type- oder ValueError\")\n",
    "    except BaseException as e: # all Exceptions derive from BaseException\n",
    "        print(e)\n",
    "        raise e # rethrow Exception"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d54fcfd7-005e-4a29-be10-28d882c9c88c",
   "metadata": {},
   "outputs": [],
   "source": [
    "class TestException(Exception):\n",
    "    pass\n",
    "\n",
    "try:\n",
    "    print(\"test\")\n",
    "    raise TypeError\n",
    "except TypeError as e:\n",
    "    raise ValueError() # in except and in finally new errors are linked to the existing error\n",
    "else:\n",
    "    raise ValueError()\n",
    "finally:\n",
    "    raise ValueError() # in except and in finally new errors are linked to the existing error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f8c62093-99bf-45bf-9274-5fa6b20bc188",
   "metadata": {},
   "outputs": [],
   "source": [
    "class TestException(Exception):\n",
    "    pass\n",
    "\n",
    "try:\n",
    "    print(\"test\")\n",
    "    raise TypeError\n",
    "except TypeError as e:\n",
    "    raise ValueError() from None # from None: prohibits linking this error to existing error\n",
    "else:\n",
    "    raise ValueError()\n",
    "finally:\n",
    "    raise ValueError() from None # from None: prohibits linking this error to existing error"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7657615-dba6-4b55-bad5-fe1532809756",
   "metadata": {},
   "source": [
    "### With, \\_\\_enter\\_\\_, \\_\\_exit\\_\\_ and contextmanager\n",
    "\n",
    "Context managers allow you to allocate and release resources using the `with`-statement.\n",
    "Both an object as well as a function may be a context manager. The object / the function has to contain instructions to create and destroy of a context.\n",
    "A context e.g. may be a file or a database connection.\n",
    "Upon creating the context the file, or the database connection is opened.\n",
    "Upon closing the context the file, or the database connection are terminated, as well.\n",
    "Any exceptions are handled for you by the context manager, freeing you of the pain of writing boilerplate code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fc6fbdf2-8b05-4a40-982d-97b8832b84b7",
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    with open(\"files/test.csv\") as file:\n",
    "        print(\"file closed: \"+ str(file.closed))\n",
    "        #raise EOFError(\"Aborted reading from file\")\n",
    "        print(file.readline())\n",
    "finally:\n",
    "    print(\"file closed: \"+ str(file.closed))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2c37d53f-af35-4c8b-8ed3-f8dc7148e85e",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Writer:\n",
    "    def __init__(self, file_name):\n",
    "        self.file_name = file_name\n",
    "    \n",
    "    def __enter__(self): # Will be called by the with-statement\n",
    "        print(\"Opening file\")\n",
    "        self.file = open(self.file_name, 'r')\n",
    "        return self.file # return value from __enter__ will be assigned using the as keyword\n",
    "    \n",
    "    def __exit__(self, exception_type, exception_value, traceback): # will be called upon exiting the with block\n",
    "        if exception_type is not None:\n",
    "            print(\"There was an error, we do not handle it\")\n",
    "            self.file.close()\n",
    "            return False # but rather pass it on\n",
    "        print(\"Closing the file\")\n",
    "        self.file.close()\n",
    "        return True\n",
    "\n",
    "try:\n",
    "    with Writer(\"files/test.csv\") as file:\n",
    "        print(\"file closed: \"+ str(file.closed))\n",
    "        #raise EOFError(\"Aborted reading from file\")\n",
    "        print(file.readline())\n",
    "finally:\n",
    "    print(\"file closed: \"+ str(file.closed))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "587213aa-258d-4020-82b5-b63144449e4a",
   "metadata": {},
   "outputs": [],
   "source": [
    "from contextlib import contextmanager\n",
    "\n",
    "class Writer:\n",
    "    def __init__(self, file):\n",
    "        self.file_name = file\n",
    "    \n",
    "    @contextmanager\n",
    "    def open_and_close(self):\n",
    "        try:\n",
    "            print(\"Opening file\")\n",
    "            self.file = open(self.file_name, 'r')\n",
    "            yield self.file # thanks to @contextmanager yield operates just like __exit__\n",
    "        finally:\n",
    "            print(\"Closing file\")\n",
    "            self.file.close()\n",
    "\n",
    "try:\n",
    "    with Writer(\"files/test.csv\").open_and_close() as file:\n",
    "        print(\"file closed: \"+ str(file.closed))\n",
    "        #raise EOFError(\"Aborted reading\")\n",
    "        print(file.readline())\n",
    "finally:\n",
    "    print(\"file closed: \"+ str(file.closed))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a058e2e6-d177-4e41-978f-213cadcca728",
   "metadata": {},
   "source": [
    "### Module and import\n",
    "\n",
    "Modules allows encapsulating functions (and data) in separate files (with the usual file extension \".py\"). Using the keyword `import` these functions may be included and used in other Python sources. The strength of Python lies in the amount and versatility of available modules."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ed1a7feb-fcc5-4a4e-920d-4f3e6cc16b7a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import platform\n",
    "\n",
    "x = platform.system()\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b207af0f-42a9-4fc3-b4d4-b833bc3d3b7d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import platform\n",
    "\n",
    "print(dir(platform)) # dir lists all attributes (functions/methods and variables) in an object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fe890031-cab2-475c-b7e6-19021f59fa8e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import platform\n",
    "\n",
    "for e in dir(platform):\n",
    "    x = getattr(platform, e)\n",
    "    if (callable(x)): # if x callable (a function or a classe containing the method __call__\n",
    "        print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f5923bfe-e5e1-4bc4-8b0b-8c4e000bc54f",
   "metadata": {},
   "outputs": [],
   "source": [
    "import platform as p # Rename the module as p for less typing\n",
    "\n",
    "x = p.system()\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "168ea390-e7a0-434b-b6f6-67d9237746aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "from platform import system # Just imports a single function/variable from a larger module\n",
    "\n",
    "print(system())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bbfd4a28-b071-483f-a1ce-7ceaa57ce99a",
   "metadata": {},
   "outputs": [],
   "source": [
    "from platform import system as s # both may be combined for just the needed functionality and less typing\n",
    "\n",
    "print(s())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49c11d22-b0ea-45eb-8277-332447dbafd6",
   "metadata": {},
   "source": [
    "Your own modules may be used just the any existing python module:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5845b297-870c-4c70-a319-df0f31b09795",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "### Let's create a module for You and write it to disk\n",
    "module_as_string = \"\"\"# import test module\n",
    "def test():\n",
    "    print(\"This is a test\")\n",
    "\"\"\"\n",
    "\n",
    "with open(\"test.py\", \"w\") as file:\n",
    "    file.write(module_as_string)\n",
    "\n",
    "### and use this very module\n",
    "import test\n",
    "\n",
    "test.test()\n",
    "\n",
    "os.remove(\"test.py\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "276942da-b7b0-4bcf-bb8a-728c5b6ffa23",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Creating Environments\n",
    "\n",
    "__IMPORTANT: to create environments from within Jupyter or in order to switch into these environments, please pay attention to [Environments and Jupyter](#Environments-und-Jupyter)__\n",
    "\n",
    "Python applications and modules often require further modules. These dependencies sometimes are bound to certain versions, e.g. Module A requires version 1 of Module C, however Module B requires C, however version 2. This creates a version conflict which needs to be resolved.\n",
    "\n",
    "In order not having to re-install module versions back an forth globally, Virtual Environments allows storing projects with their corresponding dependencies.\n",
    "\n",
    "Tp create a new Virtual Environment, please execute the following commands in a Terminal: \"File\"->\"New\"->\"Terminal\":\n",
    "\n",
    "```bash\n",
    "python3 -m venv <Name of your project for this Virtual Environment>\n",
    "```\n",
    "\n",
    "Please use the Python version, which You want to employ within your Virtual Enviroment. So, if You want to use Python3 in your environment, please use as such.\n",
    "\n",
    "Once created, the environment needs to be activated by issueing a Shell script in the environments directory:\n",
    "\n",
    "```bash\n",
    "source <Name des Virtual Environment>/bin/activate\n",
    "```\n",
    "\n",
    "In the activated environment new modules may be installed / deinstalled without changing the global set of Python modules (usually in Your $HOME/.cache/pip/)\n",
    "\n",
    "```bash\n",
    "python3 -m pip install ipykernel\n",
    "python3 -m pip uninstall ipykernel\n",
    "```\n",
    "The requested modules are stored in <Name of your project for this Virtual Environment>/lib/python/\n",
    "As soon as you don't need the enviroment you may unload it using the command:\n",
    "\n",
    "```bash\n",
    "deactivate\n",
    "```\n",
    "\n",
    "To delete a enviroment completely, you may remove the directory into which it was created.\n",
    "\n",
    "#### Environments and Jupyter\n",
    "\n",
    "When creating the Virtual Environment from the console of the bwUniCluster-Jupyter-Instance, prior to that you have to remove the already loaded `jupyter/base`-module.\n",
    "\n",
    "The module `jupyter/base`-module and all it's dependencies may be removed using the Software icon at the very left of the Jupyter Desktop by clicking \"unload\".\n",
    "\n",
    "![title](images/bwUniCluster_Jupyter_Unload_BaseModule.png)\n",
    "\n",
    "Additionally the corresponding LMod module may need to be unloaded (only necessary, if Terminal is opened before unloading the base module):\n",
    "\n",
    "```bash\n",
    "module list\n",
    "module unload jupyter/base/2023-10-10    # please adapt the name.\n",
    "```\n",
    "\n",
    "Now, after activating your new Virtual environment and install new Python modules using `pip install`. In order to use your own environment with Jupyter, you have to install the jupyter-kernel in the enviroment:\n",
    "\n",
    "```bash\n",
    "python3 -m pip install ipykernel\n",
    "```\n",
    "\n",
    "Furthermore, the kernel has to be registered for the usage out of Jupyter\n",
    "\n",
    "```bash\n",
    "python3 -m ipykernel install --user --name=<Name des Virtual Environment>\n",
    "```\n",
    "\n",
    "Such a kernel may be used in Jupyter (maybe need to reload the Browser's tab to show the kernel). It will contain all the Python modules loaded into the Virtual Environent.\n",
    "\n",
    "In Jupyter, the environment may be switched by switching between Kernels. In an opened Notebook, please use the Kernel-menu (on th top-right corner).\n",
    "\n",
    "It contains the name of the currently selected kernel: ![title](images/kernel_selection1.png)\n",
    "\n",
    "Using this menu, you get a drop-down list of the currently available (and the corresponding environments). By selecting the desired kernels and confirming the selection, the environment for a single Notebook may be changed.\n",
    "\n",
    "![title](images/kernel_selection2.png)\n",
    "\n",
    "![title](images/kernel_selection3.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51ab855f-2f43-400e-ac8a-ed074ad0a6cf",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "### Environment for the following excercises\n",
    "\n",
    "In order to make all the necessary modules accessible, one first has to create a proper Virtual Enviornment. We will uses Miniconda for this (in comparison to the approach using `pip` as shown above).\n",
    "\n",
    "Miniconda allows creating an environemtn by loading the binaries. In contrast to `pip install` this reduces the amount of required dependencise, since `pip install` may occasionally build software in the process (e.g. mpi for dask-mpi) and all components required for compilation need to be in the proper form.\n",
    "\n",
    "__IMPORTANT: now at latest you have to unload the Enviroment see [Environments and Jupyter](#Environments-und-Jupyter)).__\n",
    "\n",
    "FIrst off, we need a current version of Miniconda (all commands have to be typed in the Terminal as created by \"File\"->\"New\"->\"Terminal\"):\n",
    "\n",
    "#### Loading Miniconda Modul \n",
    "\n",
    "On bwUniCluster there are multiple versions of Miniconda made available. You may load these using:\n",
    "\n",
    "```bash\n",
    "module avail devel/miniconda/\n",
    "module load devel/miniconda/23.9.0-py3.9.15   # please adapt version\n",
    "```\n",
    "\n",
    "#### Install Miniconda\n",
    "\n",
    "As an alternative to the pre-installed miniconda modules, you may install your own installation into your HOME (please only use, if there are strong reasons, as this requires a lot of storage):\n",
    "\n",
    "```bash\n",
    "wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh\n",
    "```\n",
    "\n",
    "Then, adapt file permission, adding the Executable Bit, so that You may execute the installer\n",
    "\n",
    "```bash\n",
    "chmod +x Miniconda3-latest-Linux-x86_64.sh\n",
    "```\n",
    "\n",
    "```bash\n",
    "./Miniconda3-latest-Linux-x86_64.sh\n",
    "```\n",
    "\n",
    "While executing this installer, the script will ask You read (\"Please, press ENTER to continue\") and agree to the Miniconda license, by typting \"yes\" and hitting Enter.\n",
    "\n",
    "The question \"Press ENTER to confirm the location\" please accept the standard steting, installing into the directory $HOME/miniconda3.\n",
    "The question \"Do you wish to update your shell profile to automatically initialize conda?\" you may answer with \"no\" (Otherwise upon every login to bwUniCluster the conda environment will be activated).\n",
    "But you now have activate conda yourselve:\n",
    "\n",
    "```bash\n",
    "eval \"$($HOME/miniconda3/bin/conda shell.bash hook)\"\n",
    "```\n",
    "\n",
    "If You answered \"yes\" to the automatic initialization in Your shell profile, You may unto this mechanism using:\n",
    "\n",
    "```bash\n",
    "conda config --set auto_activate_base false\n",
    "```\n",
    "Next, the prepared yml-file may be used to install the required modules with the proper version -- otherwise you have to install each module manually.\n",
    "For the purpose of this workshop, please use the yml-File, since every module has been verified and tested with the listed version. Installing manually may retrieve newer modules which are incompatible with other modules.\n",
    "\n",
    "\n",
    "#### Installing Environment using the yml-File\n",
    "\n",
    "> An Environment stored as yml-file may be reinstalled using:\n",
    "> \n",
    "> ```bash\n",
    "> conda env create --file ~/git/workshop-parallel-jupyter/python_workshop_env.yml\n",
    "> ```\n",
    "\n",
    "> In order to have following modules be installed in the created environment, please activate: \n",
    "> \n",
    "> ```bash\n",
    "> conda activate python_workshop_env\n",
    "> ```\n",
    "\n",
    "#### Installing Environment manuelly\n",
    "\n",
    "> The enviroment for the following excercises is created using\n",
    "> \n",
    "> ```bash\n",
    "> conda create -n python_workshop_env python=3.7.11\n",
    "> ```\n",
    "> \n",
    "> The question \"Proceed (\\[y\\]/n)?\" may be answered \"y\".\n",
    "\n",
    "> Again this Environment has to be activated:\n",
    "> \n",
    "> ```bash\n",
    "> conda activate python_workshop_env\n",
    "> ```\n",
    "\n",
    "> The excercises require the packages dask, \"dask[distributed]\", bokeh, ipykernel, mpi4py, s3fs, numpy, pandas, matplotlib, seaborn, scikit-learn and dask-ml.\n",
    "> The following command will install these in the Environment:\n",
    "> \n",
    "> ```bash\n",
    "> conda install s3fs bokeh dask ipykernel numpy pandas matplotlib seaborn \"dask[distributed]\" mpi4py scikit-learn dask-ml\n",
    "> ```\n",
    "> \n",
    "> Again please answer \"Proceed (\\[y\\]/n)?\" with \"y\".\n",
    "\n",
    "> For visualization of dask-tasks and it's dependencies amongst tasks, we use the module graphviz (which requires the dot executable, which is available on bwUniCluster):\n",
    "> \n",
    "> ```bash\n",
    "> conda install -c conda-forge python-graphviz\n",
    "> ```\n",
    "> \n",
    "> Again please answer \"Proceed (\\[y\\]/n)?\" with \"y\".\n",
    "\n",
    "> It is good practice to store the finalized Environment as yml-File (which allows reproducing the environment on other devices and for other users):\n",
    "> \n",
    "> ```bash\n",
    "> conda env export > python_workshop_env.yml\n",
    "> ```\n",
    "\n",
    "Finally, we have to install dask-mpi -- which for once is not handled using the yml-file, since we need module versions, which require other modules under development (see below):\n",
    "\n",
    "```bash\n",
    "# A current release of dask-mpi may be installed using conda-forge:\n",
    "# conda install -c conda-forge dask-mpi\n",
    "# Unfortunately, the currentyl available version 2.21 may not handle adding a Dask-Cluster after the fact.\n",
    "# The upcoming versions will support it.\n",
    "#\n",
    "# For now, we may use the develop version of dask-mpi:\n",
    "#### python3 -m pip install git+https://github.com/dask/dask-mpi@76b71050b789db56af6b4b1b21bbfd33a608919c\n",
    "```\n",
    "\n",
    "To be able to use this Environment in the Jupyter-Notebook, we have to register it:\n",
    "\n",
    "```bash\n",
    "python3 -m ipykernel install --user --name=python_workshop_env\n",
    "```\n",
    "\n",
    "Inside of the terminal, you may deactivate the conda environment using:\n",
    "\n",
    "```bash\n",
    "conda deactivate\n",
    "```\n",
    "\n",
    "A list of the available Conda environments is available using:\n",
    "\n",
    "```bash\n",
    "conda env list\n",
    "```\n",
    "\n",
    "An inactive Environment may be activated again using:\n",
    "\n",
    "```bash\n",
    "conda activate <Name of the Virtual Environment>\n",
    "```\n",
    "\n",
    "__In order to use this Environment in a Kernel in Jupyter, you may have to reload the Browser (F5-Key)__\n",
    "\n",
    "Next, you may either create a new Jupyter Notebook by clicking \"File\"->\"New\"->\"Notebook\", or select the Kernel in Your existing Jupyter Notebooks (see [Environment erstellen](#Environment-erstellen))."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51c09800-4cba-461d-8f77-5258eddfc6ad",
   "metadata": {},
   "source": [
    "### Remarks on Jupyter\n",
    "\n",
    "Jupyter offers good interactivity with your code and data. The source code may be split in several cells and each and every cell executed, changed and re-executed again. Thefreo Jupyter is a good tool to design and experiment with data. In order to enable this functionality, Jupyter requests and allocates ressources from the Cluster's queueing system, even though they are hardly occupying the hardware.\n",
    "Also with regard to Python execution, the possibility to amend code and data in the cells hinders Python's GarbageCollector to clean up state.\n",
    "Therefore it is a good idea to keep to the smallest possible input data set and/or to delete data manually, as soon as it is no longer required:\n",
    "\n",
    "In retrospect:\n",
    "- Use Jupyter during the development process and for documenting/communicating ideas with others\n",
    "- Reduce the data set size as much as possible\n",
    "- Use the `del`-instruction to delete data not longer required\n",
    "- Move the code developped in Jupyter into it's stand-alone Python-Script to work on large datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "65bf5385-739c-4058-bb1a-37e9d808a1f0",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "python_workshop_env",
   "language": "python",
   "name": "python_workshop_env"
  },
  "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.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}