02_control_flow_and_loops.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "\n",
    "### \"Official\" Online-Tutorial\n",
    "https://docs.python.org/3.9/tutorial/index.html\n",
    "\n",
    "### \"Official\" Beginners guide\n",
    "https://wiki.python.org/moin/BeginnersGuide"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Control-flow\n",
    "## Truth-values \n",
    "\n",
    "The interpreter processes the instructions in the source code in a sequiential order, step by step, line by line. Often however, we need to deviate from this strict sequence to exectute code only under certain _conditions_. For such _conditions_ we test wether things are `True` or `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "attributes": {
     "classes": [],
     "id": "",
     "n": "4"
    },
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "no = False\n",
    "yes = True\n",
    "no"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Ein weiterer Wert, den Varialblen annehmen können ist `None`, wenn kein Wert\n",
    "vorgliegt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Comparisons\n",
    "\n",
    "Whether a condition holds or not, we can check with the comparison operator `==` . Note, that there are two equal signs as opposed to the assignment opererator `=`.\n",
    "Such a comparison result in eihter `True` or `False`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "attributes": {
     "classes": [],
     "id": "",
     "n": "1"
    },
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "1 + 1 == 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "attributes": {
     "classes": [],
     "id": "",
     "n": "5"
    },
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "1 + 1 == 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "The results of such comparisons can be assigned to variables. They are taking on the datatype `bool`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "attributes": {
     "classes": [],
     "id": "",
     "n": "8"
    },
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "yes = (True, False, 1, 4.5)\n",
    "type(yes)\n",
    "yes = 1 + 4 == 5\n",
    "yes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "attributes": {
     "classes": [],
     "id": "",
     "n": "7"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "wrong  = 1 * 5.33 > 5\n",
    "wrong"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Comparison operators\n",
    "Next to the equality-operator `==` a number of additional operators are available:\n",
    "- `!=` checks if something is *not* true.\n",
    "- `<` and `>` check whether the left hand operand is smaller or larger than the right hand operand  \n",
    "- `<=` und `=>` extends this to \"smaller than or equal\" and \"larger than or equal\".\n",
    "\n",
    "Note that such comparisons work for the built-types such as numerical values etc. but can be adjusted for any custom type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "1 != 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# \"a\" comes before \"b\"\n",
    "\"a\" < \"b\" "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# ord() returns the unicode-codepoint as a number\n",
    "print (ord(\"&\"), ord(\"%\"))\n",
    "\"&\" > \"%\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Combining conditionals: logic operators\n",
    "\n",
    "To combine conditions such as \n",
    "- \"it is raining **and** the sun is shining\" or\n",
    "- \"either it rains  **or** the sun is shining\"\n",
    "\n",
    "Python provides the logic operators `and` and `or`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "attributes": {
     "classes": [],
     "id": "",
     "n": "15"
    },
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "sun_is_shining = True\n",
    "it_is_raining = True\n",
    "sun_is_shining and it_is_raining"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "attributes": {
     "classes": [],
     "id": "",
     "n": "16"
    },
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "sun_is_shining or it_is_raining"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "The possible combination of operands and there results can be expressed as a table:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "|   a   |   b   |  a **and** b |  a **or** b  |\n",
    "|------|-------|-----------|----------|\n",
    "| True  | True  |   True    |   True   |\n",
    "| True  | False |   False   |   True   |\n",
    "| False | True  |   False   |   True   |\n",
    "| False | False |   False   |  False   |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### *Excersise* : Write expressions answering the following questions:\n",
    "- is 3 larger than 1?\n",
    "- is 15 not equal to 14?\n",
    "- is 3 smaller or equal to 2.5?\n",
    "- list all conditions under which \"It is raining  **and** the sun is shining\" **not** true?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Conditional execution of code: the   `if` operator\n",
    "\n",
    "Decistion to control the flow of the code can be made in the form \"if this then that\" with the `if` oprator and a subsequent `:` to indecate \"then\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "attributes": {
     "classes": [],
     "id": "",
     "n": "14"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "if 1 + 2 == 2 : print(\"correct\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "attributes": {
     "classes": [],
     "id": "",
     "n": "15"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "if 1 - 1 != 0 : print (\"correct\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "attributes": {
     "classes": [],
     "id": "",
     "n": "1"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "yes = 1 + 2 == 3\n",
    "yes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "The instructions that should be exectuted, wenn `if` conditions hold, are most often structured as  single **code block**. **Code Blocks** are indented by _either_ spaces or tabs (but not mixed). They help to reduce the clutter that other Programming languages bring to the table that often use {} braces.\n",
    "\n",
    "The Jupyter notebooks thake care of the indentation if we end a line with the \"then\" operator `:`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "attributes": {
     "classes": [],
     "id": "",
     "n": "2"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "yes = True\n",
    "if yes :\n",
    "    print (\"this is only printed if the condition is true, otherwise this block is ignored\")\n",
    "    print (yes)\n",
    "\n",
    "print (\"we left the indented code block and continue our work\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### if-then-else\n",
    "Different outcomes of conditionals can be processed with `else`. Only one of the codeblocks is executed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "attributes": {
     "classes": [],
     "id": "",
     "n": "5"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "yes = True\n",
    "if yes:\n",
    "    print (\"yes, that's right\")\n",
    "else:\n",
    "    print (\"no\")\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Wir können die Variable jetzt auf einen neuen Wert setzen und Zelle oben neu\n",
    "ausführen, wenn die Variable `wahr` den Wert `False` angemommen hat."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "attributes": {
     "classes": [],
     "id": "",
     "n": "6"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "wahr = False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Wenn-Dann-Ansonsten-Wenn-Andernfalls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "attributes": {
     "classes": [],
     "id": "",
     "n": "11"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "number = 52\n",
    "if number <= 10:\n",
    "    print (\"number is smaller than 10\")\n",
    "elif number > 10 and number < 20:\n",
    "    print (\"number between  10 and 20\")\n",
    "elif number > 20 and number < 40:\n",
    "    print (\"The number is between twenty and forty\")\n",
    "else:\n",
    "    print (\"The number is neither smaller than 10, nor between 10 and 20\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Loops\n",
    "\n",
    "Loops are applied if a script has to repeat operations. A simple example is the processing of a list of values.\n",
    "\n",
    "In loops we are checking for whether a  halting condition is fullfilled, or a code block should be exectuted again. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### The `for`-loop\n",
    "A `for` loop allows us to go through all elements in a sequence such as a list, a tuple or a string. Each time a new iteration of the loop is triggerd a temporary variable is created that takes on the value of the item from the sequence.\n",
    "\n",
    "In the block of the function - the indented part - we can define statements **once** that are then executed for every item in the sequence without repeating the same operation.\n",
    "\n",
    "\n",
    "This is an important part of the  [**\"Don't Repeat Yourself\" (DRY)**](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself) principle in\n",
    "computer programming."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "attributes": {
     "classes": [],
     "id": "",
     "n": "18"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "#instead of this\n",
    "a_list = [1, 5, 70, 100]\n",
    "print (f\"Die {a_list [0]}\")\n",
    "print (a_list [1])\n",
    "print (a_list [2])\n",
    "print (a_list [3])\n",
    "\n",
    "print (\"-------------\")\n",
    "#do this\n",
    "for number in a_list:\n",
    "    print (f\"The current value of the varible 'number' is: {number}\")\n",
    "    print (number + 99)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Createing sequences with `range`\n",
    "\n",
    "Sequences of numbers can quickly be created with the `range` function. As a _convention_ (but not a rule) simple counting variables in programming are often named \"i\" or \"j\" and \"k\".\n",
    "\n",
    "The range function also allows us to create incrementor steps."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(range(5,20,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "attributes": {
     "classes": [],
     "id": "",
     "n": "22"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "sum = 0\n",
    "for i in range (5,20,2):\n",
    "    sum = sum + i\n",
    "    print(f\"i currenly is {i},\\t The sum is now {sum}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Iterating / looping over dictionaries\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "layers = {\"sand-lime-brick-inner\": 10.0, \"Mineral wool\": 28.0, \"Air 1 cm\": 1.0, \"sand-lime-brick-outer\": 12.0 }\n",
    "layers.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "for layer in layers.keys():\n",
    "    print (layer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "overal_width = 0.0\n",
    "for width in layers.values():\n",
    "    print (width)\n",
    "    overal_width = overal_width + width\n",
    "\n",
    "    \n",
    "print (f\"The overal width is {overal_width} cm.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Walk through all keys an values of a dictionary with `.items()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "for layer, thickness in layers.items():\n",
    "    print (f\"{layer} \\t: {thickness}\" )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Excercise: Calculate the  U-value of the wall\n",
    "\n",
    "Thermal resistance R<sub>si</sub> = 0.13\n",
    "\n",
    "Thermal resistance R<sub>se</sub> = 0.04\n",
    "\n",
    "R<sub>construciton</sub> = $\\frac{d_{1}}{\\lambda_{R1}} + \\frac{d_{2}}{\\lambda_{R2}} + \\ldots + \\frac{d_{n}}{\\lambda_{Rn}} $\n",
    "\n",
    "U-value = $ \\frac{1}{R_{si} + R_{construction} + R_{se}}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "| Material | thermal transmittance $\\lambda\\$ in W/(m*K) |\n",
    "|------|-------|\n",
    "| lime brick | 0.99 |\n",
    "| mineral wool | 0.04 |\n",
    "| air layer 1 cm | 0.15 |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "lambdas = {\"KS\": 0.99, \"Mineralwolle\": 0.04, \"Luftschicht 1 cm\" : 0.15}\n",
    "r_gesamt = 0\n",
    "for schicht, dicke in schichten.items():\n",
    "    l = 0\n",
    "    if schicht.find(\"KS\") > -1:\n",
    "        l = lambdas[\"KS\"]\n",
    "    elif schicht.find(\"Mineralwolle\") > -1:\n",
    "        l = lambdas[schicht]\n",
    "    elif schicht.find(\"Luftschicht 1 cm\") > -1:\n",
    "        l = 0.15\n",
    "    r = dicke / l / 100\n",
    "    r_gesamt = r_gesamt + r \n",
    "    print (f\"{schicht} \\t: {dicke:<3} \\t lambda: {l}, R={r}\" )\n",
    "print(f\"R-Gesamt : {r_gesamt}\")\n",
    "U = 1/(0.13+r_gesamt+0.04) \n",
    "U\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### The `while`-loop\n",
    "\n",
    "In a `while`-loop instructions are exectuted until a condition is fullfiled."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "attributes": {
     "classes": [],
     "id": "",
     "n": "25"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "number = 0\n",
    "while number < 10:\n",
    "    number = number + 2\n",
    "    print (number)\n",
    "    \n",
    "print(\"The loop has terminated, the condition does not return true\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Stopping a loop with `break`\n",
    "`for`-loops can be stoped if a condition is fulfilled using the `break` key word:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "attributes": {
     "classes": [],
     "id": "",
     "n": "26"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "for i in range (1, 10):\n",
    "    if i + 5 > 10:\n",
    "        break\n",
    "    print (f\"i is {i}, we are in the loop\")\n",
    "print (\"Loop has terminated\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Stopping the current iteration with  `continue`\n",
    "In the following loop the modulo Operator `%` checks for a rest during a disvision by 2. If this results in `0`, it is an even number, the `if` the condition is true and the current loop iteration is stopped and `continued` for the next `i`. \n",
    "\n",
    "This has the effect, that only odd numbers are printed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "for i in range (1, 10):\n",
    "    if i % 2 == 0:\n",
    "        continue\n",
    "    print (i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Excercises:\n",
    "- write a loop that prints every character of the string \"Hello RWTH\". Rember that Strings are tuples.\n",
    "- Writ a `for`, that prints every second word of the sentence \"The house has to please everyone, contrary to the work of art which does not. The work is a private matter for the artist. The house is not.\" \n",
    "    - hint: strings can be split with the  [`split(' ')`](https://docs.python.org/3.8/library/stdtypes.html#str.split) funciton in single words. The length of lists can be determined with `.len()` .  Then you could either \n",
    "    -access each  nth element mit dem `[]`\n",
    "    -or use  \n",
    "    ```python\n",
    "    for element in liste:\n",
    "           print (element)`\n",
    "    ````            \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}