notebook1_2024.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Notebook 1: How to use Python Notebooks\n",
        "\n",
        "This notebook is intended for use within Google Colab.\n"
      ],
      "metadata": {
        "id": "MID7uICHR6kT"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Introduction\n",
        "Python notebooks are a way to interact with python code step by step. This notebook will teach you the basics of Google Colab and Python such that you are able to adequately use Python notebooks. You can collapse and expand each Concept as you complete the notebook with the arrow next to them: ![collapseexpand.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "eKiF_w17UFps"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Concept 1: Structure of Notebooks"
      ],
      "metadata": {
        "id": "b-bXYxyR8VTV"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "The entirety of a Python notebook is contained within either text boxes or code boxes.\n",
        "\n",
        "The purpose of a text box is to contain text.\n",
        "\n",
        "See below for an example of a text box:"
      ],
      "metadata": {
        "id": "Qr8nVTtiUhhi"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "> This is a text box. We can have any manner of text in here, it can be **bolded**, *italicized* and so on 😀. You can double left click this box to edit the text inside. When editing, you can see what will be displayed at the left of the screen---->"
      ],
      "metadata": {
        "id": "wd9494RlWSGB"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The purpose of a code box is to contain Python code. This code can be ran to produce results, which are displayed below the box.\n",
        "\n",
        "See below for an example of a code box (there is no need to mind what the code is doing for now):"
      ],
      "metadata": {
        "id": "ISrHgD0ccIaW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "1+1"
      ],
      "metadata": {
        "id": "hS3Uvqd0Yuvz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "A code box doesn't do anything until it is ran. Hover over the code box and left click on the button that appears to the left of the box ![run button.png](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEcAAAAdCAIAAAB3x+bZAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAIDSURBVFhH7Zcxa8JAGIbzF/xP/ogOinbQqYuLLlJFFzcHwdVRUTIHxMEOgmRwdhENOJUuFqFu9k3y5fQu13BGG5o0D9/g3fuefG9OL4n2lUTSVPFBKdW7Aw0ewcfnSVok8wgeViTLCEo1nU47nU6pVHp2wAcMMUnyHQj9sSKZR/CwIlmGPJVpmrVazQ3jBxIMZA2F0B8rknkEDyuSZUhSYTeo/UDu2TShP1Yk8wgeViTLuKQ6HA7b7dYwjFwuVygUqPcfKBaL+XweZizBQvoKZYT+WJHMI3hYkSyDS2VZVrVapcYder1eu92mgQ+YseSOVGarnM3U9XVgo575tNZfMuVsaxFkduFSTSYTbAK17IBUkGazWaVSoakrYMaSkKkW3Uy5O0CjSqmsQT37pOu4CjenajQa0lTgeDwOh0Oa9YAZS0KlMltOGPvyS1LNm5rWfKMB5mFzwth7e3Mqt1G3YxeWymW32/X7fdI8c8i9ckoxlVe3p9rv9zgAglO5rFYr988GM5ZgIQnKsEb/Rar5q+ajaXhq+gv0QHMRnhbUWRSpIjzZ7ZMaN59LOdlI9qeybwOcH9lIlsGlivwuLBbJPIKHFckyxFTL5ZJaVgDmGKTCQ91msxmNRirPgePxGOa//hx4TQLfRBhJe2sUePgb/m+jlCp2pKnig3ZOImmquHA+fwPbsEzXukhHhgAAAABJRU5ErkJggg==) to run the above code and confirm that 1+1=2  (it will take a moment the first time code is ran in Colab, just be patient).\n"
      ],
      "metadata": {
        "id": "pETfz625Yy80"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "\n",
        "**TASK 1**\n",
        "\n",
        "You can also create text and code boxes yourself. Create a text box underneath this one by either:\n",
        "\n",
        "\n",
        "\n",
        "1.   Selecting this text box and left clicking the \"+ Text\" button at the top-left of the notebook ![create box button.png](data:image/png;base64,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)\n",
        "2.   Hovering your mouse over the bottom edge of this text box and left clicking the \"+ Text\" button that appears ![create box button 2.png](data:image/png;base64,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)\n",
        "\n",
        "Next, create a code box by selecting the \"+ Code\" button instead.\n",
        "\n",
        "In your text box, type in your favourite colour. Next, copy the code from above calculating 1+1 into your own code box and confirm that it still displays 2."
      ],
      "metadata": {
        "id": "Gq65BapIc97W"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Concept 2: Mathematical Operations in Python"
      ],
      "metadata": {
        "id": "-XBcO9tH8ZC9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "Along with addition, all of the other mathematical operations are also available in Python, including:\n",
        "\n",
        "\n",
        "\n",
        "*   \\- for subtraction\n",
        "*   \\* for multiplication\n",
        "*   \\/ for division\n",
        "*   \\*\\* for exponentiation\n",
        "* \\/\\/ for floor division\n",
        "\n",
        "You may not be familiar with floor division. Floor division is essentially division with the result rounded down to the nearest whole number.\n",
        "\n",
        "Parenthesis ```()``` also works as you would expect in Python.\n",
        "\n",
        "\n",
        "Below are some examples showing you these operations in action. Run each example and make sure that they each return the result you would expect if you calculated it by hand."
      ],
      "metadata": {
        "id": "d3SRDm2wxF9j"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Example 1\n",
        "\n",
        "65-1"
      ],
      "metadata": {
        "id": "7Frc1sm-9jrg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Example 2\n",
        "\n",
        "2*16"
      ],
      "metadata": {
        "id": "trkNhSNo-e8d"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Example 3\n",
        "\n",
        "64/4"
      ],
      "metadata": {
        "id": "Bq2p4ISVA6Ff"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Example 4\n",
        "\n",
        "(3**2+4**2)**0.5"
      ],
      "metadata": {
        "id": "udS9koUpA9ot"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Example 5\n",
        "\n",
        "5//2"
      ],
      "metadata": {
        "id": "YhWokjVTBftH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "**TASK 2**\n",
        "\n",
        "\n",
        "Create a code box underneath and compute twelve squared:"
      ],
      "metadata": {
        "id": "ASJo_AfaB-v1"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Concept 3: Data Types"
      ],
      "metadata": {
        "id": "sM9hhtZC8czG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "So far we have been working exclusively with numbers, or more precisely, integers and floats. Floats are the numbers with decimals (Examples 3 and 4 in the previous section) while the integers are the ones without (Examples 1, 2, and 5).\n",
        "\n",
        "There isn't much functional difference between ```5``` as an integer and ```5.0``` as a float but it is important to be aware of the difference if you ever need a number to be one or the other.\n",
        "\n",
        "There are also \"strings\" in Python. Whereas integers and floats are numbers, strings can be compared to words. You can create a string by surrounding code in quotation marks."
      ],
      "metadata": {
        "id": "-yS2HyKLChrk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#One as an integer:\n",
        "\n",
        "type(1)"
      ],
      "metadata": {
        "id": "9-tMlF8x76eK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#One as a float:\n",
        "\n",
        "type(1.0)"
      ],
      "metadata": {
        "id": "U3p-a3pH8HAQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#One as a string:\n",
        "\n",
        "type(\"1\")"
      ],
      "metadata": {
        "id": "nyZlrxQ68Pne"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Run the below code and note how it produces an error:"
      ],
      "metadata": {
        "id": "vzIluthg8u8O"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\"1\"+1"
      ],
      "metadata": {
        "id": "KZyx236zQ6Dg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "The code above doesn't make sense in the same way that ```\"Twinkle, twinkle, little star\" + 1``` doesn't make sense - you can't add a number to a sentence or a word, that is why it results in an error.\n",
        "\n",
        "\n",
        "---\n",
        "**TASK 3**\n",
        "\n",
        "Edit the code below such that it solves the quadratic through the quadratic formula properly:"
      ],
      "metadata": {
        "id": "sMnQeTA7SoP8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#My quadratic is: x^2+3x+2\n",
        "\n",
        "#Root 1\n",
        "print((-3+(\"3**2-4*1*2\")**0.5)/(2*1))\n",
        "\n",
        "#Root 2\n",
        "print((-3-(\"3\"**2-4*1*2)**0.5)/(2*1))"
      ],
      "metadata": {
        "id": "p2Z5lOszURtv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "The correct code should return two distinct roots: -1 and -2."
      ],
      "metadata": {
        "id": "pbKiOkbahFx-"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Concept 4: Functions"
      ],
      "metadata": {
        "id": "wgmz1WNw9Q7V"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "You may have noticed we used a piece of code called ```print()``` in the last section. This is an example of a function.\n",
        "\n",
        "Functions take in data of certain type and number (parameters) and performs a series of operations on it to achieve a certain effect. This description is rather vague, but that is because different functions are so varied in their purpose.\n",
        "\n",
        "Let's look at the function ```print()```, this function displays the data given to it to the results box. Run the following code box:"
      ],
      "metadata": {
        "id": "lmOpPoCAVjw2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Two calculations in a row:\n",
        "1+1\n",
        "2+2"
      ],
      "metadata": {
        "id": "-L1Ea-1Xpq9U"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Notice how only the second result (from 2+2) is displayed to you. Now run this next code box where we give the ```print()``` function ```1+1``` as a parameter:"
      ],
      "metadata": {
        "id": "VcaJSbNrpvAM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Printing the first calculation and leaving the second alone:\n",
        "print(1+1)\n",
        "2+2"
      ],
      "metadata": {
        "id": "RKUIzL3aqLNU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "You can see that both results are displayed to you now. As mentioned, there are a great number of functions out there, if you ever encounter a function that you are not familiar with, it is worthwhile to search it up in Python's documentation or online websites.\n",
        "\n",
        "\n",
        "---\n",
        "**TASK 4**\n",
        "\n",
        "The function ```type()``` returns the data type of the parameter given to it. Try using the  ```type() & print()``` functions to display both the data types of ```5``` and ```5.0```.\n"
      ],
      "metadata": {
        "id": "mcDSUdlfqQK5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "5\n",
        "5.0"
      ],
      "metadata": {
        "id": "PFoDYiRIiXF0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Once ran, your code box should output the data types like so: ![t4 output.png](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAIAAAAAiCAIAAAAYiEZ5AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAANaSURBVGhD7ZnBkeIwEEU3FfIgCAiBCEiABAiAO2fu5EAO5MCRK/vhe7t6ultGtmxrtkrvMGXJcut3f0ng4c+rUZVmQGWaAZUpMuDxeGy329VqtV6v7/d71zs/z+dzv98fj8eu/Y/L5QIxt9uta4+CSSFU156ZCXYAFO92u//OADweVvm3GJBf1loGFNao3wDtInowHf527UmJDUA1caoYfWhifRGjzxjAAnEkLtBkP3Pz/YjGTjCurBLZHIaIBlBrBqds9LAp+M1kwCMzHbOBASyHLjGAAmQYrgJvwPV6ZdMs1XDR+cdH40Ox1pwUf7XrqR2QIixLOdYAaPJWc32l5u6vIALK+sKFLgFh8EG1SBEaILOjH3cxhs2hBgBE8AdDIT8M4IL1BqC52WxMp+DTptD33v4gJWB8dmo7ZXxqk2WyjAGFIg1ZR5BPTGPuoqlXtC6BwEz8lsLgkvS8zgkN8GWZhNwPYcj1pwcJDaBQxvEG6DEa9CxmAG6lMvJAGBLRkaciNgD4ZJDJ++z4wNrhb9f+IBKRG3tQzdPpxBKw6OwH4q4OMjrJHiUpA/R56JeIBo9gpDw4LUkDGsvQDKhMM6AyzYDKNAMq0wyoTDOgMkUGyFf7mV5SUvArvP/y7r/aQxW0oVnyftdDSkk+E+wAJGZe2eYmlXbq5da8go0AL3ph5BkNyC9rLQPkXVpAIXwnmNsAMymaoYyQ2AAoxs71cbm7AQR1vZEBlMWRWjdGyn8jdL/+R0K+dENYC+INSCnR/eYQE76eZgySuS0CA1gOXWKAxFITo9MYsPAPMkyY1SHmMwnX2gCtitdSrPP5zGGMKUXAhfbpKwyb84g1ALL8J6pRY8DdngoioKSHC6+Jwb0xQ2HOYRxjABLRi8ncFfRyGWoAQQQ9UcgPA5iDNwDN3/+DzCADdDX1XdyiPFJugA4SknUE+RJrzF009YrGhRggsOJ6CoLBoz0YZICeRZpGVckOoJicR3I/hKEmFQ7SvQFMg3G8AXqMRmrRtYeQbwBn50j9FIbJRocSvXj1ra8wps86JDYAQKVZ9Yj43pYfWDuqFFBrjodu9iDPZX6QAaEBooSIu1qMrpTkiFCHw0FH00kxSAqM1A/2kzSgsQzNgMo0AyrTDKjK6/UXUsNEk5LT/tQAAAAASUVORK5CYII=)"
      ],
      "metadata": {
        "id": "vueHQFHGuE79"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Concept 5: Variables"
      ],
      "metadata": {
        "id": "ynoFaytZ9iAG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "Variables are a way to store your data such that you can reuse it easily. In addition, as your code becomes more complicated, it will also become confusing to understand and use; using variables alleviates this.\n",
        "\n",
        "Variables can be visualized as a box with a label on it. You first put your number or word in the box by setting the label equal to it. Pay attention to how we assign the value to the variable. The name of the variable must be on the left of assignment operator ```=``` followed by the value on the right.\n",
        "\n",
        "```variable_name = 5``` places the integer ```5``` into a variable called ```variable_name```:\n",
        "\n",
        "![variable_example.png](data:image/png;base64,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)\n",
        "\n",
        "\n",
        "When Python sees the label later in the code, it will look to whatever is in the box instead.\n",
        "\n",
        "```variable_name + 1``` would return ```6```:\n",
        "\n",
        "![variable_example 2.png](data:image/png;base64,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)\n",
        "\n",
        "\n",
        "\n",
        "Here is an example on how variables can make the purpose of code clearer:"
      ],
      "metadata": {
        "id": "p2lFp77sVp_v"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "(2+2+3+3+2+2+3)/(7)"
      ],
      "metadata": {
        "id": "XPVljnAUr3dF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "It is difficult to discern what it is doing without any context.\n",
        "\n",
        "However, by using variables:"
      ],
      "metadata": {
        "id": "-y3zj5-bs3vP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Storing the numerator and the denominator in variables\n",
        "number_of_vowels = 2+2+3+3+2+2+3\n",
        "days_of_week = 7\n",
        "\n",
        "#Before doing the divison using the variables instead\n",
        "average_vowels = number_of_vowels/days_of_week\n",
        "print(average_vowels)"
      ],
      "metadata": {
        "id": "Ifs-_zKNuvvD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "It becomes somewhat apparent that the code is finding the average number of vowels in the names of the days of the week.\n",
        "\n",
        "It's now also possible to use these variables again like so:"
      ],
      "metadata": {
        "id": "Anm0RnqZvgER"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "number_of_consonants = 4+4+4+6+6+4+5\n",
        "\n",
        "#Using the number_of_vowels variable we created before\n",
        "vowel_ratio = number_of_vowels/number_of_consonants\n",
        "print(vowel_ratio)"
      ],
      "metadata": {
        "id": "IyvfWAN-wcQF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Notice how we could simply type in ```number_of_vowels``` without needing to compute the whole sum again.\n",
        "\n",
        "\n",
        "---\n",
        "**TASK 5**\n",
        "\n",
        "Let's apply a variable to Task 4 from Concept 4.\n",
        "\n",
        "Create a code box below, then by assigning the integer ```5``` to a variable:\n",
        "\n",
        "\n",
        "1.   Print the data type of your variable\n",
        "2.   Convert it to a float using ```your_variable = float(your_variable)``` and print out its data type again\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "hCgj6YuFxVak"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The code should output the data types exactly like in Task 4."
      ],
      "metadata": {
        "id": "ReyR3LBDKTZP"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Concept 6: Lists"
      ],
      "metadata": {
        "id": "mb4Hxsf4-Qrn"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "Whereas variables are similar to a box with a label on it, lists are similar to a row of boxes with a label on it. While a variable is capable of storing only one value, lists can store multiple.\n",
        "\n",
        "We can create a list by separating each value with a comma and enclosing it all with square brackets like so: ```list_example = [value1, value2]```\n",
        "\n",
        "```list_name = [5, 10, 15]``` places the integers 5, 10 and 15 into a list called ```list_name```:\n",
        "\n",
        "![list_example.png](data:image/png;base64,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)\n",
        "\n",
        "You may notice that there's a problem with this: If a list can store multiple values, how do we know which value is the one we want to take out and use?\n",
        "\n",
        "This is where indexing comes in. The \"boxes\" of a list are labelled or indexed in order, starting from zero. By specifying the index of the list we want, we are able to retrieve the value from that index.\n",
        "\n",
        "See the example below:"
      ],
      "metadata": {
        "id": "FJQfwbCdVuU4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#We first create a list.\n",
        "\n",
        "street = [1, \"Grafton\", \"Road\"]\n",
        "\n",
        "#To pick out the first value stored in the list, we use an index of zero.\n",
        "\n",
        "street[0]"
      ],
      "metadata": {
        "id": "RjoOBXGsg7hi"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#To pick out the second, use an index of one, and so on.\n",
        "\n",
        "street[1]"
      ],
      "metadata": {
        "id": "Wcdm8vYFmNeo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Checking the whole list we can see everything we originally stored:\n",
        "\n",
        "street"
      ],
      "metadata": {
        "id": "uVQWJGIJiJeI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#We can do everything we can with variables with each individual value of the list\n",
        "\n",
        "street[0] = float(street[0])\n",
        "street[1] = \"The jaws that bite\"\n",
        "street[2] = \"The claws that catch\"\n",
        "\n",
        "street"
      ],
      "metadata": {
        "id": "4OlsqfmkiNYr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Notice how the values stored in the list can be of different types.\n",
        "\n",
        "\n",
        "---\n",
        "**TASK 6**\n",
        "\n",
        "Edit and complete the code below such that it displays the first five prime numbers in order:"
      ],
      "metadata": {
        "id": "i2UXf-IHnmUc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "your_list = [2, 3, 11, 7, 5]\n",
        "\n",
        "print(your_list[0])\n",
        "print(your_list[1])\n"
      ],
      "metadata": {
        "id": "NfYZt3E7ogQw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Concept 7: Libraries"
      ],
      "metadata": {
        "id": "fMRirFWl-t4X"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "Of course, many others have already created functions with specific uses in mind. Libraries are a collection of functions that you can import into Python and use yourself. NumPy is a specialised library for numerical calculations, we use it for extra mathematical operations and for creating specialized lists called arrays.\n",
        "\n",
        "We first import the library with the syntax ```import library_name as prefix```:"
      ],
      "metadata": {
        "id": "YVtZeo8yWqY_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Importing numpy with np as the prefix\n",
        "import numpy as np"
      ],
      "metadata": {
        "id": "mq8ph37PLqod"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Since we imported the library as ```np``` we have to add ```np.``` to the front of the function we are using from that library. For instance, if we want to use ```exp()``` from Numpy to calculate Euler's number exponentiated to one, we do:"
      ],
      "metadata": {
        "id": "erM5aa6SLt5x"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "np.exp(1)"
      ],
      "metadata": {
        "id": "S3cz1uPkMmOt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Which gives us back Euler's number as we would expect.\n",
        "\n",
        "Earlier in this section we mentioned creating something called \"arrays\".\n",
        "\n",
        "Numpy's arrays are a type of list that are optimized for numerical calculations, hence we usually use these in physics. To turn a list into an array, we can use Numpy's ```array()``` function like so:"
      ],
      "metadata": {
        "id": "gxsdBRSdhC-J"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Creating a list first\n",
        "example_list = [1,2,3,4]\n",
        "\n",
        "#Then converting it into an array\n",
        "new_array = np.array(example_list)\n",
        "\n",
        "new_array"
      ],
      "metadata": {
        "id": "sDuZ1mi4hEG-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "There are two functional differences between a list and an array.\n",
        "\n",
        "1.   While Python's lists can contain multiple data types, Numpy's arrays can only contain one.\n",
        "2.   Numpy's arrays allow element-by-element operations\n",
        "\n",
        "You may be confused as to what the meaning of the second difference is. This is easier shown than explained. Consider the following example where we attempt to divide a list by two:"
      ],
      "metadata": {
        "id": "M8h1KQ__hnmY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "python_list = [2,4,8,16]\n",
        "\n",
        "result = python_list/2"
      ],
      "metadata": {
        "id": "n4Ls7NvXibqf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Note how the code results in an error, compared to the next example where we divide an **array** by two:"
      ],
      "metadata": {
        "id": "1pbzcJxvikp-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "python_list = [2,4,8,16]\n",
        "\n",
        "numpy_array = np.array(python_list)\n",
        "\n",
        "result = numpy_array/2\n",
        "\n",
        "print(result)"
      ],
      "metadata": {
        "id": "xre3kwa6iqW2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Which intuitively results in every value in the array being divided by two. It also changes what happens when you add lists from:"
      ],
      "metadata": {
        "id": "2kHKXeSBi9uU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Concatenation\n",
        "[1] + [1]"
      ],
      "metadata": {
        "id": "WoV59TnQrhXr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "To:"
      ],
      "metadata": {
        "id": "MGDovWK7r0Hg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Values are added\n",
        "np.array([1]) + np.array([1])"
      ],
      "metadata": {
        "id": "ZcpC72Emr1PP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "We can import many different libraries at the same time. There is another important library that you will often be using and that is Matplotlib, a library specialized in graphing. You will be introduced to Matplotlib later in this notebook.\n",
        "\n",
        "---\n",
        "**TASK 7**\n",
        "\n",
        "\n",
        "Now, create a code box below and use Numpy's ```sin()``` and ```cos()``` functions to:\n",
        "\n",
        "*   Compute sine of 30 degrees and place it into a variable\n",
        "*   Compute cosine of 60 degrees and place it into a variable\n",
        "*   Display both results in an array\n",
        "*   Print out the data type of your answer\n",
        "\n",
        "Note that Numpy's trigonometric functions use radians, not degrees. To convert degrees to radians, apply this formula:\n",
        "$$degrees/360 *2π$$\n",
        "You will not need to import Numpy again."
      ],
      "metadata": {
        "id": "b24kAG_SMuZI"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Your code should be displaying an array ```[0.5, 0.5]```. The numbers within may not be exactly 0.5 - this is because the trigonometric functions are approximated. The data type of the answer should read as ```numpy.ndarray```.\n"
      ],
      "metadata": {
        "id": "6H8VUFYERGTK"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Concept 8: While Loops"
      ],
      "metadata": {
        "id": "3Zq1Lcg4AAUN"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "Loops are a way to deal with repetitive tasks in Python. They will also be your primary method of navigating through arrays.\n",
        "\n",
        "While loops are based on the idea of running a piece of code over and over again **while** a logical statement remains true. They usually take this form:\n",
        "\n",
        "```\n",
        "while logical_statement:\n",
        "  do_something_useful\n",
        "  change_logical_statement\n",
        "\n",
        "```\n",
        "You may need a brief introduction to boolean expressions but these are quite intuitive:\n",
        "\n",
        "\n",
        "\n",
        "*   Greater than, less than, greater or equal than, etc. all work as you would expect as ```>, <, >=``` and so on.\n",
        "*   Equality is ```==``` not the ```=``` which we have been using to assign values to variables.\n",
        "*  Connecting two expressions with ```and``` returns ```True``` if both are true\n",
        "*  Connecting two expressions with ```or``` returns ```True``` if either are true\n",
        "\n",
        "\n",
        "Here's an example:"
      ],
      "metadata": {
        "id": "wuHGxFnqWCG3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#creating my variables\n",
        "growth = 5\n",
        "stock = 0\n",
        "\n",
        "#while growth is positive, add one to stock then decrease growth\n",
        "while growth > 0:\n",
        "  stock = stock + 1\n",
        "  growth = growth - 0.5\n",
        "\n",
        "#printing the end result of the variables\n",
        "print(growth)\n",
        "print(stock)"
      ],
      "metadata": {
        "id": "hVmwEbBnfsaL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "It can be seen that the code executed until ```growth > 0``` was no longer ```True```.\n",
        "\n",
        "If you're unconvinced, you can move the ```print(growth)``` and ```print(stock)``` statements into the while loop so you can see how the variables change during the while loop.\n",
        "\n",
        "\n",
        "---\n",
        "**TASK 8**\n",
        "\n",
        "Edit the code below such that it displays all the elements in the list:\n",
        "\n",
        "(Hint: If your code is producing nothing at all, check the  ```while``` statement again)"
      ],
      "metadata": {
        "id": "XtBzbRyXgbZT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_song = [\"We're\", \"no\", \"strangers\", \"to\", \"love\"]\n",
        "index = 0\n",
        "critical_error = 1\n",
        "list_length = 5\n",
        "\n",
        "while index < list_length and critical_error == 0:\n",
        "\n",
        "  current_word = my_song[index]\n",
        "  print(current_word)\n",
        "  index = index + 2\n",
        "\n"
      ],
      "metadata": {
        "id": "J_e0Ixx_jPVW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Concept 9: Using Matplotlib to Produce Graphs"
      ],
      "metadata": {
        "id": "SQYMa6enALpX"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "We can now implement what we have learnt to produce graphs with Matplotlib's Pyplot library.\n",
        "\n",
        "Let's try to make a simple line graph. The first step is of course, to ```import``` the library. From Matplotlib, we need Pyplot, so:"
      ],
      "metadata": {
        "id": "zyl35LQvWu_1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Importing pyplot (from matplotlib) with the prefix plt\n",
        "import matplotlib.pyplot as plt"
      ],
      "metadata": {
        "id": "VkestK8i7DUr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now, we can't plot anything without x and y values right? Let's make some arrays and use those as values. Although earlier we made arrays by changing them by hand from lists, Numpy has some functions which can expedite this process.\n",
        "\n",
        "Numpy's ```arange(start, stop, step)``` returns an array with values starting at ```start``` (inclusive) and ending at ```stop``` (exclusive), in increments of ```step```.\n",
        "\n",
        "Here's an example of the function running:"
      ],
      "metadata": {
        "id": "7HAYWZoJ7I3_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#np.arange with start = 1, stop = 5, step = 1:\n",
        "np.arange(1,5,1)"
      ],
      "metadata": {
        "id": "7vuvqxYUmcGv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Numpy's ```linspace(start, stop, number)``` returns an array with ```number``` values starting at ```start``` (inclusive) and ending at ```stop``` (inclusive).\n",
        "\n",
        "Here's an example of the function running:"
      ],
      "metadata": {
        "id": "NS6K4I8eqrW1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#np.linspace with start = 1, stop = 4, number = 4:\n",
        "np.linspace(1,4,4)"
      ],
      "metadata": {
        "id": "-5nyvSPWqz3F"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now that we understand how to create the arrays we want, we can proceed:"
      ],
      "metadata": {
        "id": "H_vKJ5F3vEV9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x_values = np.arange(1,5,1)\n",
        "y_values = np.linspace(1,4,4)\n",
        "\n",
        "print(x_values)\n",
        "print(y_values)"
      ],
      "metadata": {
        "id": "kA4KCudI8mT4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now to actually plot the values, we can use Matplotlib's ```plot()```. We also use ```title()``` to add a title and ```show()``` to display the graph:"
      ],
      "metadata": {
        "id": "OS-DIQ3v9bfK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Plotting y_values array against x_values array:\n",
        "plt.plot(x_values, y_values)\n",
        "\n",
        "#Setting \"A Straight Line\" as the title of the plot:\n",
        "plt.title(\"A Straight Line\")\n",
        "\n",
        "#Displaying the graph:\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "kPGja1Q4_rqz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "This is perhaps, the most barebones graph you could make - Matplotlib's capabilities are much greater than this.\n",
        "\n",
        "Setting that aside, it is important to note that there is nuance in how you plot values. Take for instance, this plot of y = sin(x):"
      ],
      "metadata": {
        "id": "IHZNsXYnA8n1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Making new x_values and y_values:\n",
        "x_values = np.linspace(0, 2*np.pi, 3)\n",
        "y_values = np.sin(x_values)\n",
        "\n",
        "#Putting labels on the x axis and y axis this time, and restricting the view of the graph to between y = -1.5 and y = 1.5\n",
        "plt.plot(x_values, y_values)\n",
        "plt.xlabel(\"x\")\n",
        "plt.ylabel(\"sin(x)\")\n",
        "plt.ylim(-1.5, 1.5)\n",
        "plt.title(\"Plot of y = sin(x)\")\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "BFN_3neODKco"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Doesn't look very much like the sine function does it? It's as if we plotted y = 0 instead.\n",
        "\n",
        "What exactly is the issue here? Well, create a code box below and have a look at our ```x_values```."
      ],
      "metadata": {
        "id": "aUveMfeaEYWR"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "It's clear exactly what is happening now. With our current x values, we are plotting exactly **3** points:\n",
        "\n",
        "\n",
        "\n",
        "1.   0, sin(0)\n",
        "2.   π, sin(π)\n",
        "3.   2π, sin(2π)\n",
        "\n",
        "In other words:\n",
        "\n",
        "\n",
        "\n",
        "1.   0, 0\n",
        "2.   π, 0\n",
        "3.  2π, 0\n",
        "\n",
        "It's important to understand what you are doing in your code.\n",
        "\n",
        "\n",
        "---\n",
        "**TASK 9**\n",
        "\n",
        "\n",
        "Here's the code from above again, alter it such that the graph has sufficient detail (but don't go overboard):"
      ],
      "metadata": {
        "id": "84O8oQyDEzhi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x_values = np.linspace(0, 2*np.pi, 3)\n",
        "y_values = np.sin(x_values)\n",
        "\n",
        "plt.plot(x_values, y_values)\n",
        "plt.xlabel(\"x\")\n",
        "plt.ylabel(\"sin(x)\")\n",
        "plt.ylim(-1.5, 1.5)\n",
        "plt.title(\"Plot of y = sin(x)\")\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "AfKvjfVgHAAX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Extension Activity 1: Defining a Function"
      ],
      "metadata": {
        "id": "H16YmhdQCjaD"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "You will often require functions which exceed the capabilities of the ones found in Python, or which are specific to what you are coding. To address this, we are able to define our own functions. The syntax for doing this is as follows:\n",
        "\n",
        "```\n",
        "def function_name(parameter1, parameter2):\n",
        "    ... #statements which define function\n",
        "    return output1, output2\n",
        "```\n",
        "\n",
        "Let me give you an example, the function below takes in an integer or a float and returns that number exponentiated to 3, 6 and 9:"
      ],
      "metadata": {
        "id": "952EpnARbhxU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Defining the function:\n",
        "def exponentiate_369(number):\n",
        "  exponent3 = number**3\n",
        "  exponent6 = number**6\n",
        "  exponent9 = number**9\n",
        "\n",
        "  return exponent3, exponent6, exponent9\n",
        "\n",
        "#Using the function:\n",
        "all_results = exponentiate_369(2)\n",
        "all_results"
      ],
      "metadata": {
        "id": "rdo3FzuSbhxV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "There are some very important points that you should note:\n",
        "\n",
        "\n",
        "*   You can have any number of parameters defined in a function, the function above has one: ```number```\n",
        "*   Whatever value is given to the function as a parameter takes the place of the name of the parameter in the rest of the function. In the example above, we gave that function ```2```. The following numbers ```exponent3```, ```exponent6``` and ```exponent9``` were then calculated with ```2``` in place of ```number```\n",
        "* You can have any number of outputs defined in a function, the function above has three. The ```print()``` function would be an example of a function that has zero.\n",
        "* The code that is defining the function is indented once past the ```def``` statement.\n",
        "\n",
        "\n",
        "---\n",
        "**TASK 10**\n",
        "\n",
        "\n",
        "Create a code box below, and try defining a function that takes in two numbers and returns their sum as a float. Check that it works by evaluating a sum of your choice and that the ```type()``` function shows that it is a float.\n"
      ],
      "metadata": {
        "id": "Yp8W2BRybhxV"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Extension Activity 2: For Loops"
      ],
      "metadata": {
        "id": "ULEutRDqDVC9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "\n",
        "We also have for loops. For loops are based on the idea of running a piece of code **for** a certain number of times. They usually take this form:\n",
        "\n",
        "```\n",
        "for value in a_sequence:\n",
        "  do_something_useful\n",
        "\n",
        "```\n",
        "\n",
        "Here's an example:"
      ],
      "metadata": {
        "id": "KziUS8_PcLZE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#creating a list with values \"Apple\", \"Salmon\" and 1\n",
        "fruit_basket = [\"Apple\", \"Salmon\", 1]\n",
        "\n",
        "#for each value in the list, check if the value is a string, then print something depending on whether it is or not\n",
        "for fruit in fruit_basket:\n",
        "\n",
        "  if type(fruit) == type(\"string\"):\n",
        "    print(fruit + \" is my favourite fruit\")\n",
        "\n",
        "  else:\n",
        "    print(str(fruit) + \" is not a fruit.\")\n",
        "\n",
        "#printing the end result of the fruit variable\n",
        "print(fruit)"
      ],
      "metadata": {
        "id": "h6B8yqt1cLZE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Note how the code within the loop was ran once for every value in the list, and that the value in the list took the place of ```fruit``` in the code. In addition, the ```fruit``` variable did not need to be created prior to the for loop.\n",
        "\n",
        "\n",
        "---\n",
        "**TASK 11**\n",
        "\n",
        "Try using a for loop below to change the given list such that each value has been divided by two:\n",
        "\n",
        "(Hint: Have a variable that keeps track of what index of the list that the for loop is on)"
      ],
      "metadata": {
        "id": "Wh0W-2t1cLZF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_numbers = [2,4,6,8,10]\n",
        "\n",
        "\n",
        "\n",
        "print(my_numbers)"
      ],
      "metadata": {
        "id": "Ec5Spcw_cLZF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Check that the list is now ```[1, 2, 3, 4, 5]```. Remember that you are altering the *original* list - not making a new one."
      ],
      "metadata": {
        "id": "dPP3cUa0cLZF"
      }
    }
  ]
}