From 187e47b4aa0caf0dd2b586bf9c0aa70789653761 Mon Sep 17 00:00:00 2001
From: EdmundGoodman <egoodman3141@gmail.com>
Date: Thu, 21 Sep 2023 19:20:19 +0100
Subject: [PATCH 1/3] Write first and second exercises

---
 week5/w5.ipynb         | 145 +++++++++++++++++++++++++++++++++++++++--
 week5/w5_answers.ipynb |  39 +++++++++--
 2 files changed, 176 insertions(+), 8 deletions(-)

diff --git a/week5/w5.ipynb b/week5/w5.ipynb
index a1bc7c4..af6a9f5 100644
--- a/week5/w5.ipynb
+++ b/week5/w5.ipynb
@@ -706,21 +706,158 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Exercise n"
+    "## Exercise 1\n",
+    "\n",
+    "In the notes above, we saw an example of turning a dictionary representation of data and methods for a square into a class.\n",
+    "\n",
+    "Below is another dictionary representation of some data and methods, this time describing cars. Your job is to turn it into a simple class which does the same thing."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "car = {\n",
+    "    \"miles_per_gallon\": 10,\n",
+    "    \"fuel_tank_size\": 50,\n",
+    "    \"colour\": \"blue\",\n",
+    "}\n",
+    "\n",
+    "def calculate_range(car):\n",
+    "    return car[\"miles_per_gallon\"] * car[\"fuel_tank_size\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create a class for a car with the same properties and methods as above\n",
+    "# If you get stuck, try looking back at the notes and see how we did it\n",
+    "# for the square example.\n",
+    "\n",
+    "\n",
+    "# Create an object instance of the class with the data from the above\n",
+    "\n",
+    "\n",
+    "# Call the range method of the object to find its range\n",
+    "\n"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Week 5 Bonus Exercises"
+    "## Exercise 2\n",
+    "\n",
+    "In this exercise, we are going to combine what we've learnt about libraries with what we know about classes to do something useful(-ish).\n",
+    "\n",
+    "The `requests` library lets us make http requests to access content on the web. As it is not part of the standard library **you will need to install it yourself** using the `pip` command line tool we discussed above.\n",
+    "\n",
+    "Once the library is installed, the next thing to do is normally to look at its documentation. For `requests`, the quickstart page can be found here: https://requests.readthedocs.io/en/latest/user/quickstart/ . This shows us how to use it to make a web request:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import requests\n",
+    "\n",
+    "response = requests.get(\"https://xkcd.com/\")\n",
+    "print(response)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Challenge n"
+    "However, if you run this code it doesn't give you what you might expect! Instead of giving you the HTML for the website, it just prints \"<Response [200]>\"!\n",
+    "\n",
+    "This is because `response` is actually an object, which contains lots of different data about the response to the request we made! We can confirm this as we say before by using `__class__`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(response.__class__)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Your second challenge is to try to get the HTML content from this response object, so you can read what the website says. This might seem impossible at first, since you don't know what the properties and methods the class has, but again documentation comes to the rescue!\n",
+    "\n",
+    "Look at this website: https://requests.readthedocs.io/en/latest/api/#requests.Response , and try to find the property which contains the HTML code, and print it out."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Print out the HTML of the response using a property of the object\n",
+    "# from the documentation\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As some extra fun(?) you can look at the other properties and methods of the classes and experiment with what they do!\n",
+    "\n",
+    "Hopefully you can see how objects are useful in the real world, especially when interacting with libraries, as lots of them are just collections of objects."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Exercise 3\n",
+    "\n",
+    "This exercise is about writing readable code. Below is some code which is designed to ____. It is **very bad™** , and your job is to rewrite it to make it more readable."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As a reminder from the notes above, these a some things you may want to think about when re-writing the code to make it more readable:\n",
+    "\n",
+    "- Meaningful and consistent variable names\n",
+    "- Use empty lines to split up sections\n",
+    "- Be consistent with indentations\n",
+    "- Avoid hard-coded constant values\n",
+    "- Use loops and functions to avoide duplication\n",
+    "- Add type hints\n",
+    "- Add docstrings to describe what functions do"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Re-write the code above so it does the same thing but is more readable\n",
+    "\n"
    ]
   },
   {
@@ -748,7 +885,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.3"
+   "version": "3.11.5"
   },
   "vscode": {
    "interpreter": {
diff --git a/week5/w5_answers.ipynb b/week5/w5_answers.ipynb
index 8c5421e..c6b8a65 100644
--- a/week5/w5_answers.ipynb
+++ b/week5/w5_answers.ipynb
@@ -11,7 +11,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Exercise n"
+    "## Exercise 1"
    ]
   },
   {
@@ -20,14 +20,25 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "raise NotImplementedError(\"Answer not written yet...\")"
+    "class Car:\n",
+    "    def __init__(self, miles_per_gallon, fuel_tank_size, colour):\n",
+    "        self.miles_per_gallon = miles_per_gallon\n",
+    "        self.fuel_tank_size = fuel_tank_size\n",
+    "        self.colour = colour\n",
+    "        \n",
+    "    def calculate_range(self):\n",
+    "        return self.miles_per_gallon * self.fuel_tank_size\n",
+    "    \n",
+    "my_car = Car(10, 50, \"blue\")\n",
+    "\n",
+    "print(my_car.calculate_range())"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Challenge n"
+    "## Exercise 2"
    ]
   },
   {
@@ -36,9 +47,29 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "raise NotImplementedError(\"Answer not written yet...\")"
+    "import requests\n",
+    "\n",
+    "response = requests.get(\"https://xkcd.com/\")\n",
+    "print(response)\n",
+    "print(response.__class__)\n",
+    "\n",
+    "print(response.content)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Exercise 3"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
   {
    "attachments": {},
    "cell_type": "markdown",

From 76322526e3f9b676094ffb607c0a2529cd75af7a Mon Sep 17 00:00:00 2001
From: EdmundGoodman <egoodman3141@gmail.com>
Date: Thu, 21 Sep 2023 19:40:13 +0100
Subject: [PATCH 2/3] Add third exercise

---
 week5/w5.ipynb         | 37 ++++++++++++++++++++++++++++---------
 week5/w5_answers.ipynb | 28 +++++++++++++++++++++++++++-
 2 files changed, 55 insertions(+), 10 deletions(-)

diff --git a/week5/w5.ipynb b/week5/w5.ipynb
index af6a9f5..2c3f4e5 100644
--- a/week5/w5.ipynb
+++ b/week5/w5.ipynb
@@ -380,7 +380,11 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Readability counts!"
+    "## Readability counts!\n",
+    "\n",
+    "> “Always code as if the guy who ends up maintaining your code will be a violent psychopath who knows where you live.”\n",
+    ">\n",
+    "> -- John F. Woods"
    ]
   },
   {
@@ -825,15 +829,32 @@
    "source": [
     "# Exercise 3\n",
     "\n",
-    "This exercise is about writing readable code. Below is some code which is designed to ____. It is **very bad™** , and your job is to rewrite it to make it more readable."
+    "This exercise is about writing readable code. Below is some code which is designed to pairwise multiply two lists of integers. It is **very bad™** , and your job is to rewrite it to make it more readable."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[6, 10, 12, 12, 10, 6]\n"
+     ]
+    }
+   ],
+   "source": [
+    "def m(l):\n",
+    "    while len(l[0]) != len(l[0]):\n",
+    "      return\n",
+    "    my_list = [0] * len(l[1])\n",
+    "    for thisIsAN_index in range(len(l[1])):\n",
+    "      my_list[thisIsAN_index] = l[0][thisIsAN_index] * l[1][thisIsAN_index]\n",
+    "    return my_list\n",
+    "print(m([[1,2,3,4,5,6],[6,5,4,3,2,1]]))"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -844,15 +865,13 @@
     "- Meaningful and consistent variable names\n",
     "- Use empty lines to split up sections\n",
     "- Be consistent with indentations\n",
-    "- Avoid hard-coded constant values\n",
-    "- Use loops and functions to avoide duplication\n",
     "- Add type hints\n",
     "- Add docstrings to describe what functions do"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
diff --git a/week5/w5_answers.ipynb b/week5/w5_answers.ipynb
index c6b8a65..ec11d65 100644
--- a/week5/w5_answers.ipynb
+++ b/week5/w5_answers.ipynb
@@ -68,7 +68,33 @@
    "execution_count": null,
    "metadata": {},
    "outputs": [],
-   "source": []
+   "source": [
+    "def pairwise_multiply(first: list[int], second: list[int]) -> list[int]:\n",
+    "    \"\"\"Pairwise multiply the elements of two lists.\n",
+    "    \n",
+    "    Args:\n",
+    "        first: The first list to pairwise multiply.\n",
+    "        second: The second list to pairwise multiply.\n",
+    "    \n",
+    "    Returns:\n",
+    "        A list containing the pairwise multiplied elements of the\n",
+    "        input lists.\n",
+    "    \"\"\"\n",
+    "    if len(first) != len(second):\n",
+    "        raise IndexError(\"Lists must be the same length!\")\n",
+    "    \n",
+    "    result: list[int] = []\n",
+    "    for i in range(len(first)):\n",
+    "        result.append(first[i] * second[i])\n",
+    "    return result\n",
+    "\n",
+    "\n",
+    "answer = pairwise_multiply(\n",
+    "    [1,2,3,4,5,6],\n",
+    "    [6,5,4,3,2,1]\n",
+    ")\n",
+    "print(answer)"
+   ]
   },
   {
    "attachments": {},

From 056a654d43b86ccb143d1bfeb83074f41c8ad729 Mon Sep 17 00:00:00 2001
From: EdmundGoodman <egoodman3141@gmail.com>
Date: Thu, 2 Nov 2023 17:54:37 +0000
Subject: [PATCH 3/3] Fix typos, and create no-code version

---
 week5/w5.ipynb         |  98 ++---
 week5/w5_no_code.ipynb | 854 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 892 insertions(+), 60 deletions(-)
 create mode 100644 week5/w5_no_code.ipynb

diff --git a/week5/w5.ipynb b/week5/w5.ipynb
index 2c3f4e5..432791f 100644
--- a/week5/w5.ipynb
+++ b/week5/w5.ipynb
@@ -52,7 +52,7 @@
     "square = {\n",
     "    \"width\": 3,\n",
     "    \"colour\": \"blue\"\n",
-    "}"
+    "}\n"
    ]
   },
   {
@@ -70,7 +70,9 @@
    "source": [
     "def calculate_area(square):\n",
     "    # Remember that `**` is the power operator\n",
-    "    return square[\"width\"] ** 2"
+    "    return square[\"width\"] ** 2\n",
+    "\n",
+    "print(calculate_area(square))\n"
    ]
   },
   {
@@ -111,7 +113,7 @@
     "class Square:\n",
     "    pass\n",
     "\n",
-    "my_square = Square()"
+    "my_square = Square()\n"
    ]
   },
   {
@@ -168,12 +170,12 @@
     "    def __init__(self, width, colour):\n",
     "        self.width = width\n",
     "        self.colour = colour\n",
-    "    \n",
+    "\n",
     "    def calculate_area(self):\n",
     "        return self.width ** 2\n",
     "\n",
     "my_square = Square(3, \"blue\")\n",
-    "print(my_square.calculate_area)"
+    "print(my_square.calculate_area())\n"
    ]
   },
   {
@@ -193,7 +195,7 @@
    "source": [
     "print(\"Hello\".__class__)\n",
     "print((100).__class__)\n",
-    "print(print.__class__)"
+    "print(print.__class__)\n"
    ]
   },
   {
@@ -263,7 +265,7 @@
    "outputs": [],
    "source": [
     "import random\n",
-    "print(random.randint(0, 10))"
+    "print(random.randint(0, 10))\n"
    ]
   },
   {
@@ -282,7 +284,7 @@
    "outputs": [],
    "source": [
     "from random import randint\n",
-    "print(randint(0, 10))"
+    "print(randint(0, 10))\n"
    ]
   },
   {
@@ -332,7 +334,7 @@
    "outputs": [],
    "source": [
     "from emoji import emojize\n",
-    "print(emojize(\":thumbs_up:\"))"
+    "print(emojize(\":thumbs_up:\"))\n"
    ]
   },
   {
@@ -452,14 +454,14 @@
     "                if nTwo > nThree != False:\n",
     "                    return 1\n",
     "                else:\n",
-    "                    ans += 1 \n",
+    "                    ans += 1\n",
     "    elif True:\n",
     "        return 1 if nOne > nThree else 2\n",
     "    return ans\n",
-    "    \n",
+    "\n",
     "print(x([5, 8, 0, 3], [4, 7, 2, 4], [9, 4, 6, 1]))\n",
     "\n",
-    "# what did I just read"
+    "# what did I just read\n"
    ]
   },
   {
@@ -477,17 +479,17 @@
    "source": [
     "def most_rounds_won(player_breakdown: list[list[int]]) -> int:\n",
     "    \"\"\"Get the index of the player who won the most rounds.\n",
-    "    \n",
+    "\n",
     "    Args:\n",
     "        player_breakdown: A list containing the lists of scores for each player,\n",
     "            which doesn't contain duplicates.\n",
-    "            \n",
+    "\n",
     "    Returns:\n",
     "        The index in the input list of the player who won the most rounds.\n",
     "    \"\"\"\n",
     "    players_in_quiz = len(player_breakdown)\n",
     "    rounds_in_quiz = len(player_breakdown[0])\n",
-    "    \n",
+    "\n",
     "    # Regroup (transpose/zip) the 2D list to compare more easily\n",
     "    # Example: [[1, 2, 3], [4, 5, 6]] into [[1, 4], [2, 5], [3, 6]]\n",
     "    round_breakdown = [\n",
@@ -507,7 +509,7 @@
     "    return counts.index(max(counts))\n",
     "\n",
     "\n",
-    "print(most_rounds_won([[5, 8, 0, 3], [4, 7, 2, 4], [9, 4, 6, 1]]))"
+    "print(most_rounds_won([[5, 8, 0, 3], [4, 7, 2, 4], [9, 4, 6, 1]]))\n"
    ]
   },
   {
@@ -580,7 +582,10 @@
    "source": [
     "# This is a function which takes an integer as its parameter, and returns a boolean\n",
     "def is_even(number: int) -> bool:\n",
-    "    return number % 2 == 0"
+    "    return number % 2 == 0\n",
+    "\n",
+    "print(is_even(2))\n",
+    "print(is_even(3))\n"
    ]
   },
   {
@@ -605,10 +610,10 @@
    "source": [
     "def say_hello(name: str) -> None:\n",
     "    print(f\"Hello {name}!\")\n",
-    "    \n",
+    "\n",
     "say_hello(\"The xSoc course\")\n",
     "# The interpreter still allows this, even though it is the wrong type\n",
-    "say_hello(123)"
+    "say_hello(123)\n"
    ]
   },
   {
@@ -641,7 +646,7 @@
     "This is a multi-line string, which isn't assigned to anything.\n",
     "\n",
     "This is how we write multi-line comments in python.\n",
-    "\"\"\""
+    "\"\"\"\n"
    ]
   },
   {
@@ -662,8 +667,8 @@
     "    \"\"\"Takes a number, and returns its square.\"\"\"\n",
     "    return number ** 2\n",
     "\n",
-    "print(\"The square function: {square.__doc__}\")\n",
-    "print(square(2))"
+    "print(f\"The square function: `{square.__doc__}`\")\n",
+    "print(square(2))\n"
    ]
   },
   {
@@ -683,22 +688,6 @@
     "You can read more about docstrings [in their PEP](https://peps.python.org/pep-0257/). Different people structure how they write docstrings in different ways, but you can read more about [Google style docstrings here](https://sphinxcontrib-napoleon.readthedocs.io/en/latest/example_google.html)."
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### Extension: List comprehensions\n",
-    "\n"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "---"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -730,7 +719,7 @@
     "}\n",
     "\n",
     "def calculate_range(car):\n",
-    "    return car[\"miles_per_gallon\"] * car[\"fuel_tank_size\"]"
+    "    return car[\"miles_per_gallon\"] * car[\"fuel_tank_size\"]\n"
    ]
   },
   {
@@ -747,8 +736,7 @@
     "# Create an object instance of the class with the data from the above\n",
     "\n",
     "\n",
-    "# Call the range method of the object to find its range\n",
-    "\n"
+    "# Call the range method of the object to find its range\n"
    ]
   },
   {
@@ -773,7 +761,7 @@
     "import requests\n",
     "\n",
     "response = requests.get(\"https://xkcd.com/\")\n",
-    "print(response)"
+    "print(response)\n"
    ]
   },
   {
@@ -791,7 +779,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "print(response.__class__)"
+    "print(response.__class__)\n"
    ]
   },
   {
@@ -810,8 +798,7 @@
    "outputs": [],
    "source": [
     "# Print out the HTML of the response using a property of the object\n",
-    "# from the documentation\n",
-    "\n"
+    "# from the documentation\n"
    ]
   },
   {
@@ -834,17 +821,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[6, 10, 12, 12, 10, 6]\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "def m(l):\n",
     "    while len(l[0]) != len(l[0]):\n",
@@ -853,7 +832,7 @@
     "    for thisIsAN_index in range(len(l[1])):\n",
     "      my_list[thisIsAN_index] = l[0][thisIsAN_index] * l[1][thisIsAN_index]\n",
     "    return my_list\n",
-    "print(m([[1,2,3,4,5,6],[6,5,4,3,2,1]]))"
+    "print(m([[1,2,3,4,5,6],[6,5,4,3,2,1]]))\n"
    ]
   },
   {
@@ -871,12 +850,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Re-write the code above so it does the same thing but is more readable\n",
-    "\n"
+    "# Re-write the code above so it does the same thing but is more readable\n"
    ]
   },
   {
diff --git a/week5/w5_no_code.ipynb b/week5/w5_no_code.ipynb
new file mode 100644
index 0000000..4b7e24d
--- /dev/null
+++ b/week5/w5_no_code.ipynb
@@ -0,0 +1,854 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# **xSoc Python Course** - Week 5\n",
+    "\n",
+    "### *Objects, Libraries, and Readability*\n",
+    "\n",
+    "🖋️ *Written by Alia & Edmund from [UWCS](uwcs.co.uk)*"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This week we will look at objects, and how they are used in libaries. We will then investigate how to write readable code.\n",
+    "\n",
+    "In this lecture, we will aim to cover:\n",
+    "\n",
+    "- Introducing objects\n",
+    "- Using libraries\n",
+    "- Writing readable code"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## A very brief introduction to objects"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Why do we need objects?\n",
+    "\n",
+    "Suppose you have some square pieces of coloured paper, and you want to write some code which models them. One way to do this is using a dictionary to store data about all the interesting aspects of the square, for example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define a square as a dictionary with a width and height\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we have this representation of the real world, we might want to use code to calculate some properties about it! For example, we can write a function which calculates a square's area:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Write a function which calculates the area of the square dictionary\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Unfortunately, there are a few issues with this representation. For example, because a dictionary is a dynamic data structure, if you mispell a key name, this will only be caught at run-time. This also means that IDEs (such as Visual Studio Code) won't be able to provide you with helpful hints."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Fortunately, there is a better way! In programming, objects are structures which allow us to bundle together data and code which uses that data. They are helpful as they make it easy to represent things in the real world."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Getting started with classes and objects\n",
+    "\n",
+    "Classes are pieces of code which specify which **data** is stored about, and what the **behaviour** of a particular type of object will be.\n",
+    "\n",
+    "A class can be thought of as a \"blueprint\" for an object. If you have a blueprint of a car, you could make many different physical cars from that single blueprint. In the same way, you can make many different objects from the same class.\n",
+    "\n",
+    "These objects are called **instances** of their class, and the process of making an object from a class is called **instantiation**.\n",
+    "\n",
+    "You can define a class using the `class` keyword, and instantiate an object from it using round brackets. For example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create an empty square class\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You might be looking at this code and think it is not very useful! This is because we have not added the two key components of the class yet, their **properties** and their **methods**."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The **properties** of a class are just which bits of data it stores about itself. In our example with paper squares, these were its width and colour.\n",
+    "\n",
+    "The **attributes** of an object refers to the actual values of the properties of its class. In our example with paper squares, these were it being 3cm wide and blue in colour. In Python, we can access an object's attributes using the dot syntax: `object.attribute`, and use it just like any other variable."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The **methods** of a class refer to the behaviours its objects will show. Methods are defined by functions within the class, and typically operate on the properties of the class. In our example with paper squares, the `calculate_area` function could be a method of the square class. As before with attributes, we can run an object's method using the dot syntax `object.method(params)`, and use it just like any other function."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Methods can (usually) only be run on the objects, not the class. This is because they may need the actual values in the object's attributes. In Python, this means that the first argument to all methods is almost always `self` - which is a reference to the object which called the method. When we are calling a method, we don't need to pass the object as an argument, this is done automatically!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In Python, we use the special `__init__` method (called a constructor, since it constructs the object) to define what properties a class will have. This method is called when we instantiate the class, and we can pass the actual values of its attributes as arguments."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "With all of this knowledge, we can re-write our paper squares example as follows:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Add a constructor and `calculate_area` method to the class, instantiate it\n",
+    "# and find its area\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### In Python, **everything** is an object!\n",
+    "\n",
+    "In Python, all objects automatically have property called `__class__`, which stores a reference to the class they were instantiated from. Using this, we can see that **everything** in Python is an object, for example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Print `.__class__` for various types\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This is because classes and objects are a really helpful way to write code to represent things, and is why it is important to know about them!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "But this top level view of objects as structures with properties which store data and methods which act on that data hopefully allows you to both:\n",
+    "- Write and use simple classes of your own\n",
+    "- Use classes other people have written to do useful things, in the form of libraries..."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "There is **lots** more to learn about how classes and objects work, such as: inheritance, class hierarchies, polymorphism, and much more! If you are interested in learning more, a [good tutorial can be found here](https://realpython.com/python-classes/)."
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Using libraries"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### What are libraries?\n",
+    "\n",
+    "We have used libraries already in this course, but it is useful to know more about them, as they can be really helpful.\n",
+    "\n",
+    "Libraries in python are collections of code related to a certain function. For example, the `random` library contains functions to generate random numbers.\n",
+    "\n",
+    "The reason libraries are so useful is they allow us to leverage code other people have written already to do a job, instead of having to do it ourselves!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### The standard library\n",
+    "\n",
+    "Some libraries are included when you install python, and are called the *standard library*. You can find a list of all of them [here](https://docs.python.org/3/library/index.html).\n",
+    "\n",
+    "The libraries we have already seen, like `random` and `sys` are in the standard library, as we didn't need to install them.\n",
+    "\n",
+    "As a reminder, to use code from a library in you program, you use the `import` keyword to bring the library into your program, which then allows you to use functions and classes from the library, for example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Print a random integer\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This imports the entire `random` library, then uses the `randint` function from it to print a random integer between one and ten.\n",
+    "\n",
+    "Sometimes, we might want to only import certain functions from the library, not the whole thing. This can be done with the `from` keyword. For example with the example above, we could instead write:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Print a random integer only importing one function\n"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Finding libraries\n",
+    "\n",
+    "On top of the standard library, there is a huge trove of other libraries written for Python. However, they do not come installed by default.\n",
+    "\n",
+    "These libraries are indexed on [PyPI (the Python Package Index)](https://pypi.org/)\n",
+    "\n",
+    "To install libraries, we need to use a tool called a package manager. There are various ones for different use cases, such as `conda` and `poetry`, but in this course we will use `pip`, as it comes with python by default."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Before you go installing random libraries, first a word of warning:\n",
+    "\n",
+    "***Non-standard libraries may contain malware***\n",
+    "\n",
+    "To check if a library is likely safe, you can look at how many stars/forks it has on GitHub (more is better), and when it was last updated (more recent is better)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To install a new library, we have to use the `pip` command line command. Go to the terminal and use `pip --help` to see the options.\n",
+    "\n",
+    "|Command|Description|\n",
+    "|-------|--------|\n",
+    "|```pip install <library name>```|Installs a library|\n",
+    "|```pip list```|Lists installed libraries|\n",
+    "|```pip uninstall <library name>```|Uninstalls a library|\n",
+    "\n",
+    "To test this, go to the terminal and use `pip install emoji` to install the \"emoji\" library."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Import `emojize` from the `emoji` library, and use it to print `:thumbs_up:`\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This should print out the thumbs up emoji! This is just a small example, but libraries can provide a lot of useful functionality, and almost all large programs will require external libraries.\n",
+    "\n",
+    "Lots of libraries have documentation websites online, for example [for the emoji library](https://carpedm20.github.io/emoji/docs/). For example, this is a screenshot of the main page of the emoji library's documentation:"
+   ]
+  },
+  {
+   "attachments": {
+    "image.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "![image.png](attachment:image.png)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "If you import a library, it's normally useful to check the documentation! As shown above, documentation often gives you examples of common cases that you might want to use the library for. It also often provides a reference for all the classes and functions in the library, which can be helpful for working out how to do something more complicated that isn't listed in the example usages."
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Doing useful(-ish) things with libraries\n",
+    "\n",
+    "Once you can use libraries effectively, a lot of cool functionality becomes really accessible. Libraries can allow you to do anything from running web servers to interacting with hardware to training machine learning models, so it's a good idea to spend some time playing around with them!\n",
+    "\n",
+    "In week 6, we will see some examples of using libraries to solve real-world problems!"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Readability counts!\n",
+    "\n",
+    "> “Always code as if the guy who ends up maintaining your code will be a violent psychopath who knows where you live.”\n",
+    ">\n",
+    "> -- John F. Woods"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Why bother?\n",
+    "\n",
+    "*\"Everyone can code!\"* is a common phrase used by motivational speakers, to attract people into trying it out. Now, think back to Week 1. How many people were in the room compared to now? A more accurate phrase is probably something like *\"Everyone can code, but not everyone has the time to do it properly.\"*\n",
+    "\n",
+    "One of the awkward realities that you're going to face is that at some point, another person might have to end up reading it. In fact, it is commonly quoted **\"code is read ten times more than it is written\"**.\n",
+    "\n",
+    "Putting in effort to make sure your script is easy for others to understand goes a long way, especially when that someone might be you, coming back to something you wrote 3 months ago. Confusing, unclear, or badly written code is often called ***spaghetti code*** - no prizes for guessing why!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# I'm not re-writing this code live...\n",
+    "\n",
+    "def x(a, b , c):\n",
+    "    ac = 0\n",
+    "    bc = 0\n",
+    "    cc  = 0\n",
+    "    i = 0\n",
+    "    for d in a:\n",
+    "        j = 0\n",
+    "        for e in b:\n",
+    "            if j != i:\n",
+    "                j = j + 1\n",
+    "                continue\n",
+    "            k =  0\n",
+    "            for f in c:\n",
+    "                if k != j:\n",
+    "                    k = k + 1\n",
+    "                    continue\n",
+    "                if k == i:\n",
+    "                    match y(d, e, f):\n",
+    "                        case 0:\n",
+    "                            ac  = ac + 1\n",
+    "                        case 2:\n",
+    "                            cc = cc + 1  # add one to cc\n",
+    "                        case _:\n",
+    "                            bc += 1\n",
+    "                else:\n",
+    "                    k = k + 2\n",
+    "                    continue\n",
+    "                k = k + 1\n",
+    "            j = j + 1\n",
+    "        i = i + 1\n",
+    "    return y(ac, bc, cc)\n",
+    "\n",
+    "def y(nOne, nTwo, nThree):\n",
+    "    ans = 0\n",
+    "    if ((nOne != nTwo) == True):\n",
+    "        match (not (nOne < nTwo)):\n",
+    "            case True:\n",
+    "                if nThree > nOne:\n",
+    "                    ans = ans + 1\n",
+    "                    ans += 1\n",
+    "            case _:\n",
+    "                ans += 1\n",
+    "                if nTwo > nThree != False:\n",
+    "                    return 1\n",
+    "                else:\n",
+    "                    ans += 1\n",
+    "    elif True:\n",
+    "        return 1 if nOne > nThree else 2\n",
+    "    return ans\n",
+    "\n",
+    "print(x([5, 8, 0, 3], [4, 7, 2, 4], [9, 4, 6, 1]))\n",
+    "\n",
+    "# what did I just read\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Can you figure out what that function does? Unless you spend an extremely long time studying it, then no, probably not. Here's a re-written version, that also works on a wider range of input parameters."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# I'm also not re-writing this code live...\n",
+    "\n",
+    "def most_rounds_won(player_breakdown: list[list[int]]) -> int:\n",
+    "    \"\"\"Get the index of the player who won the most rounds.\n",
+    "\n",
+    "    Args:\n",
+    "        player_breakdown: A list containing the lists of scores for each player,\n",
+    "            which doesn't contain duplicates.\n",
+    "\n",
+    "    Returns:\n",
+    "        The index in the input list of the player who won the most rounds.\n",
+    "    \"\"\"\n",
+    "    players_in_quiz = len(player_breakdown)\n",
+    "    rounds_in_quiz = len(player_breakdown[0])\n",
+    "\n",
+    "    # Regroup (transpose/zip) the 2D list to compare more easily\n",
+    "    # Example: [[1, 2, 3], [4, 5, 6]] into [[1, 4], [2, 5], [3, 6]]\n",
+    "    round_breakdown = [\n",
+    "        [scores[round_num] for scores in player_breakdown]\n",
+    "        for round_num in range(rounds_in_quiz)\n",
+    "    ]\n",
+    "\n",
+    "    # Used to store the rounds won per player index\n",
+    "    counts = [0 for _ in range(players_in_quiz)]\n",
+    "\n",
+    "    for round_scores in round_breakdown:\n",
+    "        # Find player index of max value for this round, and count it\n",
+    "        max_idx = round_scores.index(max(round_scores))\n",
+    "        counts[max_idx] += 1\n",
+    "\n",
+    "    # Return the index with the most rounds won\n",
+    "    return counts.index(max(counts))\n",
+    "\n",
+    "\n",
+    "print(most_rounds_won([[5, 8, 0, 3], [4, 7, 2, 4], [9, 4, 6, 1]]))\n"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Tips for readability\n",
+    "\n",
+    "In this section, we will go through a number of tips you can use to improve the readability of your code. You may be able to see where we have applied these tips in the re-written code above!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### General tips\n",
+    "\n",
+    "Remember: just because it works, doesn't mean it works well. Consider **Efficiency**, consider **Compactness**, and consider **Readability**. Take care!\n",
+    "\n",
+    "To make your code more readable, there's a few things you can do:\n",
+    "\n",
+    "- Use meaningful variable names which describe their contents\n",
+    "- Be consistent with how you name variables (such as `snake_case`)\n",
+    "- Use whitespace (empty lines) in your code to visually split up different sections\n",
+    "- Be consistent with your indentation, always using 4 spaces per indent level\n",
+    "- Avoid hard-coding values in your code\n",
+    "  - If you had an arrary of length fix, use `len(array)` rather than the number `5` to refer to its length. This makes it easier if the array changes in the future\n",
+    "  - For the rare case of constant values in your code (e.g. mathematical constants), consider writing them at the top of your code in `UPPER_CASE`\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Structuring your code\n",
+    "\n",
+    "Often, there are lots of different implementations that solve the same problem. Many of the constructs you've learned over the past weeks will also help with writing readable code, such as:\n",
+    "\n",
+    "- Using loops for repeated actions (don't just copy and paste code blocks next to each other)\n",
+    "- Using grouped data structures like lists or dictionaries instead of many separate variables\n",
+    "- Using functions if you're going to be repeatedly using the same snippets of code\n",
+    "- Using classes to group common functionality that applies to the same groups of data.\n",
+    "- Use of built-in functions and syntax, or external code libraries"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Type hinting\n",
+    "\n",
+    "When working with function that take some parameters it can be helpful to document the types of these parameters. This lets you and other developers working on the code know what type of data should be passed to the function.\n",
+    "\n",
+    "This can be achieved using **type hints**. Loosely, `:` indicates the type of a variable, `->` that a function returns a value. For functions, this looks like:\n",
+    "\n",
+    "```\n",
+    "def function_name(param1: param1_type, param2: param2_type) -> return_type:\n",
+    "    pass\n",
+    "```\n",
+    "\n",
+    "For example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Write an `is_even` function which takes an integer as its parameter,\n",
+    "# and returns a boolean\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The type after the colon or arrow can be one of the built-in types (e.g. `int`, `float`, `bool`, ...), the name of a class (and more!)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "It is important to note that type hints are **ignored by the python interpreter** therefore have no effect on the execution of your code. This means that you can pass an ``int`` to a function whose parameter is declared as a ``str`` or you can return a ``bool`` from a function whose return type is declared as ``float``. Type hints are purely for documentation and for use with external tools."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Write a function which says hello, then call it with the wrong type\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "If you want to know more about type hints, you can read [their PEP](https://peps.python.org/pep-0484/), or look at tools like [MyPy](https://mypy.readthedocs.io/en/stable/) which check the type hints."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Docstrings\n",
+    "\n",
+    "We have already seen how to write comments (lines which are ignored by the Python interpreter) using the `#` character. However, there is another way to ignore a line: creating a string, but not assigning it to a variable. For example"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Write a comment, and single and multi-line strings\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "Python docstrings are string literals which are written right after the definition of a function, class, or module. They are used to describe what their code block does. They are also automatically associated with their object as the `__doc__` attribute, so they can be printed and read later within the interpreter. For example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Write a squaring function, and print it's `.__doc__` property\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Docstrings are often more helpful than inline comments for a number of reasons, including:\n",
+    "\n",
+    "- Inline comments often become out of date if the code they are about changes, whereas docstrings talk more about interfaces than implementation\n",
+    "- They can be automatically turned into documentation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can read more about docstrings [in their PEP](https://peps.python.org/pep-0257/). Different people structure how they write docstrings in different ways, but you can read more about [Google style docstrings here](https://sphinxcontrib-napoleon.readthedocs.io/en/latest/example_google.html)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Week 5 Exercises"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Exercise 1\n",
+    "\n",
+    "In the notes above, we saw an example of turning a dictionary representation of data and methods for a square into a class.\n",
+    "\n",
+    "Below is another dictionary representation of some data and methods, this time describing cars. Your job is to turn it into a simple class which does the same thing."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "car = {\n",
+    "    \"miles_per_gallon\": 10,\n",
+    "    \"fuel_tank_size\": 50,\n",
+    "    \"colour\": \"blue\",\n",
+    "}\n",
+    "\n",
+    "def calculate_range(car):\n",
+    "    return car[\"miles_per_gallon\"] * car[\"fuel_tank_size\"]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create a class for a car with the same properties and methods as above\n",
+    "# If you get stuck, try looking back at the notes and see how we did it\n",
+    "# for the square example.\n",
+    "\n",
+    "\n",
+    "# Create an object instance of the class with the data from the above\n",
+    "\n",
+    "\n",
+    "# Call the range method of the object to find its range\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Exercise 2\n",
+    "\n",
+    "In this exercise, we are going to combine what we've learnt about libraries with what we know about classes to do something useful(-ish).\n",
+    "\n",
+    "The `requests` library lets us make http requests to access content on the web. As it is not part of the standard library **you will need to install it yourself** using the `pip` command line tool we discussed above.\n",
+    "\n",
+    "Once the library is installed, the next thing to do is normally to look at its documentation. For `requests`, the quickstart page can be found here: https://requests.readthedocs.io/en/latest/user/quickstart/ . This shows us how to use it to make a web request:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import requests\n",
+    "\n",
+    "response = requests.get(\"https://xkcd.com/\")\n",
+    "print(response)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "However, if you run this code it doesn't give you what you might expect! Instead of giving you the HTML for the website, it just prints \"<Response [200]>\"!\n",
+    "\n",
+    "This is because `response` is actually an object, which contains lots of different data about the response to the request we made! We can confirm this as we say before by using `__class__`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(response.__class__)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Your second challenge is to try to get the HTML content from this response object, so you can read what the website says. This might seem impossible at first, since you don't know what the properties and methods the class has, but again documentation comes to the rescue!\n",
+    "\n",
+    "Look at this website: https://requests.readthedocs.io/en/latest/api/#requests.Response , and try to find the property which contains the HTML code, and print it out."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Print out the HTML of the response using a property of the object\n",
+    "# from the documentation\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As some extra fun(?) you can look at the other properties and methods of the classes and experiment with what they do!\n",
+    "\n",
+    "Hopefully you can see how objects are useful in the real world, especially when interacting with libraries, as lots of them are just collections of objects."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Exercise 3\n",
+    "\n",
+    "This exercise is about writing readable code. Below is some code which is designed to pairwise multiply two lists of integers. It is **very bad™** , and your job is to rewrite it to make it more readable."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def m(l):\n",
+    "    while len(l[0]) != len(l[0]):\n",
+    "      return\n",
+    "    my_list = [0] * len(l[1])\n",
+    "    for thisIsAN_index in range(len(l[1])):\n",
+    "      my_list[thisIsAN_index] = l[0][thisIsAN_index] * l[1][thisIsAN_index]\n",
+    "    return my_list\n",
+    "print(m([[1,2,3,4,5,6],[6,5,4,3,2,1]]))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As a reminder from the notes above, these a some things you may want to think about when re-writing the code to make it more readable:\n",
+    "\n",
+    "- Meaningful and consistent variable names\n",
+    "- Use empty lines to split up sections\n",
+    "- Be consistent with indentations\n",
+    "- Add type hints\n",
+    "- Add docstrings to describe what functions do"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Re-write the code above so it does the same thing but is more readable\n"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "🖋️ ***This week was written by [Computing Society](https://go.uwcs.uk/links)***"
+   ]
+  }
+ ],
+ "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.11.5"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "7c57092efe4ff60dfd9ba12cd3127c3cb8001227526172b4b54478afc6e523e7"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}