Session_4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# An introduction to Python\n",
    "\n",
    "## Session 1.4: Loops\n",
    "\n",
    "- [The <tt>for</tt> loop](#The-for-loop)\n",
    "- [The <tt>while</tt> loop](#The-while-loop)\n",
    "- [Skipping and breaking loops](#Skipping-and-breaking-loops)\n",
    "- [More looping using range and enumerate](#More-looping)\n",
    "- [Filtering in loops](#Filtering-in-loops)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When an operation needs to be repeated multiple times, for example on all of the items in a list, we \n",
    "avoid having to type (or copy and paste) repetitive code by creating a loop. There are two ways of creating loops in Python, the <tt>for</tt> loop and the <tt>while</tt> loop."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The <tt>for</tt> loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The for loop in Python iterates over each item in a sequence (such as a list or tuple) in the order that they appear in the sequence. What this means is that a variable (<tt>code</tt> in the below example) is set to each item from the sequence of values in turn, and each time this happens the indented block of code is executed again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "\n",
    "for x in numbers:\n",
    "    print(x)\n",
    "    #print(number, end = '-')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A <tt>for</tt> loop can iterate over the individual characters in a string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "K\n",
      "o\n",
      "c\n",
      "h\n",
      "i\n",
      " \n",
      "P\n",
      "y\n",
      "t\n",
      "h\n",
      "o\n",
      "n\n"
     ]
    }
   ],
   "source": [
    "name = 'Kochi Python'\n",
    "\n",
    "for character in name:\n",
    "    print(character)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And also over the keys of a dictionary: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A Cricket\n",
      "B Football\n",
      "C Hockey\n",
      "D Badminton\n",
      "E Kabaddi\n"
     ]
    }
   ],
   "source": [
    "sports = {\"A\": \"Cricket\", \"B\": \"Football\", \"C\": \"Hockey\", \"D\": \"Badminton\", \"E\": \"Kabaddi\"}\n",
    "\n",
    "for x in sports:\n",
    "    print(x, sports[x])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Any variables that are defined before the loop can be accessed from inside the loop. So for example to calculate the summation of the items in a list of values we could define the total initially to be zero and add each value to the total in the loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "total = 0\n",
    "values = [1, 2, 4, 8, 16]\n",
    "\n",
    "for v in values:\n",
    "    total = total + v\n",
    "    # total += v\n",
    "    print(total)\n",
    "\n",
    "print(total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Naturally we can combine a <tt>for</tt> loop with an <tt>if</tt> statement, noting that we need two indentation levels, one for the outer loop and another for the conditional blocks:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tintumon  : Failed\n",
      "Dundumol  : Passed\n",
      "Dingan  : Passed\n",
      "Luttapi  : Just Pass\n"
     ]
    }
   ],
   "source": [
    "markList = {\n",
    "    'Tintumon': 22, \n",
    "    'Dundumol': 86, \n",
    "    'Dingan': 69, \n",
    "    'Luttapi': 45\n",
    "}\n",
    "\n",
    "for person in markList:\n",
    "    if markList.get(person) < 45:\n",
    "        print(person, \" : Failed\")\n",
    "        \n",
    "    elif markList.get(person) > 45:\n",
    "        print(person, \" : Passed\")\n",
    "        \n",
    "    else:\n",
    "        print(person, ' : Just Pass' )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The <tt>while</tt> loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In addition to the <tt>for</tt> loop that operates on a collection of items, there is a <tt>while</tt> loop that simply repeats while some statement evaluates to True and stops when it is False. Note that if the tested expression never evaluates to False then you have an “infinite loop”, which is not good.\n",
    "\n",
    "In this example we generate a series of numbers by doubling a value after each iteration, until a limit is reached: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5\n",
      "1.0\n",
      "2.0\n",
      "4.0\n",
      "8.0\n",
      "final value: 8.0\n"
     ]
    }
   ],
   "source": [
    "value = 0.25\n",
    "while value < 8:\n",
    "    value = value * 2\n",
    "    print(value)\n",
    "\n",
    "print(\"final value:\", value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Whats going on here is that the value is doubled in each iteration and once it gets to 8 the while test fails (8 is not less than 8) and that last value is preserved. Note that if the test were instead value `<= 8` then we would get one more doubling and the value would reach 16."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Skipping and breaking loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has two ways of affecting the flow of the <tt>for</tt> or <tt>while</tt> loop inside the block. The <tt>continue</tt> statement means that the rest of the code in the block is skipped for this particular item in the collection, i.e. jump to the next iteration. In this example negative numbers are left out of a summation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n"
     ]
    }
   ],
   "source": [
    "#Sum of positive integers in a list\n",
    "values = [10, -5, 3, -1, 7]\n",
    "\n",
    "total = 0\n",
    "for v in values:\n",
    "    if v < 0:\n",
    "        continue # Skip this iteration   \n",
    "    total += v\n",
    "\n",
    "print(total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The other way of affecting a loop is with the <tt>break</tt> statement. In contrast to the <tt>continue</tt> statement, this immediately causes all looping to finish, and execution is resumed at the next statement _after_ the loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "#Print from 1 - 7\n",
    "for n in range(1,10):\n",
    "    if n % 8 == 0:\n",
    "        break            # Quit looping at this point\n",
    "    else:\n",
    "        print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Looping gotchas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An internal counter is used to keep track of which item is used next, and this is incremented on each iteration. When this counter has reached the length of the sequence the loop terminates. This means that if you delete the current item from the sequence, the next item will be skipped (since it gets the index of the current item which has already been treated). Likewise, if you insert an item in a sequence before the current item, the current item will be treated again the next time through the loop. This can lead to nasty bugs that can be avoided by making a temporary copy using a slice of the whole sequence."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert-warning\">\n",
    "**When looping, never modify the collection!** Always create a copy of it first.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More looping"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using range"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you would like to iterate over a numeric sequence then this is possible by combining the `range()` function and a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "[5, 6, 7, 8, 9]\n",
      "[0, 3, 6, 9]\n",
      "[7, 6, 5, 4, 3]\n"
     ]
    }
   ],
   "source": [
    "print(list(range(10)))\n",
    "\n",
    "print(list(range(5, 10)))\n",
    "\n",
    "print(list(range(0, 10, 3)))\n",
    "\n",
    "print(list(range(7, 2, -1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Looping through ranges "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "4\n",
      "9\n",
      "16\n",
      "25\n",
      "36\n",
      "49\n"
     ]
    }
   ],
   "source": [
    "for x in range(8):\n",
    "    print(x*x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25, 36, 49]\n"
     ]
    }
   ],
   "source": [
    "squares = []\n",
    "for x in range(8):\n",
    "    s = x*x\n",
    "    squares.append(s)\n",
    "    \n",
    "print(squares)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Looping through list ndices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 A\n",
      "1 B\n",
      "2 C\n",
      "3 D\n",
      "4 E\n"
     ]
    }
   ],
   "source": [
    "alphabets = ['A', 'B', 'C', 'D', 'E']\n",
    "\n",
    "for index in range(len(alphabets)):\n",
    "    print(index, alphabets[index])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Looping through indices for two lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 A F\n",
      "1 B G\n",
      "2 C H\n",
      "3 D I\n",
      "4 E J\n"
     ]
    }
   ],
   "source": [
    "alphabets = ['A', 'B', 'C', 'D', 'E']\n",
    "more_alphabets = ['F', 'G', 'H', 'I', 'J']\n",
    "\n",
    "for index in range(len(alphabets)):\n",
    "    print(index, alphabets[index], more_alphabets[index])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using enumerate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Given a sequence, `enumerate()` allows you to iterate over the sequence generating a tuple containing each value along with a corresponding index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 A\n",
      "1 B\n",
      "2 C\n",
      "3 D\n"
     ]
    }
   ],
   "source": [
    "letters = ['A','B','C','D']\n",
    "for index, letter in enumerate(letters):\n",
    "    print(index, letter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(0, 'A'), (1, 'B'), (2, 'C'), (3, 'D')]\n"
     ]
    }
   ],
   "source": [
    "numbered_letters = list(enumerate(letters))\n",
    "print(numbered_letters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Filtering in loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['London', 'Glasgow']\n"
     ]
    }
   ],
   "source": [
    "city_pops = {\n",
    "    'London': 8200000,\n",
    "    'Cambridge': 130000,\n",
    "    'Edinburgh': 420000,\n",
    "    'Glasgow': 1200000\n",
    "}\n",
    "\n",
    "big_cities = []\n",
    "for city in city_pops:\n",
    "    if city_pops[city] >= 1000000:\n",
    "         big_cities.append(city)\n",
    "\n",
    "print(big_cities)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total population: 9950000\n"
     ]
    }
   ],
   "source": [
    "total = 0\n",
    "for city in city_pops:\n",
    "    total += city_pops[city]\n",
    "print(\"total population:\", total)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total population: 9950000\n"
     ]
    }
   ],
   "source": [
    "pops = list(city_pops.values())\n",
    "print(\"total population:\", sum(pops))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Next session\n",
    "\n",
    "- Go to next session: [Session 5](Session_5.ipynb)"
   ]
  }
 ],
 "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}