03_python/python_flow_control.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Flow control"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Key points of the previous lectures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's define a list and a tuple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "someNames = (\"Ana\", \"Ben\", \"Clara\", \"David\", \"Eva\", \"Fred\") # A tuple of strings\n",
    "someAges = [23, 45, 12, 45, 45, 56]                         # A list of integers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could manually create a dictionary mapping names to corresponding ages (keys to values):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "names2ages = {\"Ana\": 23, \"Ben\": 45, \"Clara\": 12, \"David\": 45, \"Eva\": 45, \"Fred\": 56}\n",
    "print( type(names2ages) )\n",
    "print( names2ages[\"Clara\"] )       # Getting age of Clara\n",
    "#print( names2ages[\"Zenon\"] )      # Zenon is not in the dictionary, error is raised"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course, given `someNames` and `someAges`, we would not create `names2ages` dictionary manually. Let's study several expressions...  \n",
    "`zip()` function returns a generator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zip(someNames, someAges)           # A generator of tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When the generator is iterated over, it knows how to produce tuples of elements from the input lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[item for item in zip(someNames, someAges)]    # Square brackets, so a list comprehension!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's use the dictionary comprehension:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "{n:a for n, a in zip(someNames, someAges)}     # Curly braces, so a dictionary comprehension!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using `dict()` to create identical dictionary (it iterates over the tuples from the generator):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n2a = dict(zip(someNames, someAges))\n",
    "n2a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, let's find unique ages by building a set from the age values of the dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print( n2a.values() )          # A generator providing a view of the dictionary values\n",
    "set(n2a.values())              # A set of the dictionary values (so no duplicates)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditional statements"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Getting user input"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's first learn how to ask the user for a text with the `input` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "txt = input()          # a prompt or message box should appear on screen\n",
    "print( type( txt ) ) \n",
    "print( txt )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note, that the user's text is returned as an object of type `str`. To convert it to an integer number use `int(...)`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "txt = input()          # a prompt or message box should appear on screen\n",
    "n = int( txt )         # txt gets converted to an integer number n\n",
    "                       # if txt is a text not representing a number then int(...) raises ValueError exception\n",
    "print( type( n ) )\n",
    "print( n )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Decision control statements: `if`, `if`/`else` and `if`/`elif`/`else`: "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The statement `if` allows to choose whether a block of code should be executed or not, depending on a provided condition.\n",
    "\n",
    "The condition expression after `if` must evaluate to `True` or `False`.  \n",
    "When the result is `True` the statement(s) in the indented block after `if`...`:` are executed.  \n",
    "Otherwise the statements of the block are skipped over.\n",
    "\n",
    "Try the following code for different inputs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = float( input() )\n",
    "if n > 0:\n",
    "    print( f\"Number {n} is positive.\" )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When the `else` clause is present, then its statement(s) are executed when the `if` condition evaluates to `False`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = float( input() )\n",
    "if n > 0:\n",
    "    print( f\"Number {n} is positive.\" )\n",
    "else:\n",
    "    print( f\"Number {n} is nonpositive (either zero or negative).\" )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `elif` clause allows testing of multiple conditions in a provided order.  \n",
    "The block corresponding to the first condition evaluated to `True` is executed and no further condition is tested.  \n",
    "When none of the conditions evaluates to `True`, the block corresponding to `else` is executed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = float( input() )\n",
    "if n > 0:\n",
    "    print( f\"Number {n} is positive.\" )\n",
    "elif n < 0:\n",
    "    print( f\"Number {n} is negative.\" ) # when needed there can be many elif parts\n",
    "else:\n",
    "    print( f\"Number {n} is zero.\" )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conditional expressions"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Note:* Python offers *a conditional expression (Python’s Ternary Operator)* which also uses `if` and `else` keywords.\n",
    "\n",
    "The following code assigns different values to the variable `t` depending on a condition (`n>0`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = float( input() )\n",
    "if n>0:\n",
    "    t = \"positive\"\n",
    "else:\n",
    "    t = \"nonpositive\"\n",
    "print( t )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above code can be written using a conditional expression:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = float( input() )\n",
    "t = \"positive\" if n>0 else \"nonpositive\"\n",
    "print( t )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is an example of a conditional expression used as the expression in a list comprehension:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ns = [ -1, 0, 1, -1, -1, 1 ]\n",
    "[\"positive\" if n > 0 else \"nonpositive\" for n in ns]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Repetition control statements: `for` loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iterable objects"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Iterable* objects are capable of providing their elements one at a time.  \n",
    "Here are some examples of iterable objects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Several characters of a family sitcom.\n",
    "iterable1 = [ \"Claire\", \"Phil\", \"Haley\", \"Cameron\", \"Luke\", \"Mitchell\", \"Jay\", \"Gloria\" ]\n",
    "\n",
    "# A color scale robust to colorblindness: https://cran.r-project.org/web/packages/viridis/vignettes/intro-to-viridis.html\n",
    "# Hexadecimal numbers: https://wiki.osdev.org/Hexadecimal_Notation\n",
    "iterable2 = ( 0xfde725, 0x5ec962, 0x21918c, 0x3b528b, 0x440154 )\n",
    "\n",
    "# An unlikely combination of numbers in a lottery 6 out of 1,2,...,44,45.\n",
    "iterable3 = { 10, 15, 23, 24, 40 }\n",
    "\n",
    "# More on colors: https://www.rapidtables.com/web/color/RGB_Color.html\n",
    "# For loop will iterate over the keys.\n",
    "iterable4 = { \"red\":0xFF0000, \"green\":0x00FF00, \"blue\":0x0000FF, \"black\":0x000000, \"white\":0xFFFFFF }\n",
    "\n",
    "# Iterable over letters of the string.\n",
    "iterable5 = \"Statistics and Data Science\"\n",
    "\n",
    "# An arithmetic progression.\n",
    "iterable6 = range( 10, 15 )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A simple `for` loop"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is an example of a `for` loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "names = [ \"Claire\", \"Phil\", \"Haley\", \"Cameron\", \"Luke\", \"Mitchell\", \"Jay\", \"Gloria\" ]\n",
    "for n in names:\n",
    "    print( n )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for n in names:\n",
    "    # loop body start\n",
    "    print( n )\n",
    "    # loop body end"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some code needs to be present in the body part. During development this code might not be ready yet. Then, use `pass` as a placeholder.  \n",
    "(*Note:* `pass` is a doing-nothing-statement and can be used anywhere, not only in `for` loops)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for n in names:\n",
    "    pass"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A `for` loop with `continue`"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's introduce several `print` commands to observe the order of code execution (i.e., the flow of the program):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print( \"Before loop\" )\n",
    "for i in range(3):\n",
    "    print( f\"Body start i={i}\" )\n",
    "    pass                           # some useful loop code could be here\n",
    "    print( f\"Body end i={i}\" )\n",
    "print( \"After loop\" )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The keyword `continue` stops execution of the remaining part of the loop's body and transfers the execution point back *to the beginning of the next iteration*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print( \"Before loop\" )\n",
    "for i in range(3):\n",
    "    print( f\"Body start i={i}\" )\n",
    "    if i==1:\n",
    "        continue\n",
    "    print( f\"Body end i={i}\" )\n",
    "print( \"After loop\" )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A `for` loop with `else` or `break`"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In `for` loops, the keyword `else` allows to introduce a block of code which is executed after all iterations of the loop are done without any `break`.  \n",
    "The `else` block is then executed even if there were no iterations at all because the iterable was empty."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print( \"Before loop\" )\n",
    "for i in range(3):\n",
    "    print( f\"Body start i={i}\" )\n",
    "    pass                           # some useful loop code could be here\n",
    "    print( f\"Body end i={i}\" )\n",
    "else:\n",
    "    print( \"Else block\" )\n",
    "print( \"After loop\" )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The keyword `break` stops execution of the remaining part of the loop's body and transfers the execution point *after the end of the loop*.  \n",
    "If an `else` part is present, `break` skips over it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print( \"Before loop\" )\n",
    "for i in range(3):\n",
    "    print( f\"Body start i={i}\" )\n",
    "    if i==2:\n",
    "        break\n",
    "    print( f\"Body end i={i}\" )\n",
    "else:\n",
    "    print( \"Else block\" )\n",
    "print( \"After loop\" )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Repetition control statements: `while` loops"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "The keyword `while` allows repeating a block of code as long as a provided condition evaluates to `True`.  \n",
    "The keywords `break`, `continue` and `else` provide the same functionality as in `for` loops."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import randint\n",
    "\n",
    "tossedNum = randint(1,6)\n",
    "while True:                       # loop forever (break is needed to stop the loop)\n",
    "    guessedNum = int( input( \"I tossed randomly a fair dice. Guess the number...\" ) )\n",
    "    if tossedNum==guessedNum:\n",
    "        print( \"Congratulations!\" )\n",
    "        break\n",
    "    print( \"You are wrong, try again...\" )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## User-defined functions"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A function, arguments and the return value"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is an example of a user-defined function `myMean`:\n",
    "- The function takes one argument `x`.  \n",
    "- The function calculates and returns the arithmetic mean of the data provided in the `x` argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def myMean( x ):                               #def function_name( arg1, arg2, ... )\n",
    "    # function body                            #    possibly some calculation here\n",
    "    return sum(x)/len(x)                       #    return result_of_the_function"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's call the new function with a list with two elements `[1, 2]`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "myMean( [1, 2] )                               # calling the function: the argument x is set to a list [1,2]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is another example of calling the new function from a dictionary comprehension:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "course2grades = {\n",
    "    \"math\": ( 7, 9, 6.5, 8, 8.5 ),\n",
    "    \"physics\": ( 9, 8.5, 9.5, 8, 7.5, 9.5 ),\n",
    "    \"philosophy\": (6, 6.5, 6, 7 )\n",
    "}\n",
    "\n",
    "{c:myMean(gs) for c, gs in course2grades.items()}"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### An argument with a default value"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here an additional argument `isGeom` is added to the function `myMean`.  \n",
    "The value of `isGeom` decides whether arithmetic or geometric mean is calculated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import log, exp\n",
    "\n",
    "def myMean( x, isGeom = False ):               # isGeom has a default value of False, used when not provided in a function call\n",
    "    if isGeom:\n",
    "        logOfX = (log(xx) for xx in x)\n",
    "        return exp( sum(logOfX) / len(x) )\n",
    "    else:\n",
    "        return sum(x) / len(x)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The new argument has a default value `False` which will be used when no value is provided when the function is called."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myMean( [1,2,3] )             # isGeom is not provided so it is set to False and the arithmetic mean is calculated"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here are different variants of providing `True` value for `isGeom`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#myMean( [1,2,3], True )           # argument names may be omitted\n",
    "#myMean( x=[1,2,3], isGeom=True )  # or provided\n",
    "myMean( [1,2,3], isGeom=True )     # or partially provided"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Raising exceptions (handling errors)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes a function might be called with wrong arguments. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#myMean([])        # raises ZeroDivisionError\n",
    "                   # our function divides by zero when x has zero elements"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Often it is useful to provide more informative (user defined) error messages with help of `raise` command throwing errors/exceptions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import log, exp\n",
    "\n",
    "def myMean( x, isGeom = False ):\n",
    "    if len(x) == 0:\n",
    "        raise RuntimeError( \"There must be at least one element to calculate mean.\" )\n",
    "    if isGeom:\n",
    "        logOfX = (log(xx) for xx in x)\n",
    "        return exp( sum(logOfX) / len(x) )\n",
    "    else:\n",
    "        return sum(x) / len(x)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, when the function is called with an empty list as `x` argument, a message easier to diagnose is shown:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# myMean([])       # raises RuntimeError with the provided message."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Describing functions"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python provides a *docstring* convention for writing documentation to functions (and other language elements).  \n",
    "A short description of a function, quoted with triple quotes, should be provided at the top of the function body:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import log, exp\n",
    "\n",
    "def myMean( x, isGeom = False ):\n",
    "    \"\"\"Calculates arithmetic or geometric mean of elements in x.\"\"\"\n",
    "    if len(x) == 0:\n",
    "        raise RuntimeError( \"There must be at least one element to calculate mean.\" )\n",
    "    if isGeom:\n",
    "        logOfX = (log(xx) for xx in x)\n",
    "        return exp( sum(logOfX) / len(x) )\n",
    "    else:\n",
    "        return sum(x) / len(x)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This documentation is available as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myMean.__doc__"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lambda functions"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's consider a simple, single-expression function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def myMean(x):\n",
    "    return sum(x)/len(x)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The same single-expression function can be written in a shorter form:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myMean = lambda x: sum(x)/len(x)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and be called with the usual notation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myMean([1,2,3])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In some contexts the `lambda` notation allows to write short, compact code."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Self-study tasks"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A function to convert an exam score to a Dutch grade"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An exam `score` is a number in a range from `0` to `maxScore`.  \n",
    "Write a function `score2grade( score, maxScore )` which implements a linear transformation of a score to a grade:\n",
    "- for `score=0` the returned grade should be `1`; \n",
    "- for `score=maxScore` the returned grade should be `10`;\n",
    "- for `score` beyond range the function should raise an exception.\n",
    "\n",
    "Add a *docstring* with a short description of the function.\n",
    "Call the function for several combinations of the arguments to check whether it works correctly."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A `lambda` function to convert score to grade"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a `lambda` function `s2g`, a simplified version of the `score2grade` function.  \n",
    "Do not check the range of `score`, do not raise the exception, do not write any *docstring*.  \n",
    "But perform the same tests as above, to check whether `s2g` works correctly."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conditional expression "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `abs(x)` function returns `x` if `x>=0` or `-x` otherwise, try `abs(-1)` and `abs(1)`.  \n",
    "You are given a list `xs` with numbers.  \n",
    "First, write a list comprehension which maps each value of `xs` through the `abs` function.  \n",
    "Next, assume that the `abs` function is not available.  \n",
    "Rewrite `abs` in the list comprehension with a conditional expression `... if ... else ...`."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arguments `sep` and `end` of `print(...)`"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uncomment separately each of the following lines. Understand the effect of `sep` argument. What is the default value of `sep` argument in the `print(...)` function?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print( \"A\", \"B\", \"C\" )\n",
    "# print( \"A\", \"B\", \"C\", sep=\"-\" )\n",
    "# print( \"A\", \"B\", \"C\", sep=\"<--->\" )\n",
    "# print( \"A\", sep=\"???\" )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, compare the output of the following two code blocks. What is the effect of the `end` argument and its default value in the `print(...)` function?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print( \"A\" )\n",
    "print( \"B\" )\n",
    "print( \"C\" )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print( \"A\", end=\"\" )\n",
    "print( \"B\", end=\"\" )\n",
    "print( \"C\" )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A condition in a loop in a loop: painting with dots"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The goal of this task is to learn how to write nested loops and conditionally print characters.  \n",
    "\n",
    "The first (external) loop should iterate over rows (let's call the loop variable `r`).  \n",
    "The second (internal in each row) loop should iterate over columns (use the variable `c`).  \n",
    "The body of the second loop should decide what character to print (e.g. `.`, `#` or a space).  \n",
    "The goal is to print shapes as shown below.\n",
    "\n",
    "For each shape define a function (names given below).  \n",
    "Each function should have a single argument `size` which defines the number of rows and columns which the shape should occupy.\n",
    "\n",
    "*Note:* Study first the `sep` and `end` arguments of the `print(...)` function in order to know how to print in a new line or how to stay in the same line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# printGrid(10)          # These commands printed the shapes\n",
    "# printBackslash(6)\n",
    "# printSlash(8)\n",
    "# printSquare(7)\n",
    "# printX(10)\n",
    "# printLUTriangle(10)\n",
    "# printRBTriangle(10)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{code-block} python\n",
    "..........        <- printGrid(10)\n",
    "..........\n",
    "..........\n",
    "..........\n",
    "..........\n",
    "..........\n",
    "..........\n",
    "..........\n",
    "..........\n",
    "..........\n",
    "\n",
    "#.....            <- printBackslash(6)\n",
    ".#....\n",
    "..#...\n",
    "...#..\n",
    "....#.\n",
    ".....#\n",
    "\n",
    ".......#          <- printSlash(8)\n",
    "......#.\n",
    ".....#..\n",
    "....#...\n",
    "...#....\n",
    "..#.....\n",
    ".#......\n",
    "#.......\n",
    "\n",
    "#######           <- printSquare(7)\n",
    "#.....#\n",
    "#.....#\n",
    "#.....#\n",
    "#.....#\n",
    "#.....#\n",
    "#######\n",
    "\n",
    "#........#        <- printX(10)\n",
    ".#......#.\n",
    "..#....#..\n",
    "...#..#...\n",
    "....##....\n",
    "....##....\n",
    "...#..#...\n",
    "..#....#..\n",
    ".#......#.\n",
    "#........#\n",
    "\n",
    "##########        <- printLUTriangle(10)\n",
    "#.......#\n",
    "#......#\n",
    "#.....#\n",
    "#....#\n",
    "#...#\n",
    "#..#\n",
    "#.#\n",
    "##\n",
    "#\n",
    "\n",
    "         #        <- printRBTriangle(10)\n",
    "        ##\n",
    "       #.#\n",
    "      #..#\n",
    "     #...#\n",
    "    #....#\n",
    "   #.....#\n",
    "  #......#\n",
    " #.......#\n",
    "##########\n",
    "```"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Rewriting the function `myMean`"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the lecture materials the following implementation of the function `myMean` was presented.  \n",
    "It works well for the list given below in the example (`vs`) but it does not work for the generator (`vs2`).  \n",
    "Understand, why it does not work for the generator.  \n",
    "Propose a different implementation of `myMean` function which works for `vs` and `vs2`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def myMean( x ):\n",
    "    return sum(x)/len(x)\n",
    "\n",
    "vs  = [ 1, 5, 10, 15, 30 ]\n",
    "vs2 = ( v**2 for v in vs )\n",
    "myMean( vs )     # this works\n",
    "#myMean( vs2 )   # this raises an exception"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Processing lines of a remote file"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's practice accessing (remote) files.\n",
    "\n",
    "*Goal:* get `README.md` file of this course and from it select only text lines containing the word `course`.  \n",
    "Store the selected text lines as a list in `textsWithCourse`.\n",
    "\n",
    "*Hints:* \n",
    "- the `url` address for the `README.md` file is `https://raw.githubusercontent.com/LUMC/EfDS/main/README.md`\n",
    "- the package `urllib.request` is needed for the function `urlopen(url)` providing access to remote locations\n",
    "- `urllib.request.urlopen(url).readlines()` returns an object iterable over single lines of the file\n",
    "- each line `l` is not yet a text string; use `l.decode( \"utf-8\" )` to get a `str` object with the text of the line\n",
    "- if `t` is a `str` object, then with `\"course\" in t` you may check whether the word `course` is in the string"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "EfDS",
   "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.13.1"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}