Introduction_to_Colab_and_Python.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/bmill42/streaming-data/blob/main/Introduction_to_Colab_and_Python.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zbJ2fw29OHAX"
      },
      "source": [
        "Attribution note: This tutorial is modified from the original [notebook](https://colab.research.google.com/github/data-psl/lectures2020/blob/master/notebooks/01_python_basics.ipynb) prepared by Mathieu Blondel, publicly available on GitHub. Here is a link to the [Apache 2.0 license](https://github.com/mrArpanM/learn-python/blob/main/LICENSE) for the original."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YV4sYCn8EPwb"
      },
      "source": [
        "# Colab Notebooks"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2HuuwOcQEYQI"
      },
      "source": [
        "For the rest of the semester, we will be programming in Python using **Jupyter notebooks** hosted through **Google Colab**. A Jupyter notebook is a file that can contain both Python code and rich text contents - it is a user-friendly way to introduce code with accompanying instructions and commentary. It is not a great way to build an app that needs to run independently, but it is perfect for learning and for working with code that is exploratory or experimental, hence the notebook's popularity in the field of machine learning.\n",
        "\n",
        "Colab is a service from Google that runs notebooks on the cloud for free, which means that you don't have to install Python on your own computer. This saves us a lot of trouble, though it does introduce some limitations: Google will end your programming session after a certain amount of time, and our code is running on a computer that we don't control."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t0XmMkPuGGOs"
      },
      "source": [
        "Beause we're working in a notebook, you can both follow along with my examples and run/modify code directly. Notebooks consist of **code cells**, which are blocks of one or more Python instructions. For example, here is a code cell that stores the result of a computation (the number of seconds in a day) in a variable and prints its value:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qeGAvLq1ALJ4"
      },
      "source": [
        "seconds_in_a_day = 24 * 60 * 60\n",
        "seconds_in_a_day"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "njoPs3q1G75-"
      },
      "source": [
        "Click on the \"play\" button to execute the cell, or press Shift-Enter while the cursor is inside the cell. You should be able to see the result. Alternatively, you can also execute the cell by pressing Ctrl + Enter if you are on Windows / Linux or Command + Enter if you are on a Mac (Shift + Enter should also work on most platforms)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NvdYaBgHHdbw"
      },
      "source": [
        "The entire notebook is a single active Python environment, so variables that you defined in one cell can later be used in other cells:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s1kp5Zv0JBSx"
      },
      "source": [
        "seconds_in_a_week = 7 * seconds_in_a_day\n",
        "seconds_in_a_week"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uALfY4q1JFQ0"
      },
      "source": [
        "Note that the order of execution is important. For instance, if we do not run the cell storing *seconds_in_a_day* first, the above cell will raise an error, as it depends on this variable. You can always clear any errors and ensure things run in the correct order by going to Runtime > Restart Session in the menu."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HvXs_KaoRWQ9"
      },
      "source": [
        "**Exercise.** Add a cell below this cell: click on this cell then click on \"+ Code\". In the new cell, compute the number of seconds in a year by reusing the variable *seconds_in_a_day*. Run the new cell."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qyLSwlxnJqXX"
      },
      "source": [
        "# Python"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3ltwm91eJyQM"
      },
      "source": [
        "Python is one of the most popular programming languages for data science, both in academia and in industry. It is also relatively user-friendly and thus a good language to start with if you are just starting out with textual programming languages.\n",
        "\n",
        "In this session we'll go over some of the basics of Python. The best way to work through this notebook (and most of the others we'll use) will be to run each cell as you get to it, after reading the accompanying text."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3EKvP6jiMZ9H"
      },
      "source": [
        "## Arithmetic operations and code comments"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DDjs0-7YQ80h"
      },
      "source": [
        "Python supports the usual arithmetic operators: `+` (addition), `*` (multiplication), `/` (division), `**` (power/exponent), `//` (integer division), `%` (modular division).\n",
        "\n",
        "Many Python environments, including Jupyter notebooks, are *interactive*, which means that you can treat them almost like a calculator - if you want to know the value of a variable or the result of a calculation, you just type the operation in directly and run the cell:"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "81 + 42"
      ],
      "metadata": {
        "id": "o_S7DNFX5_Ou"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "In a lot of other programming languages, you would need to do this in multiple steps: assign a variable and then use some kind of `print` command to write the variable's value to the screen. Python can operate this way, too:"
      ],
      "metadata": {
        "id": "UOluc2In62I5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "new_variable = 2**10\n",
        "print(new_variable)"
      ],
      "metadata": {
        "id": "QDyx1w3Z7DtT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "It's often helpful to add **comments** to code that don't affect the program's operation but help explain what's going on. In Python, the main way to add comments is to use the `#` sign; anything after the sign is ignored when the program runs."
      ],
      "metadata": {
        "id": "xq3BNnhL8f_W"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "45 // 4     # Integer division tells us how many times a number fits into another not counting any remainder"
      ],
      "metadata": {
        "id": "r9CpJ4Iu8xdC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UhcbBQUiStHG"
      },
      "source": [
        "## Lists"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RkPn1IjNTCxA"
      },
      "source": [
        "All objects in Python have a **type**. There are integers (whole numbers), floating point numbers (decimals), and strings (characters of text), among others.\n",
        "\n",
        "One of the most important types is a **list**. Lists are containers for ordered sequences of elements. Lists can be initialized empty using square brackets with nothing in them:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OrnV1ySAPtHp"
      },
      "source": [
        "my_list = []"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OwRqyYI9XnPK"
      },
      "source": [
        "or with some initial elements"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Uq5YTJ1JXpOX"
      },
      "source": [
        "my_list = ['a', 'b', 'c'] # anything in quotation marks has the *string* data type"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Hk2WmojJXyyz"
      },
      "source": [
        "Lists have a dynamic size, which means that elements can be added (appended) to them or removed. Python objects typically have **methods** associated with them---operations that can modify their contents or perform other actions.\n",
        "\n",
        "Methods are applied using the object name, a dot (`.`), and the method name with parentheses after it, e.g. `object.method()`. Sometimes the method takes in new information as an **argument**, as in the case we want to add something to a list. The argument goes inside the parentheses."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QFTNqiYiXxAh"
      },
      "source": [
        "my_list.append('d')\n",
        "my_list"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IUnJuqQ2Yhzw"
      },
      "source": [
        "We can access individual elements of a list using square brackets with a number inside. The number is an *index* that identifies where in the list an item sits. Python indices always start from zero, which is common in programming, so the third thing in the list is item `[2]`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pyFxyZPVYpG_"
      },
      "source": [
        "my_list[2]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hPMrIDYsdgMP"
      },
      "source": [
        "We can access *slices* of a list using `my_list[i:j]` where `i` is the start of the slice (again, indexing starts from 0) and `j` the end of the slice. The slightly confusing part is that the end index is not included. For instance:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ichf9p0gd7tJ"
      },
      "source": [
        "my_list[1:3]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "If you've dealt with intervals in math, list slices are always closed intervals on the low end and open intervals on the high end. Confusing? Yes. These kinds of situations are so common in computing that there's a name for the most typical kind of mistake you're likely to make: an *off by one error*. Here's an example, where I want to get the first four items of my list. What went wrong?"
      ],
      "metadata": {
        "id": "bR25vMqR-Rwy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_list[1:4]"
      ],
      "metadata": {
        "id": "vY0_n9ItAEDc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KMbzH4tzQ9rI"
      },
      "source": [
        "Sometimes, we may want everything in the list starting from a certain point. Omitting the second index means that the slice will run until the end of the list:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O7wCthKnREKV"
      },
      "source": [
        "my_list[1:]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "C5Aeu7PUebrK"
      },
      "source": [
        "We can check if an element is in the list using `in`. This gives us a Boolean value, `True` or `False`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a_P5NCi-efvb"
      },
      "source": [
        "'e' in my_list"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'d' in my_list"
      ],
      "metadata": {
        "id": "2x-6lNXsAcoR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LypIsP5gkl10"
      },
      "source": [
        "The length of a list, which is simply the number of items in it, can be obtained using the `len` function - this one is very useful."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ac0FMsaKkrWc"
      },
      "source": [
        "len(my_list)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1c3RLStf7G2I"
      },
      "source": [
        "## Strings"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Jm6hZhgz7KhI"
      },
      "source": [
        "Strings are used to store text. They can be delimited using either single quotes or double quotes, but be consistent! You can't mix them up for the same string."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cCma6Oj_7T8n"
      },
      "source": [
        "string1 = \"some text\"\n",
        "string2 = 'some other text'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Irr4xuWu7Znu"
      },
      "source": [
        "A string is basically a list of characters. As such, we can access individual elements in exactly the same way, by indexing the string variable:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "26_POhLO7iM3"
      },
      "source": [
        "string1[3] # asking for the fourth character in the string"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oA_UD0JV7oPw"
      },
      "source": [
        "and similarly for slices"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dcZFcLqQ7qCe"
      },
      "source": [
        "string1[5:]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hOQ_CIiu76YG"
      },
      "source": [
        "String concatenation is performed using the `+` operator. What's going on with the `\" \"`?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mxqNMKCY79_W"
      },
      "source": [
        "string1 + \" \" + string2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7Lox2GZCMdIB"
      },
      "source": [
        "## Conditionals"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-gXEAWFZfDTT"
      },
      "source": [
        "As their name indicates, conditionals are a way to execute code depending on whether a condition is True or False. As in other languages, Python supports `if` and `else` but `else if` is contracted into `elif`, as the example below demonstrates.\n",
        "\n",
        "Try changing the value of `my_variable` to test out the different conditions:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xC_DMZjofoYZ"
      },
      "source": [
        "my_variable = 5\n",
        "\n",
        "if my_variable < 0:\n",
        "    print(\"negative\")\n",
        "elif my_variable == 0:\n",
        "    print(\"null\")\n",
        "else: # my_variable > 0\n",
        "    print(\"positive\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ag0SUokSf9jl"
      },
      "source": [
        "Here `<` and `>` are the strict `less than` and `greater than` operators, while `==` is the equality operator (the single `=` is reserved solely for *assigning* variables). The operators `<=` and `>=` are used for `less/greater than or equal to`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qTkQ2F_jy8wz"
      },
      "source": [
        "Unlike most other languages, in Python blocks of code are delimited using indentation, i.e. tabs. That means that it's *crucial* that the code that goes along with each if/else condition is indented by one level. Try un-indenting one of the lines (or indent one that shouldn't be) and see what error you get."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "clWaFCzBMfkv"
      },
      "source": [
        "## Loops"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_A5doqhTivWe"
      },
      "source": [
        "Loops allow us to execute a block of code multiple times. There are two main types of loops: `while` loops and `for` loops."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YN8lwTxQkGEa"
      },
      "source": [
        "### While loops\n",
        "\n",
        "A `while` loop has a condition that is checked each time the loop begins. If the condition is `True`, the loop continues. If not, it stops."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7-QXGqgOjsr_"
      },
      "source": [
        "i = 0\n",
        "while i < len(my_list):\n",
        "    print(my_list[i])\n",
        "    i += 1 # equivalent to i = i + 1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Question:** Why did we set `i = 0` at the beginning, and why is `i` being modified in the loop even though it isn't being printed out?"
      ],
      "metadata": {
        "id": "-v1SRbAEDuHU"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8mEI_ocfkSvZ"
      },
      "source": [
        "### For loops\n",
        "\n",
        "A `for` loop takes in some kind of list and performs an operation once for each item in the list. There is always a special **loop variable** that holds onto the item currently being referenced in the loop.\n",
        "\n",
        "The loop variable is named right after `for` and assigned the values that come after `in`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XO6qqppikZvm"
      },
      "source": [
        "If the goal is simply to iterate over a list, we just assign the loop variable using the list itself:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PjFKzN6zkeJ7"
      },
      "source": [
        "for element in my_list:\n",
        "    print(element)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Alternatively, we can use the loop variable as a **counter** that tracks where we are in the list. This code for this looks a bit more messy, but first run it and see what it does:"
      ],
      "metadata": {
        "id": "3AeSabG1EycY"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2QObx5mckMcI"
      },
      "source": [
        "for i in range(len(my_list)):\n",
        "  print(i, my_list[i])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "See how two different things printed on each line? The first is `i`, the loop variable. The second is the actual list item, accessed using `i` an index.\n",
        "\n",
        "**Exercise:** In the next cell, isolate the code that uses the `range` function and figure out what it outputs."
      ],
      "metadata": {
        "id": "giDHhfxWFMFh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Test out the range() function"
      ],
      "metadata": {
        "id": "B2HeJSpFFkDP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Cck4zwYrex02"
      },
      "source": [
        "## Functions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n1PbIf_ohxFO"
      },
      "source": [
        "To improve code readability and reliability, it is common to assign a name to an operation so that we can call on it later without having to type out all the code again.\n",
        "\n",
        "Fundamentally, a function takes some input(s) and processes it to produce an output. The output is always indicated with the `return` keyword, and we start a new function definition with `def` (for 'define').\n",
        "\n",
        "A function's inputs, or **arguments**, are defined between the parentheses after the function's name. When we write a custom function, the name and arguments can be called anything we want."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cImA09gOhRmx"
      },
      "source": [
        "def square(x):\n",
        "    return x ** 2\n",
        "\n",
        "def multiply(a, b):\n",
        "    return a * b"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Like a loop or an `if` statement, a colon follows the first line of the definition and the rest of the code is indented."
      ],
      "metadata": {
        "id": "Rhn50vRbjErj"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Once the functions are defined, we can use them:"
      ],
      "metadata": {
        "id": "Gnik7iTYGrS5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "multiply(3, 2)"
      ],
      "metadata": {
        "id": "KsMPEHc9Gwcg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "square(5)"
      ],
      "metadata": {
        "id": "uqARGWK_HFWj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Functions can also be *composed*, which just means that the output to one function can be the input to another:"
      ],
      "metadata": {
        "id": "r9UkEcbsHKAu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "square(multiply(3, 2))"
      ],
      "metadata": {
        "id": "QraEpa88HJGL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can get the exact same result in a way that might be slightly more readable (but takes more code) by using some *intermediate variables*:"
      ],
      "metadata": {
        "id": "9eQYW2BaHa_0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mult_result = multiply(3, 2)\n",
        "square_result = square(mult_result)\n",
        "print(square_result)"
      ],
      "metadata": {
        "id": "ezFrYtlfHsy5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "75-5SOk9iYSt"
      },
      "source": [
        "Sometimes for readability it can be useful to explicitly name the arguments when you call the function. The names come from the function's definition (for built-in functions that come with Python, you can find these names in the [documentation](https://docs.python.org/3/)):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wkIUuZHhidI0"
      },
      "source": [
        "square(multiply(a=3, b=2))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LkpwbQEVMys2"
      },
      "source": [
        "## Exercises"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ASpVhol9ZXI0"
      },
      "source": [
        "**Exercise 1.** Write a function that takes in a first and last name and returns a single string of the form `\"<last>, <first>\"`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jlgyu65SaUvr"
      },
      "source": [
        "def full_name(first_name, last_name):\n",
        "  # Write your function here\n",
        "  return\n",
        "\n",
        "full_name(first_name=\"Taylor\", last_name=\"Swift\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y3so0ceoakIw"
      },
      "source": [
        "**Exercise 2.** Write a function that takes in a musical pitch (C, D, E, etc.) and returns the scale degree number of that pitch in C major.\n",
        "\n",
        "If you don't know what that means, it's ok: C major contains the seven notes `C, D, E, F, G, A, B`. The *scale degree* just refers to a note's location in that list: C is scale degree 1, G is scale degree 5, etc.\n",
        "\n",
        "Your function should take in a letter and return a number `1-7`. Return `0` if the provided note is not in the scale."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-IH-BD41bI1u"
      },
      "source": [
        "def C_scale_degree(pitch):\n",
        "    # Write your function here\n",
        "    return\n",
        "\n",
        "C_scale_degree('F')"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}