Introduction to Python.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# UCLAIS DOXATHON Python Tutorial: An introduction to Python\n",
    "\n",
    "Python is a popular high-level, dynamically typed, general-purpose programming language that supports a variety of different programming paradigms, including notably object-oriented programming. In particular, Python has been heavily adopted by the machine learning community and is blessed with a large ecosystem of tools and libraries for artificial intelligence and scientific computing more broadly.\n",
    "\n",
    "**This repository contains a collection of resources for beginners to learn the basics of Python in preparation for [DOXATHON 2023](https://doxaai.com/doxathon).**\n",
    "\n",
    "Some content has been adapted from the second tutorial ([Introduction to Python](https://github.com/UCLAIS/ml-tutorials-season-3/blob/main/week-2/1%20-%20Introduction%20to%20Python.ipynb)) of the UCL AI Society Machine Learning Tutorial Series.\n",
    "\n",
    "If you want a more comprehensive introduction to Python, take a look at the Python [documentation](https://docs.python.org/3/tutorial/)!\n",
    "\n",
    "## The Zen of Python, by Tim Peters\n",
    "\n",
    "Before diving into Python syntax, it is worth mentioning that Python as a programming language was designed with a number of guiding principles codified in the poem _The Zen of Python_ by Tim Peters. This code philosophy continues to influence the design and implementation of Python code today, and it is worth bearing in mind."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import this"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bearing in mind that 'readability counts', it is generally good practice to adopt a consistent style for writing Python code. The standard in the Python community since 2001 has been [PEP 8](https://peps.python.org/pep-0008/), and we would encourage you when you set up your environment to use an automatic code formatter, such as [Black](https://github.com/psf/black), to help format your code consistently."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic Syntax\n",
    "\n",
    "### Comments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Single-line comments look like this!\n",
    "# Everything after the '#' character on the same line is ignored.\n",
    "\n",
    "\"\"\"\n",
    "    Multi-line strings look like this. When freestanding like this,\n",
    "    they are typically used for documentation.\n",
    "\n",
    "    Properly documenting your code is especially important if you are\n",
    "    working in a team (or even on your own over a long period).\n",
    "\"\"\""
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Data Model\n",
    "\n",
    "Core to programming is dealing with **data** (particularly as it relates to real-world problems you are trying to solve). As such, we need **abstractions** that let us reason about and represent data in code, whether we are handling numbers, text or indeed, DOXA competitions.\n",
    "\n",
    "In Python, all data is represented by **objects** and the relations between them. Every object has the following:\n",
    "- an **identity**, which is a unique integer _identifying_ the object;\n",
    "- a **type** defining what the object represents and by extension the operations it supports; and\n",
    "- a **value**.\n",
    "\n",
    "The identity and type of an object never change once an object has been created and are also objects themselves. 👀\n",
    "\n",
    "## Built-in Types\n",
    "\n",
    "Python comes with many different built-in types, including numerics, sequences, mappings, classes, instances and exceptions. We are now going to get to know a few!\n",
    "\n",
    "### Numeric Types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Integers (Python integers have unlimited precision!)\n",
    "\n",
    "4       # => 4\n",
    "\n",
    "# We can include underscores in integers to make them more readable!\n",
    "1_000_000_000\n",
    "\n",
    "# Floats (IEEE 754 double-precision floating-point numbers)\n",
    "\n",
    "3.14    \n",
    "\n",
    "# Complex numbers\n",
    "\n",
    "4 + 3j\n",
    "\n",
    "# Arithmetic operations\n",
    "\n",
    "5 + 5   # => 10\n",
    "7 - 2   # => 5\n",
    "3 * 4   # => 12\n",
    "24 / 3  # => 8.0 (standard division always results in a float)\n",
    "\n",
    "30 // 4 # => 7 (integer division)\n",
    "30 % 4  # => 2 (the modulo operator, which gives the remainder)\n",
    "-30 % 4 # => 2 (modulo also works for negative numbers)\n",
    "\n",
    "2**4    # => 16 (exponentiation)\n",
    "\n",
    "type(123), type(2.6), type(4 + 6j) # allows you to check the type of number you have"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# what is going on here? blame IEEE 754 and how we represent decimal numbers\n",
    "\n",
    "0.1 + 0.2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(If you want to go on a long tangent on IEEE 754 and the representation of floating-point numbers in binary, there is an [interesting video](https://www.youtube.com/watch?v=p8u_k2LIZyo) on YouTube by Nemean on the implementation of a fast inverse square root algorithm in the game, Quake III, dating from before most modern computers had dedicated CPU instructions for the operation.)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Boolean Values\n",
    "\n",
    "**Booleans** (named after the English mathematician George Boole) are truth values that are either `True` or `False` (note the capitalisation)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "True            # => True\n",
    "False           # => False\n",
    "\n",
    "not True        # => False\n",
    "not False       # => True\n",
    "\n",
    "True and True   # => True\n",
    "True and False  # => False\n",
    "False and True  # => False\n",
    "False and False # => False\n",
    "\n",
    "True or True    # => True\n",
    "True or False   # => True\n",
    "False or True   # => True\n",
    "False or False  # => False\n",
    "\n",
    "# what is this operation?\n",
    "True ^ True     # => False\n",
    "True ^ False    # => True\n",
    "False ^ True    # => True\n",
    "False ^ False   # => False\n",
    "\n",
    "type(True), type(False)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comparison operations, such as checking for equality or inequality, evaluate to Boolean values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "4 == 4          # => True (checking for value equality)\n",
    "3 == 7          # => False\n",
    "1 != 5          # => True (checking for value inequality)\n",
    "\n",
    "1 < 2           # => True (less than)\n",
    "5 <= 5          # => True (less than or equal to)\n",
    "6 > 3           # => True (greater than)\n",
    "7 >= 8          # => False (greater than or equal to)\n",
    "\n",
    "1 < 2 < 3       # => True (these can be chained in Python, unlike other languages!)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Strings of characters look like this in Python.\"\n",
    "\n",
    "'You can also use single quotes if you prefer.'\n",
    "\n",
    "\"\"\" There are also\n",
    "    multi-line strings. \"\"\"\n",
    "\n",
    "''' You can also create multi-line strings with single quotes, \n",
    "    although this is fairly uncommon. '''\n",
    "\n",
    "\"If you want to include a double quote in a string, you need to escape it with a backslash like \\\"this\\\" or use a string enclosed with single quotes.\"\n",
    "\n",
    "'The same thing applies if you want to include a \\' character within a single-quoted string.'\n",
    "\n",
    "\"This means if you want to include a single backslash, you need to escape that too with a backslash in the following way: \\\\.\"\n",
    "\n",
    "\"You can also add new lines (\\n on modern macOS & Linux, \\r\\n on Windows) and tabs (\\t) using escape characters.\"\n",
    "\n",
    "type(\"Hello, world!\") "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generally, Python style guides encourage you to stick to double-quoted strings wherever reasonable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Strings can be concatenated together\n",
    "\n",
    "\"Hello, \" + \"world!\""
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While `+` _adds_ two numbers together, it _concatenates_ two strings together. This idea that operators can have different meanings in different contexts is known as **operator overloading**.\n",
    "\n",
    "**Note**: you cannot use the `+` operator on a string and an integer together &ndash; this will raise a `TypeError`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# len(·) can be used to find the length of a string\n",
    "\n",
    "len(\"Hello, world!\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can check for the presence of a substring within string using the `in` operator, which returns a Boolean value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"world\" in \"Hello, world!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Goodbye\" in \"Hello, world!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Goodbye\" not in \"Hello, world!\""
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "String objects &ndash; thanks to their type! &ndash; support a number of other useful operations too!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"hello\".upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"HELLO\".lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"hEllO, woRlD!\".capitalize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Hello, world!\".replace(\"world\", \"Jeremy and Ferran\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### An Aside on Variables\n",
    "\n",
    "In Python, variables are symbolic names (labels) that reference objects. The act of setting a variable to a particular value is known as **assignment**. There is no separate declaration step as in other languages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number = 123\n",
    "string = \"Hello, world!\"\n",
    "\n",
    "name = \"Jeremy\"\n",
    "\n",
    "# Format strings allow us to insert the string representation\n",
    "# of an object within a string (if it has one).\n",
    "\n",
    "f\"Hello, {name}!\""
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Variable names in Python can contain letters, digits and underscores; however, they cannot start with a digit. They are _case-sensitive_, so capitalisation matters! \n",
    "\n",
    "By convention, variable names in Python are all lowercase with words separated by underscores, e.g. `message_length`. This is known as _snake case_. 🐍"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Good variable names ✅\n",
    "\n",
    "name = \"Jeremy\"\n",
    "age = 21\n",
    "\n",
    "meaning_of_life = 42\n",
    "\n",
    "post_title = \"Introduction to Python\"\n",
    "like_count = 54\n",
    "views = 6_421\n",
    "\n",
    "# Suboptimal variable names ❌\n",
    "\n",
    "countriesVisited = 17           # (lower) camel case\n",
    "NumberOfChapters = 8            # Pascal case / upper camel case\n",
    "SPEED_OF_LIGHT = 299_792_458    # uppercase with underscores\n",
    "golden_Ratio = 1.61803399       # pure pain"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes, you might find yourself updating the value of a (typically numerical) variable in relation to itself using one of the **infix operators** we introduced earlier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1\n",
    "\n",
    "x = x + 6      # x = x + 6     => x == 7\n",
    "x = x - 1      # x = x - 1     => x == 6         \n",
    "x = x * 2      # x = x * 2     => x == 12\n",
    "x = x / 3      # x = x / 3     => x == 4.0\n",
    "x = x // 3     # x = x // 3    => x == 1.0\n",
    "x = x + 10     # x = x + 10    => x == 11.0\n",
    "x = x % 4      # x = x % 4     => x == 3.0\n",
    "\n",
    "x"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This can seem a bit verbose, so Python provides a series of **shorthand assignment operators** as **syntactic sugar** to help make your code cleaner and more readable &ndash; a useful thing to master! 🍦🍪"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1\n",
    "\n",
    "x += 6      # x = x + 6     => x == 7\n",
    "x -= 1      # x = x - 1     => x == 6         \n",
    "x *= 2      # x = x * 2     => x == 12\n",
    "x /= 3      # x = x / 3     => x == 4.0\n",
    "x //= 3     # x = x // 3    => x == 1.0\n",
    "x += 10     # x = x + 10    => x == 11.0\n",
    "x %= 4      # x = x % 4     => x == 3.0\n",
    "\n",
    "x"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### None\n",
    "\n",
    "`None` is keyword in Python that signifies that there is no value there &ndash; it is the encapsulation of emptiness, totally devoid of meaning."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "value = None        # nothing to see here!\n",
    "\n",
    "value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(value) # it still has a type though!"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Romans would be proud. In Ancient Rome, _res_ meant nothing, as well as everything or just something. Supposedly, everything is also nothing, and nothing is something. Probably. But anyway, back to Python! 😳\n",
    "\n",
    "Try not to overuse `None`, but it is certaintly helpful when you want to represent a value not being present."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Collections\n",
    "\n",
    "Collections are types that are used for containing other types! Python has several general-purpose built-in container types, such as **lists, tuples, sets and dictionaries**. More complex collections &ndash; such as queues, deques, ordered dictionaries and so on &ndash; are available through modules in the **standard library** included with every Python installation.\n",
    "\n",
    "You will want to get familiar with many of the simpler collections for the DOXATHON."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruit = [\"apple\", \"banana\", \"cherry\", \"dragon fruit\", \"elderberry\", \"fig\", \"guava\"]\n",
    "\n",
    "fruit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can find the length of a list with len(·)\n",
    "\n",
    "len(fruit)\n",
    "\n",
    "# The list of fruit above contains seven fruit! Ace!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Lists are 'subscriptable', so you can index into them\n",
    "# Python lists are zero-indexed, so list indices start from zero\n",
    "\n",
    "fruit[0]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When counting in Python, we always start at zero: 0, 1, 2, 3, 4, 5, 6, 7, _ad infinitum._"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Negative indices let you retrieve values relative to the end of the list\n",
    "\n",
    "fruit[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can also select slices of a list\n",
    "\n",
    "fruit[2:4]      # the starting index is inclusive, but the ending index is exclusive"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can omit a starting or ending point to expand to the start or end of the list\n",
    "\n",
    "fruit[1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruit[:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can also provide a step! (e.g. to skip certain elements)\n",
    "\n",
    "fruit[::2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruit[1:6:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# In case you were wondering, yes -- you can use this to reverse lists!\n",
    "\n",
    "fruit[::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# It is also a useful hack for creating soft copies of lists...\n",
    "\n",
    "fruit[:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can also append to lists\n",
    "\n",
    "fruit.append(\"honeydew melon\")\n",
    "\n",
    "fruit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# And pop from the end of a list...\n",
    "\n",
    "fruit.pop()\n",
    "\n",
    "fruit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Or anywhere really by index!\n",
    "\n",
    "dragon_fruit = fruit.pop(3)    # sorry, dragon fruit 🙃\n",
    "\n",
    "dragon_fruit, fruit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can also find the index of the first list item matching some value\n",
    "\n",
    "fruit.index(\"banana\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# And remove the first list item matching some value\n",
    "\n",
    "fruit.remove(\"guava\")   # sorry, guava\n",
    "\n",
    "fruit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Lists can be concatenated together\n",
    "\n",
    "[1, 2, 3] + [4, 5, 6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# And yes, they can also be 'multiplied'\n",
    "\n",
    "fruit * 4\n",
    "\n",
    "# Woah! So much fruit!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can also 'extend' one list with the values of another\n",
    "\n",
    "list1 = [1, 2, 3, 4]\n",
    "list2 = [5, 6, 7, 8]\n",
    "\n",
    "list1.extend(list2)\n",
    "\n",
    "list1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You will notice that while list1 has grown, list2 stays the same!\n",
    "\n",
    "list2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can also check whether or not an element is in a list with `in`\n",
    "\n",
    "\"apple\" in fruit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can 'unpack' list values (the tuples are implicit here)\n",
    "\n",
    "# \"Assign the first two fruit to a and b, and the last fruit to d,\n",
    "#  and stick any fruit in the middle in c.\"\n",
    "\n",
    "a, b, *c, d = fruit\n",
    "\n",
    "a, b, c, d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# by the way, trailing commas are allowed when creating lists\n",
    "\n",
    "long_list = [\n",
    "    1,\n",
    "    2,\n",
    "    3,\n",
    "    4,\n",
    "    5,\n",
    "    6,\n",
    "    7,\n",
    "    8,\n",
    "    9,\n",
    "    10, # <--- the 'trailing' comma\n",
    "]\n",
    "\n",
    "long_list"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Trailing commands in long list definitions are generally seen as good practice, since it reduces the chance of accidentally missing off a comma when you go to expand the list later on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Aside: Python also has an 'is' operator, which checks whether two objects\n",
    "# have the same identity, not just the same value as with ==\n",
    "\n",
    "(\n",
    "    [1, 2, 3] == [1, 2, 3], # => True\n",
    "    [1, 2, 3] is [1, 2, 3], # => False\n",
    ")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is possible for two _different_ objects to be equal by _value_ while having different identities!\n",
    "\n",
    "In general, unless you really want to check if two expressions are exactly the same object by identity, you probably want to stick to using `==` to check for equality. One appropriate use case for `is`, on the other hand, is checking whether a value is `None`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "winner = None\n",
    "\n",
    "winner is None, winner is not None"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuples\n",
    "\n",
    "Tuples are finite, immutable, ordered sequences of elements. Once a tuple is created, elements cannot be appended, removed or changed. Instead, a new tuple needs to be created.\n",
    "\n",
    "**Note**: this means that if you have a tuple of lists, the lists themselves can change, but the elements in the tuple cannot be reassigned to other objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tuples look like this\n",
    "\n",
    "()              # an empty tuple (or unit/null tuple)\n",
    "(1,)            # a 1-tuple (or monuple)\n",
    "(1, 3)          # a 2-tuple (or couple / ordered pair)\n",
    "(1, 3, 5)       # a 3-tuple (or triple)\n",
    "(1, 3, 5, 7)    # a 4-tuple (or quadruple)\n",
    "(1, 3, 5, 7, 9) # a 5-tuple (or quintuple)\n",
    "\n",
    "type(())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A lot of the same list operations also work on tuples\n",
    "\n",
    "numbers = (1, 2, 3, 4, 5, 6, 7, 8)\n",
    "\n",
    "numbers[2:]     # => (3, 4, 5, 6, 7, 8)\n",
    "\n",
    "a, b, *c = numbers\n",
    "\n",
    "a, b, c         # wait, did you notice that? an implicit tuple!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# unpacking can be useful for swapping variables in one go\n",
    "\n",
    "x = 5\n",
    "y = 7\n",
    "\n",
    "y, x = x, y\n",
    "\n",
    "f\"x = {x}, y = {y}\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionaries\n",
    "\n",
    "Dictionaries are key-value maps, where each key uniquely maps to a single value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "empty_dict = {}\n",
    "\n",
    "type(empty_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "student = {\n",
    "    \"name\" : \"Jeremy\",\n",
    "    \"age\" : 21,\n",
    "    \"degree\" : \"MEng Computer Science\",\n",
    "    \"ethnicity\" : \"look, it's complicated, okay?\"\n",
    "}\n",
    "\n",
    "# You can index into dictionaries just as you can with lists\n",
    "student[\"name\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can check if an item is present within a dictionary using 'in'\n",
    "\n",
    "\"name\" in student"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# If you would rather return a default value, use the get() method\n",
    "\n",
    "student.get(\"university\", \"UCL: London's Global University™, or something like that\")\n",
    "\n",
    "# Python supports unicode, so special symbols & emoji will not break things (too much...)! 😀"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Objects are **hashable** if they can be associated with a **hash value** that remains constant throughout the lifetime of an object. Many immutable built-in objects in Python are hashable, such as integers and strings. \n",
    "\n",
    "Immutable containers, such as tuples, are hashable if all of their elements are hashable. Lists, on the other hand, are mutable containers, so they are not hashable.\n",
    "\n",
    "This is important, as objects being hashable is key to the efficient implementation of data structures, such as dictionaries and sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Dictionaries can only have immutable, hashable objects as keys\n",
    "# This means that tuples of hashable objects are fine, but lists are not!\n",
    "\n",
    "player_positions = {\n",
    "    (1, 2): \"blue\",\n",
    "    (4, 6): \"red\",          # Trailing commas are allowed here too!\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# use .keys() to get the keys of a dictionary\n",
    "\n",
    "student.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# likewise, use .values() to get only the values\n",
    "\n",
    "student.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dictionaries can also be updated with the values from other dictionaries\n",
    "\n",
    "student.update({\n",
    "    \"languages\": [\"English\", \"French\"],\n",
    "    \"favourite_colour\": \"Blue\"\n",
    "})\n",
    "\n",
    "student"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# items can be removed from dictionaries with del\n",
    "\n",
    "del student[\"ethnicity\"]\n",
    "\n",
    "student"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# you can also 'unpack' dictionaries into other dictionaries\n",
    "\n",
    "{\n",
    "    \"foo\": 1,\n",
    "    \"bar\": 2,\n",
    "    **{\n",
    "        \"baz\": 3,\n",
    "        \"bux\": 4,\n",
    "    }\n",
    "}"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sets\n",
    "\n",
    "While lists are ordered sequences of items, sets are unordered containers of unique items."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "empty_set = set()               # Watch out, {} will create an empty dictionary!\n",
    "values = {1, 2, 3, 4, 5, 5}     # Python has a neat syntax for creating sets\n",
    "\n",
    "# This syntax might be a clue that sets are related to dictionaries, just without values\n",
    "\n",
    "values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can add values to sets\n",
    "\n",
    "values.add(6)\n",
    "\n",
    "values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can also remove values from sets\n",
    "\n",
    "values.remove(6)\n",
    "\n",
    "values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Since, sets can contain hashable objects, they can contain tuples of integers (i.e. points)\n",
    "\n",
    "points = {(1, 2), (2, 4), (3, 5)}\n",
    "\n",
    "points"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Print statements\n",
    "\n",
    "Before we progress, it would be rude not to introduce the `print()` function! [Read more in the documentation](https://docs.python.org/3/library/functions.html#print)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello, world!\")          # Glad we got that one out the way!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print(·) has plenty of useful arguments you can explore\n",
    "\n",
    "print(\"a\", \"b\", \"c\", \"d\", sep=\" | \", end=\" !\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Control Flow\n",
    "\n",
    "### Conditional statements\n",
    "\n",
    "The infamous 'if-statement' is used for executing different pieces of code based on some Boolean value.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if 1 < 2:\n",
    "    print(\"Wow, 1 < 2.\")\n",
    "\n",
    "if \"apple\" in fruit:\n",
    "    print(\"Apples are recognised as a type of fruit.\")\n",
    "elif \"banana\" in fruit:\n",
    "    print(\"Well, apples might no longer be fruit for some reason, but at least we have bananas.\")\n",
    "else:\n",
    "    print(\"Goodness, just HOW will we cope without apples and bananas?\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indentation is **really** important in Python! By convention, blocks are indented with four spaces &ndash; not tabs (however much you or I may love tabs)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For loops\n",
    "\n",
    "For loops provide a way of iterating over some **iterable**. It is possible to iterate over many of the types we have already discussed, such as the characters of a string, the items of a list and the keys of a dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for character in \"Hello\":\n",
    "    print(character)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for item in [1, 2, 3, 4]:\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dictionary = { \"a\": 1, \"b\": 2 }\n",
    "for key in dictionary:\n",
    "    print(key, dictionary[key])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# It is arguably more \"Pythonic\" to iterate over dictionaries \n",
    "# in the following way instead using .items():\n",
    "\n",
    "for key, value in dictionary.items():\n",
    "    print(key, value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can also iterate over the enumeration of a list, which\n",
    "# will number the elements (starting from zero) for you as\n",
    "# you go along and iterate over the list - neat!\n",
    "\n",
    "for index, value in enumerate(fruit):\n",
    "    print(index, value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# If you have two lists and want to iterate over them both in parallel, use zip(·, ·)\n",
    "# It will terminate after at least one of the lists gets exhausted\n",
    "\n",
    "for a, b in zip([1, 2, 3, 4], [5, 6, 7, 8, 9]): \n",
    "    print(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can zip as many iterables as you want together!\n",
    "\n",
    "# The fruit are back 👀\n",
    "for a, b, c in zip([1, 2, 3, 4], [5, 6, 7, 8, 9], fruit):\n",
    "    print(a, b, c)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we have just hinted at, you can iterate over way more than just basic types. **Generators** are special iterators that yield values that may be looped over. One common such generator is `range([start,] end)` (or with a step, `range(start, end, step)`), and you can also [define your own](https://docs.python.org/3/tutorial/classes.html#generators)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Note that the endpoint is exclusive, so you end up\n",
    "# with five numbers, zero to four\n",
    "\n",
    "for i in range(5):      \n",
    "    print(i, end=\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(1, 5):\n",
    "    print(i, end=\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(0, 10, 2):\n",
    "    print(i, end=\" \")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### While loops\n",
    "\n",
    "As in other languages, Python also has while loops."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 0\n",
    "while i < 10:\n",
    "    print(i)\n",
    "    i += 1\n",
    "\n",
    "# Yes, `while True:` would loop forever!"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comprehensions\n",
    "\n",
    "Python also has the idea of list comprehensions and dictionary comprehensions. Comprehensions are intimately related with the ideas of maps and filters from functional programming.\n",
    "\n",
    "Note: there are no tuple comprehensions; they instead result in in-line generators."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "names = [\"jeremy\", \"aliff\", \"filip\", \"yuwei\", \"luke\", \"ferran\"]\n",
    "\n",
    "[name.capitalize() for name in names]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can add filters to list comprehensions\n",
    "\n",
    "[name.upper() for name in names if 'e' in name]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can also iterate over multiple iterables at once\n",
    "[\n",
    "    (x, y)\n",
    "    for x in range(5)\n",
    "    for y in range(5)\n",
    "    if x != y\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Likewise, there are also dictionary comprehensions\n",
    "\n",
    "name_lengths = { name.upper(): len(name) for name in names }\n",
    "\n",
    "name_lengths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# As well as set comprehensions\n",
    "\n",
    "{ i for i in range(10) }"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comprehensions are a powerful tool to have in your arsenal. Here is a more complex example on how they could be used, mimicking the data format you might expect to be returned from some RESTful web API."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define a list of dictionaries containing a film and its release date\n",
    "films = [\n",
    "    {\"name\": \"Fight Club\", \"year\": 1999, \"stars\": 4.3},\n",
    "    {\"name\": \"When Harry Met Sally\", \"year\": 1989, \"stars\": 4.1},\n",
    "    {\"name\": \"Spirited Away\", \"year\": 2001, \"stars\": 4.9},\n",
    "]\n",
    "\n",
    "# get a dictionary of films by year\n",
    "films_by_year = {film[\"name\"]: film[\"year\"] for film in films}\n",
    "\n",
    "films_by_year\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exceptions\n",
    "\n",
    "Exceptions are the primary way of error handling in Python, allowing you to explicitly deal with 'exceptions' to the normal execution flow of your code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    raise ValueError(\"something terrible!\")\n",
    "except ValueError as e:\n",
    "    print(f\"Oh no, an exception arose due to {str(e)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 'except' branches can be chained\n",
    "\n",
    "try:\n",
    "    # do some complex operation\n",
    "    10 / 0\n",
    "except ValueError:\n",
    "    print(\"Ooops, it was a value error.\")\n",
    "except IndexError:\n",
    "    print(\"Or was it an index error?\")\n",
    "except ZeroDivisionError:\n",
    "    print(\"Nahhh, it was a zero division error!\")\n",
    "except:\n",
    "    print(\"This will be a catch all if none of the other branches above run.\")\n",
    "finally:\n",
    "    print(\"'Finally' blocks always run, whether or not there is an exception.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions\n",
    "\n",
    "We have seen a few built-in functions so far, such as `print` and `len`, but we can actually define our own."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Built-in Functions\n",
    "\n",
    "By default, Python has a selection of built-in functions you can use without having to import anything. We have already talked about a few of these, and it is worth taking the time to investigate what they do! Python has some [excellent documentation](https://docs.python.org/3/library/functions.html), and learning how to read documentation is an important skill.\n",
    "\n",
    "\n",
    "```\n",
    "abs(), aiter(), all(), any(), anext(), ascii(), bin(), bool(), breakpoint(), bytearray(), bytes(), callable(), chr(), classmethod(), compile(), complex(), delattr(), dict(), dir(), divmod(), enumerate(), eval(), exec(), filter(), float(), format(), frozenset(), getattr(), globals(), hasattr(), hash(), help(), hex(), id(), input(), int(), isinstance(), issubclass(), iter(), L, len(), list(), locals(), map(), max(), memoryview(), min(), next(), object(), oct(), open(), ord(), pow(), print(), property(), range(), repr(), reversed(), round(), set(), setattr(), slice(), sorted(), staticmethod(), str(), sum(), super(), tuple(), type(), vars(), zip()\n",
    "```\n",
    "\n",
    "You can also import functions from other modules. Python is fortunate to have a large standard library!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "math.sqrt(25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import randint, randrange, choice, random\n",
    "\n",
    "print(randint(0, 10))   # the start and end points are INCLUSIVE\n",
    "print(randrange(0, 10)) # the start point is INCLUSIVE, but the endpoint is EXCLUSIVE like range()\n",
    "print(choice(fruit))    # selects a random fruit\n",
    "print(random())         # generate a float in [0.0, 1.0)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exceptionally, you may wish to import a module into your current namespace under a different name. Often, this is because it may clash with a name you are already using in your code.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "statistics = [123.4, 534.234, 964.4]    # What great statistics!\n",
    "\n",
    "import statistics as stats\n",
    "\n",
    "stats.stdev([1, 2, 3, 4, 5])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While it is recommended to avoid doing so if not strictly necessary in other cases, shortening a long module name can be sometimes appropriate where it can add clarity, particularly if there would otherwise be a large number of references to the longer module name that would negatively impact the readability of the code.\n",
    "\n",
    "Common examples of this you may see in the machine learning world include the following:\n",
    "```py\n",
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "```"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to find out more about anything included within the Python standard library, check out the [documentation](https://docs.python.org/3/library/)!"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### User-defined Functions\n",
    "\n",
    "Defining your own functions allows you to create your own units of reusable code. If used appropriately, they can contribute massively to code clarity and maintainability."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add(x, y):\n",
    "    return x + y\n",
    "\n",
    "# By default, arguments are passed in the same order in which they are defined\n",
    "add(1, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python is very flexible with respect to argument order \n",
    "# if you are explicit enough about what you want to do!\n",
    "\n",
    "add(y=2, x=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# It is possible to specify default values\n",
    "\n",
    "def greet(name=\"Jeremy\"):\n",
    "    print(f\"Hello, {name}!\")\n",
    "\n",
    "greet()\n",
    "greet(\"Ferran\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As another quick aside, one important idea in _software engineering_ is the **single-responsibility principle** (SRP) that functions, classes, modules and so on should have one clear responsibility. This is related to two other principles: **don't repeat yourself** (DRY) and **keep it simple, stupid** (KISS -- no, not the rock band)!\n",
    "\n",
    "You do not have to follow these principles religiously, but they can go a long way to helping you write cleaner code.\n",
    "\n",
    "In practice, if you have a function that performs some intensive computation and then outputs the result, you might want to consider splitting that up into a function that performs the computation and another that handles how it is displayed and formatted. By decoupling these two operations from each other, this then makes code to perform the original computation much more reusable and the program a bit more maintainable!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# BEWARE: it is best not to set default values to objects -- the same objects get reused every time!\n",
    "\n",
    "def be_careful(items=[]):\n",
    "    items.append(\"foo\")\n",
    "    return items\n",
    "\n",
    "print(be_careful())\n",
    "print(be_careful())\n",
    "print(be_careful())\n",
    "\n",
    "# This probably isn't the behaviour you expect!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# If the behaviour you want is for it to always return ['foo'] in the case, \n",
    "# you probably want to do something more along these lines\n",
    "\n",
    "def be_a_bit_more_careful(items=None):\n",
    "    if items is None:\n",
    "        items = []\n",
    "\n",
    "    items.append(\"foo\")\n",
    "    \n",
    "    return items\n",
    "\n",
    "print(be_a_bit_more_careful())\n",
    "print(be_a_bit_more_careful())\n",
    "print(be_a_bit_more_careful())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can also specify type annotations, which can be useful to other programmers, \n",
    "# as well as to type checking software (linters), which can help spot bugs in code\n",
    "\n",
    "def shout(message: str) -> None:\n",
    "    print(message.upper())\n",
    "\n",
    "shout(\"hey can i interest you in some web3 blockchain machine learning techno-- *whack*\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# you can be very precise with your type annotations if you want!\n",
    "\n",
    "from typing import List\n",
    "\n",
    "\n",
    "def square_floats(numbers: List[float]) -> List[float]:\n",
    "    return [number**2 for number in numbers]\n",
    "\n",
    "\n",
    "square_floats([3.5, 7.3, 9.99, 1.0])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Recursion** is a technique that lets you define a function in terms of itself."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This function uses an example of an 'early return' 👀\n",
    "# Code often looks cleaner if you avoid 'else' clauses where they are unnecessary!\n",
    "\n",
    "def factorial(n: int):\n",
    "    if n <= 1:\n",
    "        return 1\n",
    "    \n",
    "    return n * factorial(n - 1)\n",
    "\n",
    "factorial(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Note: while recursion has its place, there is often a more efficient\n",
    "# solution that uses plain iteration (and therefore avoids the risk of\n",
    "# a call stack overflow)\n",
    "\n",
    "def factorial(n: int) -> int:\n",
    "    value = 1\n",
    "    for i in range(2, n + 1):\n",
    "        value *= i\n",
    "    return value\n",
    "\n",
    "factorial(5)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classes\n",
    "\n",
    "As has become apparent by this point, Python has first-class support for object-oriented programming. We have seen how we can create more complex data structures through **composition** (e.g. with tuples), as well as through **inheritance** (e.g. with Boolean values being sneaky subtypes of integers!). Furthermore, we have seen how we can define functions to define additional operations on data.\n",
    "\n",
    "Building on these ideas, **classes** provide a natural way to define our own more complex object types of which instances may be instantiated. They can encapsulate data within their internal state and expose a number of operations through methods that act on that data.\n",
    "\n",
    "More formally, instance objects may have data attributes (that store data within the object), as well as methods (that allow certain actions to be performed, typically involving said data attributes at least in part).\n",
    "\n",
    "They are typically named using Pascal case, i.e. `ClassName` starting with an uppercase letter with no underscores, not `className` or `class_name`.\n",
    "\n",
    "We have actually already seen classes: exceptions, such as `ValueError`, are classes that contain useful data attributes and helper methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:\n",
    "    \"\"\"A representation of a person.\"\"\"\n",
    "\n",
    "    species = \"homo sapiens\"\n",
    "\n",
    "    def __init__(self, name, age) -> None:\n",
    "        \"\"\"This method is known as the constructor.\n",
    "\n",
    "        It gets called when an instance of this class gets instantiated.\n",
    "\n",
    "        Args:\n",
    "            name (str): The name of the person.\n",
    "            age (int): The age of the person.\n",
    "        \"\"\"\n",
    "\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "\n",
    "    def get_introduction(self):\n",
    "        \"\"\"Gets an introduction for the person.\n",
    "\n",
    "        Returns:\n",
    "            str: The introduction.\n",
    "        \"\"\"\n",
    "\n",
    "        return f\"{self.name} (aged {self.age}) is a person.\"\n",
    "\n",
    "    def is_a_robot(self):\n",
    "        \"\"\"Returns whether the person is a robot or not.\n",
    "\n",
    "        Returns:\n",
    "            bool: True if a robot, otherwise False.\n",
    "        \"\"\"\n",
    "\n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Person.species"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Legendary bassist 👀\n",
    "joe_dart = Person(\"Joe Dart\", 31)\n",
    "\n",
    "print(joe_dart.get_introduction())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Fun fact**: these \"double underscore\" methods, such as `__init__()`, are known as \"dunder methods\" (or more commonly in other languages, \"magic methods\"). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Student(Person):\n",
    "    \"\"\"A representation of a student, which inherits from our\n",
    "    pre-existing representation of a Person.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, name, age, degree, year) -> None:\n",
    "        # We can call the parent's constructor! This is fairly common.\n",
    "        super().__init__(name, age)\n",
    "\n",
    "        self.degree = degree\n",
    "        self.year = year\n",
    "\n",
    "    def get_introduction(self):\n",
    "        # We can override methods if we wish\n",
    "\n",
    "        return f\"{self.name} (aged {self.age}) is a student ({self.degree}, Year {self.year}).\"\n",
    "    \n",
    "    def get_hours_of_sleep(self):\n",
    "        # We can also define new methods!\n",
    "\n",
    "        if self.degree == \"MEng Computer Science\":\n",
    "            return 0\n",
    "        \n",
    "        return 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "jeremy = Student(\"Jeremy\", 21, \"MEng Computer Science\", 4)\n",
    "\n",
    "print(jeremy.get_introduction())\n",
    "print(\"Hours of sleep:\", jeremy.get_hours_of_sleep())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ferran = Student(\"Ferran\", 19, \"MSci Neuroscience\", 2)\n",
    "\n",
    "print(ferran.get_introduction())\n",
    "print(\"Hours of sleep:\", ferran.get_hours_of_sleep())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This method comes from the Person class!\n",
    "if jeremy.is_a_robot():\n",
    "    print(\"Ooops, I've been lying to those reCAPTCHAs all this time!\")\n",
    "else:\n",
    "    print(\"Nahhh, this guy's definitely a human.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unfortunately, we are running out of time to go into classes into much more detail, but I would encourage you to read the [incredibly thorough documentation](https://docs.python.org/3/tutorial/classes.html)!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Thank you!\n",
    "\n",
    "Thank you so much for following this part of the tutorial. There is a lot of material here to digest, but you've absolutely got this!\n",
    "\n",
    "Take your time to go through the examples and experiment. In fact, you can create and edit your own code blocks in this very Jupyter notebook and experiment alongside the examples we have included! The best way to learn and internalise all this information is to put it into practice.\n",
    "\n",
    "If you are hungry to learn more about software engineering, reach out to us! In the meantime, you might want to look into some other coding principles that are important to writing clean code, such as defining clean **interfaces** between layers of our applications, the ideas of **abstraction** and **encapsulation**, and so on.\n",
    "\n",
    "Writing production-ready software can be a complex process, involving stages such as the following:\n",
    "- understanding users' requirements (possibly thinking about both functional and non-functional requirements using the MoSCoW method);\n",
    "- designing and architecting a solution (what are the different components of your system? how do they interact and scale?);\n",
    "- user interface and experience design;\n",
    "- implementation (what technologies are the right tool to solve this problem? how can you write code that is easy to maintain, test and validate the correctness of?);\n",
    "- testing (unit testing, integration testing & end-to-end testing);\n",
    "- debugging (fixing parts of the codebase that do not work as intended);\n",
    "- static analysis (can we find and correct errors in our code at build-time?);\n",
    "- and so on.\n",
    "\n",
    "Understandably, you might wish to jump straight into learning about the latest and greatest machine learning models (as you will be able to in our upcoming tutorials!), but spending the time now to get a _solid_ foundation in Python and and perhaps ideas from software engineering more broadly can be a fulfilling way of setting yourself up to tackle larger challenges.\n",
    "\n",
    "If you want to learn more about computer science, an excellent introduction is Harvard's [CS50](https://www.edx.org/cs50). They also have a 10-week course that focuses specifically on teaching Python, [CS50P](https://www.edx.org/course/cs50s-introduction-to-programming-with-python), rather than on computer science more broadly."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.1"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "369f2c481f4da34e4445cda3fffd2e751bd1c4d706f27375911949ba6bb62e1c"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}