lecture_07_loops_and_list_comprehension.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: center\">\n",
    "    <div style=\"font-size: xxx-large ; font-weight: 900 ; color: rgba(0 , 0 , 0 , 0.8) ; line-height: 100%\">\n",
    "        Loops &amp; List Comprehension\n",
    "    </div>\n",
    "    <div style=\"font-size: x-large ; padding-top: 20px ; color: rgba(0 , 0 , 0 , 0.5)\">\n",
    "        for + while\n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Loops in programming languages are used to describe recurring behavior.\n",
    "\n",
    "Python has two types of loops:\n",
    "\n",
    "- `for`: Have a fixed number of iterations known before the loop starts\n",
    "- `while`: Run an indefinite number of times, based on the condition evaluated \"while\" the loop already runs.\n",
    "\n",
    "Most Python `for` loops can easily be rewritten as `while` loops, but not vice-versa."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# For-Loop\n",
    "\n",
    "`for` loops are a type of loop that will be executed \"for a number of times\" or \"for a number of elements\".\n",
    "\n",
    "## The general structure of a `for`-loop in Python is:\n",
    "```python\n",
    "for <element> in <iterable>:\n",
    "    \"Do something in here\"\n",
    "    ...\n",
    "    \"Do more in the loop\"\n",
    "\"Outside of the loop\"\n",
    "```\n",
    "\n",
    "* An `<iterable>` is an object that Python can get an **iterator** from, when used in a `for`-loop.\n",
    "* An **iterator** will yield a new element every time it is called in a `for`-loop."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**INDENTATION**: As you can see in the example above, the __\"Do something here\"__ part is indented with 4 spaces. This tells Python that it is part of the loop. The __\"Outside of the loop\"__ part is not indented and is therefore not part of the loop.\n",
    "* You can use any amount of indentation (1-space, 2-spaces, ..., tabs) but you have to make sure that within a file you will always use the same amount."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A typical way to specify a `for`-loop in Python is by using the `range(N)` function to do something `N`-times (`range` returns an **iterable**).\n",
    "\n",
    "```\n",
    "class range(object)\n",
    " |  range(stop) -> range object\n",
    " |  range(start, stop[, step]) -> range object\n",
    " |  \n",
    " |  Return an object that produces a sequence of integers from start (inclusive)\n",
    " |  to stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.\n",
    " |  start defaults to 0, and stop is omitted!  range(4) produces 0, 1, 2, 3.\n",
    " |  These are exactly the valid indices for a list of 4 elements.\n",
    " |  When step is given, it specifies the increment (or decrement).\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "for i in range(4):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "2\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# range(start=0, stop=6, step=2):\n",
    "for i in range(0, 6, 2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Acessing elements in a container that supports access by index (tuple, list, string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "1\n",
      "3\n",
      "0\n",
      "5\n",
      "6\n",
      "7\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "m_list = [5, 1, 3, 0, 5, 6, 7, 9]\n",
    "for index in range(len(m_list)):\n",
    "    print(m_list[index])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Containers are `<iterable>`!\n",
    "\n",
    "All **containers** from\n",
    "* [Python - Loops and List Comprehension](lecture_5_loops_and_list_comprehension.ipynb) and also\n",
    "* **string** from [Python - Data types (strings, integer, floats, bool, None)](lecture_2_strings_integers_floats_bool_none.ipynb) are **iterables**.  \n",
    "\n",
    "(See [Python Glossary - iterables](https://docs.python.org/3/glossary.html) for more details)\n",
    "\n",
    "This means you do not have to use an *index*, like above, if you want to access your data sequentially."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "5\n",
      "6\n",
      "8\n",
      "[1, 2, 3]\n",
      "a\n"
     ]
    }
   ],
   "source": [
    "m_list = [1, 5, 6, 8, [1, 2, 3], 'a']\n",
    "for element in m_list:\n",
    "    print(element) # Get one element at a time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "4\n",
      "abc\n"
     ]
    }
   ],
   "source": [
    "m_tuple = (1, 2, 4, 'abc')\n",
    "for element in m_tuple:\n",
    "    print(element)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H\n",
      "e\n",
      "l\n",
      "l\n",
      "o\n",
      "!\n"
     ]
    }
   ],
   "source": [
    "m_string = 'Hello!'\n",
    "for element in m_string:\n",
    "    print(element)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "4\n",
      "a\n",
      "b\n"
     ]
    }
   ],
   "source": [
    "m_set = {1, 2, 4, 'a', 'b'}\n",
    "for element in m_set:\n",
    "    print(element)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Careful with `dict`\n",
    "A dictionary will only return the keys by default."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "c\n"
     ]
    }
   ],
   "source": [
    "m_dict = {1: 'a', 2: 'b', 'c': [1,2,3]}\n",
    "for key in m_dict:\n",
    "    print(key)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use\n",
    "- `dict.items()` To get tuples of (key, value)\n",
    "- `dict.keys()` To get only the keys [DEFAULT]\n",
    "- `dict.values()` To get only the values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "m_dict = {1: 'a', 2: 'b', 'c': [1,2,3]}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`dict.items()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TUPLES\n",
      "(1, 'a')\n",
      "(2, 'b')\n",
      "('c', [1, 2, 3])\n"
     ]
    }
   ],
   "source": [
    "print('TUPLES')\n",
    "for element in m_dict.items():\n",
    "    print(element)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**NOTE**: You can unpack a tuple to individual variables automatically."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "UNPACKED\n",
      "Key: 1, Value: a\n",
      "Key: 2, Value: b\n",
      "Key: c, Value: [1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "print('UNPACKED')\n",
    "for key, value in m_dict.items():\n",
    "    print(f\"Key: {key}, Value: {value}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`dict.keys()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "KEYS\n",
      "1\n",
      "2\n",
      "c\n"
     ]
    }
   ],
   "source": [
    "print('KEYS')\n",
    "for element in m_dict.keys():\n",
    "    print(element)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`dict.values()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "VALUES\n",
      "a\n",
      "b\n",
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "print('VALUES')\n",
    "for element in m_dict.values():\n",
    "    print(element)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterate through a Container and Enumerate Steps\n",
    "\n",
    "This is especially useful when you want to get the element and a counter at the same time. `enumerate(list)` will return a tuple `(index, list_element`).\n",
    "\n",
    "We will automatically unpack the tuple into the two variables `i`, for index, and `element`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Element at index 0 is 4. Identical to alist[0]=4\n",
      "Element at index 1 is 9. Identical to alist[1]=9\n",
      "Element at index 2 is 8. Identical to alist[2]=8\n",
      "Element at index 3 is 7. Identical to alist[3]=7\n",
      "Element at index 4 is 6. Identical to alist[4]=6\n",
      "Element at index 5 is 5. Identical to alist[5]=5\n"
     ]
    }
   ],
   "source": [
    "alist = [4,9,8,7,6,5]\n",
    "for i, element in enumerate(alist):\n",
    "    print(f'Element at index {i} is {element}. Identical to alist[{i}]={alist[i]}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# While-Loop\n",
    "\n",
    "`while` loops are a type of loop that will be executed until a condition is `False`.\n",
    "\n",
    "The general structure of a `while`-loop in Python is:\n",
    "```python\n",
    "while <condition is True>:\n",
    "    \"Do something in here\"\n",
    "```\n",
    "\n",
    "If you want a loop that does something forever use\n",
    "\n",
    "```python\n",
    "while True:\n",
    "    \"Do this forever\"\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "4\n",
      "8\n",
      "12\n",
      "16\n"
     ]
    }
   ],
   "source": [
    "counter = 0\n",
    "\n",
    "while counter < 10:\n",
    "    print(counter * 2)\n",
    "    counter += 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`while` may not execute at all if the condition is already `False`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "variable = 0\n",
    "while variable < 0:\n",
    "    print('Hey')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `Break`(ing) out of a loop\n",
    "\n",
    "You can break out of a loop at any time with `break`.\n",
    "\n",
    "This also work for `while`-loops down below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "Now we continue here...\n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    print(i)\n",
    "    if i == 5:\n",
    "        break\n",
    "print('Now we continue here...')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `Continue` to skip to the next cycle\n",
    "\n",
    "You can skip to the next iteration of a loop with `continue`. This will not execute any command in the loop after the continue and instead directly go to the next loop cycle!\n",
    "\n",
    "This also work for `while`-loops down below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "# We will skip the 5\n",
    "for i in range(10):\n",
    "    if i == 5:\n",
    "        continue # Go to 6 immediately and do not print(5)\n",
    "        print('This is never executed')\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Nesting Loops (Loops within Loops)\n",
    "\n",
    "**Note**: When nesting loops or other constructs introduced later make sure to increase the indentation of your code as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4-spaces\n",
      "0\n",
      "    8-spaces\n",
      "    0\n",
      "    8-spaces\n",
      "    1\n",
      "4-spaces\n",
      "1\n",
      "    8-spaces\n",
      "    0\n",
      "    8-spaces\n",
      "    1\n",
      "4-spaces\n",
      "2\n",
      "    8-spaces\n",
      "    0\n",
      "    8-spaces\n",
      "    1\n"
     ]
    }
   ],
   "source": [
    "for i in range(3):\n",
    "    print('4-spaces')\n",
    "    print(f'{i}')\n",
    "    for j in range(2):\n",
    "        print('    8-spaces')\n",
    "        print(f\"    {j}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# List Comprehension\n",
    "\n",
    "Python has some usefuls shorthands when working with loops.\n",
    "\n",
    "These shorthands are called **List Comprehension** and allow you to write loops in a single line.\n",
    "\n",
    "List comprehension is useful when you want to transform (also called *map*) data into something else.\n",
    "\n",
    "When using list comprehension the elements will be transformed on-the-fly and you do not have to create a new container to hold and add the transformed data to.\n",
    "\n",
    "**NOTE**: Using List Comprehension can also sometimes make reading an understanding code very difficult.\n",
    "\n",
    "## The general syntax is\n",
    "```python\n",
    "transformed_iterable = [DoSomethingWith(element) for element in <iterable>]\n",
    "\n",
    "# Which is similar to\n",
    "transformed_iterable = []\n",
    "for element in iterable:\n",
    "    transformed_iterable.append(DoSomethingWith(element))\n",
    "```\n",
    "\n",
    "## It is also possible to add a condition and filter elements\n",
    "Elements that do not meet the condition will be dropped.\n",
    "```python\n",
    "[DoSomethingWith(element) for element in <iterable> if <element meets condition>]\n",
    "```\n",
    "\n",
    "## (Bonus) List comprehension can also be nested\n",
    "\n",
    "**NOTE**: This can quickly turn into unreadable code the more layers of nesting you add!\n",
    "\n",
    "```python\n",
    "[DoSomethingWith(element) for <iterable_inner> in <iterable_outer> for element in <iterable_inner>]\n",
    "        \n",
    "# You could also see it as follows\n",
    "# the parenthesis here are just to group the loops, they are not proper Python syntax\n",
    "[DoSomethingWith(element) (for <iterable_inner> in <iterable_outer>) (for element in <iterable_inner>)]\n",
    "\n",
    "# Which is similiar to\n",
    "for iterable_inner in iterable_outer:\n",
    "    for element in iterable_inner:\n",
    "        DoSomethingWith(element)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Transform list elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 0.0]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_of_ints = [1,2,3,4,5,6,7,8,9,0]\n",
    "[float(element) for element in list_of_ints]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Transform list elements `if` matching a condition\n",
    "We only convert even numbers to floats and drop the rest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2.0, 4.0, 6.0, 8.0, 0.0]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_of_ints = [1,2,3,4,5,6,7,8,9,0]\n",
    "[float(element) for element in list_of_ints if element % 2 == 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Flatten a list of lists to a single list with nested list comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "non_flat = [ [1,2,3], [4,5,6], [7,8] ]\n",
    "[y for x in non_flat for y in x]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Transform a list of tuples into a dict\n",
    "Python allows you to automatically unpack a tuple into multiple elements which you can make use of in list comprehension.\n",
    "\n",
    "For example, the tuple `('a', 1)` will be unpacked to `key='a', value=1`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 1, 'b': 2, 'c': 3}"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_of_tuples = [('a', 1), ('b', 2), ('c', 3)]\n",
    "{key: value for key, value in list_of_tuples}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Summary\n",
    "\n",
    "* You know about **for** loops.\n",
    "* You know about **while** loops.\n",
    "* You know about the **differences between the two loop types**.\n",
    "* You have a basic understanding of **what an iterable is**.\n",
    "* You know **how to access values in basic containers using a for loop**.\n",
    "* You know what **break** and **continue** do.\n",
    "* You know how to use **list comprehension** and the basics of **when NOT to use it**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Next excercise: [Exercise 07](exercise_07_loops_and_list_comprehension.ipynb)\n",
    "### Next lecture: [Python - Functions](lecture_08_functions.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "##### Authors:\n",
    "* [Julian Niedermeier](https://github.com/sleighsoft)"
   ]
  }
 ],
 "metadata": {
  "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}