Workshop2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CH160: Introduction to Python II - Lists & arrays\n",
    "\n",
    "<img src=\"./STUFF/kb_2.jpg\" width=\"600\">\n",
    "\n",
    "\n",
    "# 1 - Introduction\n",
    "\n",
    "In workshop 1 we discussed two important *classes* of data, numbers and strings. We also saw how we could attach names to numbers and strings through the use of variables - allowing them to be stored and used repeatedly in code without having to type them out in full each time. Suppose we had a collection of numbers or strings that we wanted to use in our code (for instance, it could be a series of temperature measurements). One option open to us is to give each of these objects its own variable name - for example ```temperature_1```, ```temperature_2```, *etc*. Obviously this becomes extremely tedious as the number of objects increases. Instead, we can store collections of data directly using *lists* and *arrays*. \n",
    "\n",
    "At first glance, lists and arrays seem to do exactly the same thing (and indeed, can often be used interchangably). However, they have many important differences, and as such we will be treating them seperately in this workshop. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2 - Lists\n",
    "A list can be thought of as a way to store a collection of objects (*i.e.* numbers and strings). In this section we will learn how to define lists in Python, access the data stored in these lists, and how we can manipulate them.\n",
    "\n",
    "## 2.1 - Creating a list\n",
    "To create a list in Python, we enclose a comma-separated sequence of objects - known as the *elements* of the list -  within a pair of square brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "#CREATING LISTS IN PYTHON\n",
    "\n",
    "#create a list called 'squares' where the elements are the squares of the numbers 1-5 inclusive\n",
    "squares=[1, 4, 9, 16, 25]\n",
    "\n",
    "print(squares)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The objects contained within a list can all be of the same type (as in the example above where each object is an integer), or they can be a mixture of different data types - including other lists (placing lists within lists is known as *nesting*):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Hello', 'World!', ['a', 'b', 'c'], 3, 3.0, (3+2j)]\n"
     ]
    }
   ],
   "source": [
    "#CREATING A LIST CONTAINING MIXED DATA TYPES\n",
    "\n",
    "mixed_list=[\"Hello\", \"World!\",[\"a\", \"b\", \"c\"], 3, 3.0, 3+2j]\n",
    "print(mixed_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The only limit to how many objects a list can contain is the amount of memory the computer has available. To check how many elements a list has we can use ```len()``` command..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "#CHECKING THE LENGTH OF A LIST\n",
    "\n",
    "# Use the len(listname) command to see how many elements a list has\n",
    "print(len(mixed_list)) #note that the nested list [\"a\", \"b\", \"c\"] is counted as a single element\n",
    "\n",
    "#we can also create empty lists by typing a pair of square brackets with nothing in between\n",
    "emptyList=[]\n",
    "#The length of an empty list should be zero\n",
    "print(len(emptyList))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    \n",
    "### Task 1:\n",
    "Create and print a list containing all the prime numbers between 1 and 25. Determine how many numbers there are in the list. **Note:** [1 *is not* a prime number](https://blogs.scientificamerican.com/roots-of-unity/why-isnt-1-a-prime-number/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 5, 7, 11, 13, 17, 19, 23]\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "#TASK 1 ANSWER:\n",
    "primes=[2,3,5,7,11,13,17,19,23]\n",
    "print(primes)\n",
    "print(len(primes))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2 -  Accessing the elements of a list\n",
    "Since we use lists to store collections of objects, we need to be able to extract the values of individual list elements. To do this, we make use of *list indexing*. \n",
    "\n",
    "Each element in a list can be accessed using the variable name for that list, followed by a number representing its position in the list (the *element index*) in square brackets. Python, like several other programming languages, starts counting from 0, thus the first element in a list is given the index 0, the second element has the index 1, and so on:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1st element = 6\n",
      "2nd element = 3\n",
      "5th element = 16\n"
     ]
    }
   ],
   "source": [
    "#LIST INDEXING EXAMPLE \n",
    "\n",
    "#Create a new list (Collatz sequence starting with the number 6), and give it the variable name 'Collatz'\n",
    "Collatz=[6, 3, 10, 5, 16, 8, 4, 2, 1]\n",
    "\n",
    "#The first element of a list has the index 0\n",
    "print(\"1st element =\",Collatz[0]) #remember we can print several things at once if we separate them with commas  \n",
    "\n",
    "#The second element of a list has the index 1\n",
    "print(\"2nd element =\",Collatz[1])\n",
    "\n",
    "#The fifth element of a list has the index 4\n",
    "print(\"5th element =\",Collatz[4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2.1 -  Negative list indices\n",
    "\n",
    "Our list has 9 elements, thus the last element is accessed using ```Collatz[8]```. Alternatively, we can use negative indices to count backwards from the end of a list, thus, the last element of our list can also be accessed as ```Collatz[-1]```, with the next-to-last element being ```Collatz[-2]```, and so on:\n",
    "\n",
    "<img src=\"./STUFF/ListIndex.png\" width=\"400\"> "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "last element (postive indexing) = 1\n",
      "last element (negative indexing) = 1\n",
      "next-to-last element = 2\n"
     ]
    }
   ],
   "source": [
    "#USING NEGATIVE INDICES TO COUNT BACKWARDS THROUGH A LIST\n",
    "\n",
    "#The last elememt of the list 'Collatz' has index 8\n",
    "print(\"last element (postive indexing) =\",Collatz[8])\n",
    "\n",
    "#Alternatively we can retrieve the last element of a list unsing the negative index -1\n",
    "print(\"last element (negative indexing) =\",Collatz[-1])\n",
    "\n",
    "#The next-to-last element of a list has the index -2\n",
    "print(\"next-to-last element =\",Collatz[-2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The advantage of using negative list indices is that it means we don't need to know how long the list is to retrieve the last value, since its index will always be -1 regardless of how long the list is."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    \n",
    "### Task 2:\n",
    "Use list indexing to print the 1st, 4th, and last elements of the list of prime numbers you created in task 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "first element = 2\n",
      "fourth element = 7\n",
      "last element = 23\n"
     ]
    }
   ],
   "source": [
    "#TASK 2 ANSWER:\n",
    "print(\"first element =\", primes[0])\n",
    "print(\"fourth element =\", primes[3])\n",
    "print(\"last element =\", primes[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2.2 - Slicing lists\n",
    "If we want to retrieve a range of elements in a list simultaneously, we need to use *list slicing*. List slicing allows us to access a subset of a list by specifying two indices separated by a colon ```:```. The left slice index specifies the first element we wish to retrieve, while the right slice index specifies where we want to stop slicing, and **is not** included in the returned slice:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 5, 16, 8]\n",
      "[6, 3, 10, 5]\n",
      "[4, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "#SLICING LISTS\n",
    "\n",
    "#Using the list \"Collatz\" from earlier, and printing the third (index=2) to sixth (index=5) elements\n",
    "print(Collatz[2:6]) #the element with index 6 will not be printed\n",
    "\n",
    "#print the first four elements (with indices 0-3 inclusive) of the list\n",
    "print(Collatz[0:4])\n",
    "\n",
    "#print the last three elements of the list - requires the right slice index to be the length of the list\n",
    "print(Collatz[6:9])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the slice starts at the beginning of the list then the left slice index does not need to be specified. Similarly, if the slice extends to the end of the list the right slice index can be omitted:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6, 3, 10, 5]\n",
      "[4, 2, 1]\n",
      "[4, 2, 1]\n",
      "[6, 3, 10, 5, 16, 8, 4, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "#USEFUL SLICING NOTATION SHORTCUTS\n",
    "\n",
    "#print the first four elements of the list by only specifying the right slice index\n",
    "print(Collatz[:4])\n",
    "\n",
    "#print the last three elements of the list\n",
    "print(Collatz[6:])\n",
    "print(Collatz[-3:]) #negative indices can also be used - useful if we do not know how long the list is\n",
    "\n",
    "#omitting both indices will print the whole list\n",
    "print(Collatz[:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    \n",
    "### Task 3:\n",
    "Predict what the slice ```Collatz[1:-1]``` will return. Write code to check your answer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.3 - Manipulating lists\n",
    "One of the useful properties of lists is that they are *mutable* - this means that once a list has been created, we are free to replace, add, and remove elements at will. \n",
    "\n",
    "### 2.3.1 - Replacing elements\n",
    "To change the value of an individual element, we assign its index to the new value (much like how we change the value of a variable):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['dog', 'cat', 'rabbit', 'mouse']\n",
      "['horse', 'cat', 'rabbit', 'mouse']\n",
      "['horse', 'cat', 'rabbit', 'ring-tailed lemur']\n"
     ]
    }
   ],
   "source": [
    "#CHANGING INDIVIDUAL LIST VALUES\n",
    "\n",
    "#create our list and print it to screen\n",
    "animals=[\"dog\", \"cat\", \"rabbit\", \"mouse\"]\n",
    "print(animals)\n",
    "\n",
    "#To replace the first element of our list we just assign animals[0] to a new value\n",
    "animals[0]=\"horse\"\n",
    "print(animals)\n",
    "\n",
    "#The last element can be replace likewise\n",
    "animals[-1]=\"ring-tailed lemur\"\n",
    "print(animals)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use list slicing to replace several elements simultaneously:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['horse', 'ocelot', 'drop bear', 'ring-tailed lemur']\n"
     ]
    }
   ],
   "source": [
    "#CHANGING SEVERAL LIST ELEMENTS SIMULTANEOUSLY\n",
    "\n",
    "#replace the middle two elements of \"animals\" using list slicing\n",
    "animals[1:3]=\"ocelot\",\"drop bear\"\n",
    "\n",
    "print(animals)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the element is a number, we can manipulate it mathematically:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 2, 2, 2]\n",
      "[9, 0.6666666666666666, 4, 4096]\n"
     ]
    }
   ],
   "source": [
    "#PERFORMING MATHEMATICAL OPERATIONS ON LIST ELEMENTS\n",
    "\n",
    "#create a list containing four elements, each of which is the number 2\n",
    "some_numbers=[2, 2, 2, 2]\n",
    "print(some_numbers)\n",
    "\n",
    "#Add 7 to the first element\n",
    "some_numbers[0]=some_numbers[0]+7\n",
    "\n",
    "#Divide the second element by 3\n",
    "some_numbers[1]=some_numbers[1]/3\n",
    "\n",
    "#Multiply the third element by 2\n",
    "some_numbers[2]=some_numbers[2]*2\n",
    "\n",
    "#Raise the fourth element to the power of 12\n",
    "some_numbers[3]=some_numbers[3]**12\n",
    "\n",
    "#print the manipulated list\n",
    "print(some_numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3.2 - Adding elements to a list\n",
    "There are several methods we can use to add single elements to a list, depending upon where we want the new element to go. If we wish to add elements to the end of a list, we can use the ```append()``` command by typing ```list_name.append(new_element)```, where ```list_name``` is our list and ```new_element``` is the new element we wish to add:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['b', 'c', 'd', 'f']\n",
      "['b', 'c', 'd', 'f', 'g']\n"
     ]
    }
   ],
   "source": [
    "#ADDING ELEMENTS TO THE END OF A LIST\n",
    "\n",
    "#create a list with the name \"letters\"\n",
    "letters=[\"b\", \"c\", \"d\", \"f\"]\n",
    "print(letters)\n",
    "\n",
    "#Add the letter \"g\" to the end of the list using the append() command\n",
    "letters.append(\"g\")\n",
    "print(letters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We use the ```insert()``` command to add new entries to the beginning or middle of lists. This command is slightly more complicated to use than ```append()``` because we need to supply two *arguments* (the things we type in the parentheses of Python commands) rather than one. The first argument is the position - specified using the list index - where the new element is inserted into the list, and the second argument is the new element itself:\n",
    "\n",
    "```list_name.insert(position, new_element)```\n",
    "\n",
    "The order in which the arguments appear is important - the first argument is always the position, and the second argument is always the new element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'c', 'd', 'f', 'g']\n",
      "['a', 'b', 'c', 'd', 'e', 'f', 'g']\n"
     ]
    }
   ],
   "source": [
    "#INSERTING ELEMENTS INTO THE BEGINNING/MIDDLE OF A LIST\n",
    "\n",
    "#Add the letter \"a\" to the beginning (index=0) of the list - the index of all letters\n",
    "#to the right will increase by one as a result\n",
    "letters.insert(0, \"a\")\n",
    "print(letters)\n",
    "\n",
    "#Insert the letter \"e\" at index 4 - note that if we had chosen to insert \"e\" before\n",
    "#inserting \"a\", then we would have needed to use the index=3 to put it in the right place\n",
    "letters.insert(4, \"e\")\n",
    "print(letters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    \n",
    "### Task 4:\n",
    "The list ```powers``` in the code box below should contain the first eight values of 2$^n$ (*i.e.*, for values of $n$ between 0 and 7 inclusive). Unfortunately, the list has some missing elements, and some of the included elements are incorrect. Use the commands described in sections 2.3.1 and 2.3.2 to complete and correct the list by changing the value of existing elements and adding new elements to the list where required."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 4, 8, 16, 32, 64, 128]\n"
     ]
    }
   ],
   "source": [
    "#TASK 3 ANSWER:\n",
    "powers=[1, 2, 5, 8, 33, 63]\n",
    "\n",
    "#Correct the three incorrect values first\n",
    "powers[2]=4\n",
    "powers[4]=32\n",
    "powers[5]=64\n",
    "\n",
    "#Insert the first missing value (16) into the list at index 4\n",
    "powers.insert(4, 16)\n",
    "\n",
    "#Add the final value (128) to the end of the list\n",
    "powers.append(128)\n",
    "\n",
    "#Print the list to check\n",
    "print(powers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3.3 - Removing elements from a list\n",
    "To remove elements from a list we can use the ```pop()``` command by typing ```list_name.pop(position)```, where ```position``` is the list index of the element we want to remove. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['carrot', 'broccoli', 'onion', 'asparagus']\n"
     ]
    }
   ],
   "source": [
    "#REMOVING ELEMENTS FROM A LIST\n",
    "\n",
    "#Create a list called \"vegetables\" containing incorrect entries (fruits)\n",
    "vegetables=[\"carrot\", \"tomato\", \"broccoli\", \"onion\", \"aubergine\", \"asparagus\", \"apple\"]\n",
    "\n",
    "#tomato (list index 1) is a fruit - remove it!\n",
    "vegetables.pop(1)\n",
    "\n",
    "#aubergine is also a fruit - remove it!\n",
    "vegetables.pop(3) #note that because we removed tomato from the list, the index for aubergine has decreased by one\n",
    "\n",
    "#apple is certainly not a vegetable - remove it!\n",
    "vegetables.pop(-1) #we can also use negative indices to specify which element to remove\n",
    "\n",
    "#print the correct list\n",
    "print(vegetables)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "\n",
    "### Summary of commands introduced in section 2.3\n",
    "```a[x]=``` - change the value of the list element at index 'x'\n",
    "\n",
    "```a[x: y]=``` - change the values of the slice of list elements between indices 'x' and 'y' (exclusive) simultaneously\n",
    "\n",
    "```a.append(value)``` - add a new element to the end of list 'a'\n",
    "\n",
    "```a.insert(index, value)``` - insert a new element into list 'a' at a specified position \n",
    "\n",
    "```a.pop(index)``` - remove an element from list 'a'\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.4 - Tuples\n",
    "Before we introduce arrays, we will briefly discuss a similar Python structure - the *tuple*. Tuples are identical to lists in all respects except for two crucial properties:\n",
    "- Tuples are defined by a comma-separated sequence of values without any enclosing square brackets ```[]```.\n",
    "- Tuples are *immutable*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4.1 - Defining, indexing, and slicing tuples\n",
    "Once created, tuples are indexed and sliced in exactly the same manner as lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n",
      "5\n",
      "21\n",
      "(3, 5, 8, 13)\n"
     ]
    }
   ],
   "source": [
    "#TUPLE DEFINITION, INDEXING, AND SLICING\n",
    "\n",
    "#Create a tuple by writing a sequence of comma-separated elements\n",
    "tuple_example=1, 1, 2, 3, 5, 8, 13, 21, 34\n",
    "\n",
    "#Check we have created a tuple rather than a list\n",
    "print(type(tuple_example))\n",
    "\n",
    "#Indexing and slicing work exactly the same way as they do for lists. \n",
    "print(tuple_example[4]) #Note that we still use square brackets for indexing and slicing\n",
    "\n",
    "print(tuple_example[-2])\n",
    "\n",
    "print(tuple_example[3:7])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4.2 - Tuples are immutable\n",
    "\n",
    "Once a tuple is defined, its elements cannot be modified. If you attempt to change the value of a tuple element Python will give you an error message:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "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-20-fc1f663ea506>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;31m#Attempting to change the value of one of the elements in \"tuple_example\" will not work\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mtuple_example\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "#TUPLES CANNOT BE MODIFIED ONCE CREATED\n",
    "\n",
    "#Attempting to change the value of one of the elements in \"tuple_example\" will not work\n",
    "tuple_example[3]=4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This immutable property of tuples can be very useful, as it allows us to create a list of values which cannot be modified accidentally - *e.g.* a list of constants "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4.3 - Unpacking tuples\n",
    "Workshop 4 will teach you how to write your own *functions* - short blocks of code designed to perform a specific task. Oftentimes a function will return a tuple filled with several objects (*e.g.* the tuple could contain a list of calculated data points along with their mean and standard deviation). We would then want to give each of these objects a variable name for use later on in the program.\n",
    "\n",
    "Tuple unpacking allows us to assign variable names to all of the objects in a tuple using a single line of code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data = [1, 6, 3, 7, 4, 3, 6, 8, 4, 3, 8, 9, 3]\n",
      "mean = 5\n",
      "standard deviation = 2.386\n"
     ]
    }
   ],
   "source": [
    "#TUPLE UNPACKING\n",
    "\n",
    "#Create a tuple containing a list of data along with its mean and standard deviation - a user-defined\n",
    "#function could output a tuple like this automatically\n",
    "output_tuple=[1,6,3,7,4,3,6,8,4,3,8,9,3], 5, 2.386\n",
    "\n",
    "#Unpack the tuple into three variables called \"data\", \"mean\", and \"std_dev\"\n",
    "#these three variable names are the elements of a new tuple\n",
    "data, mean, std_dev=output_tuple\n",
    "\n",
    "#print the values of the three variables to ensure the tuple has unpacked correctly\n",
    "print(\"data =\", data)\n",
    "print(\"mean =\", mean)\n",
    "print(\"standard deviation =\", std_dev)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When unpacking a tuple, the number of variables on the left must match the number of objects contained within the oringinal tuple. If this condition is not met, Python will complain:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "too many values to unpack (expected 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-3-f2c33363d9b5>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;31m#Unpacking \"output_tuple\" from above (three objects) into two variables\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmean\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0moutput_tuple\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: too many values to unpack (expected 2)"
     ]
    }
   ],
   "source": [
    "#TUPLE UNPACKING ERRORS 1 - UNPACKING INTO TOO FEW VARIABLES\n",
    "\n",
    "#Unpacking \"output_tuple\" from above (three objects) into two variables\n",
    "data, mean=output_tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "not enough values to unpack (expected 4, got 3)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-4-f0f6a3d358b1>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;31m#Unpacking \"output_tuple\" from above (three objects) into four variables\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmean\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstd_dev\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmedian\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0moutput_tuple\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: not enough values to unpack (expected 4, got 3)"
     ]
    }
   ],
   "source": [
    "#TUPLE UNPACKING ERRORS 2 - UNPACKING INTO TOO MANY VARIABLES\n",
    "\n",
    "#Unpacking \"output_tuple\" from above (three objects) into four variables\n",
    "data, mean, std_dev, median=output_tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3 - NumPy Arrays\n",
    "Lists and tuples are examples of *data structures*, but when it comes to scientific computing and data manipulation in general, an alternative data structure - the NumPy array - rules supreme. Like lists, NumPy arrays can be used to store ordered collections of numerical data, but they can also be used to represent vectors and matrices (if you are unsure what these are, **don't worry** - we will cover these in part 2 of CH162:Mathematics).\n",
    "\n",
    "## 3.1 - Loading NumPy\n",
    "Arrays are not part of the core Python language, but one beautiful truth about Python is that there exist countless chunks of code (from rather simple things, to entire frameworks for machine learning!) that can be leveraged just by \"importing\" the corresponding \"module\". In order to use arrays in our code, we need to import a very popular Python module called [NumPy](https://numpy.org/) (short for Numerical Python).\n",
    "\n",
    "To load an optional module we use the ``import`` command. To save having to type out \"numpy\" everytime we use a command from the numpy module, we will give it the alias ``np``:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "module"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#IMPORTING THE NUMPY MODULE\n",
    "\n",
    "#The 'import' command loads NumPy, \"as np\" gives it the alias \"np\"\n",
    "#usually all optional modules are loaded at the beginning of the notebook\n",
    "import numpy as np\n",
    "\n",
    "#to see what np is, we can use the type() command\n",
    "type(np)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.2 - Lists *vs.* arrays\n",
    "Before we get to the real business of creating and manipulating arrays, it is important that we discuss the ways in which arrays are similar to lists, and the ways in which they differ:\n",
    "\n",
    "### Similarities\n",
    "- Both can be used for storing data\n",
    "- Both are mutable\n",
    "- Both are ordered - *i.e.*, each element has an index associated with it\n",
    "- Both can be sliced\n",
    "\n",
    "### Differences\n",
    "- Arrays can only contain a single data type (usually integers *or* floats, but can be strings or other objects), a list can contain a mixture of data types\n",
    "- Arrays are designed to be used in mathematical computations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.3 - Creating arrays \n",
    "### 3.3.1 - Converting lists to arrays\n",
    "We can convert existing lists to arrays using the ```np.array(list)``` command, where ```list``` can be either the name of an existing list, or a completely new list (as usual defined by a sequence of comma-separated elements enclosed within a pair of square brackets). The ```np.``` bit tells Python that the array command is part of the NumPy module, rather than core Python. If you used an alias other than np when importing NumPy, then you need to use that\n",
    "alias in place of np when using this function in your code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6] <class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "#CONVERTING EXISTING LISTS TO ARRAYS\n",
    "\n",
    "#create the list \"number_list\" containing a sequence of integers\n",
    "number_list=[1, 2, 3, 4, 5, 6]\n",
    "\n",
    "#convert list to an array using np.array() command.\n",
    "number_array=np.array(number_list)\n",
    "\n",
    "#print array and confirm that it is a NumPy array\n",
    "print(number_array, type(number_array))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[  0.   1.   8.  27.  64. 125. 216.] <class 'numpy.ndarray'>\n",
      "[] <class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "#CREATING NEW ARRAYS DIRECTLY\n",
    "\n",
    "# np.array() command used directly on a newly defined list containing integers and a floating point number\n",
    "cubes=np.array([0, 1, 8.0, 27, 64, 125, 216])\n",
    "\n",
    "#print array and confirm that it is a NumPy array\n",
    "print(cubes, type(cubes))\n",
    "\n",
    "#we can also create an empty array this way\n",
    "empty_array=np.array([])\n",
    "print(empty_array, type(empty_array))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the code cell directly above, note that the final array is made up entirely of floating point numbers, even though only one of the  elements in the intial list was a floating point number. This is because arrays can only contain a single data type."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3.2 Creating arrays using built-in commands\n",
    "\n",
    "\n",
    "NumPy has several commands available that will automatically create and populate arrays:\n",
    "\n",
    "### arange\n",
    "\n",
    "The first of these is the ```np.arange(start, stop, step)``` function which will create an array containing evenly-spaced elements. The three arguments are:\n",
    "\n",
    "- ```start``` The first number in the array\n",
    "- ```stop``` The end point of the array (this number **is not** included in the array) \n",
    "- ```step``` The spacing between elements \n",
    "\n",
    "If each of the ```start```, ```stop```, and ```step``` values are integers, the array will be populated with integers. If any of these values are floating point numbers, then all the elements of the array will likewise be floating point numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = [0 1 2 3 4 5 6 7 8 9]\n",
      "b = [0.  1.5 3.  4.5 6.  7.5 9. ]\n"
     ]
    }
   ],
   "source": [
    "#GENERATING ARRAYS DIRECTLY 1 - np.arange()\n",
    "\n",
    "#Array containing all of the integers between 0 and 10 exclusive\n",
    "a=np.arange(0, 10, 1) #np.arange(10) would give the same result because 'start' and 'step' are the default values\n",
    "print(\"a =\", a)\n",
    "\n",
    "#Array containing the numbers between 0 and 10, separated by 1.5\n",
    "b=np.arange(0, 10, 1.5)\n",
    "print(\"b =\", b)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    \n",
    "### Task 5:\n",
    "Use the ```arange``` command to automatically generate an array containing numbers between 25 and 177, spaced by a value of 23"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 25  48  71  94 117 140 163]\n"
     ]
    }
   ],
   "source": [
    "#TASK 5 ANSWER:\n",
    "task5_array=np.arange(25, 177, 23)\n",
    "print(task5_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### linspace\n",
    "An alternative method to generate an array of evenly space elements is to use the ```np.linspace(start, stop, num)``` function, where: \n",
    "- ```start``` the first number in the array\n",
    "- ```stop``` the last number in the array (unlike ```arange```, this number is included)\n",
    "- ```num``` the number of elements in the array, ```linspace``` will make these evenly spaced\n",
    "\n",
    "The array generated using ```linspace``` will be populated with floating point numbers by default."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c = [ 2.    5.25  8.5  11.75 15.  ]\n",
      "d = [0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]\n"
     ]
    }
   ],
   "source": [
    "#GENERATING ARRAYS DIRECTLY 2 - np.linspace()\n",
    "\n",
    "#Array containing five evenly spaced elements between 2 and 15\n",
    "c=np.linspace(2, 15, 5)\n",
    "print(\"c =\", c) #note that unlike the 'arange' command, the 'stop' value is included in the array\n",
    "\n",
    "#Array containing the whole numbers 0-9 inclusive\n",
    "d=np.linspace(0, 9, 10)\n",
    "print(\"d =\", d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    \n",
    "### Task 6:\n",
    "Use the ```linspace``` function to automatically generate an array containing five evenly spaced values between 0 and $\\pi$. Print the array to screen.\n",
    "\n",
    "**Useful commands**\n",
    "\n",
    "```np.pi``` - returns the value of $\\pi$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.         0.78539816 1.57079633 2.35619449 3.14159265]\n"
     ]
    }
   ],
   "source": [
    "#TASK 6 ANSWER:\n",
    "task6_array=np.linspace(0, np.pi, 5)\n",
    "print(task6_array)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### zeros\n",
    "The final method we shall mention is the ```np.zeros(num)```. As the name suggests, this will create an array with ```num``` elements, where each element is set to 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "array_of_nothingness = [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n"
     ]
    }
   ],
   "source": [
    "#GENERATING ARRAYS DIRECTLY 3 - np.zeros()\n",
    "\n",
    "#Create an array with 10 elements, each of them equal to zero\n",
    "array_of_nothingness=np.zeros(10)\n",
    "print(\"array_of_nothingness =\", array_of_nothingness)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You are probably wondering why we would ever want to generate an array containing zeros! This method can be very useful if we want to initialise an array to store data in at a later point (although we need to know how many data points we will be storing ahead of time). Replacing elements in a NumPy array is far quicker than adding elements to an existing array (on my computer, replacing 100000 elements in an array takes ~15 ms, whereas adding 100000 elements to an initially empty array takes ~130 times longer)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "\n",
    "### Summary of commands introduced in section 3.3\n",
    "All of the commands below assume that the NumPy module has been imported and given the alias 'np'.\n",
    "\n",
    "``np.array()`` - either create a new array, or convert an existing list into an array\n",
    "\n",
    "```np.arange(start, stop, step``` - create an array of elements, each separated by a value equal to $step$, between the numbers $start$ and $stop$ (exclusive)\n",
    "\n",
    "``np.linspace(start, stop, num)`` - create a regularly spaced array of $num$ numbers between the $start$ and $stop$ values (inclusive) \n",
    "\n",
    "```np.zeros(num)``` - creates an array of length $num$, where each element is equal to 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.4 - Manipulating arrays\n",
    "### 3.4.1 - indexing and slicing\n",
    "Arrays are indexed and sliced in the same manner as lists (and tuples):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "full array: [0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ]\n",
      "third element: 0.2\n",
      "next-to-last element: 0.9\n",
      "elements 4-7: [0.3 0.4 0.5 0.6]\n"
     ]
    }
   ],
   "source": [
    "#ARRAY INDEXING AND SLICING\n",
    "\n",
    "#Automatically create array containing 11 evenly spaced elements between 0 and 1 inclusive\n",
    "test_array=np.linspace(0, 1, 11)\n",
    "print(\"full array:\", test_array)\n",
    "\n",
    "#Check the value of the third element using indexing\n",
    "print(\"third element:\", test_array[2])\n",
    "\n",
    "#Check the value of the penultimate element using negative indexing\n",
    "print(\"next-to-last element:\", test_array[-2])\n",
    "\n",
    "#Check value of fourth through seventh element using slicing\n",
    "print(\"elements 4-7:\",test_array[3:7])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.4.2 - Manipulating array elements\n",
    "Again, array elements are manipulated using the same methods as we use for lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "modified array: [ -5.     0.1    0.2    0.3    0.16   0.25   0.36   0.7    0.8    0.9\n",
      " 100.  ]\n"
     ]
    }
   ],
   "source": [
    "#MANIPULATING ARRAY ELEMENTS\n",
    "\n",
    "#Using the array \"test_array\" defined in the code cell directly above\n",
    "#Change the value of the first element in the array to -5 - number will automatically be converted to a float\n",
    "test_array[0]=-5\n",
    "\n",
    "#Change the value of the final element to 100\n",
    "test_array[-1]=100\n",
    "\n",
    "#change the values of elements 5-7 simultaneously using slicing\n",
    "test_array[4:7]=0.16, 0.25, 0.36\n",
    "\n",
    "print(\"modified array:\", test_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.5 - Using arrays in mathematical computations\n",
    "The biggest diffence between lists and arrays is how they respond to mathematical manipulation. As an example, consider the list of numbers ``number_list=[1,2,3,4]``. Suppose we wanted to create a second list of numbers where each element is 3 times larger than the corresponding value in ``number_list`` (<i>i.e.</i> 3, 6, 9, 12). One might be tempted to simply *multiply the original list by 3*..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output = [1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "#MULTIPLYING LISTS HAS UNEXPECTED RESULTS...\n",
    "\n",
    "#Create list of numbers\n",
    "number_list=[1,2,3,4]\n",
    "\n",
    "#Multiply this list by 3\n",
    "number_list=number_list*3\n",
    "\n",
    "#look at the result\n",
    "print('Output =', number_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Clearly this has not done what we intended! Things get even worse if we attempt other simple manipulations (such as adding 1 to each element, or computing the sine, *etc.*) with the code failing to run and generating an error message (give it a go...).\n",
    "\n",
    "If we wish to mathematically manipulate the numbers contained within lists we need to do it one element at a time:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output = [3, 6, 9, 12]\n"
     ]
    }
   ],
   "source": [
    "#MULTIPLYING LIST ELEMENTS BY A CONSTANT NEEDS TO BE DONE ONE ELEMENT AT A TIME\n",
    "\n",
    "#Reintialise list (we modified number_list in the cell above)\n",
    "number_list=[1,2,3,4]\n",
    "\n",
    "#Multiply each element in turn by 3 \n",
    "number_list[0]=number_list[0]*3\n",
    "number_list[1]=number_list[1]*3\n",
    "number_list[2]=number_list[2]*3\n",
    "number_list[3]=number_list[3]*3\n",
    "\n",
    "#look at the result\n",
    "print('Output =', number_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we have success!\n",
    "\n",
    "If, on the otherhand, we created our original data in the form of an array, our first approach would have worked in the way we intended:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "output = [ 3  6  9 12]\n"
     ]
    }
   ],
   "source": [
    "#MULTIPLYING EACH ELEMENT OF AN ARRAY BY A CONSTANT - DIRECT MANIPULATION\n",
    "\n",
    "#Create array of numbers \n",
    "number_array=np.array([1, 2, 3, 4])\n",
    "\n",
    "#Multiply this array by 3\n",
    "number_array=number_array*3\n",
    "\n",
    "#look at the result\n",
    "print('output =', number_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This example shows us the big advantage arrays have over lists when we are interested in mathematical manipulations of the contents - we can transform all the elements of an array in one go! This not only works for multiplication, but for any other mathematical operation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = [-2. -1.  0.  1.  2.  3.  4.  5.]\n",
      "a+3 = [1. 2. 3. 4. 5. 6. 7. 8.]\n",
      "a/2 = [-1.  -0.5  0.   0.5  1.   1.5  2.   2.5]\n",
      "(a^3)+1 = [ -7.   0.   1.   2.   9.  28.  65. 126.]\n",
      "cos(a) = [-0.41614684  0.54030231  1.          0.54030231 -0.41614684 -0.9899925\n",
      " -0.65364362  0.28366219]\n",
      "10^a = [1.e-02 1.e-01 1.e+00 1.e+01 1.e+02 1.e+03 1.e+04 1.e+05]\n"
     ]
    }
   ],
   "source": [
    "#EXAMPLES OF SOME MATHEMATICAL OPERATIONS USING ARRAYS\n",
    "\n",
    "#create an array containing all the whole numbers from -2 to 5, inclusive\n",
    "a=np.linspace(-2,5,8)\n",
    "print(\"a =\", a)\n",
    "\n",
    "#Add 3 to each element\n",
    "print(\"a+3 =\", a+3)\n",
    "\n",
    "#Divide by 2\n",
    "print(\"a/2 =\", a/2)\n",
    "\n",
    "#Cube the array then add 1\n",
    "print(\"(a^3)+1 =\", a**3+1)\n",
    "\n",
    "#Cosine of a\n",
    "print(\"cos(a) =\", np.cos(a)) #NumPy has the same mathematical functions as 'math' module introduced in workshop 1\n",
    "\n",
    "#10 raised to the power of each of the elements in the array\n",
    "print(\"10^a =\", 10**a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arrays can also be added, subtracted, multiplied and divided by each other on an element-by-element basis - provided the two arrays are the same length:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a+b = [ 6  8 10 12]\n",
      "a-b = [-4 -4 -4 -4]\n",
      "a*b = [ 5 12 21 32]\n",
      "b/a = [5.         3.         2.33333333 2.        ]\n"
     ]
    }
   ],
   "source": [
    "#COMBINING ARRAYS ON AN ELEMENT-BY-ELEMENT BASIS\n",
    "\n",
    "#Create two arrays, each with four elements\n",
    "a=np.array([1, 2, 3, 4])\n",
    "b=np.array([5, 6, 7, 8])\n",
    "\n",
    "print(\"a+b =\", a+b)\n",
    "print(\"a-b =\", a-b)\n",
    "print(\"a*b =\", a*b) #note that this is not the same thing as taking the dot or cross product of two vectors!\n",
    "print(\"b/a =\", b/a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "   \n",
    "### Task 7:\n",
    "In workshop 1 you were asked to calculate the gravitational force $F_g$ that attracts two bodies with masses $M=1$ kg and $m = 0.5$ kg as a function of their separation $r$:\n",
    "\n",
    "$$\n",
    "F_g(r)= - \\frac{G \\cdot M \\cdot m}{r^2}\n",
    "$$\n",
    "\n",
    "In the equations above, $G=6.674 \\cdot 10^{-11}$ m$^{3}\\cdot$kg$^{-1}\\cdot$s$^{-2}$ is the *gravitational constant*, while $r$ is the distance between said two bodies (in units of metres).\n",
    "\n",
    "We are going to repeat this calculation here, but rather than performing the calculation several times (once for each value of $r$), we are first going to place all of our $r$ values in an array and use this to generate a second array containing all of the corresponding $F_g$ values.\n",
    "\n",
    "* <b>Step 1</b>: Define three variables:\n",
    "    - \"G\" to be equal to $6.674\\cdot 10^{-11}$\n",
    "    - \"M\" to be equal to $1$\n",
    "    - \"m\" to be equal to $\\frac{1}{2}$<br>\n",
    "* <b>Step 2</b>: Create an array called \"r\" containing the whole numbers 1 through 10 inclusive (use either the ```linspace``` or ```arange``` commands to automatically generate this array).\n",
    "\n",
    "* <b>Step 3</b> Generate an array called \"F_g\" containing the corresponding $F_g$ values. Print both arrays to screen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "r = [ 1  2  3  4  5  6  7  8  9 10]\n",
      "F_g = [-3.33700000e-11 -8.34250000e-12 -3.70777778e-12 -2.08562500e-12\n",
      " -1.33480000e-12 -9.26944444e-13 -6.81020408e-13 -5.21406250e-13\n",
      " -4.11975309e-13 -3.33700000e-13]\n"
     ]
    }
   ],
   "source": [
    "#TASK 7 ANSWER:\n",
    "\n",
    "#Define variables\n",
    "G=6.674e-11 #m^3.kg^-1.s^-2\n",
    "M=1 #m\n",
    "m=0.5 #m\n",
    "\n",
    "#Create array of r values\n",
    "r=np.arange(1,11)\n",
    "\n",
    "#Calculate F_g array\n",
    "F_g=-(G*M*m)/r**2\n",
    "\n",
    "#Print both arrays\n",
    "print(\"r =\", r)\n",
    "print(\"F_g =\", F_g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}