01.07 for loops.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h1>for-loops<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#The-for-loop\" data-toc-modified-id=\"The-for-loop-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>The <em>for</em> loop</a></span><ul class=\"toc-item\"><li><span><a href=\"#Exercise-1\" data-toc-modified-id=\"Exercise-1-1.1\"><span class=\"toc-item-num\">1.1&nbsp;&nbsp;</span>Exercise 1</a></span></li></ul></li><li><span><a href=\"#The-range-command\" data-toc-modified-id=\"The-range-command-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>The <code>range</code> command</a></span><ul class=\"toc-item\"><li><span><a href=\"#Exercise-2\" data-toc-modified-id=\"Exercise-2-2.1\"><span class=\"toc-item-num\">2.1&nbsp;&nbsp;</span>Exercise 2</a></span></li></ul></li><li><span><a href=\"#The-enumerate-function\" data-toc-modified-id=\"The-enumerate-function-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>The <code>enumerate</code> function</a></span></li><li><span><a href=\"#List-comprehension\" data-toc-modified-id=\"List-comprehension-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>List comprehension</a></span></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## The _for_ loop\n",
    "\n",
    "In on of the previous chapter we have defined the word list `word_list`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "word_list = [\"my\", \"name\", \"is\", \"Olaf\"]\n",
    "print(word_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We also learned, that we can access individual entries via indexing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(word_list[0])\n",
    "print(word_list[1])\n",
    "print(word_list[2])\n",
    "print(word_list[3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instead of printing out each entry by indexing each element manually, we can automatize this task with a so-called _for_-loop:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "for any_index in any_list_of_length_N:\n",
    "    N-times iteration of your command(s)\n",
    "    that command can even use the any_index-value\n",
    "        \n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `any_list_of_length_N` is any list, over which we'd like to iterate\n",
    "- `any_index` is an iterator-placeholder, that gets/becomes each value of the list step-by-step with each iteration\n",
    "- the commands followed after the \"`:`\" will be executed as many times as `any_list_of_length_N` has entries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Note:</b> Python relies on indentation (whitespace at the beginning of a line) to define scope in the code of the for-loop. The for-block does not require a specific \"end\"-indicator, just un-indent after you finished the block.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [],
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# for-loop example 1:\n",
    "print(word_list)\n",
    "for current_word in word_list:\n",
    "    print(current_word)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, `current_word` becomes step-by-step the entries of the pre-defined `word_list` list-variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [],
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# for-loop, same example 1, just different naming:\n",
    "for iii in word_list:\n",
    "    print(iii)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 1\n",
    "\n",
    "1. Create a new script and define the number list `number_list = [67, 68, 69, 70]`.\n",
    "2. Write a _for_-loop, that iterates over `number_list` and prints out each element entry-by-entry.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your solution 1 here:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary><strong>Toggle solution</strong></summary>\n",
    "\n",
    "```python\n",
    "# Solution 1:\n",
    "print(\">>>\")\n",
    "number_list = [67, 68, 69, 70] \n",
    "for entry in number_list:\n",
    "    print(f\"current entry: {entry}\")\n",
    "``` \n",
    "<script src=\"https://gist.github.com/username/a39a422ebdff6e732753b90573100b16.js\"></script>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The `range` command\n",
    "Sometimes you don't want the iterator becoming directly the entries of the iterating list, but an index value. This can be achived via the `range` command paired with the `len` command:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [],
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# for-loop example 2.1:\n",
    "#print(f\"the length of my list is {len(word_list)}\")\n",
    "\n",
    "for i in range(0, 4): \n",
    "    print(f\"current index is: {i}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for iii in range(0, 4):\n",
    "    print(iii, \":\", word_list[iii])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# for-loop example 2.2:\n",
    "print(f\"the length of my list is {len(word_list)}\")\n",
    "\n",
    "N = len(word_list)\n",
    "\n",
    "for i in range(0, N):\n",
    "    print(f\"at current index {i} there is \" \n",
    "          f\"the entry: {word_list[i]}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "word_list.append(\"some\")\n",
    "word_list.append(\"more\")\n",
    "word_list.append(\"text\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "N = len(word_list)\n",
    "\n",
    "for i in range(0, N, 1):\n",
    "    print(f\"at current index {i} there is \" \n",
    "          f\"the entry: {word_list[i]}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# similar too:\n",
    "for i in range(N):\n",
    "    print(f\"at current index {i} there is \" \n",
    "          f\"the entry: {word_list[i]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `range` command accepts three arguments: `range(start, stop, step)`:\n",
    "- generates an iterator from `start`-vaule (included) to `stop`-value (not included) in the given integer `step`-size.\n",
    "- skipping the `start`-vaule let's `range` by default start at 0.\n",
    "- skipping the `step`-vaule let's `range` by default step in step-sizes of 1.\n",
    "\n",
    "E.g., `range(0, 4, 1)` is identical to `range(4)`. \n",
    "\n",
    "\n",
    "The output of `range` is nothing that you can print out or use as a variable - it's a specific iterator-construct for the _for_-loop. But there is a workaround to get (and validate) the iterator entries generated by `range`: `list(range(start, stop, step))`. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(range(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "aa = range(10)\n",
    "print(aa)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_new_list = list(range(0,10,1))\n",
    "print(f\"my_new_list: {my_new_list}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "my_new_list_2 = list(range(3,10,2))\n",
    "print(f\"my_new_list_2: {my_new_list_2}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_new_list_3 = list(range(len(word_list)))\n",
    "print(f\"my_new_list_3: {my_new_list_3}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 2\n",
    "\n",
    "1. Create a new cell in your script from the previous exercise.\n",
    "2. Create a new number list `number_list_2` that ranges from 3 to 13 in the step-size of 1 (use the `range` and `list` command).\n",
    "3. Write a _for_-loop, that iterates over `number_list_2` and prints out each element entry-by-entry and its accoriding index, by using the `range` and `len` command.\n",
    "4. Modify the step-size to 2 and re-run you script/cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your solution 2 here:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary><strong>Toggle solution</strong></summary>\n",
    "\n",
    "```python\n",
    "# Solution 2:\n",
    "number_list_2 = list(range(3, 14,1))\n",
    "print(\">>>\")\n",
    "print(f\"number_list_2: {number_list_2}\")\n",
    "print(f\"the length of number_list_2: {len(number_list_2)}\")\n",
    "print(\"\")\n",
    "\n",
    "step_size = 3\n",
    "\n",
    "for i in range(0, len(number_list_2), step_size):\n",
    "    print(f\"{i}. index has the value {number_list_2[i]}\")\n",
    "``` \n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ],
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Example use-case:\n",
    "print(\">>>\")\n",
    "number_list_3 = list(range(5, 16,1))\n",
    "print(f\"{len(number_list_2)}, {len(number_list_3)}\")\n",
    "print(\"\")\n",
    "\n",
    "step_size = 1\n",
    "\n",
    "for i in range(0, len(number_list_2), step_size):\n",
    "    print(f\"{number_list_2[i]} + {number_list_3[i]} = \"\n",
    "          f\"{number_list_2[i] + number_list_3[i]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## The `enumerate` function\n",
    "`enumerate` is another useful function, which provides you with both, the current index and the current value of a given list over which you are iterating:\n",
    "\n",
    "```python\n",
    "enumerate(iterable, start=0)\n",
    "```\n",
    "\n",
    "with\n",
    "\n",
    "* `iterable`: any object that supports iteration (e.g., lists)\n",
    "* `start`: the index value from which the counter is to be started, by default it is 0\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Example with enumerate command:\n",
    "my_list = ['apple', 'windows', 'android', 'linux']\n",
    "for counter, value in enumerate(my_list):\n",
    "    print(f\"counter {counter} relates to entry: {value} = \" \n",
    "          f\"{my_list[counter]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "for counter, value in enumerate(my_list, 3):\n",
    "    print(f\"counter {counter} relates to entry: {value}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List comprehension\n",
    "List comprehension is an elegant way of defining or creating sets in Python that is very close to the mathematical notation of sets. Let's express for example the expression\n",
    "\n",
    "$$ \\left[\\; x^2 \\; |\\; x \\in [0, 1, 2, 3, 4] \\;\\right] $$\n",
    "<p style=\"text-align: center;\"> (reads: the set of x to the square such that x is an element of the list 0, 1, 2, 3, 4.) </p>\n",
    "\n",
    "via list comprehension:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "result = [ (x*x) for x in [0, 1, 2, 3, 4]]\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or even shorter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "print([ (x*x) for x in [0, 1, 2, 3, 4]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# instead of:\n",
    "for x in [0, 1, 2, 3, 4]:\n",
    "    #print(x*x)\n",
    "    print(x**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Note:</b> You have to put the list comprehension into straight brackets, which converts the result into a list. Otherwise the output will be just a so-called \"generator object\":\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "print( (x*x) for x in [0, 1, 2, 3, 4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List comprehension also works with pre-defined lists (_sequences_):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "word_list = [\"hello\", \"this\", \"is\", \"a\", \"list\", \"comprehension\"]\n",
    "print( [word for word in word_list])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Summary:</b> An advantage of list comprehension is the reduced complexity of your code (you end up with less lines of code). But may be this complexity reduction, i.e., putting many commands into one line, makes your code difficult to oversee at the beginning.\n",
    "</div>"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.8.16 | packaged by conda-forge | (default, Feb  1 2023, 16:05:36) \n[Clang 14.0.6 ]"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": true,
   "title_cell": "for-loops",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  },
  "vscode": {
   "interpreter": {
    "hash": "4dbe93ddc4bed5499d29720f38f7446a34b15f2f3201b881b9bf1c1a4baa393f"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}