Lab 2.2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Edited: 17th September 2023*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CMM201 &mdash; Lab 2.2\n",
    "\n",
    "In this lab, we use three new collection types `list`, `set` and `dict`, which are all mutable collections. `list` will be the most familiar because it works almost exactly like a `tuple`.\n",
    "\n",
    "## Lists\n",
    "\n",
    "When defining a list, we need to use square brackets.\n",
    "\n",
    "We have to include the square brackets, otherwise, Python will think we want a tuple!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[10, 20, 30]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As will all other types, we can assign lists to variables, use them as function arguments, and return values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [10, 20, 30]\n",
    "\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x):\n",
    "    return x[0]\n",
    "\n",
    "f([5000, 4000, 3000, 2000, 1000])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def g(a, b):\n",
    "    return [1, 2, a, b, b, a]\n",
    "\n",
    "g(100, 200)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indexing, slicing, and iterations works exactly as it does with `tuple`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [10, 20, 30, 40, 50, 60]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x[2:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for element in x:\n",
    "    print(element)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for index, element in enumerate(x):\n",
    "    print(index, element, sep='\\t')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All of this should be familiar.\n",
    "\n",
    "With lists, however, we can also mutate them.\n",
    "\n",
    "This following code creates a list containing `[1, 2, 3]` then mutates the second element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [1, 2, 3]\n",
    "x[1] = 100\n",
    "\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we had another reference to the list, another name binding, we would see the same change reflected there."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [1, 2, 3]\n",
    "y = x\n",
    "x[1] = 100\n",
    "\n",
    "print('x equals', x)\n",
    "print('y equals', y)\n",
    "print('Are they the same?', x == y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is **not** the case if we had used variable reassignment (instead of mutation) to change `x`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [1, 2, 3]\n",
    "y = x\n",
    "x = [1, 100, 3]\n",
    "\n",
    "print('x equals', x)\n",
    "print('y equals', y)\n",
    "print('Are they the same?', x == y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With `tuple` we only have the choice of variable reassignment, because mutation is not allowed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1, 2, 3\n",
    "x[1] = 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also add items to the end of a list,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [10, 20, 30]\n",
    "x.append(40)\n",
    "\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "delete items from a list by index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [10, 20, 30, 40]\n",
    "del x[2]\n",
    "\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or by specifying the value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [10, 20, 30, 40]\n",
    "x.remove(20)\n",
    "\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and sort a list in-place using the `.sort()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [30, 20, 10, 40]\n",
    "x.sort()\n",
    "\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(a)** Loop over each item in the `tuple` named `foo` and if the element is divisible by `3`, add it to the `list` names `bar`. `bar` should end up with the values `[33, 30, 9, 21, 15]`.\n",
    "\n",
    "**Hint:** Use `%`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "foo = 1, 71, 2, 33, 30, 9, 1, 10, 21, 13, 1, 11, 15\n",
    "\n",
    "...\n",
    "\n",
    "print('foo =', foo)\n",
    "print('bar =', bar)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(b)** Modify your program so that `bar` ends up in sorted order.\n",
    "\n",
    "**Hint:** There is more than one way you could choose to do this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can read more about lists and list methods here:\n",
    "    \n",
    "https://docs.python.org/3/library/stdtypes.html?highlight=list#list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sets\n",
    "\n",
    "A set is a collection which has no particular order. Everything is either inside or not inside a set.\n",
    "\n",
    "For example, in this set, there are 6 elements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = {1, 5, 'a', 'hello', 3.14, (1, 2, 3)}\n",
    "\n",
    "print('the elements are:')\n",
    "for element in x:\n",
    "    print(element)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can check if a `set` contains an element using the `in` keyword.\n",
    "\n",
    "This will result in a `bool`, which is `True` if the element is in the set, `False` otherwise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 in x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2 in x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(1, 2, 3) in x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(3, 2, 1) in x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that you can have a `tuple` as an element of a set.\n",
    "\n",
    "But you cannot have a list as an element of a set. Elements of a set must be immutable!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "{1, 2, 3, [4, 5, 6]}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In fact, we can't even test if a `list` is in a `set` using `in`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[4, 5, 6] in x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A set cannot be indexed. We add items to a set with `.add()` and remove with `.remove()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = {1, 2, 3, 4}\n",
    "x.add(5)\n",
    "x.remove(3)\n",
    "\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(c)** Write a program which will loop over the elements of `all_data` and if the item is in the set `wanted`, add it to `result`. You should get `result = {1, 10}`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_data = {1, 2, 3, 4, 10, 20, 30, 40, 100, 200, 300, 400}\n",
    "wanted = {1, 7, 10}\n",
    "\n",
    "...\n",
    "\n",
    "print('result =', result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can actually accomplish the above with one of the set methods `.intersection()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_data = {1, 2, 3, 4, 10, 20, 30, 40, 100, 200, 300, 400}\n",
    "wanted = {1, 7, 10}\n",
    "\n",
    "result = all_data.intersection(wanted)\n",
    "\n",
    "print('result =', result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or using `&` for shorthand."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_data = {1, 2, 3, 4, 10, 20, 30, 40, 100, 200, 300, 400}\n",
    "wanted = {1, 7, 10}\n",
    "\n",
    "result = all_data & wanted\n",
    "\n",
    "print('result =', result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can read more about sets and set methods here:\n",
    "    \n",
    "https://docs.python.org/3/library/stdtypes.html?highlight=set#set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A dictionary is a set of unique keys, but each key has an associated value. Like phone numbers in a phone book.\n",
    "\n",
    "To create a `dict`, use `{}`, and you can specify keys and values on construction."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = {1 : 2, 3 : 4}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can loop over the keys of a `dict`,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for k in x:\n",
    "    print('the dict has key', k)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or the values,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for v in x.values():\n",
    "    print('the dict has value', v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or (possible the more common use case), both:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for k, v in x.items():\n",
    "    print('the dict has key', k, 'with associated value', v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because `dict` (like `list` and `set`) is a mutable type, we can modify it.\n",
    "\n",
    "Unlike `list` (and `tuple`) we don't access by numerical index `0`, `1`, `2`, `3`, `4`, `5`...\n",
    "\n",
    "We specify the key in the index when reading a value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "scores = {'Alice' : 100, 'Bob' : 70, 'Charlie' : 80}\n",
    "\n",
    "scores['Alice']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and the same way when writing a value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "scores['Alice'] = 120\n",
    "\n",
    "scores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "to add a new element, we just write to a currently unused key."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "scores['Dan'] = 20\n",
    "\n",
    "scores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To remove an item, we use the `del` keyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "del scores['Bob']\n",
    "\n",
    "scores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(d)** Use the following lists, and a loop to create a `dict` with the key `'Alice'` mapped to the value `555100`, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "keys = ['Alice', 'Bob', 'Charlie']\n",
    "values = [555100, 555200, 555300]\n",
    "result = {}\n",
    "\n",
    "...\n",
    "\n",
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can read more about dictionaries and dict methods here:\n",
    "\n",
    "https://docs.python.org/3/library/stdtypes.html?highlight=dict#dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## While Loops\n",
    "\n",
    "So far we have seen one type of loop, a `for` loop.\n",
    "\n",
    "A for loop is the preferred way to iterate over a set of data, or as we will see lines in a text file.\n",
    "\n",
    "There is another type of loop, called a `while` loop.\n",
    "\n",
    "You can think of a while loop like an if statements, except that an if statement checks once if a Boolean condition is true, whereas a while loop will keep checking over and over again until it is true.\n",
    "\n",
    "The example below rolls random numbers until it rolls a 6."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "number = random.randint(1, 6)\n",
    "print(f'rolled {number}')\n",
    "\n",
    "while number != 6:\n",
    "\n",
    "    number = random.randint(1, 6)\n",
    "    print(f'rolled {number}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that the condition is based on the variable `number`. We must make sure to modify this variable inside the body of the loop, otherwise the loop will never end, and we will need to terminate the Kernel in Jupyter manually to stop it!\n",
    "\n",
    "One useful use for while loops is repeatedly prompting the user until they give a certain input.\n",
    "\n",
    "For example, the box below will keep prompting you forever, until you type exactly the text `Hello` in the input box. Make sure to match the casing, uppercase `H`, lowercase `ello`!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "text = ''\n",
    "while text != 'Hello':\n",
    "    text = input('Please input the word \\'Hello\\' here : ')\n",
    "print('Thank you!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could be a bit looser with the specific input, for example, this code will stop when there box contains the word `Hello`, but is case-insensitive and allows for other text around the word too. For example, `hELlo world` will also work, so will `shellop`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "text = ''\n",
    "while 'hello' not in text.lower():\n",
    "    text = input('Please input the word \\'Hello\\' here : ')\n",
    "print('Thank you!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "number = None\n",
    "while number is None:\n",
    "    try:\n",
    "        number = input('Type an integer : ')\n",
    "        number = int(number)\n",
    "    except ValueError:\n",
    "        print(f'\\'{number}\\' does not look like an integer!!!\\nTry again...')\n",
    "        number = None\n",
    "print(f'Thank you!\\n{number} is definitely an integer.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can probably tidy up this code a little.\n",
    "\n",
    "Previously you have seen extracting repeated code to a function. Even though there isn't really repeated code, it may be a good idea to introduce a function anyway.\n",
    "\n",
    "Let's call it `read_integer`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_integer():\n",
    "    try:\n",
    "        number = input('Type an integer : ')\n",
    "        return int(number)\n",
    "    except ValueError:\n",
    "        print(f'\\'{number}\\' does not look like an integer!!!\\nTry again...')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number = None\n",
    "while number is None:\n",
    "    number = read_integer()\n",
    "print(f'Thank you!\\n{number} is definitely an integer.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that in the refactored version the main program is reduced to only 4 lines, which is very manageable to understand. Let's look at them one-by-one.\n",
    "\n",
    "    number = None\n",
    "    \n",
    "This initialised the variable to a default value, `None` is a placeholder which means no value has been set. If we tried to run the code without this, then expression in the next line would fail because `number` is not defined.\n",
    "\n",
    "    while number is None:\n",
    "\n",
    "This means to loop the following code block until the variable `number` is set to something else other than `None`. It is conventional to use the was `is` instead of `==` when comparing something to `None`. Actually it would still work if you replaced `is` with `==`. For all other comparisons, use `==`.\n",
    "\n",
    "        number = read_integer()\n",
    "\n",
    "This line calls our function, `read_integer`, which will either return an `int` or it will return `None`.\n",
    "\n",
    "    print(f'Thank you!\\n{number} is definitely an integer.')\n",
    "    \n",
    "The last line is not indented, so it is only executed once, after the while loop ends.\n",
    "\n",
    "**(e)** What would happen if we accidentally indented the last line by 4 spaces instead of 0?"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note about `return`:\n",
    "\n",
    "Programmers familiar with other languages like Java or C++ might notice that we are not returning anything on the `except` path. We could write `return None` there, but actually Python does this automatically. In Python, if there is no `return` statement on one path of a function, `None` will automatically be returned!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More Collection Practice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(f)** Write a function, `highest_min` which accepts two lists, and returns the one whose minimum element is the largest. **Your function should be a pure function.**\n",
    "\n",
    "For example, `highest_min([3, 10, 1], [2, 5, 9])` will return `[2, 5, 9]` because the minimum element of the `[3, 10, 1]` is `1` and the minimum element of `[2, 5, 9]` is `2`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def highest_min(a, b):\n",
    "    ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "highest_min([3, 10, 1], [2, 5, 9])    # should return [2, 5, 9]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [50, 300, 10, 20]\n",
    "y = [15, 30]\n",
    "\n",
    "print(highest_min(x, y))    # should print [15, 30]\n",
    "print()\n",
    "print(x)    # should print [50, 300, 10, 20]\n",
    "print(y)    # should print [15, 30]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(g)** Write a function `counts` which loops over the input `data` and creates a `dict` indicating how many times each element appears (see the example test code)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def counts(data):\n",
    "    ...\n",
    "\n",
    "counts(['a', 4, 10, 4, 'b', 'a'])    # returns {'a': 2, 4: 2, 10: 1, 'b': 1}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above question we implement this counting function manually, however, there is a built-in type called `Counter` which will do this for us."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import Counter\n",
    "\n",
    "Counter([1, 3, 3, 7])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The returned type is a `Counter`, but if we wanted to convert this back to a standard `dict`, we can typecast it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict(Counter([1, 3, 3, 7]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Processing Files\n",
    "\n",
    "In the previous lab we looked at the example file `lab_text.txt`:\n",
    "\n",
    "    apples:£0.62\n",
    "    bananas:£0.13\n",
    "    oranges:£0.30\n",
    "    \n",
    "and we learned how to iterate the file to identify a single line of interest.\n",
    "\n",
    "But now, we know how to add things to collections.\n",
    "\n",
    "**(h)** Write a program to read the file `lab_text.txt` and load the prices into a `dict` named `prices`, you should get `{'apples' : 0.62, 'bananas' : 0.13, 'oranges' : 0.30}`, each value should be a `float`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Unit 2.3, we will see that well-structured datasets like these can be read and processed more conveniently with libraries such as 'Pandas', for manipulating structured data.\n",
    "\n",
    "But we can also process data which is a little messier, since we have complete control over what the program is doing.\n",
    "\n",
    "Processing messier datasets is very common in activities like 'Web scraping', which is when we use a program to download information from a website, which has been generated to be human-readable, not necessarily designed for machine-processing.\n",
    "\n",
    "We have a modified version of the text file, called `lab_text_2.txt` which has an extra few lines of text added\n",
    "\n",
    "    Today's fruit prices are\n",
    "    \n",
    "    apples:£0.62\n",
    "    bananas:£0.13\n",
    "    oranges:£0.30\n",
    "\n",
    "**(i)** Modify your program to ignore any lines that don't contain the separator character `:`, and read in `lab-text_2.txt`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is another variant of the file:\n",
    "    \n",
    "    \n",
    "    Today's fruit prices are\n",
    "    -------------------\n",
    "    | apples   £ 0.62 |\n",
    "    | bananas  £ 0.13 |\n",
    "    | oranges  £ 0.30 |\n",
    "    -------------------\n",
    "\n",
    "You will find this data in `lab_text_3.txt`.\n",
    "    \n",
    "**(j)** Modify your program again to take account of the new format."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When processing messier semi-structured datasets, it is usually necessary to look at the raw data file manually and make decisions about how to write the code to work for this file. Unfortunately this can be time-consuming for particularly messy datasets, and sometimes if the file is updated with new data, the program you wrote stops working as the format is altered slightly, breaking the assumptions we made.\n",
    "\n",
    "For this reason it is preferred that we work with structured data, like `.csv` files. This is what we will be using in Unit 2.3."
   ]
  }
 ],
 "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
}