Workshop 3 - Python basics - model answers.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## INTRO\n",
    "## WELCOME TO THE FIRST JUPYTER NOTEBOOK OF THE CORNDEL ANALYTICS DIPLOMA\n",
    "\n",
    "# First let's take the time to familiarise yourself with the layout...\n",
    "#  - a Jupyter Notebook is divided into cells (boxes)\n",
    "#  - in this workbook, we have titled cells\n",
    "#  - for example, the title of this cell is \"INTRO\"\n",
    "#  - at the top are buttons that are used to:\n",
    "#      - save progress;\n",
    "#      - add a new cell;\n",
    "#      - cut/copy/paste cells;\n",
    "#      - move cells up/down in the running order;\n",
    "#      - run code;\n",
    "#      - stop code;\n",
    "#      - resart the kernel; and\n",
    "#      - choose whether the cell should be used as markdown or to write code.\n",
    "\n",
    "# The current cell is set up for writing code but we have used it exclusively for comments\n",
    "# Comments are lines of text that don't actually do anything\n",
    "# We use the '#' symbol to indicate to the machine when we want text to be a comment\n",
    "\n",
    "# The next cell is set up as 'markdown'\n",
    "# This means that it looks like a heading rather than a block of code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## FIRST FUNCTION\n",
    "## CHECKING YOUR ANSWERS\n",
    "\n",
    "# A function in Python is a device that takes certain inputs (or arguments)\n",
    "#  and uses them to produce an output.\n",
    "# We will meet several functions throughout the day.\n",
    "\n",
    "# However, we first want to introduce the 'check' function developed exclusively for this workshop:\n",
    "#  the check function can be used to check your answers to he various tasks listed below.\n",
    "# The argument that it takes is the Task Number, and this is entered inside the parentheses.\n",
    "\n",
    "# For example, to check that you have completed Task 1 correctly,\n",
    "#  you would write:\n",
    "\n",
    "# check(1)\n",
    "\n",
    "# To get this function working you first need to run the last block of code in this document.\n",
    "# Then you can return back to this point and continue reading..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## ASSIGNING A VARIABLE\n",
    "# Let's create a new variable and set its value as 1\n",
    "my_first_variable = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## ID FUNCTION\n",
    "# The id() function tells me what ID Python is using to refer to this variable\n",
    "id(my_first_variable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## TYPE FUNCTION\n",
    "# The type() function tells me what data type it contains\n",
    "type(my_first_variable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ** Task 1 ** #\n",
    "# In the space provided create a new variable called 'my_new_variable' and set its value equal to 2\n",
    "# --------------------------------------------------- #\n",
    "\n",
    "my_new_variable = 2\n",
    "\n",
    "# --------------------------------------------------- #"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "check(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## THE DATA TYPES\n",
    "# There are 6 main data types that we use in Python.\n",
    "# In this workshop, we will concentrate on only three types: numbers, strings, lists\n",
    "# We have also shown some examples of the other 3 types below but we will not need these\n",
    "\n",
    "# numbers:\n",
    "a = 4\n",
    "a = 5.8\n",
    "\n",
    "# strings\n",
    "a = 'a string using single quotes'\n",
    "a = \"a string using double quotes\"\n",
    "a = \"\"\"a sting using\n",
    "       three double\n",
    "       quotes\"\"\"\n",
    "\n",
    "# lists\n",
    "a = [4,5.8,'a string']\n",
    "\n",
    "# tuples\n",
    "# a = (4,5.8,'a string using single quotes')\n",
    "\n",
    "# dictionaries\n",
    "# a = {'key1':25, 'key2':8}\n",
    "# a = {'key1':'large', 'key2':'small'}\n",
    "\n",
    "# files (the code below doesn't work because the file does not exist)\n",
    "# a = open('test.csv',r')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ** Task 2 ** #\n",
    "# In the space provided create:\n",
    "#  - a variable called 't2_int' containing an integer\n",
    "#  - a variable called 't2_float' containing a non-integer numeric value\n",
    "#  - a variable called 't2_string' containing a string of at least 20 characters\n",
    "#  - a variable called 't2_list' containing exactly 5 elements\n",
    "# --------------------------------------------------- #\n",
    "\n",
    "t2_int = 8\n",
    "t2_float = 5.55\n",
    "t2_string = 'abcdefghijklmnopqrst'\n",
    "t2_list = [2, 3, t2_int, t2_string, 4.5]\n",
    "\n",
    "# --------------------------------------------------- #"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "check(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ** Task 3 ** #\n",
    "# Give t2_float a new value so that it has the string data type\n",
    "# --------------------------------------------------- #\n",
    "\n",
    "t2_float = 'now a string'\n",
    "print(type(t2_float))\n",
    "\n",
    "# --------------------------------------------------- #"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "check(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Expressions & Statements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## EXPRESSIONS & STATEMENTS\n",
    "# An expression is a combination of values, variables and operators\n",
    "#  - e.g. \"6 + 8\" is an expression\n",
    "# An expression by itself does not anything,\n",
    "#  although Python will usually display the value of the last expression listed in the code\n",
    "\n",
    "# A statement, or command, is a unit of code that can be executed by the Python interpreter\n",
    "#  - e.g. \"a = 6 + 8\" is a statement\n",
    "\n",
    "a = 5 - 9   # This is a statement and will be executed by the interpreter\n",
    "99 / 23     # This expression will not be displayed\n",
    "56 + 44     # This expression will be displayed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## PRINT FUNCTION\n",
    "# We can also use the print fucntion, which acts as a statement, to display values\n",
    "print(a)\n",
    "print(90 / 40)\n",
    "print(56 + 44)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## OPERATORS IN PYTHON\n",
    "\n",
    "# Mathematical operators: +, -, *, /, //, %\n",
    "a = 6 + 8\n",
    "b = 14 / 2\n",
    "c = 7 % 5\n",
    "d = 14 // 4\n",
    "\n",
    "# String operators: +, *\n",
    "e = 'E'\n",
    "f = 'F'\n",
    "g = 'E' + 'F'\n",
    "h = 'F' * 3\n",
    "i = 'F' * a\n",
    "\n",
    "# Comparison operators: ==, !=, <, >, <=, >=\n",
    "a == b + 7\n",
    "a < c\n",
    "d >= a\n",
    "g == 'FE'\n",
    "\n",
    "# Logical operators: and, &, or, |, not\n",
    "(14 == 7 + 7) and (3 == 6 / 2)\n",
    "(5 == 2 + 7) & (3 == 6 / 2)\n",
    "(5 == 2 + 3) or (g == 'FE')\n",
    "(5 == b + 5) | (g == 'FE')\n",
    "not (g == 'FE')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ** Task 4 ** #\n",
    "# Experiment with each type of operator. Can you work out what they all do?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "check(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ** Task 5 ** #\n",
    "# Use variables x, y, z respectively to contain the answers to the following calculations:\n",
    "#  x - 700 / 699\n",
    "#  y - The remainder when 999900001111 is divided by 901\n",
    "#  z - The string '5' repeated 137 times\n",
    "# --------------------------------------------------- #\n",
    "\n",
    "x = 700 / 699\n",
    "print(x)\n",
    "\n",
    "y = 999900001111 % 901\n",
    "print(y)\n",
    "\n",
    "z = '5' * 137\n",
    "print(z)\n",
    "\n",
    "# --------------------------------------------------- #"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "check(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Some simple methods and functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## PRINT\n",
    "# The print() function outputs a value to be displayed within the Jupyter Notebook\n",
    "\n",
    "print('This is some text')\n",
    "a = 'This is some more text'\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## INDEXING\n",
    "# We can refer to the Nth element in a list or tuple by using square brackets []\n",
    "\n",
    "my_list = [4,5.8,'a string using single quotes']\n",
    "print(my_list[0])\n",
    "print(my_list[1])\n",
    "print(my_list[0:2])\n",
    "print(my_list[0:3])\n",
    "print(my_list[2][2:8])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## CHANGING DATA TYPE\n",
    "# We can change a variable from one type to another using the following functions:\n",
    "#  - str()\n",
    "#  - float()\n",
    "#  - int()\n",
    "\n",
    "# For example:\n",
    "a = str(1001)\n",
    "print(a*2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Another example\n",
    "a = int(5.55)\n",
    "print(a*2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# And another example\n",
    "a = float('5'+'4.5')\n",
    "print(a*2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ** Task 6 ** #\n",
    "# Earlier, we created three variables 'x', 'y', 'z'. We will use them for this task.\n",
    "# Run check(5) to make sure that they still have the right values.\n",
    "#  - create a variable called 'new_x' which contains 'x' but converted to string type\n",
    "#  - create a variable called 'new_y' which contains 'y' but converted to float type\n",
    "#  - create a variable called 'new_z' which contains 'z' but converted to integer type and then divided by 5\n",
    "# --------------------------------------------------- #\n",
    "\n",
    "new_x = str(x)\n",
    "new_y = float(y)\n",
    "new_z = int(z) / 5\n",
    "\n",
    "# --------------------------------------------------- #"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "check(6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ** Task 7 ** #\n",
    "# Can you find values which produce an error when used inside the int(), float(), and str() functions?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "int('string')\n",
    "float('4.5')\n",
    "str(8.665) # Haven't found anything (does not mean it isn't possible)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "check(7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ** Task 8 ** #\n",
    "# Earlier, we created a list with exactly 5 elements called 't2_list'.\n",
    "# Assign values to 2 new variables based on whatever values you chose earlier:\n",
    "#  - create a variable called 'list_4' which contains the 4th element of 't2_list'\n",
    "#  - create a variable called 'list_sub' which contains the last three elements of 't2_list'\n",
    "# --------------------------------------------------- #\n",
    "\n",
    "list_4 = t2_list[3]\n",
    "list_sub = t2_list[-3:]\n",
    "\n",
    "# --------------------------------------------------- #"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "check(8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ** Task 9 ** #\n",
    "# A variable called 'long_string' is created below, and is assigned a value.\n",
    "# Use the space provided to create a new variable called 'one_letter'\n",
    "#  that contains the 68th letter in the string.\n",
    "\n",
    "long_string = \"\"\"\n",
    "sdkljafvvv asdfasldkfnmsd 'sgset#'43tsgdsvp,lqw3fv\n",
    "24p-0[vf;sdf.q234sv'8ew486,h-n sd;1]sdfgvk,gv944ej\n",
    "lllppppe342fvsdk1nnnnnasdf''t8;##af2lwr5ds#''#sd'd\"\"\"\n",
    "\n",
    "# --------------------------------------------------- #\n",
    "\n",
    "one_letter = long_string[67]\n",
    "\n",
    "# --------------------------------------------------- #"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "check(9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pseudo code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## PSEUDO CODE\n",
    "# Pseudo code is a false code or a representation of code which can be\n",
    "#   understood by even a layman with some school level programming knowledge\n",
    "\n",
    "# Below is an example of pseudo-code used to calculate N! (1 x 2 x ... x N)\n",
    "\n",
    "## -------------------------------------------------------------------- ##\n",
    "# PSEUDO CODE EXAMPLE\n",
    "\n",
    "Set N equal to 12\n",
    "Set A equal to 1\n",
    "Set I equal to 1\n",
    "\n",
    "For as long as I is less than or equal to N, do the following steps:\n",
    "    Set A equal to itself multiplied by I\n",
    "    Increase the value of I by 1\n",
    "    \n",
    "Print the value of A\n",
    "\n",
    "## -------------------------------------------------------------------- ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![title](flowexample.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ** Task 10 ** #\n",
    "# Form a pair with somebody else in the group.\n",
    "# Consider the two pieces of pseudo-code below and pick one piece each.\n",
    "# Spend some time to understand how the code works, perhaps creating your own flow chart.\n",
    "# Take it in turns to each explain your piece of pseudo-code to your partner."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## -------------------------------------------------------------------- ##\n",
    "# PSEUDO CODE 1\n",
    "# This is a function for calculating compound interest, \n",
    "#  given an initial bankroll, an interest rate, and  time period\n",
    "\n",
    "Whenever the keyword \"CompInt\" is written, complete the following steps for three inputs, B, I, and T:\n",
    "\n",
    "    Set MULTIPLIER equal to 1 plus I\n",
    "    Set TOTAL_MULTIPLIER equal to MULTIPLIER to the power of T\n",
    "    Set FINAL_OUTPUT equal to B multiplied by TOTAL_MULTIPLIER\n",
    "    \n",
    "    Print the value of FINAL_OUTPUT\n",
    "\n",
    "CompInt for B = 100, I = 0.1, T = 3\n",
    "\n",
    "## -------------------------------------------------------------------- ##\n",
    "# PSEUDO CODE 2\n",
    "# This is for listing all the prime numbers between 11 and 250\n",
    "#  a prime number is an integer which only has two divisors: itself and one\n",
    "\n",
    "Set START equal to 11\n",
    "Set END equal to 250\n",
    "\n",
    "For all integers (I) between START and END, inclusive, complete the following steps:\n",
    "\n",
    "    If the value I is greater than 1, then do the following steps:\n",
    "    \n",
    "        For all integers (J) greater than 1 and less than I, complete the following steps:\n",
    "            If I is not divisible by J then continue\n",
    "            Otherwise stop and do not follow any more steps\n",
    "\n",
    "        Print the value of I\n",
    "\n",
    "## -------------------------------------------------------------------- ##"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ** Task 11 ** #\n",
    "# Either in your pair, or by yourself, work out what the piece of pseudo-code below does.\n",
    "# What would the final result be?\n",
    "# You can check your answer by creating a variable called 'answer'\n",
    "#  with the value that you think is correct, and then use the check() function.\n",
    "\n",
    "## -------------------------------------------------------------------- ##\n",
    "# PSEUDO CODE 3\n",
    "\n",
    "Set N equal to 245\n",
    "\n",
    "Repeat the following steps until the STOP instruction is reached:\n",
    "\n",
    "    If N is even then do the following step:\n",
    "        Set N equal to N divided by 2\n",
    "    \n",
    "    Otherwise, if N is odd then do the following steps:\n",
    "        If the first digit of the number either a 1, 3, 5, 7 or 9 then do the following step:\n",
    "            STOP\n",
    "        Otherwise, do the following step:\n",
    "            Set N equal to itself but with the digits reversed (e.g. 456 becomes 654)\n",
    "        \n",
    "Print the value of N\n",
    "\n",
    "## -------------------------------------------------------------------- ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## IF statements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## IF STATEMENTS\n",
    "# If statements are used to divide code into separate blocks\n",
    "#  which are only run if a specified condition is True\n",
    "\n",
    "test_integer = 169\n",
    "test_divisor = 13\n",
    "\n",
    "if test_integer % test_divisor == 0:\n",
    "    print(str(test_integer)+' divides '+str(test_divisor))\n",
    "\n",
    "elif test_integer % 11 == 0:\n",
    "    print(str(test_integer)+' divides 11')\n",
    "    \n",
    "else:\n",
    "    print(str(test_integer)+' does not divide either 11 or '+str(test_divisor))\n",
    "\n",
    "# Note who we used indentation (the tab key) to diffentiate\n",
    "# blocks of code that are dependent on an IF statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ** Task 12 ** #\n",
    "# In the space provided below,\n",
    "#  complete the skeleton code below to produce an algorithm\n",
    "#  which checks whether a string variable called 'input_string'\n",
    "#  starts with the letter 'a' and prints \"True\" if it does.\n",
    "\n",
    "## -------------------------------------------------------------------- ##\n",
    "\n",
    "input_string = '<type some text here>'\n",
    "\n",
    "if input_string[0] == 'a':\n",
    "    print('True')\n",
    "\n",
    "## -------------------------------------------------------------------- ##"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "check(12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ** Task 13 ** #\n",
    "# In the space provided below,\n",
    "#  complete the skeleton code below to produce an algorithm\n",
    "#  which checks whether the length of string variable\n",
    "#  called 'input_string' is more than 20 characters.\n",
    "#  If it is, print the length of the string,\n",
    "#  if it is not, print, 'the string is not long enough'.\n",
    "\n",
    "## -------------------------------------------------------------------- ##\n",
    "\n",
    "input_string = '<type some text here>'\n",
    "\n",
    "if len(input_string) > 20:\n",
    "    print(len(input_string))\n",
    "else:\n",
    "    print('the string is not long enough')\n",
    "\n",
    "## -------------------------------------------------------------------- ##"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "check(13)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## FOR loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## FOR LOOPS\n",
    "# For statements are used to loop through values and perform a block of code\n",
    "#  sequentially for each value\n",
    "\n",
    "test_string = \"The for loop below will print each letter of this string individually\"\n",
    "\n",
    "for i in range(0,len(test_string)):\n",
    "    if i%8 == 0:\n",
    "        print(test_string[i])\n",
    "\n",
    "# Note who we used indentation (the tab key) to diffentiate\n",
    "# blocks of code that are executed within a FOR loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ** Task 14 ** #\n",
    "# In the space provided below,\n",
    "#  complete the skeleton code below to produce an algorithm\n",
    "#  which prints each of the first 20 square numbers (1, 4, 9, 16, ...).\n",
    "\n",
    "## -------------------------------------------------------------------- ##\n",
    "\n",
    "for i in range(1,21):\n",
    "    print(i * i)\n",
    "    \n",
    "for i in range(1,21):\n",
    "    print(i ** 2)\n",
    "\n",
    "## -------------------------------------------------------------------- ##"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "check(14)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ** Task 15 ** #\n",
    "# In the space provided below,\n",
    "#  complete the skeleton code below to produce an algorithm\n",
    "#  which loops through all of the elements in the list variable called 'list_1'\n",
    "#  and prints each element that begins with the letter 'p'.\n",
    "\n",
    "list_1 = ['albania','portugal','pakistan','moldova','chile','brazil','paraguay','canada',\n",
    "          'panama','indonesia','philippines','new zealand','palestine','papua new guinea']\n",
    "\n",
    "## -------------------------------------------------------------------- ##\n",
    "\n",
    "for i in range(0,len(list_1)):\n",
    "    z = list_1[i]\n",
    "    if z[0] = 'p':\n",
    "        print(z)\n",
    "\n",
    "for i in range(0,len(list_1)):\n",
    "    if list_1[i][0] = 'p':\n",
    "        print(list_1[i])\n",
    "        \n",
    "for i in list_1:\n",
    "    if i[0] = 'p':\n",
    "        print(i)\n",
    "\n",
    "## -------------------------------------------------------------------- ##"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "check(15)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## OPTIONAL TASKS\n",
    "\n",
    "# 16. Write some code which loops through and prints every even number\n",
    "#     between two specified numbers (you do not necessarily need an IF statement)\n",
    "\n",
    "start = 1\n",
    "end = 8\n",
    "for i in range(start,end+1):\n",
    "    if i%2 == 0:\n",
    "        print(i)\n",
    "\n",
    "# 17. Convert the three pieces of pseudo-code outlined above into Python code\n",
    "\n",
    "## PSEUDO EXAMPLE ##\n",
    "# Set N equal to 12\n",
    "# Set A equal to 1\n",
    "# Set I equal to 1\n",
    "\n",
    "# For as long as I is less than or equal to N, do the following steps:\n",
    "#     Set A equal to itself multiplied by I\n",
    "#     Increase the value of I by 1\n",
    "    \n",
    "# Print the value of A\n",
    "\n",
    "N = 12\n",
    "A = 1\n",
    "I = 1\n",
    "for i in range(0,N+1):\n",
    "    A *= I\n",
    "    \n",
    "## PSEUDO 1 ##\n",
    "\n",
    "# Whenever the keyword \"CompInt\" is written, complete the following steps for three inputs, B, I, and T:\n",
    "\n",
    "#     Set MULTIPLIER equal to 1 plus I\n",
    "#     Set TOTAL_MULTIPLIER equal to MULTIPLIER to the power of T\n",
    "#     Set FINAL_OUTPUT equal to B multiplied by TOTAL_MULTIPLIER\n",
    "    \n",
    "#     Print the value of FINAL_OUTPUT\n",
    "\n",
    "# CompInt for B = 100, I = 0.1, T = 3\n",
    "\n",
    "def CompInt(B, I, T):\n",
    "    MULTIPLIER = I + 1\n",
    "    TOTAL_MULTIPLIER = MULTIPLIER ** T\n",
    "    FINAL_OUTPUT = B * TOTAL_MULTIPLIER\n",
    "    print(FINAL_OUTPUT)\n",
    "\n",
    "CompInt(B = 100, I = 0.1, T = 3)\n",
    "\n",
    "## PSEUDO 2 ##\n",
    "\n",
    "# Set START equal to 11\n",
    "# Set END equal to 250\n",
    "\n",
    "# For all integers (I) between START and END, inclusive, complete the following steps:\n",
    "\n",
    "#     If the value I is greater than 1, then do the following steps:\n",
    "    \n",
    "#         For all integers (J) greater than 1 and less than I, complete the following steps:\n",
    "#             If I is not divisible by J then continue\n",
    "#             Otherwise stop and do not follow any more steps\n",
    "\n",
    "#         Print the value of I\n",
    "\n",
    "START = 11\n",
    "END = 250\n",
    "for i in range(START,END+1):\n",
    "    if i > 1:\n",
    "        check = 0\n",
    "        for j in range(2,i):\n",
    "            if i % j == 0:\n",
    "                check += 1\n",
    "        if check == 0:\n",
    "            print(i)\n",
    "            \n",
    "## PSEUDO CODE 3 ##\n",
    "\n",
    "# Set N equal to 245\n",
    "\n",
    "# Repeat the following steps until the STOP instruction is reached:\n",
    "\n",
    "#     If N is even then do the following step:\n",
    "#         Set N equal to N divided by 2\n",
    "    \n",
    "#     Otherwise, if N is odd then do the following steps:\n",
    "#         If the first digit of the number either a 1, 3, 5, 7 or 9 then do the following step:\n",
    "#             STOP\n",
    "#         Otherwise, do the following step:\n",
    "#             Set N equal to itself but with the digits reversed (e.g. 456 becomes 654)\n",
    "        \n",
    "# Print the value of N\n",
    "\n",
    "N = 245\n",
    "STOP = 0\n",
    "while STOP == 0:\n",
    "    if N % 2 == 0:\n",
    "        N /= 2\n",
    "    elif str(N)[0] in ['1','3','5','7','9']:\n",
    "        STOP = 1\n",
    "    else:\n",
    "        N = int(str(int(N))[::-1])\n",
    "print(N)\n",
    "\n",
    "# 18. Write some code which checks whether a string is a palindrome\n",
    "#     Palindrome means that it reads the same forwards as it does backwards\n",
    "\n",
    "string_to_check = '33383233'\n",
    "\n",
    "reverse_string = ''\n",
    "for i in range(0,len(string_to_check)):\n",
    "    reverse_string = reverse_string + string_to_check[-i-1]\n",
    "    \n",
    "if string_to_check == reverse_string:\n",
    "    print('PALINDROME')\n",
    "\n",
    "# 19. The largest palindromic number made from multiplying two 2-digit numbers is 9009 (= 91 x 99)\n",
    "#     Find the largest palindromic number made from multiplying two 3-digit numbers\n",
    "#     You can check your answer by creating a variable called 'answer'\n",
    "#     with the value that you think is correct, and then use the check() function\n",
    "\n",
    "biggest = 0\n",
    "for i in range(100,1000):\n",
    "    for j in range(100,1000):\n",
    "        product = str(i * j)\n",
    "        reverse_product = ''\n",
    "        for x in range(0,len(product)):\n",
    "            reverse_product = reverse_product + product[-x-1]\n",
    "        if (product == reverse_product) & (i*j > biggest):\n",
    "            biggest = i * j\n",
    "answer = biggest\n",
    "\n",
    "check(19)\n",
    "\n",
    "# 20. Write code which randomly simulates a knock-out tournament between 8 participants\n",
    "#     you might need to import the random package, as shown below\n",
    "\n",
    "import random as rd\n",
    "participants = ['Bjorn Borg','Usain Bolt','Man United','Chicago Bulls','Japan','Wasps','Bobby Fisher','Ayrton Senna']\n",
    "\n",
    "def knockout_round(p_list):\n",
    "    new_p_list = list()\n",
    "    for i in range(0,int(len(p_list)/2)):\n",
    "        rnd = rd.random()\n",
    "        if rnd < 0.5:\n",
    "            new_p_list.append(p_list[i*2])\n",
    "        else:\n",
    "            new_p_list.append(p_list[i*2+1])\n",
    "    print(new_p_list)\n",
    "    return(new_p_list)\n",
    "\n",
    "while len(participants) > 1:\n",
    "    participants = knockout_round(participants)\n",
    "\n",
    "print('And the winner is...')\n",
    "print(participants[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importing a package"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## IMPORT RANDOM\n",
    "# Python has many in-built packages for particular purposes\n",
    "# But these packages are not automatically available when you start Python\n",
    "# You need to import the package first\n",
    "\n",
    "# The code below imports a package called \"random\"\n",
    "import random\n",
    "\n",
    "# The random package has several functions including the following:\n",
    "a = random.randint(1, 100)\n",
    "b = random.randrange(1, 9, step = 2)\n",
    "c = random.choice(['A','E','I','O','U'])\n",
    "d = random.random()\n",
    "\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can also import the package with an alias to simplify the code:\n",
    "import random as rd\n",
    "print(rd.random())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## OPTIONAL TASKS\n",
    "\n",
    "# 21. Work out what each of the random functions listed above does.\n",
    "# 22. Which might be useful when simulating a knock-out tournament?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "check(21)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "check(22)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CHECK FUNCTION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## CHECK FUNCTION\n",
    "congrats_list = ['Boom! Well done','You got it right','100% correct','Excellent','You are the best.']\n",
    "\n",
    "def congrats(i):\n",
    "    print(congrats_list[i%5])\n",
    "\n",
    "def check(q_num):\n",
    "    \n",
    "    if q_num == 1:\n",
    "        try:\n",
    "            if my_new_variable == 2:\n",
    "                congrats(q_num)\n",
    "            else:\n",
    "                print('not quite')\n",
    "        except:\n",
    "            print('not quite')\n",
    "            \n",
    "    elif q_num == 2:\n",
    "        try:\n",
    "            counter = 0\n",
    "            if type(t2_int) == int:\n",
    "                print('t2_int is correct')\n",
    "                counter += 1\n",
    "            if type(t2_float) == float:\n",
    "                print('t2_float is correct')\n",
    "                counter += 1\n",
    "            if (type(t2_string) == str) & (len(t2_string) >= 20):\n",
    "                print('t2_string is correct')\n",
    "                counter += 1\n",
    "            if (type(t2_list) == list) & (len(t2_list) == 5):\n",
    "                print('t2_list is correct')\n",
    "                counter += 1\n",
    "            if counter == 4:\n",
    "                congrats(q_num)\n",
    "            else:\n",
    "                print('not quite')\n",
    "        except:\n",
    "            print('not quite')\n",
    "    \n",
    "    elif q_num == 3:\n",
    "        try:\n",
    "            if type(t2_float) == str:\n",
    "                congrats(q_num)\n",
    "            else:\n",
    "                print('not quite')\n",
    "        except:\n",
    "            print('not quite')\n",
    "    \n",
    "    elif q_num == 4:\n",
    "        print('this is an exploratory task, there is no right/wrong')\n",
    "            \n",
    "    elif q_num == 5:\n",
    "        try:\n",
    "            counter = 0\n",
    "            if x == 700 / 699:\n",
    "                print('x is correct')\n",
    "                counter += 1\n",
    "            if y == 999900001111 % 901:\n",
    "                print('y is correct')\n",
    "                counter += 1\n",
    "            if z == '5' * 137:\n",
    "                print('z is correct')\n",
    "                counter += 1\n",
    "            if counter == 3:\n",
    "                congrats(q_num)\n",
    "            else:\n",
    "                print('not quite')\n",
    "        except:\n",
    "            print('not quite')\n",
    "            \n",
    "    elif q_num == 6:\n",
    "        try:\n",
    "            counter = 0\n",
    "            if new_x == str(700 / 699):\n",
    "                print('new_x is correct')\n",
    "                counter += 1\n",
    "            if new_y == float(999900001111 % 901):\n",
    "                print('new_y is correct')\n",
    "                counter += 1\n",
    "            if new_z == int('5' * 137) / 5:\n",
    "                print('new_z is correct')\n",
    "                counter += 1\n",
    "            if counter == 3:\n",
    "                congrats(q_num)\n",
    "            else:\n",
    "                print('not quite')\n",
    "        except:\n",
    "            print('not quite')\n",
    "    \n",
    "    elif q_num == 7:\n",
    "        print('this is an exploratory task, there is no right/wrong')\n",
    "    \n",
    "    elif q_num == 8:\n",
    "        try:\n",
    "            counter = 0\n",
    "            if list_4 == t2_list[3]:\n",
    "                print('list_4 is correct')\n",
    "                counter += 1\n",
    "            if list_sub == t2_list[2:5]:\n",
    "                print('list_sub is correct')\n",
    "                counter += 1\n",
    "            if counter == 2:\n",
    "                congrats(q_num)\n",
    "            else:\n",
    "                print('not quite')\n",
    "        except:\n",
    "            print('not quite')\n",
    "    \n",
    "    elif q_num == 9:\n",
    "        try:\n",
    "            if one_letter == '3':\n",
    "                congrats(q_num)\n",
    "            else:\n",
    "                print('not quite')\n",
    "        except:\n",
    "            print('not quite')\n",
    "    \n",
    "    elif q_num == 10:\n",
    "        print('this is an interpreting/explaining task, there is no right/wrong')\n",
    "    \n",
    "    elif q_num == 11:\n",
    "        try:\n",
    "            if answer == 17:\n",
    "                congrats(q_num)\n",
    "            else:\n",
    "                print('not quite')\n",
    "        except:\n",
    "            print('not quite')\n",
    "    \n",
    "    elif q_num == 12:\n",
    "        print('check with a facilitator if you need to confirm that your code is correct')\n",
    "    \n",
    "    elif q_num == 13:\n",
    "        print('check with a facilitator if you need to confirm that your code is correct')\n",
    "    \n",
    "    elif q_num == 14:\n",
    "        print('check with a facilitator if you need to confirm that your code is correct')\n",
    "    \n",
    "    elif q_num == 15:\n",
    "        print('check with a facilitator if you need to confirm that your code is correct')\n",
    "    \n",
    "    elif q_num == 16:\n",
    "        print('check with a facilitator if you need to confirm that your code is correct')\n",
    "    \n",
    "    elif q_num == 17:\n",
    "        print('check with a facilitator if you need to confirm that your code is correct')\n",
    "    \n",
    "    elif q_num == 18:\n",
    "        print('check with a facilitator if you need to confirm that your code is correct')\n",
    "    \n",
    "    elif q_num == 19:\n",
    "        try:\n",
    "            if answer == 906609:\n",
    "                congrats(q_num)\n",
    "            else:\n",
    "                print('not quite')\n",
    "        except:\n",
    "            print('not quite')\n",
    "    \n",
    "    elif q_num == 20:\n",
    "        print('check with a facilitator')\n",
    "    \n",
    "    elif q_num == 21:\n",
    "        print('check with a facilitator')\n",
    "    \n",
    "    elif q_num == 22:\n",
    "        print('check with a facilitator')\n",
    "            \n",
    "    else:\n",
    "        print('that task number does not exist')"
   ]
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}