1_02_Getting_Started_With_Colab.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyMDs5cxsylWKWDmuINJgYh9",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/edwardoughton/spatial_computing/blob/main/1_02_Getting_Started_With_Colab.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Getting started with Google Colab**\n",
        "\n",
        "In this class we will use `Google Colab` to engage with the course content and run Python code in a single integrated development environment.\n",
        "\n",
        "Some of you may have used `Jupyter Notebooks` previously to read, write and run code (also known as iPython Notebooks, thus the .ipynb file extension).\n",
        "\n",
        "In which case, you might have been familiar with the traditional approach to running Python. This often begins with downloading the data science meta-package Anaconda, creating a virtual environment to run the code, and then getting started with your notebook.\n",
        "\n",
        "Thankfully, Colab does at lot of this hard work for us, enabling us to run Python code from a web browser on Google Cloud. Essentially, this is a virtual machine, meaning we will run the analysis on Google's servers, rather than using our own computing resources (e.g., CPU/GPU, RAM etc.).\n",
        "\n",
        "Each notebook is stored in your Google Drive, and you can easily share each one further with friends, collaborators, professors etc.\n",
        "\n",
        "This means we might not need to create a virtual environment at all, massively simplifying the process for new comers to begin reading and writing Python code.\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "1XkASiz6wJuX"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Requirements**\n",
        "\n",
        "There are a set of key requirements you will need, including:\n",
        "\n",
        "1.   A Google account with Google Drive\n",
        "2.   An Internet connection (e.g., >10 Mbps)\n",
        "\n",
        "If you do not have a Google account (I know, unlikely in this day and age), please can you create one now.\n"
      ],
      "metadata": {
        "id": "phEUzB7D4EPF"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Exploring Colab**\n",
        "\n",
        "Now we get to start the fun part (*playing with some introductory Python code!*).\n",
        "\n",
        "To do that, we can go to Colab and start a new notebook (click the big `New notebook` button):\n",
        "\n",
        "https://colab.research.google.com/\n",
        "\n",
        "To summarize, a notebook is basically a collection of cells which we can define as either being text *or* code. Here, the text is written in Markdown, and the code is written in Python. In fact, we can combined both executable code, our markdown text, and HTML code, images and many other file types in this single flexible format.\n",
        "\n",
        "You can learn other programming languages, however Python is one of the most powerful that you can still easily read.\n",
        "\n",
        "Ideally, you should aim to become an advanced programmer in a language such as Python, before you look to become a beginner/intermediate programmer in another (as there is great value in becoming a pro, rather than being a beginner in multiple).\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "ZqlNYhFawNHj"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Modes and navigation**\n",
        "\n",
        "Importantly, Colab, like any iPython notebook (.ipynb) has two modes:\n",
        "\n",
        "- Edit mode. Press enter (or double-click) on a cell to directly edit the contents you are located on.\n",
        "- Command mode. Press escape to exit a cell and then navigate elsewhere.\n",
        "\n",
        "Once you are in command mode, it is possible to navigate using the up or down arrows on your keyboard navigation section.\n",
        "\n",
        "Pressing shift and up/down will allow you to multiple highlight (e.g., in preparation for a copy/paste).\n"
      ],
      "metadata": {
        "id": "r8zUrv8q2dLN"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Executing code**\n",
        "\n",
        "Our first example of a code cell is present below, where we will print a string to the console (a string is a sequence of characters).\n",
        "\n",
        "Either click the round play button, or type control + enter to execute (or Apple command + enter on Mac)."
      ],
      "metadata": {
        "id": "lvs5kcdRlvA2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Welcome to GGS590\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Bc-RwO8Ulowy",
        "outputId": "64934dea-9c53-4278-872d-4f3fa5365987"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Welcome to GGS590\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Congratulations, you have run your first Python code in this class!\n",
        "\n"
      ],
      "metadata": {
        "id": "VU87HyLkqk4L"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Commenting in a code cell**\n",
        "We are able to write comments into our Python cells by using the pound sign e.g., '#'."
      ],
      "metadata": {
        "id": "UZyn6MbyyLH5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 2 + 2    <- hashed out, so Python does not execute!\n",
        "1 + 1     #<- whereas Python will execute this"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MBYo78RSqmT6",
        "outputId": "e10d29cc-1ba8-44c7-8682-8967440496e2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {},
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Text cells**\n",
        "\n",
        "Alternatively you can add in your own text cells. When you hover between each cell, you will see either the `Code` or `Text` icons show up, which you can click on as desired (you can also convert a code cell to a text cell by pressing control + M M).\n",
        "\n",
        "Have a go at adding a text cell below."
      ],
      "metadata": {
        "id": "R8KRG0UXw2Fe"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "As mentioned previously, Markdown is a simple markup language (essentially, a basic approach for outlining a document text/image layout and presentation format).\n",
        "\n",
        "Some key formatting includes the following:\n",
        "\n",
        "*   Making an item bold using a **double asterisk**.\n",
        "*   Making an item italicized using a *single asterisk*.\n",
        "*   Adding a strikethrough using ~~double tilde~~.\n",
        "*   Or adding a hyperlink [using square parentheses followed by the address in regular parentheses](https://www.google.com).\n",
        "\n",
        "The other key formatting technique you might like to use is for heading titles, as follows:\n",
        "\n",
        "*   \"# Large heading\"           \n",
        "*   \"## Medium heading\"\n",
        "*   \"### Small heading\"\n",
        "*   \"#### Very small heading\"\n",
        "\n",
        "These titles are all in quotes to prevent Colab thinking they are real section headings. Remember to remove the quotes if you want to use them properly. Colab will add each heading to the table of contents.\n",
        "\n",
        "For more information, see the Colab Markdown guide, [here](https://colab.research.google.com/notebooks/markdown_guide.ipynb)."
      ],
      "metadata": {
        "id": "ka89VaU9sbYZ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Python as a calculator**\n",
        "Obviously, we will want to run a range of operations and Python is very supportive for numerical computing.\n",
        "\n",
        "Addition:\n"
      ],
      "metadata": {
        "id": "eqfS5LYRmhkY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "2 + 5"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PVwq0Y2gmwn4",
        "outputId": "fae43d49-37ba-411d-8e75-055729f5a8b7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "7"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Subtraction:"
      ],
      "metadata": {
        "id": "E303BVRRm4xH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "20 - 10"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Z0Mhafbjm17Y",
        "outputId": "3e5d4d90-4e23-4625-eec5-6a6d4e2a7f91"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "10"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Multiplication:"
      ],
      "metadata": {
        "id": "x72RXCkfm3pY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "3 * 2"
      ],
      "metadata": {
        "id": "Uu8YwPt_nS8h"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Division:"
      ],
      "metadata": {
        "id": "g6Hnk7iInZ-H"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "50 / 10"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ClquzYNYnck4",
        "outputId": "d8cb9e02-3a4f-4c23-dc8c-3332bf9d45a7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5.0"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Raising a number to a power:"
      ],
      "metadata": {
        "id": "np5qQ9y0nk_w"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "3**3"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "o9J0Ua_0oB6X",
        "outputId": "44e52f4c-a81b-40e6-c6c3-f17c989764e6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "27"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Do not forget to follow a proper order of operations, such as Parenthesis, Exponents, Multiplication, Division, Addition and Subtraction (PEMDAS) (or other common variant BODMAS, BIDMAS etc.).\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "Dk2vAQncpYjp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Consider\n",
        "8 / 2 + 2"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3qjN9wuMp2dI",
        "outputId": "b399b4e2-f336-42a5-ab2f-015f55ac0293"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "6.0"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Versus\n",
        "8 / (2 + 2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "m421eVEWqHUo",
        "outputId": "97fb884a-5142-44ec-9a37-f234178a7836"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2.0"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Scientific notation**\n",
        "\n",
        "We can also write in scientific notation using the `e` character to signify the number of zeros. There are many benefits.\n",
        "\n",
        "For example, for 1,000 we can write:"
      ],
      "metadata": {
        "id": "qeE1Ke0noU3U"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "1e3"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NPLWtdiXoWek",
        "outputId": "303f9780-c228-4ede-c75b-8376c67cdeca"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1000.0"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Just as for 1 million we can write:"
      ],
      "metadata": {
        "id": "L7Yi1urwo-gH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "1e6"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Sh21LsLUpC3J",
        "outputId": "0f8cf4a4-54fa-4ced-cd9c-807dcc125d65"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1000000.0"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **In-line commenting**\n",
        "\n",
        "Be aware that the pound/hash sign enables you to directly write natural language into a coding cell.\n",
        "\n",
        "For example, in the coding cell below we have both hashed out text, and code we want to execute.\n",
        "\n",
        "Examine how using `#` will indicate to Python you want to ignore whatever is written to the right hand side of this line.\n",
        "\n"
      ],
      "metadata": {
        "id": "qRIU2pOOD07q"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# In-line commenting\n",
        "# 2 + 2    <- hashed out, so Python does not execute 2 + 2!\n",
        "1 + 1     #<- whereas Python will execute this"
      ],
      "metadata": {
        "id": "YSBbZ06GD0c6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Example: Please have a go running `4 + 8` hashed out, and `5 - 2` unhashed\n"
      ],
      "metadata": {
        "id": "LULNol2FE6Ul"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Exercise**\n",
        "\n",
        "Create a new Colab notebook for this task. The aim is for you to apply and reinforce what you have learned here on code/text cells.\n",
        "\n",
        "Your smartwatch has provided you with detailed stepcount data for your day. You want to verify if the calories burned estimate this metric correctly.\n",
        "\n",
        "For your age/body type, you understand you are likely to burn 0.04 calories per step.\n",
        "\n",
        "Do the following for at least 5 daily periods:\n",
        "\n",
        "*   Create a text cell describing an activity period (e.g., walked to class from bus stop), how far you walked (e.g., 1,000 steps), and at what time (e.g., 4pm) (for the purposes of this exercise, please be creative).  \n",
        "*   Then add a code cell below which calculates the calories burned for that period.\n",
        "*   At the end, create a summary cell which summarizes the calories for each period.\n",
        "\n",
        "Use what you have learned in this introductory lecture to properly style your text and code cells, to make the calculations intelligible and clear to an external reviewer.\n"
      ],
      "metadata": {
        "id": "NU_XOdBsoLJl"
      }
    }
  ]
}