B08. Loops & Iterating.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# B08: Loops & Iterating"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At a basic level loops and iterating allow us to perform the same action or actions on a series of items. This allows us to automate long drawn out processes and also to write succinct and efficient code.\n",
    "\n",
    "We'll be looking at three forms of looping as part of this section:\n",
    "\n",
    "* For Loops\n",
    "* While Loops\n",
    "* List Comprehensions\n",
    "\n",
    "Lets start by creating a list of item to iterate through:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## For Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The most common form of loop is the for loop. For loops iterate through the items in a sequence and can be used on all the data structures we met in the previous sections, although for now we're going to use a list. Let's have a look at the syntax:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mylist1 = [0,1,2,3,4,5,6,7,8,9]\n",
    "for bananas in mylist1:                  # Basic for loop to print the contents of a list\n",
    "    print(bananas)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You'll notice that the syntax shares some conventions with a function, like the use of a colon (:) and indented whitespace to indicate the contents of the loop.\n",
    "\n",
    "What the loop is doing here is picking the first item from mylist1: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and using it as a parameter to execute the contents of the for loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When Python gets to the end of the loop, it goes back to the beginning and selects the second item from mylist 1 and uses it to execute the contents of the foor loop. Essentially the code the entire loops runs is as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(0)\n",
    "print(1)\n",
    "print(2)\n",
    "print(3)\n",
    "print(4)\n",
    "print(5)\n",
    "print(6)\n",
    "print(7)\n",
    "print(8)\n",
    "print(9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One other important thing to note about the syntax is where I've used <b>item</b> above. This word can be absolutely anything that adheres to Python naming conventions and is very similar to how we defined keyword parameters for functions.\n",
    "\n",
    "However we have to use this keyword consistently throughout the for loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "for x in mylist1:               \n",
    "    print(\"This is iteration number %s\" % (x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's also good practice to keep this word as sensible as possible as it will help others when picking up your code!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## While Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As the name suggests, while loops will execute while a certian condition or conditions are met. They use boolean logic to continually evaluate the conditions, stopping when a False value is returned.\n",
    "\n",
    "A basic while loop is shown below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "i = 0                    # Setting the starting value for i\n",
    "mylist1 = []             # Blank list to append items to\n",
    "\n",
    "while i <= 9:            # While loop syntax\n",
    "    mylist1.append(i)    # Appends the current value of i to the list\n",
    "    i = i + 1            # Adding 1 to i for the current iteration\n",
    "\n",
    "mylist1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One <b>VERY</b> important thing to note when using while loops is to make sure you increment the iterable as shown:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "i = i + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you don't do this, your while loop will run to infinity and cause your Jupyter session to crash! The easy way out of this is to close the Jupyter 'shell' window and restart a new session in your browser."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List Comprehensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List comprehensions are a quick and easy way to interate through a list and create another list as an output. The syntax might appear a little daunting at first but they are deceptively simple and powerful. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mylist2 = [10,20,30,40,50,60,70,80,90,100]\n",
    "\n",
    "mylist3 = [item * 10 for item in mylist2]     # List Comprehension syntax\n",
    "mylist3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we break this down, what we're telling Python here is:\n",
    "\n",
    "1. For every item in mylist 2 <b>[for item in mylist2]</b>\n",
    "2. Multiply it by 10 <b>[item * 10]</b>\n",
    "3. Create me a new list with the output <b>mylist3 =</b>\n",
    "\n",
    "Let's have a look at a slightly more complicated example which will convert celsius to Fahrenheit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "celsius = [0,10,20.1,34.5]\n",
    "fahrenheit = [ ((float(9)/5) * item + 32) for item in celsius ] # Convert Celsius to Fahrenheit\n",
    "fahrenheit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Advanced Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we're going to explore some more advanced looping and incorporate some other stuff we've learnt as well!\n",
    "\n",
    "Imagine we run a sweet shop and have a list of transactions for our day. We want to offset these transactions against our balance and keep a running total of how much money we have.\n",
    "\n",
    "However, unfortunately for us, the data we have isn't great and contains a mixture of floats, integers and strings as well as some errors so we're going to have to be creative in how we approach this!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "transactions = [2.34,8.99,6,-5.7,9,12.65,-9,-18.84,1.92,11.45,'100',-6.54,11.20,3.30,-5,2.98,'Error']\n",
    "balance = [100.00,102.34]\n",
    "\n",
    "'''My Solution to the problem:'''\n",
    "\n",
    "for item in transactions:\n",
    "    if type(item) == float:              \n",
    "        balance.append(balance[-1] + item)     # Add the amount to the last value in the list and append the new amount \n",
    "    elif type(item) == int:\n",
    "        item = float(item)                     # Convert the integer to a float\n",
    "        balance.append(balance[-1] + item)     # Add the amount to the last value in the list and append the new amount\n",
    "    elif type(item) == str: \n",
    "        try:\n",
    "            item = float(item)                 # Try and convert the string to a float\n",
    "            balance.append(balance[-1] + item) # Add the amount to the last value in the list and append the new amount\n",
    "        except ValueError:                     # In the event of a ValueError, ignore the value\n",
    "            pass\n",
    "        \n",
    "balance  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.5.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}