Python_Basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "fd9f5217-c57f-439d-82a4-346e78f4f8d4",
   "metadata": {
    "id": "fd9f5217-c57f-439d-82a4-346e78f4f8d4"
   },
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    \n",
    "# Introduction to Python\n",
    "    \n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "BxtXmW5Cz38U",
   "metadata": {
    "id": "BxtXmW5Cz38U"
   },
   "source": [
    "## Notebook Basics"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f6a573a-881d-4c06-8701-c2d6ae64cc4d",
   "metadata": {
    "id": "1f6a573a-881d-4c06-8701-c2d6ae64cc4d"
   },
   "source": [
    "* Evaluate cells by pressing `Shift + Enter`\n",
    "* Code runs in the order in which you evaluate cells, not in the order in which cells are written.\n",
    "* Auto-completion with `Ctrl-Space`/`Cmd-Space`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c48d3dbf-14b6-43d9-8eb4-528a67910b0c",
   "metadata": {
    "id": "c48d3dbf-14b6-43d9-8eb4-528a67910b0c"
   },
   "source": [
    "## Python is great!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "983b8449-be70-4026-9cf9-0b28bdeade8a",
   "metadata": {
    "id": "983b8449-be70-4026-9cf9-0b28bdeade8a"
   },
   "source": [
    "*What* makes Python great?\n",
    "\n",
    "- Interpreted language (no compiling)\n",
    "- Interactive (IPython and Jupyter/Colab notebooks)\n",
    "- Lots of packages (batteries included!)\n",
    "- Great **community**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6e580eda-0486-440e-9c2f-e47941edad39",
   "metadata": {
    "id": "6e580eda-0486-440e-9c2f-e47941edad39"
   },
   "outputs": [],
   "source": [
    "# Zen of Python\n",
    "import this"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a52860c-47ea-4382-b794-be40c4584e45",
   "metadata": {
    "id": "7a52860c-47ea-4382-b794-be40c4584e45"
   },
   "source": [
    "The material for this lecture is collected primarily from:\n",
    "* [Python Programming And Numerical Methods: A Guide For Engineers And Scientists](https://pythonnumericalmethods.berkeley.edu/notebooks/Index.html)\n",
    "* [Python Scripting for Computational Molecular Science](https://education.molssi.org/python_scripting_cms/)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b5af8eb-3efa-45c9-a527-74f941890c5f",
   "metadata": {
    "id": "6b5af8eb-3efa-45c9-a527-74f941890c5f"
   },
   "source": [
    "## Basic Syntax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aKHKSiqq1qAD",
   "metadata": {
    "id": "aKHKSiqq1qAD"
   },
   "outputs": [],
   "source": [
    "# Lines starting with a hash/pound sign are comments\n",
    "# meaning that they are not evaluated as code.\n",
    "#\n",
    "# Comments are useful to add short (and not so short)\n",
    "# blurbs of text explaning a particular part of your code"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30f69686-a931-4d33-9fa0-7b420c973505",
   "metadata": {
    "id": "30f69686-a931-4d33-9fa0-7b420c973505"
   },
   "source": [
    "### Variables and Basic Types"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee3e2f5f-e7ce-4755-afbf-a6fa6ee9228d",
   "metadata": {
    "id": "ee3e2f5f-e7ce-4755-afbf-a6fa6ee9228d"
   },
   "source": [
    "The assignment operator, denoted by the `=` symbol, assigns values to variables. The line `var_a = 3` takes the known value, 3, and assigns that value to the variable `var_a`.\n",
    "\n",
    "An important aspect of any piece of code is how readable it is for other developers (or future you), so avoid abstract variable names like `a`, `var`, `var1`, `var2`, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "70f75e19-6eab-4f7e-a486-275f7845c73b",
   "metadata": {
    "id": "70f75e19-6eab-4f7e-a486-275f7845c73b"
   },
   "outputs": [],
   "source": [
    "pi = 3.1415"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "k1tgyXi2hOgH",
   "metadata": {
    "id": "k1tgyXi2hOgH"
   },
   "source": [
    "You can write the value of a variable to the screen (or terminal) using the `print()` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "X2H_ATehhLpD",
   "metadata": {
    "id": "X2H_ATehhLpD"
   },
   "outputs": [],
   "source": [
    "print(pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "VR0axWrv4v4s",
   "metadata": {
    "id": "VR0axWrv4v4s"
   },
   "source": [
    "If a variable is not defined, trying to use it will result in a `NameError`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7RnNtX_F4u0T",
   "metadata": {
    "id": "7RnNtX_F4u0T"
   },
   "outputs": [],
   "source": [
    "print(phi)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "OgdcbQqkuJ48",
   "metadata": {
    "id": "OgdcbQqkuJ48"
   },
   "source": [
    "To format your print statements nicely, you can use 'f-strings', which make your `print()` statement look like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2xPPo-mMumZd",
   "metadata": {
    "id": "2xPPo-mMumZd"
   },
   "outputs": [],
   "source": [
    "print(f\"The value of pi is {pi}\")  # enclose variables in curly brackets"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eeVIc1oBjF7j",
   "metadata": {
    "id": "eeVIc1oBjF7j"
   },
   "source": [
    "Variables can be of multiple *types* and unlike in other programming languages, the type is not (necessarily) declared when you create the variable, nor it remains constant since variables can be overwritten. Use the `type()` function to check the type of your variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "96S_u94ojFbb",
   "metadata": {
    "id": "96S_u94ojFbb"
   },
   "outputs": [],
   "source": [
    "type(pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "-ExgrrBEkzqQ",
   "metadata": {
    "id": "-ExgrrBEkzqQ"
   },
   "source": [
    "Python offers several built-in *basic* types, in particular `str` (for text strings), `int` and `float` (for numerical variables), and `bool` (for boolean algebra used in comparisons)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ekRuJa7OnimZ",
   "metadata": {
    "id": "ekRuJa7OnimZ"
   },
   "outputs": [],
   "source": [
    "an_integer = 42 # Just an integer\n",
    "a_float = 0.1 # A non-integer number, up to a fixed precision\n",
    "a_boolean = True # A value that can be True or False\n",
    "a_string = '''just enclose text between two 's, or two \"s, or do what we did for this string''' # Text\n",
    "none_of_the_above = None # The absence of any actual value or variable type"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df83a35d-f7f7-43cb-80e3-760d0e11f97c",
   "metadata": {
    "id": "df83a35d-f7f7-43cb-80e3-760d0e11f97c"
   },
   "source": [
    "You can do algebra with numerical variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c518574f-3c14-4360-b056-4d48e3d3d446",
   "metadata": {
    "id": "c518574f-3c14-4360-b056-4d48e3d3d446"
   },
   "outputs": [],
   "source": [
    "pi * pi"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a141f0e-0c58-4bd6-a8a0-1bd395cd2cae",
   "metadata": {
    "id": "5a141f0e-0c58-4bd6-a8a0-1bd395cd2cae"
   },
   "source": [
    "or assign the result of a calculation to a new variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ec17fdd4-f089-46a7-ba89-76a8ceb08609",
   "metadata": {
    "id": "ec17fdd4-f089-46a7-ba89-76a8ceb08609"
   },
   "outputs": [],
   "source": [
    "pi2 = pi * pi\n",
    "print(pi2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "nJw1uxCwp9pr",
   "metadata": {
    "id": "nJw1uxCwp9pr"
   },
   "source": [
    "But sometimes operators behave differently if the variable types are different"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "vEOYBoBOp9R2",
   "metadata": {
    "id": "vEOYBoBOp9R2"
   },
   "outputs": [],
   "source": [
    "three = \"3\"\n",
    "seven = \"7\"\n",
    "print(three + seven)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8bcf5b0-2465-4a35-a291-155f403139f6",
   "metadata": {
    "id": "b8bcf5b0-2465-4a35-a291-155f403139f6"
   },
   "source": [
    "Comparisons are made using the `==` (equality) and `!=` (inequality) operators:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "46987bc6-fae3-4a68-9dab-1e0d82a1f671",
   "metadata": {
    "id": "46987bc6-fae3-4a68-9dab-1e0d82a1f671"
   },
   "outputs": [],
   "source": [
    "pi2 == pi * pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9746a684-0983-4692-936f-e08e3fbe8667",
   "metadata": {
    "id": "9746a684-0983-4692-936f-e08e3fbe8667"
   },
   "outputs": [],
   "source": [
    "pi2 != pi"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0ee44d4-dc8c-4f8c-b29e-a59586e702a4",
   "metadata": {
    "id": "a0ee44d4-dc8c-4f8c-b29e-a59586e702a4"
   },
   "source": [
    "We can assign the value of one variable to another"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "81f1fe5f-a0e9-4a1f-bf6f-98a845a445c7",
   "metadata": {
    "id": "81f1fe5f-a0e9-4a1f-bf6f-98a845a445c7"
   },
   "outputs": [],
   "source": [
    "another_pi2 = pi2\n",
    "print(f\"The value of pi2 is: {pi2} and the value of another_pi2 is: {another_pi2}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e244d7ec-a83d-4864-a387-92d4271c599e",
   "metadata": {
    "id": "e244d7ec-a83d-4864-a387-92d4271c599e"
   },
   "source": [
    "We can also assign multiple variables in one line, but try and keep readability in mind:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "872756cd-8def-41cc-873d-dfe8696cbe46",
   "metadata": {
    "id": "872756cd-8def-41cc-873d-dfe8696cbe46"
   },
   "outputs": [],
   "source": [
    "three, seven = 3, 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "13a00ffc-07f6-4298-b16b-14027002b5f3",
   "metadata": {
    "id": "13a00ffc-07f6-4298-b16b-14027002b5f3"
   },
   "outputs": [],
   "source": [
    "print(three + seven)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "518c51b3-d826-4eb5-b9cf-6049d2254c0a",
   "metadata": {
    "id": "518c51b3-d826-4eb5-b9cf-6049d2254c0a"
   },
   "source": [
    "Finally, you can update variables 'in place' using this type of syntax, e.g. for incrementing an integer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ae62f574-4e30-4c3b-a4c7-dd6c6a381aaa",
   "metadata": {
    "id": "ae62f574-4e30-4c3b-a4c7-dd6c6a381aaa"
   },
   "outputs": [],
   "source": [
    "an_int = 1\n",
    "an_int = an_int + 1\n",
    "print(an_int)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0917934d-6d39-4089-84a0-41140c783d3f",
   "metadata": {
    "id": "0917934d-6d39-4089-84a0-41140c783d3f"
   },
   "source": [
    "This operation is so common that there is an short form for the increment:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fa93d832-4939-4999-8b84-b23bcf8a7fc8",
   "metadata": {
    "id": "fa93d832-4939-4999-8b84-b23bcf8a7fc8"
   },
   "outputs": [],
   "source": [
    "an_int += 1\n",
    "print(an_int)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a79f7c40-b405-43be-8b03-04b1a32e447f",
   "metadata": {
    "id": "a79f7c40-b405-43be-8b03-04b1a32e447f"
   },
   "source": [
    "### Python as a calculator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "afd55390-0c8c-4e44-8ed9-90c0c2a17dbc",
   "metadata": {
    "id": "afd55390-0c8c-4e44-8ed9-90c0c2a17dbc"
   },
   "outputs": [],
   "source": [
    "7 + 11"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31804fd4-2910-468e-a6cc-f38b320f0d33",
   "metadata": {
    "id": "31804fd4-2910-468e-a6cc-f38b320f0d33"
   },
   "source": [
    "The usual order of operations is respected. You can also use parentheses to ensure a certain order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7a322c56-2f3b-4825-a237-25ffbb5d483a",
   "metadata": {
    "id": "7a322c56-2f3b-4825-a237-25ffbb5d483a"
   },
   "outputs": [],
   "source": [
    "result = (3 * 4) / (2**2 + 4 / 2)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f224ecd4-df82-408b-a6b8-eac982fecdef",
   "metadata": {
    "id": "f224ecd4-df82-408b-a6b8-eac982fecdef"
   },
   "source": [
    "Arithmetic with complex numbers uses `j` with a number in front, or the explicit type keyword `complex`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e642114a-7c7c-43a4-bbcb-66e42bdf4f69",
   "metadata": {
    "id": "e642114a-7c7c-43a4-bbcb-66e42bdf4f69"
   },
   "outputs": [],
   "source": [
    "(3 + 4j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4cee4a15-f485-42e5-9f99-0a8ca565495a",
   "metadata": {
    "id": "4cee4a15-f485-42e5-9f99-0a8ca565495a"
   },
   "outputs": [],
   "source": [
    "complex(3, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "_qD9Tjcpr8qy",
   "metadata": {
    "id": "_qD9Tjcpr8qy"
   },
   "source": [
    "Basic mathematical functions such as `abs`, `sin`, `cos`, `log`, etc are readily available as functions or easily brought into your code via *imports*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "949c59b7-5b65-4630-9e4e-e835b350c2ed",
   "metadata": {
    "id": "949c59b7-5b65-4630-9e4e-e835b350c2ed"
   },
   "outputs": [],
   "source": [
    "abs(3 + 4j) # Absolute value"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "hjF941QUw7JR",
   "metadata": {
    "id": "hjF941QUw7JR"
   },
   "source": [
    "**Exercise** Complete the following piece of code to calculate the area of a circle given its radius, following the formula: $area = {pi} * {r}^{2}$.\n",
    "\n",
    "Use the value of `pi` stored in the `math` module as `math.pi`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fvrTe9I7xiLZ",
   "metadata": {
    "id": "fvrTe9I7xiLZ"
   },
   "outputs": [],
   "source": [
    "radius = 5\n",
    "area = ...\n",
    "print(area)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "SYIsS_avvAP6",
   "metadata": {
    "id": "SYIsS_avvAP6"
   },
   "source": [
    "### Modules and Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5238b2d4-ac73-4645-920e-03d12648814a",
   "metadata": {
    "id": "5238b2d4-ac73-4645-920e-03d12648814a"
   },
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "GX5wxcWQsvVP",
   "metadata": {
    "id": "GX5wxcWQsvVP"
   },
   "outputs": [],
   "source": [
    "math.cos(0.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "q-wWAg8mtNtL",
   "metadata": {
    "id": "q-wWAg8mtNtL"
   },
   "source": [
    "Modules (also called libraries), are collections of code pre-written by yourself or some other developer that are installed and made available to your Python installation. You can then import them with the keyword `import`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "GJtk_fl9tmY2",
   "metadata": {
    "id": "GJtk_fl9tmY2"
   },
   "source": [
    "If the developers of the module are nice, they write nice documentation that you can access with the function `help()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fKLHr0NEs5Dz",
   "metadata": {
    "id": "fKLHr0NEs5Dz"
   },
   "outputs": [],
   "source": [
    "help(math)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f65d3b7-9829-4f16-8be1-25e3e26f8eed",
   "metadata": {
    "id": "4f65d3b7-9829-4f16-8be1-25e3e26f8eed"
   },
   "source": [
    "A shorter version of `help()` is avaiable specifically in notebooks using the `?` character."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5841daea-69d2-4794-b86d-f0f7ab7bb550",
   "metadata": {
    "id": "5841daea-69d2-4794-b86d-f0f7ab7bb550"
   },
   "outputs": [],
   "source": [
    "math?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2IBCWML0t98M",
   "metadata": {
    "id": "2IBCWML0t98M"
   },
   "source": [
    "The `help()` function also works for functions themselves:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a-YOt4MxuDW_",
   "metadata": {
    "id": "a-YOt4MxuDW_"
   },
   "outputs": [],
   "source": [
    "help(math.cos)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "KRoyNmIouJ_Q",
   "metadata": {
    "id": "KRoyNmIouJ_Q"
   },
   "source": [
    "The listing of all modules available with your installation of Python, the so-called standard library, is available at: https://docs.python.org/3/library/index.html. These do not include third-party modules like `numpy`, `pandas`, or `sklearn`, that require a specific installation step."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "OW6mYpwRzuJt",
   "metadata": {
    "id": "OW6mYpwRzuJt"
   },
   "source": [
    "**Exercise** Find a module in the standard library to generate random numbers and use it to add 'noise' to the following variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "xoYnORTSzt6W",
   "metadata": {
    "id": "xoYnORTSzt6W"
   },
   "outputs": [],
   "source": [
    "noise = ...\n",
    "x = 4.235\n",
    "print(x + noise)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cce3b46e-af7c-4644-868a-d79ae4b5abd5",
   "metadata": {
    "id": "cce3b46e-af7c-4644-868a-d79ae4b5abd5"
   },
   "source": [
    "### Container Types: lists, tuples, sets, and dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6SLR5IhRvMFM",
   "metadata": {
    "id": "6SLR5IhRvMFM"
   },
   "source": [
    "So far we have been using 'basic' variable types, but programs need more complex data structures to be efficient. These include container data types, such as `list`, `tuple`, and `set`, as well as mapping types like `dict`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "nsDrvwfb6KH0",
   "metadata": {
    "id": "nsDrvwfb6KH0"
   },
   "source": [
    "#### Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fcf83b02-8043-4b71-be36-921b0b9fab02",
   "metadata": {
    "id": "fcf83b02-8043-4b71-be36-921b0b9fab02"
   },
   "source": [
    "**Lists** are groups of objects (values, variables, even functions). We construct them using square brackets [] with objects separated by commas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e788f68c-f7d7-4550-9246-10f3643cdd42",
   "metadata": {
    "colab": {
     "background_save": true
    },
    "id": "e788f68c-f7d7-4550-9246-10f3643cdd42"
   },
   "outputs": [],
   "source": [
    "values = [7, 11, 13, 17, 19, 23, 29]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d6437c0-f085-4d3e-aafd-13e7fba73d4f",
   "metadata": {
    "id": "8d6437c0-f085-4d3e-aafd-13e7fba73d4f"
   },
   "source": [
    "Very importantly, **indexing in Python starts at 0**. The first item on a list is numbered 0, not 1. This means the last index of a list in Python is its `length - 1`, not length."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "752def10-796e-48a6-bc5b-ae3506d20f92",
   "metadata": {
    "id": "752def10-796e-48a6-bc5b-ae3506d20f92"
   },
   "outputs": [],
   "source": [
    "values[0], values[1], values[2], values[3], values[4], values[5], values[6]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "043693dd-66da-42bf-9215-e1688ddaf935",
   "metadata": {
    "id": "043693dd-66da-42bf-9215-e1688ddaf935"
   },
   "source": [
    "There are built-in functions for handling lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eccc2988-6939-4508-ba2f-974b4ed4f662",
   "metadata": {
    "id": "eccc2988-6939-4508-ba2f-974b4ed4f662"
   },
   "outputs": [],
   "source": [
    "len(values)  # length of a list, the number of elements in it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "D2r0gEW6WSax",
   "metadata": {
    "colab": {
     "background_save": true
    },
    "id": "D2r0gEW6WSax"
   },
   "outputs": [],
   "source": [
    "sum(values)  # sums all values in the list (values[0] + values[1] + ...)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "NEGa2M5S0cHu",
   "metadata": {
    "id": "NEGa2M5S0cHu"
   },
   "source": [
    "Trying to access indices that are not defined (usually because the list is too short) results in an `IndexError`. Get used to the types of errors in Python as they offer good clues to what the problem with your code is."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1c5ec7dc-ae42-4fad-915e-c5b2aa11667f",
   "metadata": {
    "id": "1c5ec7dc-ae42-4fad-915e-c5b2aa11667f"
   },
   "outputs": [],
   "source": [
    "values[7]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c0e5041-37ae-4c7d-8eaa-afea50698b7e",
   "metadata": {
    "id": "1c0e5041-37ae-4c7d-8eaa-afea50698b7e"
   },
   "source": [
    "You can access list elements in reverse. For example, the last element of the list is"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5a824680-e07a-43f6-814f-ee9989c0280e",
   "metadata": {
    "id": "5a824680-e07a-43f6-814f-ee9989c0280e"
   },
   "outputs": [],
   "source": [
    "values[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "490d72ef-43a6-480a-8934-25fa80eeb7cf",
   "metadata": {
    "id": "490d72ef-43a6-480a-8934-25fa80eeb7cf"
   },
   "source": [
    "You can also access sections of a list, using what are known are slices. The slice notation, `list[i:j]`, returns all values of the list from `list[i]` to `list[j - 1]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8ccd732d-9e78-4796-8fcc-504bb26a66bd",
   "metadata": {
    "id": "8ccd732d-9e78-4796-8fcc-504bb26a66bd"
   },
   "outputs": [],
   "source": [
    "values[0:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92076e72-ac63-46cc-b92d-74bc91b85288",
   "metadata": {
    "id": "92076e72-ac63-46cc-b92d-74bc91b85288"
   },
   "source": [
    "If you do not include a start index, the slice automatically starts at the first element. If you do not include an end index, the slice automatically goes to the last element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "af17f1bb-094f-4316-b8fe-a869339abdf9",
   "metadata": {
    "id": "af17f1bb-094f-4316-b8fe-a869339abdf9"
   },
   "outputs": [],
   "source": [
    "values[:7], values[4:]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "IB_mWNrH3734",
   "metadata": {
    "id": "IB_mWNrH3734"
   },
   "source": [
    "Slices can also take a *third* element which is known as the *stride*. This allows you to take non-contiguous chunks of a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "huTZ3ut34DXS",
   "metadata": {
    "id": "huTZ3ut34DXS"
   },
   "outputs": [],
   "source": [
    "values[0:4:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "WAEDGBqH4JGI",
   "metadata": {
    "id": "WAEDGBqH4JGI"
   },
   "outputs": [],
   "source": [
    "values[::2]  # Ommiting the two first values also works"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ef8f01b-0fb8-4ebf-ae6f-33f22d34113d",
   "metadata": {
    "id": "6ef8f01b-0fb8-4ebf-ae6f-33f22d34113d"
   },
   "source": [
    "Lists can include objects of different types, although this often leads to complications down the line with your code!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eedffce2-c5aa-4798-a9fd-47cf098c50aa",
   "metadata": {
    "id": "eedffce2-c5aa-4798-a9fd-47cf098c50aa"
   },
   "outputs": [],
   "source": [
    "mixed_list = ['one', 1, 1e6, [1,1], True, None]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "db5DM98U8Qau",
   "metadata": {
    "id": "db5DM98U8Qau"
   },
   "outputs": [],
   "source": [
    "print(mixed_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e51b1320-e4af-4266-80f3-049c05c2faf6",
   "metadata": {
    "id": "e51b1320-e4af-4266-80f3-049c05c2faf6"
   },
   "source": [
    "You can join lists together by \"adding\" them, or replicate a list by \"multiplying\" it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a0636ba8-9604-4cde-b7ca-5939c0edc118",
   "metadata": {
    "id": "a0636ba8-9604-4cde-b7ca-5939c0edc118"
   },
   "outputs": [],
   "source": [
    "values2 = values + values\n",
    "print(values2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ea7efa57-c419-4d56-9b66-c04df2d2421c",
   "metadata": {
    "id": "ea7efa57-c419-4d56-9b66-c04df2d2421c"
   },
   "outputs": [],
   "source": [
    "values3 = values * 3\n",
    "print(values3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0TcA5UFW5grA",
   "metadata": {
    "id": "0TcA5UFW5grA"
   },
   "source": [
    "Lists have 'attached' functions, or methods, that offer ways of appending values to them, extending them with other lists, removing values, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "X8GpOoo_5smB",
   "metadata": {
    "id": "X8GpOoo_5smB"
   },
   "outputs": [],
   "source": [
    "values = []  # an empty list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "CuzSd_Ov5vYt",
   "metadata": {
    "id": "CuzSd_Ov5vYt"
   },
   "outputs": [],
   "source": [
    "values.append(1)\n",
    "print(values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "-lzRXfkF5yhA",
   "metadata": {
    "id": "-lzRXfkF5yhA"
   },
   "outputs": [],
   "source": [
    "values.extend(values)\n",
    "print(values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "QF8_qRBo52uN",
   "metadata": {
    "id": "QF8_qRBo52uN"
   },
   "outputs": [],
   "source": [
    "values.remove(1)  # removes the first value matching the argument\n",
    "print(values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "DxPhr6rO5-4k",
   "metadata": {
    "id": "DxPhr6rO5-4k"
   },
   "outputs": [],
   "source": [
    "values.append(2)\n",
    "values.index(2)  # left-most (first) position of the argument."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ZCkr8D466N8o",
   "metadata": {
    "id": "ZCkr8D466N8o"
   },
   "source": [
    "#### Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "edf43aff-155b-4a5b-a69a-a03502830317",
   "metadata": {
    "id": "edf43aff-155b-4a5b-a69a-a03502830317"
   },
   "source": [
    "Strings, although a 'basic' type, behave also like a 'list' of characters and share many functionalities with lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "60b4ca7a-f2a9-4cb7-ae99-e1d623374e64",
   "metadata": {
    "id": "60b4ca7a-f2a9-4cb7-ae99-e1d623374e64"
   },
   "outputs": [],
   "source": [
    "words = 'Hello World!'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8886c993-01cc-4f8d-b5be-1280b62e2da8",
   "metadata": {
    "id": "8886c993-01cc-4f8d-b5be-1280b62e2da8"
   },
   "source": [
    "You can slice them similar to lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "264f94cb-01ec-4ccd-ad65-52bdaff58d6e",
   "metadata": {
    "id": "264f94cb-01ec-4ccd-ad65-52bdaff58d6e"
   },
   "outputs": [],
   "source": [
    "words[:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "qbqAdDd96gpc",
   "metadata": {
    "id": "qbqAdDd96gpc"
   },
   "source": [
    "Some methods work equally on strings and list (and other container types)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "txQ_P7sG6fsA",
   "metadata": {
    "id": "txQ_P7sG6fsA"
   },
   "outputs": [],
   "source": [
    "len(words)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9d5ee84-7559-44f3-ac69-aeb988e70096",
   "metadata": {
    "id": "c9d5ee84-7559-44f3-ac69-aeb988e70096"
   },
   "source": [
    "But strings are not lists, and as such they lack some of the list methods we saw above:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "R4GM6ttW8xYv",
   "metadata": {
    "id": "R4GM6ttW8xYv"
   },
   "outputs": [],
   "source": [
    "words.append(\"Goodbye!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38XqT7fs621a",
   "metadata": {
    "id": "38XqT7fs621a"
   },
   "source": [
    "They do have, however, useful methods of their own:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ffb5b5ea-ab21-4574-8c6a-0a98d088582e",
   "metadata": {
    "id": "ffb5b5ea-ab21-4574-8c6a-0a98d088582e"
   },
   "outputs": [],
   "source": [
    "list_of_words = words.split()  # Splits string by a character, default is any white space.\n",
    "print(list_of_words)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lfcbaICx7I9r",
   "metadata": {
    "id": "lfcbaICx7I9r"
   },
   "source": [
    "#### Mutable vs Immutable Objects"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "XJRfCIyH7bly",
   "metadata": {
    "id": "XJRfCIyH7bly"
   },
   "source": [
    "An important aspect of Python variable types, particularly containers, is the definition of `immutability`. Certain data types are immutable, meaning their values cannot be changed. Others, can be changed, and it is very important to know the difference."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "-JobPJkS9_LN",
   "metadata": {
    "id": "-JobPJkS9_LN"
   },
   "source": [
    "Lists are `mutable`, and so are `set` and `dict` types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "AOfZTPIZ8Quj",
   "metadata": {
    "id": "AOfZTPIZ8Quj"
   },
   "outputs": [],
   "source": [
    "values = [\"a\", \"b\", \"c\"]\n",
    "print(values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "McBzzaBE8X6G",
   "metadata": {
    "id": "McBzzaBE8X6G"
   },
   "outputs": [],
   "source": [
    "values[1] = \"e\"  # lists are mutable\n",
    "print(values)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ZwaPmcA18xK6",
   "metadata": {
    "id": "ZwaPmcA18xK6"
   },
   "source": [
    "**Exercise**\n",
    "What do you think is the result of the following code?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dzn-_S8r8bpS",
   "metadata": {
    "id": "dzn-_S8r8bpS"
   },
   "outputs": [],
   "source": [
    "values2 = values\n",
    "values2.append(\"x\")\n",
    "print(values == values2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "VSHoPzOd9MNO",
   "metadata": {
    "id": "VSHoPzOd9MNO"
   },
   "source": [
    "Strings, unlike lists, are `immutable`. Other examples of immutable data types are `tuples` and `frozenset`, and all other basic data types (`float`, `int`, etc)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "OzQuSKuY9eQg",
   "metadata": {
    "id": "OzQuSKuY9eQg"
   },
   "outputs": [],
   "source": [
    "words = \"The beautiful game\"\n",
    "words[5] = \"x\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "XJT8JHUs-Kx2",
   "metadata": {
    "id": "XJT8JHUs-Kx2"
   },
   "source": [
    "Knowing this, the following piece of code might be puzzling."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "w7K9uL36-Ono",
   "metadata": {
    "id": "w7K9uL36-Ono"
   },
   "outputs": [],
   "source": [
    "words = \"Hello\"\n",
    "words += \" World!\"\n",
    "print(words)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "BWCOVP0c-0fc",
   "metadata": {
    "id": "BWCOVP0c-0fc"
   },
   "source": [
    "Using the `id()` function, we can check that the words variable is actually re-written, not changed. `id()` returns the object's memory address and is a unique identifier for a given object/variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7mRKX8Vu-voK",
   "metadata": {
    "id": "7mRKX8Vu-voK"
   },
   "outputs": [],
   "source": [
    "words = \"Hello\"\n",
    "print(id(words))\n",
    "words += \" World!\"\n",
    "print(id(words))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ILUaEyj2_CSr",
   "metadata": {
    "id": "ILUaEyj2_CSr"
   },
   "source": [
    "Compare this with the list example above:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7zDPEdsU_EZb",
   "metadata": {
    "id": "7zDPEdsU_EZb"
   },
   "outputs": [],
   "source": [
    "values = [\"a\", \"b\", \"c\"]\n",
    "print(id(values))\n",
    "values[1] = \"x\"\n",
    "print(id(values))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "Rxq3uBwC_ckW",
   "metadata": {
    "id": "Rxq3uBwC_ckW"
   },
   "source": [
    "#### Tuples, Sets, and Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5qfHVQTr_jIk",
   "metadata": {
    "id": "5qfHVQTr_jIk"
   },
   "source": [
    "**Tuples** are containers like lists, except that they are immutable. They're often used when you - as a developer - want to make sure that their values are never changed by mistake by your program (or users)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "GAvn2nT1_tuB",
   "metadata": {
    "id": "GAvn2nT1_tuB"
   },
   "outputs": [],
   "source": [
    "a_tuple = (1, 2, 3)\n",
    "print(a_tuple[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "RNbUp1iXWYj-",
   "metadata": {
    "id": "RNbUp1iXWYj-"
   },
   "outputs": [],
   "source": [
    "a_tuple[1] = 9"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f497d1d3-cc66-45c3-a6e5-d0c379b59cbe",
   "metadata": {
    "id": "f497d1d3-cc66-45c3-a6e5-d0c379b59cbe"
   },
   "source": [
    "**Sets** are unordered collections with no duplicate elements. They support mathematical operations like union, intersection, and complement. They are defined by using a pair of curly braces with its elements separated by commas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "659c905c-a0b3-4bd4-bfaa-5ebd562d59a3",
   "metadata": {
    "id": "659c905c-a0b3-4bd4-bfaa-5ebd562d59a3"
   },
   "outputs": [],
   "source": [
    "my_set = {1, 2, 3, 4 ,5}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "xgbmd362WonP",
   "metadata": {
    "id": "xgbmd362WonP"
   },
   "source": [
    "Because they are inherently 'unordered', they do not have a sense of 'position' and therefore cannot be indexed like lists or tuples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "KsNisOvn9z2g",
   "metadata": {
    "id": "KsNisOvn9z2g"
   },
   "outputs": [],
   "source": [
    "my_set[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14d6ff7e-a2ba-48ba-a129-163a0f6bc8a2",
   "metadata": {
    "id": "14d6ff7e-a2ba-48ba-a129-163a0f6bc8a2"
   },
   "source": [
    "A common use case for sets is to find unique elements in lists or tuples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bc114a8f-4cb4-422b-b49d-4868ea159914",
   "metadata": {
    "id": "bc114a8f-4cb4-422b-b49d-4868ea159914"
   },
   "outputs": [],
   "source": [
    "values = [1, 1, 2, 3, 4 , 5, 5]\n",
    "value_set = set(values)\n",
    "print(value_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3f5ab576-f5e9-4383-b341-280adbd3b7cf",
   "metadata": {
    "id": "3f5ab576-f5e9-4383-b341-280adbd3b7cf"
   },
   "outputs": [],
   "source": [
    "set_a = {1, 2, 3}\n",
    "set_b = {3, 4 ,5}\n",
    "\n",
    "intersection_ab = set_a & set_b\n",
    "print(intersection_ab)\n",
    "\n",
    "union_ab = set_a | set_b\n",
    "print(union_ab)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0831a6e0-ec70-441e-8447-7d0ce3574aae",
   "metadata": {
    "id": "0831a6e0-ec70-441e-8447-7d0ce3574aae"
   },
   "source": [
    "**Dictionaries** consist of key-value pairs. Keys are unique and must be immutable objects, whereas values can be anything. Like sets, dictionary keys are *hashable*, meaning they support very fast comparisons compared to lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fe167e7e-225e-46a2-b39c-1d24d00b6e25",
   "metadata": {
    "id": "fe167e7e-225e-46a2-b39c-1d24d00b6e25"
   },
   "outputs": [],
   "source": [
    "my_dict = {\"a\": 1, \"b\": 2, \"c\": 3}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "SA5qBLDwX6hk",
   "metadata": {
    "id": "SA5qBLDwX6hk"
   },
   "source": [
    "Dictionaries use the indexing notation to access elements, but instead of numerical indices, you use the keys inside the square brackets, and get the corresponding value instead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "KqI6AbPI9mA8",
   "metadata": {
    "id": "KqI6AbPI9mA8"
   },
   "outputs": [],
   "source": [
    "print(my_dict[\"a\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "MQlKBebmO7n7",
   "metadata": {
    "id": "MQlKBebmO7n7"
   },
   "source": [
    "New keys can be introduced, or existing keys updated, using the same notation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "gc2LxWidO7SX",
   "metadata": {
    "id": "gc2LxWidO7SX"
   },
   "outputs": [],
   "source": [
    "my_dict[\"d\"] = 4\n",
    "my_dict[\"a\"] = 9\n",
    "print(my_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c42b6c9d-ea00-4608-afac-ef1d8459dbf9",
   "metadata": {
    "id": "c42b6c9d-ea00-4608-afac-ef1d8459dbf9"
   },
   "source": [
    "Dictionary keys and values can be accessed individually with the `.keys()` and `.values()` methods. Using `.keys()` returns a set-like object that supports intersection, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f2479d5f-2b69-4c3e-a8f0-26c1b208488b",
   "metadata": {
    "id": "f2479d5f-2b69-4c3e-a8f0-26c1b208488b"
   },
   "outputs": [],
   "source": [
    "a_dict = {\"a\": 1, \"b\": 2, \"c\": 3}\n",
    "b_dict = {\"a\": 9, \"d\": 2, \"e\": 5}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7e0aee12-4321-4c7d-8953-34749715c4b4",
   "metadata": {
    "id": "7e0aee12-4321-4c7d-8953-34749715c4b4"
   },
   "outputs": [],
   "source": [
    "keys_in_common = a_dict.keys() & b_dict.keys()\n",
    "print(keys_in_common)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "LQIb81iFYuDn",
   "metadata": {
    "id": "LQIb81iFYuDn"
   },
   "source": [
    "Dictionaries also have a very useful `.update()` method that allows us to merge them. Note that since they must have unique keys, duplicate keys will be overwritten."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8NTfFu2YOrY6",
   "metadata": {
    "id": "8NTfFu2YOrY6"
   },
   "outputs": [],
   "source": [
    "a_dict.update(b_dict)  # update modifies a_dict in-place, no copies.\n",
    "print(a_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bboy7bphPYPL",
   "metadata": {
    "id": "bboy7bphPYPL"
   },
   "source": [
    "Finally, it is easy to check if a given key exists in a dictionary, using the `in` operator. This operation is *very* fast in dictionaries, compared to for example lists. The result of these checks is a boolean (`True`/`False`) and can be used in conditionals, which we will learn about later today."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "xyDNgz3ZPldG",
   "metadata": {
    "id": "xyDNgz3ZPldG"
   },
   "outputs": [],
   "source": [
    "a_in_dict = \"a\" in a_dict\n",
    "print(a_in_dict)\n",
    "x_in_dict = \"x\" in a_dict\n",
    "print(x_in_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "129d5c08-ce17-4ef8-b980-55e02d2b5cea",
   "metadata": {
    "id": "129d5c08-ce17-4ef8-b980-55e02d2b5cea"
   },
   "source": [
    "## Control Flow Tools"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "Sc96LCTXP1xw",
   "metadata": {
    "id": "Sc96LCTXP1xw"
   },
   "source": [
    "Part of the power of programming comes from the time saved when automating certain tasks. To this end, developers use control flow tools to define how their programs behave and react to certain inputs or results.\n",
    "\n",
    "In the next section of this workshop, we will cover three control flow tools that are present in nearly every program you will read (and eventually write). These are:\n",
    "* Loops: to repeat a piece of code a certain number of times.\n",
    "* Conditionals: to create branches that execute certain parts of your program depending on certain outcomes.\n",
    "* Functions: a construct that allows you to define a piece of code once and call it whenever necessary, optionally with flexible arguments."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "CMcmtK5QQ4kt",
   "metadata": {
    "id": "CMcmtK5QQ4kt"
   },
   "source": [
    "### Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06bd9dd6-418e-41d9-9206-267d84cce0f9",
   "metadata": {
    "id": "06bd9dd6-418e-41d9-9206-267d84cce0f9"
   },
   "source": [
    "There are several types of loops in Python. The most common is the for-loop, that repeats a piece of code a set number of times, and is defined as follows:\n",
    "\n",
    "```python\n",
    "for variable in iterable:\n",
    "    do things using variable\n",
    "```\n",
    "- Watch for the colon `:` at the end of a `for` statement.\n",
    "- Watch for the indentation (white space at the beginning of the line) on the second line.\n",
    "\n",
    "Indentation is *very* important in Python and defines what code gets executed as part of the for-loop. The convention is to use 4 spaces (not tabs) for each level of indentation (you can nest for-loops!). That said, most modern editors that understand Python syntax will take care of that for you."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aJH0FgL3R_bV",
   "metadata": {
    "id": "aJH0FgL3R_bV"
   },
   "source": [
    "The container data structures we saw above, like lists, lend themselves very nicely to programming with for-loops."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "nIhesLZ2-8hq",
   "metadata": {
    "id": "nIhesLZ2-8hq"
   },
   "outputs": [],
   "source": [
    "values = [1, 2, 3, 4, 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "49dd79b3-e0d5-4007-9b99-38a58b09b6dd",
   "metadata": {
    "id": "49dd79b3-e0d5-4007-9b99-38a58b09b6dd"
   },
   "outputs": [],
   "source": [
    "values_squared = []\n",
    "for val in values:\n",
    "    print(f\"working on value {val}\")\n",
    "    values_squared.append(val**2)\n",
    "\n",
    "print(\"Final result\", values_squared)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3770abfb-49fe-4f06-a11a-791392bfbcc8",
   "metadata": {
    "id": "3770abfb-49fe-4f06-a11a-791392bfbcc8"
   },
   "source": [
    "The `range` built-in function in Python allows us to generate a series of integers bounded by two values. Its arguments are the same as the slices we used for lists before: `range(start, end, step)`. As with slicing, the `end` parameter is not included in the result, so you will generate a series of numbers from `start` until `end - 1` in increments of `step`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "z01I0-SrTJDm",
   "metadata": {
    "id": "z01I0-SrTJDm"
   },
   "outputs": [],
   "source": [
    "n = 5\n",
    "for i in range(1, n):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "68e03c35-b4cd-457b-a441-0765863498c8",
   "metadata": {
    "id": "68e03c35-b4cd-457b-a441-0765863498c8"
   },
   "outputs": [],
   "source": [
    "n = 5\n",
    "for i in range(n):  # by default, start = 0\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6FLmOwL2TN5J",
   "metadata": {
    "id": "6FLmOwL2TN5J"
   },
   "outputs": [],
   "source": [
    "n = 5\n",
    "for i in range(0, n, 2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59ad10fa-983a-4d0d-8a16-1f8363a5c63f",
   "metadata": {
    "id": "59ad10fa-983a-4d0d-8a16-1f8363a5c63f"
   },
   "source": [
    "**Exercise**\n",
    "Write a for loop that produces the sum of a series of numbers. In other words, e.g. $result = \\sum_{n=1}^{10} n$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "56c23242-4d06-4b5d-80a6-fe261e6cbf05",
   "metadata": {
    "id": "56c23242-4d06-4b5d-80a6-fe261e6cbf05"
   },
   "outputs": [],
   "source": [
    "n = 10\n",
    "result = 0\n",
    "for i in range(1, n + 1):\n",
    "    result += i\n",
    "\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4WKjNP6GUDg9",
   "metadata": {
    "id": "4WKjNP6GUDg9"
   },
   "source": [
    "**Exercise** Write a for loop that uses the `random` module to create a list of 10 random numbers between 0 and 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "sgmrJ9OGUNnf",
   "metadata": {
    "id": "sgmrJ9OGUNnf"
   },
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "random_list = []\n",
    "for _ in range(10):\n",
    "    val = random.random()\n",
    "    random_list.append(val)\n",
    "print(random_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35aa4aed-5f7c-4ddc-8b29-1f33e177154c",
   "metadata": {
    "id": "35aa4aed-5f7c-4ddc-8b29-1f33e177154c"
   },
   "source": [
    "### Conditional statements"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff4ef5c6-3a32-46fb-bd72-61c424fce64c",
   "metadata": {
    "id": "ff4ef5c6-3a32-46fb-bd72-61c424fce64c"
   },
   "source": [
    "A conditional statement is a code construct that executes blocks of code only if certain conditions are met. These conditions are represented as logical expressions that return a boolean value (`True` or `False`).\n",
    "\n",
    "```python\n",
    "if logical expression:\n",
    "    code block\n",
    "```\n",
    "\n",
    "The word `if` is a keyword. When Python sees an if-statement, it will determine if the associated logical expression is true. If it is true, then the code in code block will be executed. If it is false, then the code in the if-statement will not be executed. The way to read this is “If logical expression is true then do code block.”"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "KwwNdHeSWrVR",
   "metadata": {
    "id": "KwwNdHeSWrVR"
   },
   "outputs": [],
   "source": [
    "n = 2\n",
    "if n > 1:\n",
    "  print(\"n is larger than 1\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "u2nsr5HBWPx8",
   "metadata": {
    "id": "u2nsr5HBWPx8"
   },
   "outputs": [],
   "source": [
    "values = list(range(10))\n",
    "for i in values:\n",
    "    if i % 2:\n",
    "        print(f\"{i} is odd\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "U9USGsCUWVSg",
   "metadata": {
    "id": "U9USGsCUWVSg"
   },
   "source": [
    "You can also define a complete branch that gives you control over what to do if the condition is true or false, using the `else` keyword. Again, mind the indentation.\n",
    "\n",
    "```python\n",
    "if logical_expression\n",
    "    code block run if true\n",
    "else\n",
    "    code block run if false\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "496cc686-7a41-43a0-8102-f299d73ed254",
   "metadata": {
    "id": "496cc686-7a41-43a0-8102-f299d73ed254"
   },
   "outputs": [],
   "source": [
    "values = list(range(10))\n",
    "\n",
    "for i in values:\n",
    "    if i % 2:\n",
    "        print(f\"{i} is odd\")\n",
    "    else:\n",
    "        print(f\"{i} is even\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42bb3d92-2919-45ae-88d5-1ca22f978180",
   "metadata": {
    "id": "42bb3d92-2919-45ae-88d5-1ca22f978180"
   },
   "source": [
    "**Exercise** Write a small piece of code that draws 10 random numbers and adds to a list only those larger than 0.5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8c55af07-876f-4056-ac35-b3a155b47e7a",
   "metadata": {
    "id": "8c55af07-876f-4056-ac35-b3a155b47e7a"
   },
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "values = []\n",
    "for _ in range(10):\n",
    "    num = random.random()\n",
    "    if num > 0.5:\n",
    "      values.append(num)\n",
    "print(values)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7953f985-2bbc-457c-bb1c-ccfff7506d5e",
   "metadata": {
    "id": "7953f985-2bbc-457c-bb1c-ccfff7506d5e"
   },
   "source": [
    "You can use if statements in a concise way (ternary operators)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "CgIcMvhdXqun",
   "metadata": {
    "id": "CgIcMvhdXqun"
   },
   "source": [
    "### Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a9f7f12-c104-4615-8da4-48b668d0c08a",
   "metadata": {
    "id": "8a9f7f12-c104-4615-8da4-48b668d0c08a"
   },
   "source": [
    "Functions in programming - also called methods or subroutines - are a sequence of instructions that can be repeatedly called. Think of them as mini programs within your program. They help organize our code and break it down into logical pieces (modules) that are more easily understood.\n",
    "\n",
    "We've been using several functions in this workshop. Some, like `range()`, `type()`, and `len()`, take an argument and produce an output. Others, like `random.random()` do not take any input but produce an output.\n",
    "\n",
    "As a general rule of thumb, when organizing your code, you want to break it up so that functions perform one task. Think of it like this: if you have to use \"and\" to describe what a function does, you probably want two.\n",
    "\n",
    "Here's the pseudocode for a function definition:\n",
    "```python\n",
    "def function_name(parameters):\n",
    "    \"\"\"documentation\"\"\"\n",
    "    ** function body code **\n",
    "    return output\n",
    "```\n",
    "\n",
    "Just like `for` loops and `if` statements, functions use indentation to define what code belongs to them. Another important piece of a function that is very often overlooked is its documentation (or docstring). This is a string that contains a short description of what your function does, its arguments, and the expected output.\n",
    "\n",
    "Finally, you often \"bind\" the result of a function to a variable, for re-use. For instance, in the following example, we assign to the variable `n_values` the result of the call to `len()` on the list `values`.\n",
    "\n",
    "```python\n",
    "values = [....]\n",
    "n_values = len(values)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "098d409b-89d2-4903-9555-2747c5da43c5",
   "metadata": {
    "id": "098d409b-89d2-4903-9555-2747c5da43c5"
   },
   "outputs": [],
   "source": [
    "def square(n):\n",
    "    return n**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "414ba957-cf1b-4430-8f9a-71d1b260415b",
   "metadata": {
    "id": "414ba957-cf1b-4430-8f9a-71d1b260415b"
   },
   "outputs": [],
   "source": [
    "res = square(2)\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9669d6bd-ae80-426c-9f01-511dd7ed3b76",
   "metadata": {
    "id": "9669d6bd-ae80-426c-9f01-511dd7ed3b76"
   },
   "outputs": [],
   "source": [
    "help(square)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "08eb7161-8beb-4ad3-a82a-3ea548c2eced",
   "metadata": {
    "id": "08eb7161-8beb-4ad3-a82a-3ea548c2eced"
   },
   "outputs": [],
   "source": [
    "def square(n):\n",
    "    \"\"\"Return the square of a number.\"\"\"\n",
    "    return n**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4c76a096-dadf-4851-a74c-2f980dd39b7e",
   "metadata": {
    "id": "4c76a096-dadf-4851-a74c-2f980dd39b7e"
   },
   "outputs": [],
   "source": [
    "help(square)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a81fd631-b59b-4455-abcb-ae186b9e1868",
   "metadata": {
    "id": "a81fd631-b59b-4455-abcb-ae186b9e1868"
   },
   "source": [
    "**Exercise** Define a function that adds two numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7054c8fb-bf4d-47ea-b628-c2332be608b7",
   "metadata": {
    "id": "7054c8fb-bf4d-47ea-b628-c2332be608b7"
   },
   "outputs": [],
   "source": [
    "def sum_two(a, b):\n",
    "    \"\"\"Add two numbers.\"\"\"\n",
    "    return a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1891e32e-0919-481f-935d-504aeeee9eaf",
   "metadata": {
    "id": "1891e32e-0919-481f-935d-504aeeee9eaf"
   },
   "outputs": [],
   "source": [
    "print(sum_two(1,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe0ad010-12b1-4f77-89d6-6b7d6e422727",
   "metadata": {
    "id": "fe0ad010-12b1-4f77-89d6-6b7d6e422727"
   },
   "source": [
    "#### Local and Global Scopes\n",
    "An important aspect of functions is scoping. Variables defined inside a function are not accessible outside of it - they are in the *local* scope of the function. Variables defined outside of functions - the *global* scope - can still be accessed (and modified) inside the function. You can explicitly declare a function variable as global using the `global` keyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cc9076d3-8f36-4688-8757-950ecd4e6851",
   "metadata": {
    "id": "cc9076d3-8f36-4688-8757-950ecd4e6851"
   },
   "outputs": [],
   "source": [
    "def f():\n",
    "    x = 10\n",
    "    print(f\"Value inside function: {x}\")\n",
    "\n",
    "x = 20\n",
    "f()\n",
    "print(f\"Value outside function: {x}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "zjcLCzQhMOXV",
   "metadata": {
    "id": "zjcLCzQhMOXV"
   },
   "outputs": [],
   "source": [
    "def f(x):\n",
    "    x += 1\n",
    "    print(f\"Value inside function: {x}\")\n",
    "\n",
    "x = 20\n",
    "f(x)\n",
    "print(f\"Value outside function: {x}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "T6XnjCHNM7bQ",
   "metadata": {
    "id": "T6XnjCHNM7bQ"
   },
   "outputs": [],
   "source": [
    "def f():\n",
    "    global x\n",
    "    x += 1\n",
    "    print(f\"Value inside function: {x}\")\n",
    "\n",
    "x = 20\n",
    "f()\n",
    "print(f\"Value outside function: {x}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lM48hSM5MZHl",
   "metadata": {
    "id": "lM48hSM5MZHl"
   },
   "source": [
    "**Exercise** How many items will `values` at the end of this short program? Why?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3tBwyPYeMU5R",
   "metadata": {
    "id": "3tBwyPYeMU5R"
   },
   "outputs": [],
   "source": [
    "def duplicate(alist):\n",
    "    alist.extend(alist)\n",
    "\n",
    "values = [0, 1, 2]\n",
    "duplicate(values)\n",
    "print(values)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "VvfQ6jySNiKE",
   "metadata": {
    "id": "VvfQ6jySNiKE"
   },
   "source": [
    "## Final Exercise\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "Sg-qgq4-Njwb",
   "metadata": {
    "id": "Sg-qgq4-Njwb"
   },
   "source": [
    "Let's put all we've learned today together in a final exercise. Write a short program that estimates the value of *pi* using a Monte Carlo method.\n",
    "\n",
    "The algorithm is as follows: for a given number of iterations, generate multiple 2D points (x, y) with coordinates between -1 and 1. Count the points that fall inside a circle of radius 1 using the formula ${x}^2 + {y}^2 <= 1$. Multiplying the ratio of points inside the circle to the total number of points sampled by 4 gives you an approximation of *pi*, based on the relations between the area of the circle and the area of the square:\n",
    "\n",
    "\n",
    "$\n",
    "\\frac{A(circle)}{A(square)} = \\frac{\\pi * {r}^2}{4{r}^2}\n",
    "\\\\\n",
    "\\pi = 4 * \\frac{A(circle)}{A(square)}\n",
    "$\n",
    "\n",
    "Tips:\n",
    "\n",
    "* use `random.uniform()` to generate a random number between two bounds.\n",
    "* write a custom function to test if points fall inside the circle."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "hjTVtlRIPmgo",
   "metadata": {
    "id": "hjTVtlRIPmgo"
   },
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "N_ITER= 5_000_000\n",
    "\n",
    "def is_in_circle(x, y):\n",
    "    return x**2 + y**2 <= 1\n",
    "\n",
    "n_inside = 0\n",
    "for it in range(N_ITER):\n",
    "  # Create point\n",
    "  x = random.uniform(-1, 1)\n",
    "  y = random.uniform(-1, 1)\n",
    "  # Check if in circle\n",
    "  if is_in_circle(x, y):\n",
    "    n_inside += 1\n",
    "\n",
    "pi_estimate = 4 * n_inside / N_ITER\n",
    "print(f\"Final estimated value of pi is {pi_estimate:.4f} after {N_ITER} iterations\")"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [
    "a79f7c40-b405-43be-8b03-04b1a32e447f"
   ],
   "provenance": []
  },
  "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.10.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}