03_control_flow.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Python 3: Control Flow\n",
    "\n",
    "Notebooks 01-03 will give a quick introduction to the Python programming language, explaining variables, operators, data structures, control flow, functions and some other useful techniques.\n",
    "\n",
    "This notebook will cover ways to change the control flow in a python program, to allow for code to be executed repeatedly, allow it to only be executed under specified conditions, and to simplify code and write it in a more structured way. We will finish by introducing two very useful tools in Python - list comprehensions and format strings.\n",
    "\n",
    "We will cover:\n",
    "* Loops\n",
    "    * `for` loops\n",
    "    * `while` loops\n",
    "    * `break` and `continue`\n",
    "* Conditional statements\n",
    "    * `if` statements\n",
    "    * `else` and `elif` statements\n",
    "* Functions\n",
    "* Useful techniques\n",
    "    * Formatting strings\n",
    "    * List comprehensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loops\n",
    "\n",
    "Generally a python program is executed line by line, starting from the top of the code and proceeding to the bottom.\n",
    "\n",
    "However we can use control flow elements like `for` loops and `if` statements to execute lines repeatedly, or to only execute code when the right conditions are met."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### While loops\n",
    "\n",
    "A `while` loop will keep executing a block of code as long as the condition associated with it is `True`.\n",
    "\n",
    "In the code below we use a `while` loop to print out the contents of a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List item 0 is 0\n",
      "List item 1 is 6\n",
      "List item 2 is 4\n",
      "List item 3 is 7\n",
      "While loop has finished\n"
     ]
    }
   ],
   "source": [
    "my_list = [0, 6, 4, 7]\n",
    "\n",
    "index = 0\n",
    "while index < len(my_list): # Note that len() just returns the length of the list.\n",
    "    # Note that these statements are indented, making them part of the while loop\n",
    "    print(\"List item\", index, \"is\", my_list[index]) \n",
    "    index = index + 1\n",
    "\n",
    "print(\"While loop has finished\") # Note this isn't indented, so not part of the while loop\n",
    "# This means it only executes once."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that in the example above *indentation* is very important. Python uses indentation to determine which statements are part of the while loop. Unlike other languages such as C, in python indentation has meaning and is an essential part of the code.\n",
    "\n",
    "The above example is one way of printing the items in a list, but is a little cumbersome to write. `while` loops are useful, but can be tricky and it's easy to accidentally write a loop that behaves incorrectly, or doesn't terminate and runs forever.\n",
    "\n",
    "When iterating over a list or other structure, it's usually easier to use a `for` loop."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For loops\n",
    "\n",
    "For loops iterate over objects in a data structure, letting you perform an action on each:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "2\n",
      "4\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "my_list = [0, 1, 2, 3]\n",
    "for element in my_list:\n",
    "    print(element * 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Often we want to perform an action a set number of times. In this case it's easiest to use a for loop with a range object:\n",
    "\n",
    "Ranges are special objects which represent a series of integer values within a set range."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "range(0, 10)\n",
      "<class 'range'>\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "my_range = range(10) # This creates a range object \n",
    "print(my_range) # This range represents the integers from 0 to 10 (not including 10).\n",
    "print(type(my_range)) # Note that range objects have their own type.\n",
    "print(my_range[5]) # But you can index them like tuples.\n",
    "# Like tuples, they're immutable (so don't try to modify them like e.g. my_range[5] = 2)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Range objects are very convenient for running for loops over a range of integer values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 0 number == 4\n",
      "Iteration 1 number == 8\n",
      "Iteration 2 number == 16\n",
      "Iteration 3 number == 32\n",
      "Iteration 4 number == 64\n",
      "Iteration 5 number == 128\n",
      "Iteration 6 number == 256\n",
      "Iteration 7 number == 512\n",
      "Iteration 8 number == 1024\n",
      "Iteration 9 number == 2048\n",
      "2048\n"
     ]
    }
   ],
   "source": [
    "number = 2\n",
    "for i in range(10):\n",
    "    number *= 2 # This is shorthand for number = number * 2\n",
    "    print(\"Iteration\", i, \"number ==\", number)\n",
    "print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes you want to iterate over a list, but also want access to the index of each item in the list.\n",
    "\n",
    "You can get access to both using the `enumerate()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The list has value 5 at index 0\n",
      "The list has value 42 at index 1\n",
      "The list has value 78 at index 2\n",
      "The list has value 3 at index 3\n"
     ]
    }
   ],
   "source": [
    "my_list = [5, 42, 78, 3]\n",
    "for index, value in enumerate(my_list):\n",
    "    print(\"The list has value\", value, \"at index\", index)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also iterate over a dict object, but remember that dicts contain key-value pairs.\n",
    "\n",
    "Doing a basic for loop will iterate over the keys:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The key a maps to the value hello\n",
      "The key b maps to the value 20\n"
     ]
    }
   ],
   "source": [
    "my_dict = {\"a\": \"hello\", \"b\": 20}\n",
    "for key in my_dict:\n",
    "    print(\"The key\", key, \"maps to the value\", my_dict[key])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are alternatives, for example using the `.items()` method of the dict, we can iterate over keys and values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The key a maps to the value hello\n",
      "The key b maps to the value 20\n"
     ]
    }
   ],
   "source": [
    "my_dict = {\"a\": \"hello\", \"b\": 20}\n",
    "for key, value in my_dict.items():\n",
    "    print(\"The key\", key, \"maps to the value\", value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's important to remember there are no guarantees about what **order** the dictionary's key-value pairs will be returned in. It won't necessarily be in alphabetical order of keys, or the order you created or added items to the dict in."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The keywords `break` and `continue` can be used to change the normal flow of a `while` or `for` loop.\n",
    "\n",
    "When the `break` statement is executed, it immediately leaves the current loop, and does not execute any of the remaining iterations.\n",
    "\n",
    "When the `continue` statement is executed, it skips to the next iteration of the loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start of while loop\n",
      "Start of for loop iteration 0\n",
      "Start of for loop iteration 1\n",
      "Start of for loop iteration 2\n"
     ]
    }
   ],
   "source": [
    "while(True): # Normally a while(True) loop would continue executing forever...\n",
    "    print(\"Start of while loop\")\n",
    "    break # But the break statement causes it to exit after one loop.\n",
    "    print(\"End of while loop\") # Because it exits immediately, this isn't executed.\n",
    "\n",
    "for i in range(3):\n",
    "    print(\"Start of for loop iteration\", i)\n",
    "    continue # This skips the remaining statements in the current loop\n",
    "    print(\"End of for loop iteration\", i) # Because of the continue statement, this will never be executed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`break` and `continue` can be useful, but can also make code harder to follow, so should be used sparingly."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise: The Fibonnacci Sequence\n",
    "\n",
    "You might be familiar with the [Fibonnacci sequence](https://en.wikipedia.org/wiki/Fibonacci_number) - a sequence generated with a very simple update rule, with surprising links to biology and the natural world.\n",
    "\n",
    "This follows a very simple update rule - the first two terms are:\n",
    "\n",
    "`f_0 = 0`\n",
    "\n",
    "`f_1 = 1`\n",
    "\n",
    "The remaining terms are generated according to the rule:\n",
    "\n",
    "`f_n = f_n-1 + f_n-2`\n",
    "\n",
    "Write a script to generate all Fibonnacci numbers under 100 using a `while` loop. Then use a `for` loop to print the first 21 Fibonnacci numbers. Print each number in turn. You can use the table on [the Wikipedia page](https://en.wikipedia.org/wiki/Fibonacci_number) to check your code is correct."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_val = 100\n",
    "\n",
    "# Write code using a while loop to print out Fibonnacci numbers less than `max_val`:\n",
    "# Your code here...\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_vals = 21\n",
    "\n",
    "# Write code using a for loop to print out `num_vals` Fibonnacci numbers:\n",
    "# Your code here..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise: The Sieve of Erastosthenes\n",
    "\n",
    "The [Sieve of Erastosthenes](https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes) is an extremely old (2000 years +) algorithm to find all prime numbers below a given number. The name refers to how it starts with a list of all integers under a certain value, and gradually eliminates non-prime numbers from the list (sifting them out, like using a sieve).\n",
    "\n",
    "Try to implement the Sieve of Erastosthenes, and find all prime numbers under 30. See the [wikipedia page](https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes) for a description of the algorithm\n",
    "\n",
    "Here are some tips to get you started:\n",
    "\n",
    "* To check if one number divides another, use the modulo operator `%`. For example, if `a` is divisible by `b`, then `a % b == 0` will be `True`.\n",
    "* I'd suggest keeping a list indicating which numbers are maybe prime, and which you've eliminated. This could be a list of boolean values, which start off as all `True`.\n",
    "* As the wikipedia page notes, you can stop once your divisor is at least `sqrt(30)` (use the `math.sqrt()` function, you'll have to `import math` first).\n",
    "\n",
    "Your answer should be 2, 3, 5, 7, 11, 13, 17, 19, 23, 29. Once your code works, try increasing max_val to generate more primes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prime numbers under 30:\n",
      "[2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30]\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "max_val = 30\n",
    "\n",
    "# Implement the Sieve of Erastosthenes\n",
    "number_is_prime = [True for i in range(max_val + 1)] # This makes a List containting 31 True values. See List comprehensions below for more detail.\n",
    "\n",
    "# 0 and 1 are not prime, set these to false\n",
    "number_is_prime[0] = False \n",
    "number_is_prime[1] = False  \n",
    "\n",
    "# Implement the algorithm here, and set the other non-prime values to False\n",
    "# Your code here...\n",
    "\n",
    "# Print out your results\n",
    "print(\"Prime numbers under %d:\" % max_val)\n",
    "print([i for i in range(len(number_is_prime)) if number_is_prime[i]]) # This uses a list comprehension - see later in this notebook for more info."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### If statements\n",
    "\n",
    "If statements are used to execute code only if a condition is met. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Value is less than 20\n"
     ]
    }
   ],
   "source": [
    "value = 10 * 40 / 30\n",
    "if value < 20:\n",
    "    print(\"Value is less than 20\")\n",
    "else:\n",
    "    print(\"Value is not less than 20\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `else` code will only execute if the condition in `if` is `False`.\n",
    "\n",
    "You can make more complex tests by using `elif` (short for else if):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Value is greater than 1\n"
     ]
    }
   ],
   "source": [
    "value = 5.5 * 1.5 / 4.5\n",
    "if value > 1:\n",
    "    print(\"Value is greater than 1\")\n",
    "elif value > 0:\n",
    "    print(\"Value is between 0 and 1\")\n",
    "else:\n",
    "    print(\"Value is less than or equal to 0\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can test multiple different conditions in an if statement using logical operators like `and`, `or` etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Both value_a and value_b are multiples of 4.\n"
     ]
    }
   ],
   "source": [
    "value_a = (6 * 14)\n",
    "value_b = (18 * 8)\n",
    "if value_a % 4 == 0 and value_b % 4 == 0:\n",
    "    print(\"Both value_a and value_b are multiples of 4.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions\n",
    "\n",
    "Functions are a useful way to wrap up code that you plan to use frequently, and make code more structured and easy to understand and change.\n",
    "\n",
    "A function takes a number of inputs (called arguments) and returns zero or more values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "def multiply_by_two(number):\n",
    "    return number * 2\n",
    "\n",
    "my_number = 4\n",
    "print(multiply_by_two(my_number))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If your function doesn't return anything (it doesn't have a `return` statement) it will return `None` by default.\n",
    "\n",
    "Here we're defining a function that waits for 1 second before completing. The function we need to do this is contained in the `time` package, which is built in to python. To use it, we need to import it first, using `import time`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "def wait_one_second():\n",
    "    time.sleep(1.0)\n",
    "\n",
    "print(wait_one_second())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions can return more than one value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 3\n"
     ]
    }
   ],
   "source": [
    "def get_first_and_last_element(my_list):\n",
    "    return my_list[0], my_list[-1]\n",
    "\n",
    "my_list = [0, 1, 2, 3]\n",
    "first, last = get_first_and_last_element(my_list)\n",
    "print(first, last)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions can also have keyword arguments. These are handy because they can be assigned default values, meaning if a function has lots of arguments you don't need to set all of them. They also make code easier to follow when calling the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.2869703307801985\n",
      "107051.08900137029\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "def gaussian(x, sigma=1.0, mu=0.0):\n",
    "    scale = 1.0 / (sigma * math.sqrt(2.0 * math.pi))\n",
    "    return scale * math.exp(-0.5 * (x - mu) * (x - mu) / (sigma * sigma))\n",
    "\n",
    "a = gaussian(10, sigma=5, mu=2) # You can supply all the arguments\n",
    "print(a)\n",
    "\n",
    "b = gaussian(5) #Or you can skip any that have a default value, and the default value will be used\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Other useful techniques"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Formatting strings\n",
    "\n",
    "If you want to print out a number of values, it can be helpful to use python's string formatting to get them into the format you want."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This string contains variables a 10, b 1.500000 and c hello\n"
     ]
    }
   ],
   "source": [
    "a = 10\n",
    "b = 1.5\n",
    "c = \"hello\"\n",
    "\n",
    "formatted_string = \"This string contains variables a %d, b %f and c %s\" % (a, b, c)\n",
    "\n",
    "print(formatted_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the special values you insert into the string depend on the type of data you want to show:\n",
    "* `%d` for integer values (stands for \"decimal\")\n",
    "* `%f` for floating-point values \n",
    "* `%s` for strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When printing floating point values, you can change the formatting to choose how many decimal points to display:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Default format 1.414214\n",
      "10 decimal places 1.4142135624\n",
      "20 decimal places 1.41421356237309514547\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "a = math.sqrt(2)\n",
    "print(\"Default format %f\" % a)\n",
    "print(\"10 decimal places %0.10f\" % a)\n",
    "print(\"20 decimal places %0.20f\" % a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List comprehensions\n",
    "\n",
    "List comprehensions are a quick, compact way to create lists. The syntax is similar to a for loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 4, 8, 16, 32, 64, 128, 256, 512]\n",
      "[1, 2, 4, 8, 16, 32, 64, 128, 256, 512]\n",
      "['A', 'B']\n"
     ]
    }
   ],
   "source": [
    "# This is a list comprehension\n",
    "# It creates an list, powers_of_two. The syntax shows what to assign to each element in the list.\n",
    "# Note that ** means power, e.g. 2**2 == 4\n",
    "powers_of_two = [2**i for i in range(10)]\n",
    "print(powers_of_two)\n",
    "\n",
    "# This is the same as:\n",
    "powers_of_two = []\n",
    "for i in range(10):\n",
    "    powers_of_two.append(2**i)\n",
    "\n",
    "print(powers_of_two)\n",
    "# So list comprehensions are really just a shorthand for a for loop like this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['A', 'B']\n",
      "['A', 'B']\n"
     ]
    }
   ],
   "source": [
    "#Here is another example. Note that name[0] takes the first character of the string name.\n",
    "names = [\"Alice\", \"Bob\"]\n",
    "first_initials = [name[0] for name in names]\n",
    "print(first_initials)\n",
    "\n",
    "# Again, this is equivalent to:\n",
    "first_initials = []\n",
    "for name in names:\n",
    "    first_initials.append(name[0])\n",
    "print(first_initials)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also add conditional statements to list comprehensions (they go at the end):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 2, 4, 6, 8]\n"
     ]
    }
   ],
   "source": [
    "# This makes a list of all even numbers less than 10:\n",
    "even_numbers = [i for i in range(10) if i % 2 == 0]\n",
    "# Note that numbers are only added to the list if they satisfy the conditional statement\n",
    "# i.e. if i % 2 == 0 evaluates to True.\n",
    "print(even_numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Further Reading\n",
    "\n",
    "There are many more elements to the Python language that we haven't had time to cover in this short introduction. One of the most useful are classes, which provide a way to group data and code, allowing for better organisation and code reuse.\n",
    "\n",
    "If you'd like to know more about classes, or other topics in the language, I'd recommend the [official python tutorial](https://docs.python.org/3/tutorial/index.html). The section introducing classes is [here](https://docs.python.org/3/tutorial/classes.html).\n",
    "\n",
    "Particularly if you work on python code in a group, or professionally, it can be helpful to stick to some guidelines for the style and formatting of your code. The official style guide, [PEP-8](https://peps.python.org/pep-0008/) is widely used, and a good place to start learning. \n",
    "\n",
    "If you work on a bigger project in python, you'll want to split your code between multiple files, and probably split those files up into directories. To learn how to do this I'd recommend the [python tutorial on Modules and Packages](https://docs.python.org/3/tutorial/modules.html). I'd also look up how to [install packages using pip](https://docs.python.org/3/tutorial/venv.html#managing-packages-with-pip) (or potentially [conda](https://docs.conda.io/projects/conda/en/latest/user-guide/concepts/installing-with-conda.html) if you're using it).\n",
    "\n",
    "We discussed the use of `enumerate()` in `for` loops above - there is also a somewhat similar function `zip()` which allows a for loop to iterate over two lists simultaneously. There is more information on this [in the documentation here](https://docs.python.org/3/library/functions.html#zip).\n",
    "\n",
    "String formatting can also be achieved with the `string.format()` method, rather than the `%` operator. For more details on how to use `string.format()` see the [documentation here](https://docs.python.org/3/library/string.html#formatstrings)."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.8.5 ('base')",
   "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.8.5"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "c921a71fa7d5301530abc76a09084737c3fca4b7328b11bbb5dba4e94f78eaed"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}