for-loops_4_texts.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# for - loops\n",
    "\n",
    "- [1. basic loops](#1)\n",
    "- [2. looping texts](#2)\n",
    "- [3. Exercises](#3)\n",
    "-- [3.1 Typewriter Effect](#4)\n",
    "-- [3.2 Dada Poem Generator](#5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a class=\"anchor\" id=\"1\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. basic loops\n",
    "\n",
    "Loops can be used to execute a block of code several times. The most commonly used loop is the `for` loop with the following syntax:\n",
    "\n",
    "```python\n",
    "for value in iterable:\n",
    "    # do things\n",
    "```\n",
    "\n",
    "`iterable` can be any _series_, e.g. a list, a tuple or a string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "1.2\n",
      "a\n"
     ]
    }
   ],
   "source": [
    "for x in [3, 1.2, 'a']:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "h\n",
      "e\n",
      "l\n",
      "l\n",
      "o\n"
     ]
    }
   ],
   "source": [
    "for letter in 'hello':\n",
    "    print(letter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Executing a code block `n` times\n",
    "\n",
    "Sometimes we want a block of code to execute a certain amount of iterations. For this purpose we can use the `range` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "some code to be executed n times\n",
      "some code to be executed n times\n",
      "some code to be executed n times\n",
      "some code to be executed n times\n",
      "some code to be executed n times\n"
     ]
    }
   ],
   "source": [
    "# Of course we don't need to use the variable (in this case i) inside our code block:\n",
    "for i in range(5):\n",
    "    print('some code to be executed n times')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also call the function with the arguments `start`, `stop` and (optionally) `step`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n",
      "6\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "for i in range(2, 10, 2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cancel a loop or skip steps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `break` command can be used to stop a loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "for i in range(100):\n",
    "    if i > 3:\n",
    "        break\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `continue` command only cancels the current step of the loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "for i in range(4):\n",
    "    if i == 1:\n",
    "        continue\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating lists with `for` loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use for-loops to create lists. For that we have to write the for-loop inside square brackets []."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'n', ' ', 'i', 't', 'e', 'r', 'a', 'b', 'l', 'e']\n"
     ]
    }
   ],
   "source": [
    "x = [c for c in 'an iterable']\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "# Another example with range:\n",
    "x = [i for i in range(6)]\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A very handy concept to work with lists in Python is called _list comprehension_. With the following syntax, an operation is applied to each element of the given series. A list with the computed elements is returned:\n",
    "\n",
    "```python\n",
    "new_elements = [operation(element) for element in iterable]\n",
    "```\n",
    "\n",
    "Here, for example, the operation $x^2$ is applied to all $x \\in [0,10]$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[x**2 for x in range(11)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercises:\n",
    "\n",
    "- ?\n",
    "- ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a class=\"anchor\" id=\"2\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 2. looping texts\n",
    "...now we are going short back to the Mattis' Sequencing Notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(hier könnten wir **exercises** draus machen...)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "He Hazardous of we strong\n",
      "follow bacteria walks\n",
      "by town guy place\n",
      "\n"
     ]
    }
   ],
   "source": [
    "text = '''\n",
    "He Hazardous of we strong\n",
    "follow bacteria walks\n",
    "by town guy place\n",
    "'''\n",
    "print(text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['\\nHe', 'Hazardous', 'of', 'we', 'strong\\nfollow', 'bacteria', 'walks\\nby', 'town', 'guy', 'place\\n']\n"
     ]
    }
   ],
   "source": [
    "text_list = text.split(' ')\n",
    "print(text_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(text_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for i in range(len(text_list)):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "He\n",
      "Hazardous\n",
      "of\n",
      "we\n",
      "strong\n",
      "follow\n",
      "bacteria\n",
      "walks\n",
      "by\n",
      "town\n",
      "guy\n",
      "place\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for i in range(len(text_list)):\n",
    "    print(text_list[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0  -  \n",
      "He\n",
      "1  -  Hazardous\n",
      "2  -  of\n",
      "3  -  we\n",
      "4  -  strong\n",
      "follow\n",
      "5  -  bacteria\n",
      "6  -  walks\n",
      "by\n",
      "7  -  town\n",
      "8  -  guy\n",
      "9  -  place\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for i in range(len(text_list)):\n",
    "    print(i, ' - ', text_list[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another sometimes useful loop is `enumerate()`. It iterates through a *series* and returns each value with the index of that value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 \t \n",
      "He\n",
      "1 \t Hazardous\n",
      "2 \t of\n",
      "3 \t we\n",
      "4 \t strong\n",
      "follow\n",
      "5 \t bacteria\n",
      "6 \t walks\n",
      "by\n",
      "7 \t town\n",
      "8 \t guy\n",
      "9 \t place\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for index, value in enumerate(text_list):\n",
    "    print(index, '\\t', value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<a class=\"anchor\" id=\"4\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1 Typewriter Effect"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### try to make a for-loop to simulate an typewriter effect"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# you'll need the following 2 libraries\n",
    "from time import sleep\n",
    "import sys"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "you will need 3 different functions to do that:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sleep\n",
    "# sys.stdout.write\n",
    "# sys.stdout.flush"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### try to find out (remember the *little-helpers*) what you can do with them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "well..., we are using our text-string `text` to animate it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "He Hazardous of we strong\n",
      "follow bacteria walks\n",
      "by town guy place\n",
      "\n"
     ]
    }
   ],
   "source": [
    "text = '''\n",
    "He Hazardous of we strong\n",
    "follow bacteria walks\n",
    "by town guy place\n",
    "'''\n",
    "print(text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "#### now, try to code the typewriter-effect (replace all `pass` with your code):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "for letter in text:         # for each character in each line\n",
    "    pass                    # 'print' a single character, and keep the cursor there.\n",
    "    pass                    # 'sys.stdout.write' it into a buffer\n",
    "    pass                    # 'sys.stdout.flush' the buffer\n",
    "    pass                    # use 'sleep' to decide how many milliseconds will be between output each character"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "He Hazardous of we strong\n",
      "follow bacteria walks\n",
      "by town guy place\n"
     ]
    }
   ],
   "source": [
    "#hier eine beispielversion in der der buffer direkt in print gesetzt:\n",
    "for letter in text:\n",
    "    print(letter, end='', flush=True)\n",
    "    sleep(0.05)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "#### try to humanize your output (a human being will not type on letter each millisecond)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# you will need the following library\n",
    "from random import uniform"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[0;31mSignature:\u001b[0m \u001b[0muniform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
       "\u001b[0;31mDocstring:\u001b[0m Get a random number in the range [a, b) or [a, b] depending on rounding.\n",
       "\u001b[0;31mFile:\u001b[0m      ~/anaconda3/lib/python3.7/random.py\n",
       "\u001b[0;31mType:\u001b[0m      method\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "uniform?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "replace the `pass` with your code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "He Hazardous of we strong\n",
      "follow bacteria walks\n",
      "by town guy place\n"
     ]
    }
   ],
   "source": [
    "for letter in text:\n",
    "    print(letter, end='')\n",
    "    sys.stdout.flush()\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<a class=\"anchor\" id=\"5\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2 Dada Poem Generator \n",
    "(wie in mattis' notebook nur mit for-schleife...)\n",
    "\n",
    "How to Make a Dadaist Poem\n",
    "- (method of Tristan Tzara)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Take a newspaper.\n",
      "Take some scissors.\n",
      "Choose from this paper an article of the length you want to make your poem.\n",
      "Cut out the article.\n",
      "Next carefully cut out each of the words that makes up this article and put them all in a bag.\n",
      "Shake gently.\n",
      "Next take out each cutting one after the other.\n",
      "Copy conscientiously in the order in which they left the bag.\n",
      "Them poem will resemble you.\n",
      "And there you are – an infinitely original author of charming sensibility, even though unappreciated by the vulgar herd.\n"
     ]
    }
   ],
   "source": [
    "# set variable\n",
    "newspaper = \"\"\"\n",
    "Take a newspaper.\n",
    "Take some scissors.\n",
    "Choose from this paper an article of the length you want to make your poem.\n",
    "Cut out the article.\n",
    "Next carefully cut out each of the words that makes up this article and put them all in a bag.\n",
    "Shake gently.\n",
    "Next take out each cutting one after the other.\n",
    "Copy conscientiously in the order in which they left the bag.\n",
    "Them poem will resemble you.\n",
    "And there you are – an infinitely original author of charming sensibility, even though unappreciated by the vulgar herd.\"\"\" \n",
    "\n",
    "print(newspaper)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### ...remember the code from mattis' *sequenzing-notebook*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "want them of scissors.\n",
      "Choose article this some this put article carefully other.\n",
      "Copy the make each out unappreciated an which and an you.\n",
      "And of a gently.\n",
      "Next original the paper out in bag.\n",
      "Shake sensibility, they even in order poem.\n",
      "Cut there infinitely cutting take cut a length herd. will the the bag.\n",
      "Them up vulgar the one you newspaper.\n",
      "Take you of left that the resemble poem conscientiously author charming to your the are though makes words after each in from – article.\n",
      "Next \n",
      "Take by out all\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "# Split string into list.\n",
    "word_list = newspaper.split(' ')\n",
    "# Shuffle list.\n",
    "random.shuffle(word_list)\n",
    "# Join list to string.\n",
    "word_str = ' '.join(word_list)\n",
    "print(word_str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### now, try to make a for-loop out of it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### finally try to animate your cut-up:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}