pyladies-munich-workshop3-data-flow.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Practical Session of PyLadies Munich Beginners Workshop 3\n",
    "\n",
    "## Theory of **data flow** and **data control**\n",
    "\n",
    "As seen before in the theory part, Truth evaluation of expressions are the most important part to \n",
    "understand for more advanced control flow elements like switches or loops."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 63,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "bool(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 64,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "bool(...)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 65,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "bool(None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 66,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "bool([])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 67,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "bool({})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 68,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "bool([[],[],None])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 69,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "all([[],{},None])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Some Loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits = ['banana', 'apple', 'orange']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "banana\n",
      "apple\n",
      "orange\n",
      "no more fruits available.\n"
     ]
    }
   ],
   "source": [
    "for fruit in fruits:\n",
    "    print(fruit)\n",
    "else:\n",
    "    print('no more fruits available.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "start = 1\n",
    "end = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "start value (6) was larger than end value (5)\n"
     ]
    }
   ],
   "source": [
    "while start <= end:\n",
    "    print(start)\n",
    "    start += 1\n",
    "else:\n",
    "    print('start value ({start}) was larger than end value ({end})'.format(start=start, end=end))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "start = 1\n",
    "end = 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "let us print just the even values between start and end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "while True:\n",
    "    if start >= end:\n",
    "        break\n",
    "    start += 1\n",
    "    if start % 2:\n",
    "        continue\n",
    "    print(start)\n",
    "else: \n",
    "    print('start value ({start}) was larger than end value ({end})'.format(start=start, end=end))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Some Dice Game\n",
    "\n",
    "a dice has the values between **1** and **6**, so we could play a bit with a dice and test what we have learned so far.\n",
    "\n",
    "### infinite generator\n",
    "\n",
    "first let us produce a dice that will generate a random number between 1 and 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "def dice():\n",
    "    while True:\n",
    "        value = round( random.random() * 6 + 0.5 )\n",
    "        yield value\n",
    "\n",
    "roll_dice = dice()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A simple value expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 82,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "next(roll_dice)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another simple value expression that generates a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 3, 2, 2, 5, 5, 6, 4, 6, 5]"
      ]
     },
     "execution_count": 83,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "rolls = [next(roll_dice) for i in range(10)]\n",
    "rolls"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "lets try to calculate the average value of our dice rolls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.49"
      ]
     },
     "execution_count": 85,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "tries = 100\n",
    "sum((next(roll_dice) for i in range(tries))) / tries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Something more complex\n",
    "define a class that makes it possible to count all different roll results and return a statistic how often each number has been thrown"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DiceStats(object):\n",
    "    \n",
    "    def __init__(self):\n",
    "        self.result = {}            \n",
    "            \n",
    "    def add(self, roll):\n",
    "        self.result[roll] = self.result.get(roll, 0) + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "so now create an instance of this `DiceStats` and show the results after 1000 tries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 161, 2: 183, 3: 160, 4: 147, 5: 167, 6: 182}"
      ]
     },
     "execution_count": 88,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "stats = DiceStats()\n",
    "tries = 1000\n",
    "for roll in range(tries):\n",
    "    stats.add(next(roll_dice))\n",
    "    \n",
    "stats.result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "stats.add(42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 161, 2: 183, 3: 160, 4: 147, 5: 167, 6: 182, 42: 1}"
      ]
     },
     "execution_count": 94,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "stats.result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "stats_average = 0\n",
    "tries = 0\n",
    "for key, value in stats.result.items():\n",
    "    stats_average += key * value\n",
    "    tries += value\n",
    "stats_average = stats_average / tries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1000"
      ]
     },
     "execution_count": 90,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "tries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.522"
      ]
     },
     "execution_count": 91,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "stats_average"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "def my_takt_generator():\n",
    "    num = 1\n",
    "    while True:\n",
    "        yield num\n",
    "        num = num % 4 + 1\n",
    "\n",
    "takt = my_takt_generator()\n",
    "\n",
    "counter = 0\n",
    "for takt_elem in takt:\n",
    "    print(takt_elem)\n",
    "    counter += 1\n",
    "    if counter >= 60:\n",
    "        break\n",
    "    time.sleep(1)"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {},
   "outputs": [],
   "source": [
    ""
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3.0
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.4.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}