02_Logic_and_Loops.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "nbpresent": {
     "id": "1b512b88-7b5d-405a-9038-0728da9e45c4"
    },
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "# knocked together by mattw for professional skills module"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Assignments - no, not those\n",
    "\n",
    "In python an assignment is when you tell python what value a variable should have\n",
    "\n",
    "```python\n",
    "a = 3\n",
    "x = range(10)\n",
    "y = 3*a\n",
    "```\n",
    "\n",
    "Unlike in your Algebra class, we can *reassign* the values of variables (the name is a clue, I guess)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "print(x)\n",
    "x = x + 1\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we wanted to get to $2^{32}$ we wouldn't want to have to type this out every time - we'd automate it using something called a loop. \n",
    "\n",
    "But first we need another bit of syntax."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Logic and control\n",
    "\n",
    "yesterday we introduced the idea of logical variables `True` and `False`.\n",
    "\n",
    "```python\n",
    "    if something:\n",
    "        do stuff\n",
    "```\n",
    "\n",
    "and possibly more complex variants with `if`, `else` and `elif`. This can be used to control what happens in your program (think of the FizzBuzz example).\n",
    "\n",
    "It can also be used to control loops.\n",
    "\n",
    "*Note the indentation (by [four spaces](https://www.python.org/dev/peps/pep-0008/)), the indentation is what tells python which bit is the stuff to do, and which is the rest of your code*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "if True: # this works because True (python variable) is defined to be true!\n",
    "    print(\"not False\")\n",
    "else:\n",
    "    print(\"False\")    \n",
    "    \n",
    "print(\"this is the rest of my code, blank lines don't matter.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "*check for yourself* that False is false."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Loops\n",
    "\n",
    "Again, thinking of the FizzBuzz example, we needed to count up to 100 - and we want the computer to do the work, not us. We use a construct called a loop.  \n",
    "\n",
    "There are two most useful ones in Python called `while` and `for`. They can be used interchangable really, but sometimes it is easier or clearer to use one or the other."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# find multiples of 7\n",
    "factor = 7\n",
    "count = 1\n",
    "while count < 101: # while loop with control on size of count\n",
    "    if count % factor == 0 : # another control. It checks there is no remainder when count is divied by factor\n",
    "        print(count)\n",
    "    count = count + 1 # important, otherwise the loop would go on forever!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "In this case a `for` loop would be better, because we know exactly how many times we want to go through the loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# find multiples of 7\n",
    "factor = 7\n",
    "count = 1\n",
    "for count in range(101): # range is a function that returns a list of numbers\n",
    "    if count % factor == 0 :\n",
    "        print(count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "So a while loop often makes sense when we aren't really sure beforehand how many calculations we need to do, but the `for` loop is better for a fixed number of iterations (iterations = times through the loop)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Find first 4 numbers divisible by 2029\n",
    "factor = 2029\n",
    "counter = 1\n",
    "multiples_found = 0\n",
    "while multiples_found < 5: # while loop with control on number of factors found\n",
    "    if counter % factor == 0 : # another control. It checks there is no remainder when count is divied by factor\n",
    "        print(counter)\n",
    "        multiples_found += 1 # important, otherwise the loop would go on forever!\n",
    "    counter += 1 # important, otherwise the loop would go on forever!\n",
    "print(\"done\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "*Check* the cell above isn't quite right - it prints the first 5 multiples of 2029, not 4 as asked. \n",
    "\n",
    "- Correct it, and check you get why it doesn't quite work as it is."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "The first two excercises work with loops and logic.\n",
    "\n",
    "More info on [Control Flow Tools](https://docs.python.org/3/tutorial/controlflow.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "85886b03-a3ed-4f7d-801f-4e6464dbb4f8"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Getting help\n",
    "you can enter a command and ? and details should come up in a window at the bottom of the notebook - e.g.\n",
    "\n",
    "For general help on ipython type ? in a code cell and execute (shift+enter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "nbpresent": {
     "id": "5844e9b6-79ba-4203-aa79-e227fc6e3398"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "nbpresent": {
     "id": "cb168d3c-5f2f-4cc3-9290-49393dc20bbe"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "type?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "481fc776-332f-4aba-88df-c98fa0ef117a"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Google is your friend."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "56cbc232-8b22-49bc-9755-1de2fbb11e2e"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "In the next sessions we will talk more about functions and objects which will (hopefully) make the help texts and documentation more understandable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "a5d56a08-2ef8-46b8-ab2b-8408079f934a"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Google is your friend (at least for this kind of thing)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "nbpresent": {
     "id": "3a5712fd-a07c-4911-9e8b-926abba05fb6"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Getting data interactively from the user\n",
    "\n",
    "you can get input from the screen to make an interactive program using the input command.\n",
    "\n",
    "We can also use [magic](http://ipython.readthedocs.org/en/stable/interactive/magics.html#line-magics) command `%%file` to save code from our notebook to a file.\n",
    "\n",
    "Note that this saves the code to file, but it doesn't run it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbpresent": {
     "id": "8eb592b1-e8b8-488d-9600-444daa5ffb58"
    },
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%file number_game.py\n",
    "# The above \"magic\" command saves the contents\n",
    "# of the current cell to file.  We'll see more of these later\n",
    "\n",
    "x = 0\n",
    "max_tries = 10\n",
    "count = 0\n",
    "\n",
    "while True:\n",
    "    x_new = int(input(\"Enter a new number: \"))\n",
    "    if x_new > x:\n",
    "        print(\" -> it's bigger than the last!\")\n",
    "    elif x_new < x:\n",
    "        print(\" -> it's smaller than the last!\")\n",
    "    else:\n",
    "        print(\" -> no change!  I'll exit now\")\n",
    "        break\n",
    "        \n",
    "    x = x_new\n",
    "        \n",
    "    count += 1\n",
    "    if count > max_tries:\n",
    "        print(\"too many tries...\")\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "d2bc9190-bb4e-429e-bfc9-cdb7661d93e7"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Where did that file get saved?\n",
    "\n",
    "We can use the `ls` command to look at the current directory. We'll talk a bit about directories and file systems later in the course."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbpresent": {
     "id": "3694bcb8-d190-4494-a295-60ed4c5295f9"
    },
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "ls"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "7f89dd46-a76c-4afe-8e36-a1b6c88ae8b9"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "we can run a python file in the current directory like this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbpresent": {
     "id": "58cb56dc-1a09-4e1f-a67c-b54657b10895"
    },
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "% run number_game.py # this magic command runs the given file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Types\n",
    "\n",
    "Sometimes we need to use the right type of 'thing' for a job - this is a bit like units, you can't add 10 feet to 1 minute. In the same way you can't add a string to an integer.\n",
    "\n",
    "Lets check this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# these don't work as they mix expected behaviour of strings and numbers\n",
    "\n",
    "fork_handle = 4 + \"candle\" # can't add integer to a string\n",
    "\n",
    "dead_parrot = 0.0 * \"parrot\" # can't multiply a string by a real number"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "One example where this happens is if you read input from the user. To do this we use the `input()` function. \n",
    "\n",
    "```python\n",
    "my_input_as_a_string = input(\"this is the prompt for the user\")\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "my_input = input(\"enter a 'number'\")\n",
    "print(type(my_input))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbpresent": {
     "id": "3a172323-a1be-4189-8fc0-026bc136bc51"
    },
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a_string = \"spam and eggs\"\n",
    "type(a_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "We can convert the string to a number `float()` to make a floating point (approximation to a real) number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbpresent": {
     "id": "ac239d5c-91cd-482f-acc7-3ddc40b7ed8b"
    },
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a_number = \"4.0\"\n",
    "print(type(a_number))\n",
    "print(type(float(a_number)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "ca1d4544-7380-4ae1-8c22-5cded17e53f4"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "One of the excercises is to convert an input in Fahrenheit to Celcius. So, you need to be a bit careful - the input command reads in a 'string', a list of letters and you'll want to use it as a number.\n",
    "\n",
    "We'll come across other types (arrays, sequences, matrices ... ) later on."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "2dd83ba4-fbf1-4aca-9184-fb877d77db99"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Very quick introduction to functions\n",
    "\n",
    "You won't really need this yet, but they are mentioned in the textbook and just to have a quick look might be helpful.\n",
    "\n",
    "Instead of writing to a file we could make our own function - to do so we need:\n",
    "\n",
    "1. def statement \n",
    "2. the name of the function\n",
    "3. the arguments it is called with in brackets as a comma separated list\n",
    "4. a ':' \n",
    "5. and to indent the next line\n",
    "\n",
    "```python\n",
    "def my_function(argument_one, argument_two ... argument_n):\n",
    "    some stuff\n",
    "    more stuff\n",
    "\n",
    "main bit\n",
    "```\n",
    "\n",
    "In python indentation is the way different levels of code are grouped together. It should look familiar from loops and logic structures.\n",
    "\n",
    "We call the function in the same way we've used the `range()`, `print()` or `input()`\n",
    "\n",
    "```python\n",
    "my_function(a,b ... n)\n",
    "# or\n",
    "thingy = my_function(a,b ... n)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "nbpresent": {
     "id": "5f160dae-c0e2-4e03-9365-25b4196f8986"
    },
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def lots_of_spam(spam):\n",
    "    print(50*spam) # this is bad"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbpresent": {
     "id": "3b4c22c5-6cf6-443e-a158-a9402965345c"
    },
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "lots_of_spam(\"spam\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "But you wouldn't want some function you call to just automatically write lots of stuff. \n",
    "\n",
    "Instead we `return` what we want - *at the end of the function*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "nbpresent": {
     "id": "28829543-aa47-4cc3-8892-0fbcaf2fcef3"
    },
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def lots_of_spam(spam):\n",
    "    return 50*spam\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbpresent": {
     "id": "cbb0ac6a-244e-4aef-b438-774376de4283"
    },
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "#run the function by calling it with the arguments in brackets\n",
    "#here we want the argument to be a string - the \"\" make this so.\n",
    "#Could also use the str() function\n",
    "my_spam = lots_of_spam(\"spam\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(my_spam)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "d56c7e0f-05d3-4a7b-aeba-dfcd3e7c33ec"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "## Return statement\n",
    "\n",
    "the return statement is what comes back from the function. \n",
    "```\n",
    "my_spam = lots_of_spam(\"spam\")\n",
    "```\n",
    "Here we send a string \"spam\" into the function lots_of_spam and it `returns` a string which is 50 copies ot the string we put in."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "nbpresent": {
     "id": "f5595c09-8727-4f31-840b-07bc98c9b368"
    },
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "#you can give your function two arguments like this\n",
    "def spam_and_eggs(spam,n):\n",
    "    return n*(5*spam + 3*\"eggs\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbpresent": {
     "id": "1ad7e219-ce3a-4149-8d0f-6ceb872cd717"
    },
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "print(spam_and_eggs(\"spam\",3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Libraries\n",
    "\n",
    "For now, just think of libraries as collections of functions that you can call.\n",
    "\n",
    "You `import` a library to add its functions to a program / notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.41421356237\n"
     ]
    }
   ],
   "source": [
    "import numpy as np # extensive maths library\n",
    "\n",
    "print(np.sqrt(2)) # the square root function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "b9239e4f-d76a-4637-8eea-3c321b205311"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Try out the exercises and read over online tutorials too. The only way to get OK with this is to try things and make lots of mistakes.\n",
    "\n",
    ">The road to wisdom? Well it’s plain and simple to express:  \n",
    "Err  \n",
    "and err  \n",
    "and err again  \n",
    "but less  \n",
    "and less  \n",
    "and less.\n",
    "\n",
    "> *Piet Hein* - https://en.wikipedia.org/wiki/Grook\n",
    "\n",
    "Well go over this material again in much more detail in the next weeks."
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.3"
  },
  "nbpresent": {
   "slides": {
    "0a35c910-7bac-4a4e-a753-f319ca7561d8": {
     "id": "0a35c910-7bac-4a4e-a753-f319ca7561d8",
     "prev": null,
     "regions": {
      "cdeecf90-ccd5-43c4-bdc2-f899945aa49d": {
       "attrs": {
        "height": 0.8000000000000002,
        "width": 0.8,
        "x": 0.010410620074411993,
        "y": 0.25320257985158756
       },
       "id": "cdeecf90-ccd5-43c4-bdc2-f899945aa49d"
      }
     }
    }
   },
   "themes": {}
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}