Practical_1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Welcome! \n",
    "\n",
    "# Practical 1 - An introduction to data types, operations and loops\n",
    "\n",
    "Welcome to the first practical in our Python programming course. Over the course of this module we are going to take an applied approach to learning Python. We do this by working through examples of basic numerical computation to data input and analysis. We cannot teach you everything Python has to offer in this course, but we can give you a set of tools to begin your journey.\n",
    "\n",
    "In this practical we are going to cover some core operations most Python programs will have. This gives you chance to learn the syntax that the Python interpreter expects. Remember, learning to program is similar to learning any other language, including a general appreciation of what the hardware underneath the software is doing. This course will provide you with a number of templates to keep and maybe modify and re-use as you build up your own expanding library of examples.\n",
    "\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "<b>Objectives:</b> The objectives of todays practical are:\n",
    "\n",
    " - 1) [Understand how data types are represented and how to use common arithmetic operators](#Part1)\n",
    "      * [Exercise 1: Set the value of two new variables and print to screen](#Exercise1)\n",
    "      * [Exercise 2: Implement equations as combinations of arithmetic operators](#Exercise2)\n",
    " - 2) [Arrays and lists](#Part2)\n",
    "      * [Exercise 3: Add two more entries to a list and change an existing entry](#Exercise3)\n",
    " - 3) [Loops and conditional statements](#Part3)\n",
    "      * [Exercise 4: Cycling through arrays and modifying values](#Exercise4)\n",
    "\n",
    "Please note that you should not feel pressured to complete every exercise in class. These practicals are designed for you to take outside of class and continue working on them. Proposed solutions to all exercises can be found in the 'solutions' folder.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "<b>Please note:</b> After reading the instructions and aims of any exercise, search the code snippets for a note that reads ------'INSERT CODE HERE'------ to identify where you need to write your code \n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1) Understand how data types are represented in Python <a name=\"Part1\">\n",
    "\n",
    "In the following section we will see how both numeric and string variables are handled and manipulated. For this, we will first look at the type of variables we work with and then how they are stored and processed.\n",
    "\n",
    "### Numbers (integers, floats and complex numbers):\n",
    "\n",
    "As per the official Python documentation, there are three distinct numeric types: \n",
    "\n",
    " - integers\n",
    " - floating point numbers\n",
    " - complex numbers. \n",
    " \n",
    "We talk briefly about this during the lectures, and will revisit this in more detail as we move into our course. Integers have unlimited precision in that you could use an integer with a growing number of digits that would be limited by the memory on your machine. Floating point numbers are usually implemented using double precision. Complex numbers have a real and imaginary part, which are each a floating point number. Let us see what this means using our first bit of code. In the following 'code box' I'm going to use three variables <code> x,y and z </code> and assign them either an integer, floating point or complex value.\n",
    "\n",
    "| Type | Format | Description | \n",
    "| --- | --- | --- |\n",
    "| int [Integer] |  a = 10 | Signed Integer | \n",
    "| float [Floating point] | a = 45.67 | Floating point real values | \n",
    "| complex | a = 3.14J | (J) Contains integer in the range 0 to 255. | \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Whenever you see a hash symbol [#] in Python code, this represents a comment which is ignored by the interpreter. \n",
    "# This is where a code developer will add some personal comments or add key notes that enable others to understand\n",
    "# and/or use the code she/he developed.\n",
    "\n",
    "# So let's assign some values to some variables. By the way, the variable names are not important, but are more \n",
    "# of an issue regarding style and documentation. \n",
    "# Also note that I'm not defining what each variable is expecting in the first place. \n",
    "# In other words, I don not have to tell the interpreter what data type to expect in, say, x:\n",
    "\n",
    "x = 2.3 # float\n",
    "y = 4 # integer\n",
    "z = 5 + 6j # complex [we are not going to use complex numbers in our course so this is the first and last instance]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you click anywhere in the above code box, and then proceed to click <code> 'Run' </code> from the menu bar, you should notice nothing happens. Not very interesting, but we have assigned values to three variables. Now we can print our variables to screen using the 'print' function as per below. Once again, select the cell below and click <code> 'Run' </code> from the top menu:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 2.3\n",
      "y = 4\n",
      "z = (5+6j)\n"
     ]
    }
   ],
   "source": [
    "# Just adding comment here for the sake of it...\n",
    "print(\"x =\", x)\n",
    "print(\"y =\", y)\n",
    "print(\"z =\", z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looks correct! We can also ask Python to check the numeric type using the <code> type </code> function. Thus:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The data type of x is <class 'float'>\n",
      "The data type of y is <class 'int'>\n",
      "The data type of z is <class 'complex'>\n"
     ]
    }
   ],
   "source": [
    "print(\"The data type of x is\",type(x))\n",
    "print(\"The data type of y is\",type(y))\n",
    "print(\"The data type of z is\",type(z))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's look at some more specifics for type _float_ from the official Python documentation. We have a number of formatting permutations we could use:\n",
    "\n",
    "| Property | Syntax |\n",
    "|------|------|\n",
    "| It can have a sign | \"+ -\" | \n",
    "| We can express infinity as |  \"Infinity\" \"inf\" | \n",
    "| If we dont have a number, referred to as 'Not a Number' [NaN] | \"nan\" | \n",
    "\n",
    "For example, look at the following examples where Im using the command <code> float </code> to print out the floating point number of a string in the brackets ().\n",
    "\n",
    "```python\n",
    ">>> float('+1.23')\n",
    "1.23\n",
    ">>> float('   -12345')\n",
    "-12345.0\n",
    ">>> float('1e-003')\n",
    "0.001\n",
    ">>> float('+1E6')\n",
    "1000000.0\n",
    ">>> float('-Infinity')\n",
    "-inf\n",
    ">>> float('NaN')\n",
    "nan\n",
    "```\n",
    "\n",
    "We can use a positive or negative assignment. Notice also the use of lower case 'e' and upper case 'E', indicating the power of 10 (2.5e2 = $2.5 x 10^{2} = 250$)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "<b> Exercise 1. Set the value of two new variables and print to screen <a name=\"Exercise1\"> </b> \n",
    "    \n",
    "Set the value of two new variables <code> temperature </code> and <code> mass </code> equal to 298 Kelvin [as an integer] and 3.78 Kilograms [as a float]. Then print their data type to the screen. \n",
    "    \n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The data type of temperature is <class 'int'> and has a value of  298\n",
      "The data type of mass is <class 'float'> and has a value of  3.78\n"
     ]
    }
   ],
   "source": [
    "#------'INSERT CODE HERE'------\n",
    "temperature =  # Kelvin\n",
    "mass = # Kg\n",
    "#------------------------------\n",
    "\n",
    "print(\"The data type of temperature is\",type(temperature), \"and has a value of \",temperature)\n",
    "print(\"The data type of mass is\",type(mass), \"and has a value of \",mass)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arithmetic Operators (add, subtract, multiply, divide and raise to a power)\n",
    "\n",
    "In most applications, and in any language, we are going to use basic mathematical operations such as addition, multiplication and division. In the following table you can see a column of operations using Python syntax and the equivalent result. \n",
    "\n",
    "| Operation | Result |\n",
    "| --- | --- |\n",
    "| x + y |  sum of x and y |\n",
    "| x - y |  difference of x and y |\n",
    "| x * y |  product of x and y |\n",
    "| x / y |  quotient of x and y |\n",
    "| abs(x) |  absolute value or magnitude of x |\n",
    "| int(x) |  x converted to integer |\n",
    "| float(x) |  x converted to floating point |\n",
    "| pow(x, y) | x to the power y |\n",
    "| x ** y | x to the power y |\n",
    "\n",
    "\n",
    "In the following code we demonstrate how to perform basic arithmetic on either defined variables or pure numbers using appropriate Python syntax, and add comments using the # symbol."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "z =  9.9\n",
      "var3 =  1.3000000000000003\n",
      "end_temperature =  315.64\n",
      "price_per_kg =  5.217391304347826\n",
      "result =  42.43998894277659\n"
     ]
    }
   ],
   "source": [
    "# Addition examples [+]\n",
    "# 1) Define variables and add\n",
    "x = 2.4\n",
    "y = 7.5\n",
    "z = x + y\n",
    "print(\"z = \", z)\n",
    "\n",
    "# Subtraction examples [-]\n",
    "var1 = -3.4\n",
    "var2 = 4.7\n",
    "var3 = var1 + var2\n",
    "print(\"var3 = \", var3)\n",
    "\n",
    "# Multiplication examples [*]\n",
    "starting_temperature  = 273.14 # Kelvin\n",
    "d_temp_d_time = 3.4 # Kelvin per second\n",
    "duration = 12.5 # seconds\n",
    "end_temperature = starting_temperature + d_temp_d_time*duration\n",
    "print(\"end_temperature = \", end_temperature)\n",
    "\n",
    "# Division examples \n",
    "Price = 12 # £ sterling\n",
    "weight = 2.3 # kg\n",
    "price_per_kg = Price / weight # £ per kg\n",
    "print(\"price_per_kg = \", price_per_kg)\n",
    "\n",
    "# Exponetation examples\n",
    "base = 2.3\n",
    "power = 4.5\n",
    "result = base ** power\n",
    "print(\"result = \", result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the division example, did you notice we actually asked Python to divide an integer by a float? This is ok in the sense that Python will, by default, change the type of the variable with the lowest precision to the same as the highest. \n",
    "\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "<b> Exercise 2. Implement equations as combinations of arithmetic operators  <a name=\"Exercise2\">  </b> Implement the following equations as combinations of arithmetic operators given above: \n",
    "    \n",
    "\n",
    "| Description | Form  |\n",
    "| --- | --- |\n",
    "|<img width=200/>|<img width=500/>|\n",
    "| Einstein's relativistic mass-energy relation |  $E = mc^2$ | \n",
    "| De Broglie Wavelength | $\\lambda  = \\frac{h}{{m\\upsilon }}$ |\n",
    "| Ideal gas equation | $PV = nRT$ |\n",
    "| Temperature from Degrees Kelvin to Celsius | $^\\circ C = K - 273$ |\n",
    "\n",
    "Where we provide values for the following constants referred to in each:\n",
    "\n",
    " - Planck's constant, h = $6.62607004 x 10^{-34}$\n",
    " - Speed of light in a vaccuum, c = $3 x 10^{8} m s^{-1}$\n",
    " - Ideal Gas constant, R = 8.205736×$10^{-5}$ $\\frac{m3⋅atm}{K⋅mol}$\n",
    "\n",
    "You should see the following output:\n",
    "    \n",
    "    The relativistic energy of an electron =  8.199e-14\n",
    "    The De Broglie wavelength of an eletron =  1.3697557246543088e-10\n",
    "    The Pressure of our ideal gas =  0.05260061405059999\n",
    "    The Temperature in Celsius =  25.149999999999977\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-6-4678a2bcf770>, line 13)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-6-4678a2bcf770>\"\u001b[0;36m, line \u001b[0;32m13\u001b[0m\n\u001b[0;31m    E =   # Energy of electron [J]\u001b[0m\n\u001b[0m                                  ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "# Constants used in equations\n",
    "c = 3.0e8 # Speed of light, [m/s]\n",
    "h = 6.62607004e-34 # Plank's constant [J s]\n",
    "m = 9.11e-31 # Mass of Electron in kg\n",
    "T = 298.15 # Assume temperature is 298.15 K\n",
    "R = 8.205736e-5 # Ideal Gas Constant [m3⋅atm/ K⋅mol]\n",
    "V = 1.0 # Assumed volume in ideal gas law\n",
    "n = 2.15 # Number of moles of gas used in the ideal gas law\n",
    "vel = 5.31e6 # Assumed velocity of eletron in De Broglies rule [m/sec]\n",
    "\n",
    "#------'INSERT CODE HERE'------\n",
    "# Einsteins relativistic mass-energy relation\n",
    "E =   # Energy of electron [J]\n",
    "\n",
    "# De Broglie's Wavelength\n",
    "Lambda =   # Wavelength [m]\n",
    "\n",
    "# Ideal gas equation\n",
    "P =    # Pressure [atm]\n",
    "\n",
    "# Covert above equation to degrees Celsius\n",
    "T_celsius = \n",
    "\n",
    "#------------------------------\n",
    "\n",
    "print(\"The relativistic energy of an electron = \", E)\n",
    "print(\"The De Broglie wavelength of an eletron = \", Lambda)\n",
    "print(\"The Pressure of our ideal gas = \",P)\n",
    "print(\"The Temperature in Celsius = \",T_celsius)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2) Arrays: Lists, tuples and dictionaries  <a name=\"Part2\">\n",
    "\n",
    "In most programming applications we want to store and update values in an array, be it 1D, 2D, 3D or even more. Python comes with 3 ways to store this information known as: \n",
    "\n",
    " - lists\n",
    " - tuples\n",
    " - dictionaries.\n",
    "  \n",
    "For applications focused on numerical computations, the module known as Numpy is used for manipulating and creating/modifying numerical values in arrays. We meet this module in Practical 3. The reason is that Numpy has been optimised for use in this way and can be significantly faster than 'non-Numpy' approaches we will use in this class. We will be using the Numpy package throughout this course, but we will also come across a 'list'. \n",
    "\n",
    "So, why are there multiple methods?\n",
    "\n",
    "Lists and tuples are perhaps the most common used data structures in Python. They have a number of similarities:\n",
    "\n",
    " - They both store a collection of items sequentially\n",
    " - They can store items of any data type. So this include numeric and non-numeric.\n",
    " - Any item is accessible via its index. We will see this below\n",
    " \n",
    " \n",
    "<div class=\"alert alert-block alert-danger\">\n",
    "<b>Indexing </b> Please note, Python indexes start at 0\n",
    "</div>\n",
    " \n",
    "However they have a key difference which is:\n",
    "\n",
    ">> Lists are mutable while tuples are immutable. This means we can change/modify the values of a list but we cannot change/modify the values of a tuple.\n",
    " \n",
    "They also have a different syntax. Let's run through some examples below. Notice again Im using whatever variable name I want. To re-run the code in a box, such as that provided below, click anywhere in the box and then click on the 'Run' symbol in the notebook toolbar. For example, once you have read through the below, try accessing a different element from the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'London'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# First let's create an identical list and tuple containing names of places\n",
    "# Lists use square brackets, whereas tuples use parentheses\n",
    "\n",
    "list_capitals = ['London','Paris','Rome','Ankara']\n",
    "tuple_capitals = ('London','Paris','Rome','Ankara')\n",
    "\n",
    "# If we want to access a particular element from a list of a tuple, we use the same bracket notation but also \n",
    "# remember that python indexing starts at 0. Thus, for the first element in the list we would write:\n",
    "\n",
    "list_capitals[0]\n",
    "\n",
    "# Now click run on this portion of code and you should see the word 'London' below, if accessing element [0]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4th entry in the list is  Ankara\n",
      "4th entry in the tuple is  Ankara\n"
     ]
    }
   ],
   "source": [
    "# Now lets access the 4th element of both the list and tuple. Note im using the print command here so we can see\n",
    "# both printed to the screen:\n",
    "\n",
    "print(\"4th entry in the list is \",list_capitals[3])\n",
    "print(\"4th entry in the tuple is \",tuple_capitals[3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The key different between lists and tuples are the ability to change values. This impacts on efficiency, which we wont cover in detail during this course; Lets try to change and then print the 2nd entry in both the list and tuple. Let's try to change this to <code> Beijing </code>. See the code below. When you click <code> Run </code>, does it produce an error?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "full list array =  ['London', 'Beijing', 'Rome', 'Ankara']\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-6-7f3517109973>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"full list array = \"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlist_capitals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mtuple_capitals\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'Beijing'\u001b[0m \u001b[0;31m# note the index value and the [] bracket notation\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      8\u001b[0m \u001b[0;31m# print full array to the screen\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"full list array = \"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mtuple_capitals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "# Change the 2nd entry to 'Beijing'\n",
    "\n",
    "list_capitals[1] = 'Beijing' # note the index value and the [] bracket notation\n",
    "# print full array to the screen\n",
    "print(\"full list array = \",list_capitals)\n",
    "\n",
    "tuple_capitals[1] = 'Beijing' # note the index value and the [] bracket notation\n",
    "# print full array to the screen\n",
    "print(\"full list array = \",tuple_capitals)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You will see an error as we cannot change the entry in the tuple. Following on from this, we can change the size of a list, but we cannot change the size of a tuple. Imagine we want to add a 5th entry to our list. To do this we can append to the list by using the \n",
    "\n",
    "```python\n",
    ">>[Name of list].append() \n",
    "```\n",
    "\n",
    "operation. Thus, look at the following code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Append another city to our list as follows, and then print the new array\n",
    "list_capitals.append('Moscow')\n",
    "# print full array to the screen\n",
    "print(\"full list array = \",list_capitals)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "<b> Exercise 3. Add two more entries to a list and change an existing entry  <a name=\"Exercise3\"> </b> \n",
    "    \n",
    "Append to your existing list the following cities, in sequential order:\n",
    " - Manchester\n",
    " - Edinburgh\n",
    " \n",
    "    Then change the existing value of the 5th element, which is currently <code> Moscow </code>, to <code> Hanoi </code>. When youy have finished this, and run the code, you should see an output resembling:\n",
    "\n",
    "```python\n",
    "full list array =  ['London', 'Beijing', 'Rome', 'Ankara', 'Hanoi', 'Manchester', 'Edinburgh']\n",
    "```\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "full list array =  ['London', 'Beijing', 'Rome', 'Ankara', 'Hanoi', 'Edinburgh', 'Manchester', 'Edinburgh']\n"
     ]
    }
   ],
   "source": [
    "#------'INSERT CODE HERE'------\n",
    " \n",
    " \n",
    " \n",
    "#------------------------------\n",
    "\n",
    "# print full array to screen\n",
    "print(\"full list array = \",list_capitals)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3) Loops and conditional statements  <a name=\"Part3\">\n",
    "\n",
    "Once we have information stored in an array, or wish to generate information iteratively, we start to use a combination of **loops** and **conditional statements**. Let us focus on loops during this practical.\n",
    "\n",
    "\n",
    "### Loops\n",
    "Take the previous list, or array, of city names. We could, as we have done, print each entry individually like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "first entry is London\n",
      "second entry is Beijing\n",
      "third entry is Rome\n"
     ]
    }
   ],
   "source": [
    "print(\"first entry is\",list_capitals[0])\n",
    "print(\"second entry is\",list_capitals[1])\n",
    "print(\"third entry is\",list_capitals[2])\n",
    "\n",
    "#...and so on\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However we often work with very large arrays and this simply wouldnt be feasible or just too time consuming. We might want to generate values to be stored in a very large array, based on a specific algorithm, which would be better automated. Loops allow us to do this. Take our previously constructed list. The following code demonstrates using a loop to print each value in turn. Take note of the way the loop is contructed, the syntax and the need for introducing a space within the loop. We will discuss this shortly. In fact, obeying the white space rule is a fundamental requirement in Python\n",
    "\n",
    "<div class=\"alert alert-block alert-danger\">\n",
    "<b>White space rule </b> Whenever a series of commands, or command, is terminated by a colon :, the following line should be indented. Examples typically include loops and function definitions.\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'list_capitals' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-5-b6516ff33405>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mstep\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m7\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m \u001b[1;31m# I have introduced a variable called 'step'. It dosnt matter what name we use\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m     \u001b[1;31m# but see how the same variable, once defined by the loop, is used to access entries in our array\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlist_capitals\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mstep\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'list_capitals' is not defined"
     ]
    }
   ],
   "source": [
    "# Example loop to print entries in our list of capital cities\n",
    "for step in range(7): # I have introduced a variable called 'step'. It dosnt matter what name we use\n",
    "    # but see how the same variable, once defined by the loop, is used to access entries in our array\n",
    "    print(list_capitals[step])\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us break this down a little. The loop counts through a fixed number of integer values using the <code> range </code> function. We will start looking at functions in our third practical. Briefly, this Python function creates a sequence of numbers that define each iteration of the loop. By default, this sequence is based on integer values but you can modify this by passing optional arguments which we will not cover in this practical. For now, this generates values from 0 to 6. Recall, Python indexing starts at 0. In fact, lets add another line within our loop such that we can access the value of our 'step' variable within each loop iteration as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "London\n",
      "the value of step is  0\n",
      "Beijing\n",
      "the value of step is  1\n",
      "Rome\n",
      "the value of step is  2\n",
      "Ankara\n",
      "the value of step is  3\n",
      "Hanoi\n",
      "the value of step is  4\n",
      "Edinburgh\n",
      "the value of step is  5\n",
      "Manchester\n",
      "the value of step is  6\n"
     ]
    }
   ],
   "source": [
    "# The following loop counts through a fixed number of integer values using the range function. We have defined the \n",
    "# limit of values to be iterated through by knowledge of how big our array is. If you ask Python to print\n",
    "# any entries beyond the boundaries of our array, you would get an error message. Try it!\n",
    "\n",
    "for step in range(7): # I have introduced a variable called 'step'. It dosnt matter what name we use\n",
    "    # but see how the same variable, once defined by the loop, is used to access entries in our array\n",
    "    print(list_capitals[step])\n",
    "    print(\"the value of step is \", step)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have only looked at a list containing strings, or words. Let's try a numerical example. Assume we want to create two new lists, <code> x </code> and <code> y </code>. Both have 100 elements. The <code> x </code> array contains integer values from 1 to 100, and the <code> y </code> array is defined by the basic equation <code> y=x*3.4 </code>. Check out the code below. This uses a combination of creating a new list, defining a loop and applying a numerical operation: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The 1st element of x is  1\n",
      "The 1st element of y is  3.4\n",
      "The 2nd element of x is  2\n",
      "The 2nd element of y is  6.8\n",
      "The 3rd element of x is  3\n",
      "The 3rd element of y is  10.2\n",
      "The 4th element of x is  4\n",
      "The 4th element of y is  13.6\n",
      "The 81st element of x is  81\n",
      "The 81st element of y is  275.4\n"
     ]
    }
   ],
   "source": [
    "# Create two empty lists. We are going to fill these in the loop\n",
    "x = []\n",
    "y = []\n",
    "\n",
    "# Create a loop that cycles through 100 values, then implement the equation defined above\n",
    "for step in range(100):\n",
    "    \n",
    "    # First lets define a value in our x array. We know x goes from 1-100 so, knowing Python\n",
    "    # indexing starts at 0, do you understand the following operation\n",
    "    x.append(step+1)\n",
    "    # So for our first iteration, step is 0 and thus we place the value '1' into x\n",
    "    \n",
    "    # We might aswell also define our y values. \n",
    "    # Take your time to understand whats going on below.\n",
    "    y.append(x[step]*3.4)\n",
    "    # We can break it down into 3 phases\n",
    "    # 1) We want to append a value to our y array using .append()\n",
    "    # 2) We want to take the associated value from the x array using our index given by the 'step' variable\n",
    "    # 3) We want to implement the function given by equation xx.\n",
    "    \n",
    "# Below the indented space above, the loop has finished. Lets print the first 4 values from both\n",
    "# our x and y values\n",
    "\n",
    "print(\"The 1st element of x is \",x[0])\n",
    "print(\"The 1st element of y is \",y[0])\n",
    "\n",
    "print(\"The 2nd element of x is \",x[1])\n",
    "print(\"The 2nd element of y is \",y[1])\n",
    "\n",
    "print(\"The 3rd element of x is \",x[2])\n",
    "print(\"The 3rd element of y is \",y[2])\n",
    "\n",
    "print(\"The 4th element of x is \",x[3])\n",
    "print(\"The 4th element of y is \",y[3])\n",
    "\n",
    "# What about the 81st element of x and y?\n",
    "print(\"The 81st element of x is \",x[80])\n",
    "print(\"The 81st element of y is \",y[80])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "<b> Exercise 4. Cycling through arrays and modifying values <a name=\"Exercise4\">  </b>  Create a loop that implements the function:\n",
    "\n",
    "\\begin{eqnarray} \n",
    "Y = X^{2.8}\n",
    "\\end{eqnarray}\n",
    "\n",
    "Where <code> x </code> is an array of 50 values from 1 to 50.\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initiliase an empty list for both 'x' and 'y'\n",
    "x = []\n",
    "y = []\n",
    "\n",
    "# Now loop through 50 values and append each list accordingly.\n",
    "# One list contained values for 'x', the other 'y'.\n",
    "# Please note the operator ** is needed to raise one number to another [e.g 2**3]\n",
    "#------'INSERT CODE HERE'------\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "#------'INSERT CODE HERE'------\n",
    "    \n",
    "# Print the last four values from both our x and y arrays\n",
    "print(\"The 47th element of x is \",x[46])\n",
    "print(\"The 47th element of y is \",y[46])\n",
    "\n",
    "print(\"The 48th element of x is \",x[47])\n",
    "print(\"The 48th element of y is \",y[47])\n",
    "\n",
    "print(\"The 49th element of x is \",x[48])\n",
    "print(\"The 49th element of y is \",y[48])\n",
    "\n",
    "print(\"The 50th element of x is \",x[49])\n",
    "print(\"The 50th element of y is \",y[49])\n"
   ]
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}