Loops/Loops.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "KFib138AzHLW"
   },
   "source": [
    "<img src=\"https://github.com/Center-for-Health-Data-Science/PythonTsunami/blob/oct_2022_3days/figures/HeaDS_logo_large_withTitle.png?raw=1\" width=\"300\">\n",
    "\n",
    "<img src=\"https://github.com/Center-for-Health-Data-Science/PythonTsunami/blob/oct_2022_3days/figures/tsunami_logo.PNG?raw=1\" width=\"600\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jzzrpQS-zxnF"
   },
   "source": [
    "# Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HrDeygtfzx7P"
   },
   "source": [
    "Consider the code below: It prints the numbers 1 through 10 using what we've learned so far.  \n",
    "This notebook is about how to do the same task less tediously. **Loops** are a way to repeatedly execute some code, in a simple and succinct way."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "tjj39-AazwAb"
   },
   "outputs": [],
   "source": [
    "print(1)\n",
    "print(2)\n",
    "print(3)\n",
    "print(4)\n",
    "print(5)\n",
    "print(6)\n",
    "print(7)\n",
    "print(8)\n",
    "print(9)\n",
    "print(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "VBLCVfQoseEh"
   },
   "source": [
    "Indeed, we can use a for loop to do the same in only two lines:\n",
    "\n",
    "```python\n",
    "#pseudo code\n",
    "for number in number_list:\n",
    "    print number\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "aCmVJXXBzHLn"
   },
   "outputs": [],
   "source": [
    "number_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "\n",
    "#the variable number is initialized inside the for statement.\n",
    "#You do not need to declare it before. It will continue to exist after the loop.\n",
    "for number in number_list:\n",
    "    print(number)\n",
    "\n",
    "print(\"Now we are done.\")\n",
    "print(\"What is number now?\", number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DGXTd_1SseEj"
   },
   "source": [
    "Loops are part of flow control. The code inside the loop is (usually) executed several times, whereas lines such as above are only executed one time. The program also needs to know when the loop is over and we return to 'linear' flow. Like in `if` blocks, this is made clear with indentation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "EClTb9Qy0i8U"
   },
   "source": [
    "## **`for`** loops\n",
    "\n",
    "In Python, **`for`** loops are written like this:\n",
    "\n",
    "```python\n",
    "for element in sequence:\n",
    "    this code is executed inside the loop\n",
    "    and this code too\n",
    "    \n",
    "now we are not in the loop anymore    \n",
    "```\n",
    "The idea is that we go through our sequence step by step and perform a certain action (here `print()` on each element in the sequence).\n",
    "\n",
    "- ``element`` is a variable and can be called whatever you want.\n",
    "\n",
    "- ``sequence`` is a sequence we iterate over. It is some kind of collection of items, for instance: a `str` of characters, a `range`, a list etc. It is also often called an iterable.\n",
    "\n",
    "Note that the body of the loop is **indented**. This is important for [**flow**](https://colab.research.google.com/drive/11xJCNmKS1pFDxEjnYhJruDYAOGEbb3RK#scrollTo=7PmpZ4oTyPHw). When we write a command on the same indentation level as the initial `for` statement, the loop is over. This will be executed after the loop."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Zlj0LILxu9TA"
   },
   "source": [
    "### `for` loops using `for ... in`\n",
    "\n",
    "You go through the contents of any iterable such as a list or a dictionary using `for ... in` like shown before with the `number_list`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "jHskWVZ-vVy-"
   },
   "outputs": [],
   "source": [
    "#try it out!\n",
    "countries = ['Denmark', 'Spain', 'Italy']\n",
    "\n",
    "# iterate over the ountries as we did with the list of numbers above:\n",
    "for country in countries:\n",
    "    print(country)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "gSAzxl6bvdoB"
   },
   "source": [
    "The `country` part is about how we want to refer to the element we are looking at right now. You can freely choose this variable name."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rP62SBxWzHLw"
   },
   "source": [
    "### `for` loops using `range()`\n",
    "\n",
    "Instead of writing out a list with all the numerical values we want to go through there is quicker way. We can create it using `range()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "aI1zSyEw1Tvk"
   },
   "outputs": [],
   "source": [
    "for number in range(1, 11):\n",
    "    print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ZCj6EX711bw1"
   },
   "source": [
    "The [**`range()`**](https://docs.python.org/3/library/functions.html#func-range) function returns a sequence of numbers, starting from 0 by default, and increments by 1 by default, and stops at a specified number (which is not included in the range).\n",
    "\n",
    "Based on what we learned so far you might think that it creates a list, but it does **not**. In fact, range **does not do anything** by itself, but can be used inside a for loop to create the sequence to loop over.\n",
    "\n",
    "> The syntax is: `range(start, stop, step)`\n",
    "\n",
    "The *step* parameter tells the function how many steps to skip and which direction to count (**`+`** for **up** and **`-`** for **down**).\n",
    "\n",
    "Examples:\n",
    "\n",
    "- `range(8)` gives you integers from 0 through 7.\n",
    "\n",
    "- `range(2, 9)` will give you integers from 2 to 8.\n",
    "\n",
    "- `range(10, 20, 2)`  will give you even numbers from 10 to 18. Remember, the upper limit of the range is excluded!\n",
    "\n",
    "- `range(9, 0, -1)`  will start from 9 and give you integers down to 1.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "dI_lYduNseEn"
   },
   "outputs": [],
   "source": [
    "#try it out!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5nylK238seEn"
   },
   "source": [
    "### `for` loops using `enumerate()`\n",
    "\n",
    "Another useful function to know for `for` loops is `enumerate`. Like its name hints, `enumerate` helps us to *enumerate* the contents of an iterable.\n",
    "\n",
    "The different to `for ... in` is that `enumerate` will also tell us the position of an element in the iterable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "LzVKG8MTseEo"
   },
   "outputs": [],
   "source": [
    "# get both items and their position\n",
    "for index, country in enumerate(countries):\n",
    "    print(\"My number\" + str(index) + \" favorite country is: \" + country)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "o42yFkWx4WyO"
   },
   "source": [
    "# Exercise 1\n",
    "\n",
    "_~ 20 minutes_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xqhI0vljzHL0"
   },
   "source": [
    "**a.** Use a for loop to iterate over `range(4)`. Which numbers does it produce?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "amW1Ja7kzHL0"
   },
   "outputs": [],
   "source": [
    "# your code goes here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pHR_ctAfzHL0"
   },
   "source": [
    "**b.** Now write a for loop using `range` that prints the numbers 1 to 4."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "nJj4ebrLzHL1"
   },
   "outputs": [],
   "source": [
    "# your code goes here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1453WLTVzHL1"
   },
   "source": [
    "**c.** What numbers do you get when you use the following range inside a for loop? Write out the loop to check.\n",
    "\n",
    "`range(12,0,-3)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "B1LU-GHpzHL2"
   },
   "outputs": [],
   "source": [
    "# your code goes here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YqDcWibUzHL2"
   },
   "source": [
    "**d.** Loop through numbers 1-20:\n",
    "- If the number is 4 or 13, print \"x is unlucky\"\n",
    "- Otherwise:\n",
    "    - If the number is even, print \"x is even\"\n",
    "    - If the number is odd, print \"x is odd\"\n",
    "\n",
    "> check [`Conditions.ipynb`](https://colab.research.google.com/github/Center-for-Health-Data-Science/PythonTsunami/blob/fall2021/Conditionals/Conditions.ipynb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "AC4dgNEPzHL3"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LwSW0hrCseEs"
   },
   "source": [
    "**e.** In the code below we're counting from 0 as python usually does. Can you fix so that it starts writing from 1?\n",
    "\n",
    "```python\n",
    "# get both items and their position\n",
    "for index, country in enumerate(countries):\n",
    "    print(\"My number\" + str(index) + \" favorite country is: \" + country)\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "fuNGQzXLseEs"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4NJV8SnW2dcf"
   },
   "source": [
    "## **`while`** loops\n",
    "\n",
    "We can also iterate over a sequence using a **`while`** loop, which has a different format:\n",
    "\n",
    "```python\n",
    "while condition:\n",
    "    expression\n",
    "```\n",
    "`while` loops continue to execute while a certain condition is `True`, and will end when it becomes `False`.\n",
    "\n",
    "```python\n",
    "user_response = \"Something...\"\n",
    "while user_response != \"please\":\n",
    "    user_response = input(\"Ah ah ah, you didn't say the magic word: \")\n",
    "```\n",
    "\n",
    "`while` loops require more careful setup than `for` loops, since you have to specify the termination conditions manually.\n",
    "\n",
    "Be careful! If the condition doesn't become `False` at some point, your loop will continue ***forever***!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "dKlSQ64XzHL4"
   },
   "outputs": [],
   "source": [
    "my_float = 50.0\n",
    "\n",
    "while my_float > 1:\n",
    "    my_float = my_float / 4\n",
    "    print(my_float)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xKOz5qSs5bfV"
   },
   "source": [
    "# Exercise 2\n",
    "\n",
    "_~15 minutes_\n",
    "\n",
    "**a.** What does the following loop do?\n",
    "```python\n",
    "    i = 1\n",
    "    while i < 5:\n",
    "        i + i\n",
    "        print(i)\n",
    "```\n",
    "    \n",
    "> Hint: is the value of `i` changing?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "MEX_6xXPzHL4"
   },
   "outputs": [],
   "source": [
    "# your code goes here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "NlbI1VH4zHL5"
   },
   "source": [
    "**b.** What does the following loop do?\n",
    "```python\n",
    "    i = 0\n",
    "    while i <= 5:\n",
    "        i = i + 1\n",
    "        print(i)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "iu3oul_BzHL5"
   },
   "outputs": [],
   "source": [
    "# your code goes here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CYMshsgmzHL6"
   },
   "source": [
    "**c.** Fix the infinite loop below so that it doesn't run endlessly anymore:\n",
    "```python\n",
    "    # this code runs forever...\n",
    "    x = 0\n",
    "    while x != 11:\n",
    "        x += 2\n",
    "        print(x)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "aH1WA-K7zHL6"
   },
   "outputs": [],
   "source": [
    "# your code goes here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XKETo3jK3aue"
   },
   "source": [
    "## Python loop control\n",
    "\n",
    "Controlled exit, skipping a block of code, or ignoring external factors that might influence your code, can be achieved with the Python statements: `break`, `continue`, and `pass`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xFv803XuzHL7"
   },
   "source": [
    "### ***`break`*** statement\n",
    "\n",
    "The keyword `break` gives us the ability to exit out of a loop whenever we want, and can be used in both `while` and `for` loops.\n",
    "\n",
    "Example:\n",
    "\n",
    "``` python\n",
    "for letter in 'Python':\n",
    "    if letter == 'h':\n",
    "        break\n",
    "    print('Current Letter:', letter)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Eff6JwP0zHL7"
   },
   "source": [
    "The `break` statement needs to be within the block of code under your loop statement, ususally after a conditional `if` statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "VsEuKOb731qP"
   },
   "outputs": [],
   "source": [
    "for letter in 'Python':\n",
    "    if letter == 'h':\n",
    "        break\n",
    "    print('Current Letter :', letter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Uf24LfUJzHL8"
   },
   "source": [
    "### ***`continue`*** statement\n",
    "\n",
    "The [`continue`](https://docs.python.org/3/tutorial/controlflow.html#break-and-continue-statements-and-else-clauses-on-loops) statement in Python gives you the option to skip over the part of a loop where a condition is met, but to go on to complete the rest of the loop. That is, it disrupts the iteration of the loop that fulfills the condition and returns the control to the beginning of the loop. It works with both `while` and `for` loops.\n",
    "\n",
    "Example:\n",
    "\n",
    "``` python\n",
    "for letter in 'Python':\n",
    "    if letter == 'h':\n",
    "        continue\n",
    "    print('Current Letter :', letter)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "V3Bic6PVzHL9"
   },
   "source": [
    "The difference in using `continue` rather than `break` is that the loop will continue despite the disruption when the condition is met."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "8DJUYVlNzHL9",
    "outputId": "0e7f26f8-3053-4c76-9ccf-e996895f3560"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current Letter : P\n",
      "Current Letter : y\n",
      "Current Letter : t\n",
      "Current Letter : o\n",
      "Current Letter : n\n"
     ]
    }
   ],
   "source": [
    "for letter in 'Python':\n",
    "    if letter == 'h':\n",
    "        continue\n",
    "    print('Current Letter :', letter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "n_HVORV8zHL9"
   },
   "source": [
    "### ***`pass`*** statement\n",
    "\n",
    "The [`pass`](https://docs.python.org/3/tutorial/controlflow.html#pass-statements) statement is used when a statement is required syntactically but you do not want any command or code to execute. It's a *null* operation.\n",
    "\n",
    "Now what does this mean? Because of flow control, statements like `if` and `for` need to be followed by an indented block of code or the program will crash. There can however be special situation where we want literally nothing to happen, or we don't know yet what should happen. Then we use `pass`.\n",
    "\n",
    "A common reason for this that some operation should happen eventually but we haven't gotten around to implementing it yet.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "nLgJjFzzj1EH"
   },
   "source": [
    "Compare the output of this to the code block above where we used `continue`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "JJ4O026WzHL-",
    "outputId": "8a1bf996-2aa8-4190-bb19-9f1984f09642"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current Letter : P\n",
      "Current Letter : y\n",
      "Current Letter : t\n",
      "Current Letter : h\n",
      "Current Letter : o\n",
      "Current Letter : n\n"
     ]
    }
   ],
   "source": [
    "for letter in 'Python':\n",
    "    if letter == 'h':\n",
    "        pass\n",
    "        #perhaps in the future something special should happen when the letter is h\n",
    "\n",
    "    print('Current Letter :', letter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "FIEj-qc5zHL-"
   },
   "source": [
    "# Exercise  \n",
    "\n",
    "_~ 15 minutes_\n",
    "\n",
    "Write a loop that:\n",
    "\n",
    "- iterates over each character in the string `\"I live in CPH, and I like it here.\"`;\n",
    "- for each character checks if it is a space;\n",
    "- if it is a space, then just continue with the loop;\n",
    "- if the character is not a space, do the following:\n",
    "- check if it is a comma `,` ;\n",
    "- if the character is a comma `,`, break the loop;\n",
    "- if the character is not a comma, print it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "XfAKZMP9seEy"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "provenance": [],
   "toc_visible": true
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.9"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "toc-autonumbering": true
 },
 "nbformat": 4,
 "nbformat_minor": 1
}