Lab 2.1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Edited: 17th September 2023*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CMM201 &mdash; Lab 2.1\n",
    "\n",
    "Now that we are in to the second block of CMM201, the focus is on data. We need to look at storing multiple items of data in a single variable. This can be done with collections, such as lists, and set which we will see next week. But this unit is all about the **tuple**, which is the simplest collection type.\n",
    "\n",
    "## Creating Tuples\n",
    "\n",
    "We can create a tuple by separating the elements with commas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1, 25, 91, 6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice the Jupyter output displays the tuple with round brackets `(` `)`. These aren't really part of the tuple, it's just how it's displayed. If you like, you can put round brackets around it. It won't change what object you're creating."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(1, 25, 91, 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can assign a tuple to a variable, in the same we do with any other type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 2, 4, 8, 16"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and recall the variable later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is no way to change the tuple once it is created, but we can create a new tuple and reuse the old variable name.\n",
    "\n",
    "Let's say we want the tuple to add `32` to the end of the tuple, just throw away the old tuple and create a brand new tuple containing the items we want."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 2, 4, 8, 16, 32\n",
    "\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can add elements to a tuple using the `+` operator, however, this does *not* change the tuple, it simply creates a new tuple!\n",
    "\n",
    "Let's say we want to add `64, 128, 256`, the following code will create a new tuple containing both the old and newly added elements.\n",
    "\n",
    "By the way, notice that in this case we do need he brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x + (64, 128, 256)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that `x` is unaffected."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want `x` to change, we must use the assignment operator `x = `... something\n",
    "\n",
    "For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = x + (64, 128, 256)\n",
    "\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `+=` operator also works as an assignment.\n",
    "\n",
    "Recall from unit one that if we have a variable `y` which store a number, we can increase the variable by one by writing `y = y + 1` or the shorthand `y += 1`.\n",
    "\n",
    "**Note:** You may notice that there is an extra comma `,` here, that's not a mistake. We are specifying a length-one tuple. A tuple with **exactly one item** needs a trailing comma."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x += (512, )\n",
    "\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the next unit, we will encounter *mutable* collections, but for tuples, we can't change the individual values, except by creating a new tuple.\n",
    "\n",
    "**(a)** Create a tuple called `shopping` to store three **strings** which are items or shopping/groceries. You can choose which three items to use."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can check the length of the tuple using the `len` method. The following should show `3` as an output cell, assuming you created the tuple with exactly three items."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(shopping)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(b)** Modify the variable `shopping` so that in addition to the current three items, it also contains once more item, which you can choose."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can check to verify that your `shopping` has updated and now has your four items in total."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "shopping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(shopping)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indexing and Slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The items of a tuple are indexed, starting from `0` and going up to one less than the length. We can retrieve an element using indexing.\n",
    "\n",
    "This syntax will give the second (not the first!!!) element from your shopping list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "second_item = shopping[1]\n",
    "\n",
    "second_item"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Actually, strings can be indexed in the same way, let's get the first character of the string of this item."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "first_character = second_item[0]\n",
    "\n",
    "first_character"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also index backwards, for example, if we want the last item of a tuple, we could count the number of items, then subtract one:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "shopping[len(shopping) - 1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "but it is better to use negative indexing. This is a lot easier for someone to read and understand your code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "shopping[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, `-2` will give the second-last element.\n",
    "\n",
    "Usually we use positive indexing, but if we were doing something like selecting the last element, then negative indexing come sin handy.\n",
    "\n",
    "Let's define another tuple to use an example. This will be of length `5`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "example = 10, 1000, 42, 'Banana', 3.14"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is a table showing how the indices line up.\n",
    "\n",
    "| Element        | 10 | 1000 | 42 | 'Banana' | 3.14 |\n",
    "|----------------|---:|-----:|---:|:--------:|-----:|\n",
    "| Positive Index |  0 |    1 |  2 |    3     |    4 |\n",
    "| Negative Index | -5 |   -4 | -3 |    -2    |   -1 |\n",
    "\n",
    "**(c)** Use positive indexing to get the element 'Banana'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(d)** Now use negative indexing to get the same element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is a method defined on tuples called `index`, which will tell you the index of the first instance of an item. For example, this will tell you the index `4`. It will give the positive index, not the negative index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "example.index(3.14)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(e)** Use `.index` to check the index of 'Banana'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slicing works like indexing, except that we are getting more than one item.\n",
    "\n",
    "Looking again at our table of indices:\n",
    "\n",
    "| Element        | 10 | 1000 | 42 | 'Banana' | 3.14 |\n",
    "|:---------------|---:|-----:|---:|---------:|-----:|\n",
    "| Positive Index |  0 |    1 |  2 |        3 |    4 |\n",
    "| Negative Index | -5 |   -4 | -3 |       -2 |   -1 |\n",
    "\n",
    "Say we wanted the items `1000`, `42`, and `Banana`. We need to specify:\n",
    "\n",
    "- The index of the first item (the index of `1000` is `1` or `-4`)\n",
    "- The index one higher than the index of the last item (the index of `Banana` is `3`, so one higher is `4` or `-1`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "example[1:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could have used negative indexing, so any of these would work:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "example[1:-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "example[-4:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "example[-4:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also specify a stride.\n",
    "\n",
    "A slice that begins at index `0`, end at index `4` is `[0:5]`\n",
    "\n",
    "This has a stride of `1`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "example[0:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But a slice with a stride of `2` (meaning we take only every 2nd item is `[0:5:2]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "example[0:5:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that since `0` is the beginning, we can leave it blank, and Python will assume we mean the beginning:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "example[:5:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And also, note that `5` is the end, so we can leave it blank and Python will assume we mean the end:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "example[::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the next exercise we will define another tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "powers = 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(f)** Using positive indexing, create a slice containing `8, 16, 32, 64`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use negative indexing to define the same slice."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "powers[-8:-4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(g)** Starting at the element `8`, go to the end in steps of `3`, i.e. `8, 64, 512`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions\n",
    "\n",
    "Functions can accept any type of variable as an argument (including collections) and return any type of variable as a return value (including collections).\n",
    "\n",
    "You just saw a function, `len`, which accepts a collection as an argument.\n",
    "\n",
    "In the example, we used the value of a variable as an argument"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But, like with other types, we can still pass a tuple as an argument, even if it is not assigned to another variable already.\n",
    "\n",
    "Like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len((2, 4, 8, 16, 32, 64, 128, 256, 512))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Why the double brackets?\n",
    "\n",
    "The outermost brackets are there to call the function.\n",
    "\n",
    "The innermost brackets are there to make it clear to Python that there is only one argument, a `tuple`.\n",
    "\n",
    "What happens if we remove the inner brackets?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(2, 4, 8, 16, 32, 64, 128, 256, 512)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see a `TypeError`. Python thinks we are trying to call `len` with multiple different arguments, but `len` takes only one argument. An easy mistake to make!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(h)** Use the `len` function to check the length of a `tuple` containing exactly **one** element, which is the string `'hello'`. You should find the length is `1`. (If you get `5`, then something went wrong!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before continuing with functions, let's talk about 'unpacking'.\n",
    "\n",
    "If you know the length of a tuple, you can write some convenient code to assign each of the individual elements to different variables, without having to specify indices.\n",
    "\n",
    "For example, this length-two tuple which stores a person's name and age:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "person = 'Bob', 36"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can 'unpack' the tuple by using commas on the left-hand side of an assignment operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name, age = person\n",
    "\n",
    "print(f\"{name}'s age is {age}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is equivalent to"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = person[0]\n",
    "age = person[1]\n",
    "\n",
    "print(f\"{name}'s age is {age}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For this next exercise we will define a tuple containing information about a company."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "company = 'Alphabet Inc.', 'GOOGL', 1616.11"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(i)** Refactor the following code to use tuple unpacking."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "company_name = company[0]\n",
    "ticker_symbol = company[1]\n",
    "stock_price = company[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we know about unpacking, we can use this to have a function return multiple values.\n",
    "\n",
    "Let's look at an example, here we are going to take a tuple as an argument, and return the mean and median of the data. For this, we will use a package called *NumPy*, which should come pre-installed with your installation of Anaconda.\n",
    "\n",
    "To import NumPy you type:\n",
    "\n",
    "    import numpy\n",
    "\n",
    "However, it is a convention to instead use:\n",
    "\n",
    "    import numpy as np\n",
    "    \n",
    "which means that we are aliasing `numpy` as the shorter `np` for convenience. A lot of Python packages used in data science are often imported with a standard two-letter alias, such as `pd` for `pandas`, `px` for `plotly-express`, and `tf` for `tensorflow`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "def averages(data):\n",
    "    return np.mean(data), np.median(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's call the function on a data set of `13, 0, 1, 5`, not forgetting the double brackets because we have not assigned the tuple to a variable first!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "averages((13, 0, 1, 5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, we got a tuple as a result, but we probably want to do something with these separately. So let's use unpacking."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mean, median = averages((13, 0, 1, 5))\n",
    "\n",
    "print(f'The mean of our data is {mean}.')\n",
    "print(f'The median of our data is {median}.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you don't like having to remember to use double-brackets, there are a couple of ways around this. One is to always assign our tuple to a variable first:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = 13, 0, 1, 5\n",
    "\n",
    "averages(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But, there is an alternative. We can define out function with what is often called 'star args'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def averages(*data):\n",
    "    return np.mean(data), np.median(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When the argument is defined as star args, Python will cleverly understand our function call even without the double-brackets!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "averages(13, 0, 1, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The down-side is that we can only do this with the final positional argument.\n",
    "\n",
    "**(j)** Define a function called roller, which rolls two six-sided dice and returns the **total**, and the **highest**. For example, if the roles were 5 and 3, it would return 8 (total) and 5 (highest)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "def roller():\n",
    "    ...\n",
    "\n",
    "total, highest = roller()\n",
    "\n",
    "print(f'The total rolled was {total}')\n",
    "print(f'The highest die rolled was {highest}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iteration\n",
    "\n",
    "Iteration, or looping, is a very common thing to do with a data set.\n",
    "\n",
    "We don't need a data set to do a loop, using the `range` generator we can loop over the numbers `0` to `9` (just a like in a slice, we specify one more than the number we want to end on, this is a very common computer science convention)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(10):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember the Fibonacci sequence function from before? This was defined using recursion."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fib(n):\n",
    "    if n == 1:\n",
    "        return 1\n",
    "    if n == 2:\n",
    "        return 1\n",
    "    return fib(n-2) + fib(n-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can actually define this function using recursion instead:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fib(n):\n",
    "    previous, current = 0, 1\n",
    "    for i in range(n-1):\n",
    "        previous, current = current, previous + current\n",
    "    return current"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fib(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Doing it this way is actually more efficient, and allows us to work out the value of fib of very large numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fib(1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's look at the function piece by piece.\n",
    "\n",
    "First we define starting values a and b. We can do this by typing\n",
    "\n",
    "    previous = 0\n",
    "    current = 1\n",
    "\n",
    "or with unpacking\n",
    "\n",
    "    previous, current = 0, 1\n",
    "\n",
    "Either would work.\n",
    "\n",
    "Then we loop up until the number we want:\n",
    "\n",
    "    for i in range(n):\n",
    "\n",
    "and each time we update the two numbers. The next number in the sequence will be the sum of the current two numbers, and the previous will be the old current number.\n",
    "\n",
    "    previous, current = current, previous + current\n",
    "\n",
    "Let's take an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fib(6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First we have\n",
    "\n",
    "    previous, current = 0, 1\n",
    "\n",
    "then we count `0` on the iteration, and update the numbers to\n",
    "\n",
    "    previous, current = 1, 0 + 1\n",
    "\n",
    "which is\n",
    "\n",
    "    previous, current = 1, 1\n",
    "\n",
    "then we count `1` and update to\n",
    "\n",
    "    previous, current = 1, 2\n",
    "\n",
    "then we count `2` and update to\n",
    "\n",
    "    previous, current = 2, 3\n",
    "\n",
    "then we count `3` and update to\n",
    "\n",
    "    previous, current = 3, 5\n",
    "\n",
    "then we count `4` and update to\n",
    "\n",
    "    previous, current = 5, 8\n",
    "\n",
    "and return `current` which is `8`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Most of the time, we will be dealing with iterating over data. But it is important to know that we don't need a data set to iterate.\n",
    "\n",
    "Let's move on to iterating data sets. We will start with a tuple of a shopping list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "shopping = 'apple', 'orange', 'banana', 'pears'\n",
    "\n",
    "shopping"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you have learned indexes, and `range`, you may be tempted to do this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for index in range(len(shopping)):\n",
    "    print(shopping[index])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But don't do the above, it's very bad style.\n",
    "\n",
    "It is a very common thing for beginner Python programmers to try.\n",
    "\n",
    "It can be refactored into a much simpler form below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for item in shopping:\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want to keep track of the index as we print, we might think to try this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for index in range(len(shopping)):\n",
    "    print(index, shopping[index], sep='\\t')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But again, there is a much simpler refactoring"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for index, item in enumerate(shopping):\n",
    "    print(index, item, sep='\\t')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Did you notice the unpacking? Each time around the loop, `enumerate` returns a tuple of two elements, and we are unpacking them into two variables, `index` and `item`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`enumerate` is a generator function.\n",
    "\n",
    "Another generator function is `reversed`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for item in reversed(shopping):\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that we loop over the shopping list backwards, but the original tuple is unaffected."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "shopping"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another function used for the same purpose (although not a generator for some technical reason) is `sorted`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for item in sorted(shopping):\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`sorted` may fail if you are mixing types in the tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1, 52, 'Apple'\n",
    "\n",
    "for item in sorted(x):\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is because Python can't decide where 'Apple' goes in relation to `1` and `52`.\n",
    "\n",
    "We can iterate over in reverse sorted order, using both..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = 'b', 'c', 'a'\n",
    "\n",
    "for item in reversed(sorted(data)):\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, there is a better way, `sorted` takes an optional *named* argument called `reverse`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = 'b', 'c', 'a'\n",
    "\n",
    "for item in sorted(data, reverse=True):\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A named argument is a type of optional argument to a function, where you need to specify the argument name and value.\n",
    "\n",
    "In this module, we won't cover *defining* functions with named arguments, but we will be using them in some functions like this. You will also find that later, when we use the Pandas and Plotly libraries, there are often named arguments."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(k)** Using what we have learned above, use the data given to produce the following output:\n",
    "\n",
    "    0 - Apple\n",
    "    1 - Cherry\n",
    "    2 - Coconut\n",
    "    3 - Orange\n",
    "    4 - Peach\n",
    "    5 - Pear"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits = 'Cherry', 'Orange', 'Pear', 'Apple', 'Coconut', 'Peach'\n",
    "\n",
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reading Files\n",
    "\n",
    "In a later unit, we will use Pandas to read structured datasets like `.csv` files.\n",
    "\n",
    "But using a programming language, such as Python, we can also process unstructured / semi-structured data.\n",
    "\n",
    "We have a file called `lab_text.txt` which is available on Moodle. It contains the following text:"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "apples:£0.62\n",
    "bananas:£0.13\n",
    "oranges:£0.30"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since this is well-structured, we could use Pandas, however, we are going to process this file manually using a loop to show how is it done.\n",
    "\n",
    "To open a file we use `with open('...') as file`, where `file` is the name of the variable we are choosing. We could choose any other valid variable name, but `file` seems like a sensible name for the file. Maybe if we were opening many files at once we might need to give them different, clearer names.\n",
    "\n",
    "Note that in this module we recommend adding `, encoding='utf-8'` to the open function call. The code may work just fine without it. But, this is there because some students are working on laptops where the default language is not set to English, and there is a chance that Python will guess the encoding of the file incorrectly causing it to misread certain symbols like `£`. Adding the encoding argument usually fixes this.\n",
    "\n",
    "To loop over a file, we use a for loop on the file variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('lab_text.txt', encoding='utf-8') as file:\n",
    "    for line in file:\n",
    "        print(line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since the lines come with an extra line break, we may want to strip this off using our string processing methods. `line` is just a string, and we can use any of our usual string processing which we learned in Unit 1.5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('lab_text.txt', encoding='utf-8') as file:\n",
    "    for line in file:\n",
    "        line = line.strip()\n",
    "        print(line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(l)** Write a program which loops over the file `lab_text.txt` and prints out the name of an item of fruit, only if the price is greater than 25p. You should get:\n",
    "\n",
    "    apples\n",
    "    oranges"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('lab_text.txt', encoding='utf-8') as file:\n",
    "    for line in file:\n",
    "        line = line.strip()\n",
    "        ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Map and Filter (Advanced)\n",
    "\n",
    "Next we will go over map and filter. This is a slightly advanced topic. You might choose to skip it for now and perhaps revisit later.\n",
    "\n",
    "Mapping and filtering will be revisited in the context of Pandas in CMM202."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Map and filter are examples of higher-order functions. This is because the use a function as one of the arguments.\n",
    "\n",
    "Map takes two arguments, a function to apply and a data set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def square(x):\n",
    "    return x ** 2\n",
    "\n",
    "data = 1, 2, 3, 4\n",
    "\n",
    "for item in map(square, data):\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We might want to keep the original data too, we can use the generator function `zip` to iterate over two things at once.\n",
    "\n",
    "For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "foo = 2, 5, 6\n",
    "bar = 7, 7, 1\n",
    "\n",
    "for x, y in zip(foo, bar):\n",
    "    print(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is another example of unpacking.\n",
    "\n",
    "Now let's combine the result of out map, with the original data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def square(x):\n",
    "    return x ** 2\n",
    "\n",
    "data = 1, 2, 3, 4\n",
    "\n",
    "for original, transformed in zip(data, map(square, data)):\n",
    "    print(original, transformed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The filter function works similarly, but takes a function which returns a Boolean, saying whether to include an item of data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def less_than_four(x):\n",
    "    return x < 4\n",
    "\n",
    "data = 1, 2, 3, 4\n",
    "\n",
    "for item in filter(less_than_four, data):\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function `less_than_four` will return `True` for `1`, `2`, and`3`, and return `False` for `4`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(m)** Using `map` and `filter`, and our functions `less_than_four` and `square`, write a loop which prints out the squares of the data items if the original item is less than 4.\n",
    "\n",
    "You should get:\n",
    "\n",
    "    0\n",
    "    1\n",
    "    4\n",
    "    9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "data = 0, 1, 2, 3, 4, 5\n",
    "\n",
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(n)** Using `map` and `filter`, and our functions `less_than_four` and `square`, write a loop which prints out the squares of the data items if the square is less than 4.\n",
    "\n",
    "You should get:\n",
    "\n",
    "    0\n",
    "    1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "data = 0, 1, 2, 3, 4, 5\n",
    "\n",
    "..."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}