simlang_2+3_lab.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Simulating Language 2 and 3, Intro to Python (lab)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "During this course we will be using a simplified subset of the programming language Python to build and run the simulations. We’re using Python because its code is concise and clear, and the meaning of the code is transparent. It’s a simplified subset, because we want to avoid using Python- specific features as much as possible, so that you could (if you wanted) take our code and translate it into another programming language without difficulty.\n",
    "\n",
    "We're running Python inside an interactive *notebook*, which you're looking at now. (If you're looking at this on the website, then this page won't be interactive. You'll need to upload it to a *notebook server* to use it. There's more information on how to do this on the Learn page for the course.) \n",
    "\n",
    "These notebooks allow us to freely mix text, computer programs, and graphs. It's a really natural way of doing scientific computing as you will see in this course. The notebook is made up of \"cells\" which you can move between with the mouse or arrow keys. The cells come in different types. We'll be using \"markdown\" cells, which let you type in formatted text, and \"code\" cells, which let you type in and run Python instructions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluation\n",
    "\n",
    "Python is an interactive language. If you are in a \"code\" cell (indicated by `In` in the margin), Python is waiting for instructions. Once you enter the instructions into the cell, you can make Python \"evaluate\" your instructions by pressing SHIFT+ENTER.\n",
    "\n",
    "You can use Python just like a calculator, using the familiar mathematical operators ( + - * / ) to build an expression. When you press SHIFT+ENTER, Python evaluates the expression you entered, and prints the result.\n",
    "\n",
    "Try typing some of these expressions in the cell below this one, and then use SHIFT+ENTER to evaluate them.\n",
    "\n",
    "```python\n",
    "1 + 3\n",
    "7 - 5\n",
    "2 * 3 - 5\n",
    "2 * (3 - 5)\n",
    "9 / 2\n",
    "```\n",
    "\n",
    "Notice that Python only shows you one answer - the one for the last expression you've asked it to evaluate.\n",
    "\n",
    "You can edit this cell and try different things by clicking in it or using the arrow keys on the keyboard. When you press SHIFT+ENTER, it will be reavaluated again. Alternatively, you can use the menu bar to insert a new code cell if you wish."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables\n",
    "\n",
    "We use variables to store and manipulate data. Variable names begin with an alphabetic character, with subsequent characters being letters, numbers, or the underscore `_`. Python is case-sensitive, so `candidates` and `Candidates` are the names of different variables (to avoid confusion, it’s a good idea to use a standard style for variable names in your programs).\n",
    "\n",
    "To assign a value to a variable, use the equals sign `=` followed by the value. The same value can be assigned to multiple variables by separating them each with the equals sign. (Note: unlike in some other programming languages, variables are automatically declared when first assigned a value, so there is no need for separate variable declaration.)\n",
    "\n",
    "Try typing the following three lines into the cell below and then press SHIFT+ENTER once you've typed them all in:\n",
    "\n",
    "```python\n",
    "x = 2\n",
    "y = 1\n",
    "a = b = 0\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python does not give any response to a variable assignment, because nothing is evaluated. To check the value of a variable, you can type its name in the cell, and Python evaluates it as an expression. Alternatively, we can force Python to print out the value of an expression by using the `print` function.\n",
    "\n",
    "Try the following three lines. Type them all in the cell below and then press SHIFT+ENTER:\n",
    "\n",
    "```python\n",
    "print(x)\n",
    "z = y + b\n",
    "z\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below, we see two ways to change the value of a variable based on its existing value: the statement `x = x + 1` adds one to the original value of `x`, and stores the result in `x`, overwriting the original value. The compound operator `+=` is a useful shorthand for this behaviour, and has exactly the same effect. Try evaluating the following expressions in the cell below to make sure you understand what they do.\n",
    "\n",
    "```python\n",
    "x = x + 1\n",
    "print(x)\n",
    "x += 3\n",
    "print(x)\n",
    "x / 2\n",
    "```\n",
    "\n",
    "What is the value of `x` now? (You can check if you were right by typing `x` in a cell and evaluating it.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists\n",
    "\n",
    "Often, we want to store multiple related values in a single data structure, and lists are the most basic way to accomplish this (and the only one you'll need for this course!). A list is enclosed in square brackets `[ ]`, with commas separating the individual elements of the list.\n",
    "\n",
    "These individual elements can be accessed and assigned new values by using the index operator `[n]`, where `[n]` refers to the nth element in the list. Note that in Python, indexes start from zero, not one (i.e. the ‘first’ element in a list has index 0). Try evaluating these lines in the cell below.\n",
    "\n",
    "```python\n",
    "mylist = [1, 2, 3, 4]\n",
    "print(mylist)\n",
    "print(mylist[0])\n",
    "mylist[1] = 5\n",
    "print(mylist)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A sequential subset of the list can be obtained by using the slicing operator `[m:n]`, which returns all items starting from the mth element, and up to (but not including) the nth element. Either m or n can be omitted, in which case the beginning (or end, respectively) of the list is assumed in place of the missing value.\n",
    "\n",
    "```python\n",
    "print(mylist[0:2])\n",
    "print(mylist[:2])\n",
    "print(mylist[1:])\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function `len(list)` returns the number of items in the list, or its length. We'll return to functions and how they are used later.\n",
    "\n",
    "```python\n",
    "print(mylist)\n",
    "len(mylist)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Single items can be added to the end of an existing list using the list function `list.append(item)`. The list function `list.remove(item)` removes the first occurrence of item from list.\n",
    "\n",
    "```python\n",
    "print(mylist)\n",
    "mylist.append(6)\n",
    "print(mylist)\n",
    "mylist.remove(3)\n",
    "print(mylist)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists are very important structures in Python, and it is worth spending some time to make sure you understand how they work and are comfortable with them.\n",
    "\n",
    "1. Make a list of the first four even numbers 2, 4, 6, 8 called `evens` and check that it is stored correctly.\n",
    "2. Check the length of evens using the `len` function.\n",
    "3. What happens when you evaluate `evens[4]`? Why?\n",
    "4. Extract the middle two numbers from `evens`.\n",
    "5. Append the number 10 to the end of `evens`, and check that it is stored correctly.\n",
    "6. Create a new list of integers and use it to verify that the `remove` function does indeed remove the first occurrence of an item from a list.\n",
    "\n",
    "Remember, you can insert fresh code cells below (using the \"insert\" menu) if you want to keep track of all your answers to these questions separately."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists can themselves also contain other lists, which provides an easy way to create complex and flexible data structures. In the example below, the second element of `complex_list` is itself a list. To access the individual items of this sub-list, just use the index operator again, as shown. In principle, there is no limit to the nesting of lists.\n",
    "\n",
    "```python\n",
    "complex_list = [1, [2, 3], 4]\n",
    "print(complex_list[0])\n",
    "print(complex_list[1])\n",
    "print(complex_list[1][1])\n",
    "```\n",
    "\n",
    "N.B. When we start to get long variable names like this, it can be a pain to keep typing them in. The code cell has a very clever trick that allows you to take a shortcut. If you start typing something and press TAB, then Python will try and \"auto-complete\" the rest of what you're typing as best it can. So, the second line of the python code above can be typed in as: `pri TAB (complex_ TAB [0])`. If you press TAB too early, and Python can't guess what you mean, it will give you a list of possible options to choose from. Have a play around with this feature and you'll soon get very fast at entering code!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How long is the list `listc` below? Guess the answer first before running the code!\n",
    "\n",
    "```python\n",
    "lista = [1, 2, 3, 4]\n",
    "listb = [5, 6, 7]\n",
    "listc = [lista, listb]\n",
    "len(listc)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Code blocks and conditionals\n",
    "\n",
    "Blocks of code in Python are identified by indentation, not by curly brackets or begin/end markers as in other languages. The beginning of a block is marked by an increase in indentation, and the end is marked by a return to the previous level of indentation; all the lines of code in the same block must therefore be indented at the same level. This makes Python code easy to read, but can be tricky to get used to at first. Within a code cell, some aspects of indentation are handled automatically, but when it comes to writing more complex programs you’ll have to do indentation manually, using tabs.\n",
    "\n",
    "A conditional statement is used to execute a block of code only in certain circumstances (when the conditional expression is true); it is introduced by the word `if`, followed by the conditional expression, and a colon (`:`) to introduce the conditional code block. If the conditional expression is true, then the code block is executed.\n",
    "\n",
    "Conditional expressions in Python use the comparison operators `==` (equal to), `<` (less than), `<=` (less than or equal to), `>` (greater than), `>=` (greater than or equal to), `!=` (not equal to), and they can be joined together into complex expression using `and`, `or` and `not`. Note particularly the operator equal to (`==`), which uses **two** equals signs; one equals sign assigns a value to a variable!\n",
    "\n",
    "In this example, the conditional expression is `x == 0`. If this statement is true, then the indented code block below is executed. When typing this example, note that the cell will helpfully indent the next line after the conditional expression automatically, as it knows that another indented code block must follow.\n",
    "\n",
    "```python\n",
    "x = y = 0\n",
    "if x == 0:\n",
    "    y = 1\n",
    "print(y)\n",
    "```\n",
    "   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also use an `else:` statement, followed by another code block which is executed when the conditional expression is false, as in the example below:\n",
    "\n",
    "```python\n",
    "x = 4\n",
    "y = 3\n",
    "if x <= y:\n",
    "    z = 1\n",
    "else:\n",
    "    z = 2\n",
    "print(z)\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## For-loops\n",
    "\n",
    "The `for` loop can be used to run one code block repeatedly for a set of elements. In the example, each of the elements in the list `[1, 3, 5]` is taken in turn, its value is assigned to the variable `n`, and then the following code block is executed with this value of `n` (in this case, print each value multiplied by 2).\n",
    "\n",
    "```python\n",
    "for n in [1, 3, 5]:\n",
    "    print(n * 2)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Often we simply want a loop to count up through a range of numbers. To do that, there's a shortcut to create a list of numbers without having to type them all out. The function `range` does this. So, for example, `range(1, 10)` creates a sequence of the numbers from 1 up to *but not including* 10. If you omit the first number, Python assumes you want the list to start from zero. We can use the sequence generated from `range` function directly in a for loop.\n",
    "\n",
    "```python\n",
    "for n in range(3):\n",
    "    print(n, n + 3)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Random numbers\n",
    "\n",
    "In simulations, we frequently need access to random numbers; Python helpfully provides a built-in random number generator for this purpose, in a special module, or self-contained file. To load the random module containing the generator, we import it into Python. If you try to access the random number generator before it is imported, an error will result.\n",
    "\n",
    "Once the random module is imported, there are a number of different ways to access different kinds of random numbers:\n",
    "\n",
    " - `random.choice(seq)` returns a random element from a given sequence\n",
    " - `random.randrange(n)` picks a random integer up to but not including n\n",
    " - `random.random()` produces a random floating-point number between 0 and 1\n",
    " \n",
    "```python\n",
    "import random\n",
    "mylist = [1, 2, 3, 4]\n",
    "print(random.choice(mylist))\n",
    "print(random.choice(mylist))\n",
    "print(random.randrange(10))\n",
    "print(random.random())\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions\n",
    "\n",
    "Functions are the building blocks of most programming languages, and we will use them extensively in this course; their purpose is to execute a small portion of code with a well-defined, specific function, before returning to the main program. It is a very good idea to use functions in your programs, as they can help greatly in reducing duplication of code, allowing the decomposition of a program into simpler steps, and hiding unnecessary detail from users.\n",
    "\n",
    "To call a function, we simply type its name, together with the names of any arguments or parameters between following brackets. We have seen a number of functions already, including:\n",
    "\n",
    "- the `len` function, which took the name of a list as its argument, and returned the number of items in that list;\n",
    "- the `range` function, which can take a single number as an argument, and return a list of numbers from 0 up to but not including that number;\n",
    "- the functions in the random module which returned different kinds of random number."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, functions are defined using the `def` keyword, followed by the name of the function, the arguments it takes in brackets, and a colon to introduce the body of the function in a code block, indented as before.\n",
    "\n",
    "Functions usually return a value, specified by the `return` statement followed by the expression which is evaluated and returned. In the example below, the `square` function is defined with a single argument `x`, and it simply returns the value of this argument multiplied by itself. (Note that I have left a blank line at the end of the function. This is purely a convention to make the code more readable.)\n",
    "\n",
    "```python\n",
    "def square(x):\n",
    "    return x * x\n",
    "\n",
    "print(square(5))\n",
    "print(square(9))\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define your own functions and test them to check that they return what you expect.\n",
    "\n",
    "1. a function which calculates and returns the product of two numbers (i.e. the outcome of multiplying the numbers together);\n",
    "2. a function which returns the first item in a list;\n",
    "3. a function which returns the last item in a list;\n",
    "4. a function which takes a list and prints out the square of each value in the list in turn; \n",
    "5. a function which returns the largest number in a list (for extra geek points, see if you can figure out how to write one without using a for loop).\n",
    "\n",
    "N.B. You should be able to define all these using only the basic elements of Python we've learned so far!\n",
    "\n",
    "Remember you can insert multiple \"code\" cells below if you want to work on each function separately, and want to save all your work in the notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting\n",
    "\n",
    "We frequently want to plot the results of our simulations - to include figures in reports, but also because visualisation is often the best way to understand what is happening in a simulation. To do this, we can use the \"matplotlib\" module (and indeed these two modules can be mixed in powerful ways). For the time being we'll make very simple plots, but later in the course we may get onto more sophisticated plotting of data.\n",
    "\n",
    "http://matplotlib.org\n",
    "\n",
    "If we want our graphs to appear in our notebooks (rather than as a separate window) there are some commands we need to enter into the notebook, in addition to loading the relevant modules. Typically, you'd have these right at the top of every notebook you'll be working with in this course.\n",
    "\n",
    "```python\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "from IPython.display import set_matplotlib_formats\n",
    "set_matplotlib_formats('svg', 'pdf')\n",
    "```\n",
    "\n",
    "N.B. You might get a warning first time you run this. Don't worry about it!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For very simple plots, there are two stages in creating a graph:\n",
    "\n",
    "1. Set up the plot, using `plt.plot`\n",
    "2. Label the axes using `plt.xlabel` and `plt.ylabel`\n",
    "\n",
    "For example:\n",
    "\n",
    "```python\n",
    "x_vals = range(-1, 3)\n",
    "y_vals = [1, 2, 3, 4]\n",
    "plt.plot(x_vals, y_vals)\n",
    "plt.xlabel(\"the x axis label\")\n",
    "plt.ylabel(\"the y axis label\")\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you don’t provide x values to `plt.plot`, matplotlib will generate them for you automatically: there will be as many x values as y values, the first value being 0.\n",
    "\n",
    "You can plot multiple lines on the same graph by using multiple `plt.plot` lines in the same cell:\n",
    "\n",
    "```python\n",
    "y_vals = [1, 2, 3, 4]\n",
    "y_vals_doubled = [2, 4, 6, 8]\n",
    "neg_y_vals = [-1, -2, -3, -4]\n",
    "neg_y_vals_doubled = [-2, -4, -6, -8]\n",
    "plt.plot(y_vals, color='purple')\n",
    "plt.plot(y_vals_doubled, color='purple')\n",
    "plt.plot(neg_y_vals, color='blue')\n",
    "plt.plot(neg_y_vals_doubled, color='blue')\n",
    "```\n",
    "\n",
    "If you want to save a figure to use in another document (e.g. your assignment), then you can use the following command to save it as a particular filename (N.B., this has to be done in the same cell as the lines above):\n",
    "\n",
    "```python\n",
    "plt.savefig(\"filename.pdf\")\n",
    "```\n",
    "\n",
    "You can then access and download this file from the Jupyter Server file list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}