crash_course.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "4f8c0a34",
      "metadata": {
        "id": "4f8c0a34"
      },
      "source": [
        "# Python Crash Course\n",
        "\n",
        "Welcome to the Python Crash Course! In this course, we will go over the basics of the Python programming language and how to use it for statistical analysis using standard libraries."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "f1c5969e",
      "metadata": {
        "id": "f1c5969e"
      },
      "source": [
        "## Introduction\n",
        "\n",
        "A programming language is a formal language used to write computer programs. It is a set of instructions and rules that a computer can understand and execute. Programming languages allow programmers to communicate with computers, telling them what to do and how to do it. There are many different programming languages, each with its own syntax and set of features. Some languages are designed for specific tasks, such as web development or scientific computing, while others are more general-purpose and can be used for a wide variety of applications."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "b70f0fcb",
      "metadata": {
        "id": "b70f0fcb"
      },
      "source": [
        "### Jupyter Notebook\n",
        "\n",
        "The Python code we write will be in a Jupyter Notebook, which is a document that allows you to combine code, text, and visualizations in a single, shareable, interactive environment. It is an ideal format for teaching programming because it allows you to provide explanations, examples, and exercises all in one place. You can think of each cell as a separate section of code that we can run independently. This is particularly helpful when testing out different parts of our code.\n",
        "\n",
        "To run a cell, simply click on the cell to select it and then either press the play button on the left of the cell or use the shortcut 'Shift + Enter'. The code in that cell will then be executed, and any output or errors will be displayed directly below the cell.\n",
        "\n",
        "To create a new cell, click on the \"+ Code\" or \"+ Text\" button on the top left of the screen. You can also use keyboard shortcuts to add a cell (`Ctrl+M` followed by `B` to add a cell below, and `Ctrl+M` followed by `A` to add a cell above).\n",
        "\n",
        "To see the table of contents, click the `⋮☰` icon to the left."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "3a68a92e",
      "metadata": {
        "id": "3a68a92e"
      },
      "source": [
        "### Python\n",
        "\n",
        "Python is a popular programming language that is easy to use and learn. It is particularly useful for data analysis and statistical computing, as there are many libraries available that make working with data easier. This means that you can quickly go from coding basics to useful analysis for your work.\n",
        "\n",
        "In this crash course, we'll start by covering some basic programming concepts:\n",
        "\n",
        "* Handling Data\n",
        "* Operators\n",
        "* Control Structures\n",
        "\n",
        "We'll then move on to working with some standard Python libraries which are essential for data analysis and visualization:\n",
        "\n",
        "* NumPy\n",
        "* Pandas\n",
        "* Matplotlib\n",
        "\n",
        "Finally, we'll introduce some statistical concepts and show how to use Python to perform some basic statistical analysis. I'll try to tie it to some sleep science related examples, but this isn't my area of expertise."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "f28649d0",
      "metadata": {
        "id": "f28649d0"
      },
      "source": [
        "### Hello, World!\n",
        "\n",
        "\"Hello, World!\" is one of the most basic programs taught in introductory computer science. All it does is writes the text \"Hello, World!\" In Python, this can be accomplished with one simple line of code. Anything after a `#` is a comment that the computer ignores. \n",
        "\n",
        "The following cell is our first code cell that can be executed as we described above. Note that the first cell you run will take a little longer because the interpreter environment has to load."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "a25f19d6",
      "metadata": {
        "id": "a25f19d6"
      },
      "outputs": [],
      "source": [
        "# Write the text \"Hello, World!\" to the console\n",
        "print('Hello, World!')  # Output: Hello, World!"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ee6de3d6",
      "metadata": {
        "id": "ee6de3d6"
      },
      "source": [
        "## Handling Data\n",
        "\n",
        "We're going to need ways to store and manipulate our data, or else we're doing little more than what we could do with pencil and paper."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "89354c97",
      "metadata": {
        "id": "89354c97"
      },
      "source": [
        "### Variables\n",
        "\n",
        "Variables are used to store values in Python. The equal sign `=` is used to assign a value to a variable. We can reference these variables multiple times to perform various calculations."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "9388030f",
      "metadata": {
        "id": "9388030f"
      },
      "outputs": [],
      "source": [
        "# Define three variables\n",
        "x = 2\n",
        "y = 3\n",
        "z = 5\n",
        "\n",
        "# Print the contents of the variables\n",
        "print(x)  # Output: 2\n",
        "print(y)  # Output: 3\n",
        "print(z)  # Output: 5"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "1ec5c3e8",
      "metadata": {
        "id": "1ec5c3e8"
      },
      "source": [
        "We can check the currently stored variables by clicking the `{𝑥}` icon to the left. Click on each to check its current value."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "cc9c3d96",
      "metadata": {
        "id": "cc9c3d96"
      },
      "source": [
        "### Types\n",
        "\n",
        "In Python, data types define the type of data that a variable can hold. Here are the most common data types in Python:\n",
        "\n",
        "* Integer: A whole number. Written using numerals.\n",
        "* Float: A decimal number. Includes a decimal point.\n",
        "* String: A sequence of characters. Enclosed by `''` or `\"\"`.\n",
        "* Boolean: A binary value representing True or False. Must be capitalized.\n",
        "* List: A collection of values. Comma delimited between brackets.\n",
        "* Tuple: A collection of ordered and immutable values. Comma delimited between parentheses.\n",
        "* Dictionary: A collection of key-value pairs. Comma delimited between braces with colons between keys and values.\n",
        "\n",
        "The syntax for defining data of these types is shown below. Note that here we are not printing the values of the variables as above, but rather their types."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "688be364",
      "metadata": {
        "id": "688be364"
      },
      "outputs": [],
      "source": [
        "# Define variables with different data types\n",
        "a = 1                            # Integer\n",
        "b = 2.5                          # Float\n",
        "c = 'apple'                      # String\n",
        "d = True                         # Boolean\n",
        "e = [1, 2, 9]                    # List\n",
        "f = (4, 5, 6)                    # Tuple\n",
        "g = {'h': 'banana', 'i': False}  # Dictionary\n",
        "\n",
        "# Print the type of each variable\n",
        "print(type(a))  # Output: <class 'int'>\n",
        "print(type(b))  # Output: <class 'float'>\n",
        "print(type(c))  # Output: <class 'str'>\n",
        "print(type(d))  # Output: <class 'bool'>\n",
        "print(type(e))  # Output: <class 'list'>\n",
        "print(type(f))  # Output: <class 'tuple'>\n",
        "print(type(g))  # Output: <class 'dict'>"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "f1f239ab",
      "metadata": {
        "id": "f1f239ab"
      },
      "source": [
        "* What data type was used in our first example?\n",
        "* What data type were `x`, `y`, and `z`?\n",
        "\n",
        "Try confirming your answers programmatically."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "0b98d0fc",
      "metadata": {
        "cellView": "form"
      },
      "outputs": [],
      "source": [
        "#@title Reference solution\n",
        "print(type('Hello, World!'))  # Output: <class 'str'>\n",
        "print(type(x))                # Output: <class 'int'>\n",
        "print(type(y))                # Output: <class 'int'>\n",
        "print(type(z))                # Output: <class 'int'>"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "51bd1bb8",
      "metadata": {
        "id": "51bd1bb8"
      },
      "source": [
        "### Accessing and Modifying Collections\n",
        "\n",
        "The last three types we defined above (lists, tuples, and dictionaries) are collections. The `[]` operator is used to access or modify elements in collections. We index starting at 0. Here are some examples:\n",
        "\n",
        "- `my_list[0]` accesses the first element of `my_list`\n",
        "- `my_list[0] = new_value` assigns `new_value` to the first element of `my_list`\n",
        "- `my_tuple[0]` accesses the first element of `my_tuple`\n",
        "- Tuples are immutable, which means you cannot change their contents once they are created.\n",
        "- `my_dict['key']` accesses the value associated with `'key'` in `my_dict`\n",
        "- `my_dict['new_key'] = new_value` adds a new key-value pair to `my_dict`\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "9342c0d9",
      "metadata": {
        "id": "9342c0d9"
      },
      "outputs": [],
      "source": [
        "# Access the third element of the list\n",
        "print(e[2])    # Input: [1, 2, 9]                    # Output: 9\n",
        "# Change the third element of the list\n",
        "e[2] = 3\n",
        "print(e)                                             # Output: [1, 2, 3]\n",
        "\n",
        "# Access the first element of the tuple\n",
        "print(f[0])    # Input: (4, 5, 6)                    # Output: 4\n",
        "# Attempt to change the first element of the tuple (this will fail!)\n",
        "# f[0] = 10    # Uncomment this line to see the error message\n",
        "\n",
        "# Access the value associated with 'h' in the dictionary\n",
        "print(g['h'])  # Input: {'h': 'banana', 'i': False}  # Output: banana\n",
        "# Add a new key-value pair to the dictionary\n",
        "g[(x, y)] = [8, 'stuff', 0]\n",
        "print(g)\n",
        "# Output: {'h': 'banana', 'i': False, (2, 3): [8, 'stuff', 0]}"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "d3a64361",
      "metadata": {
        "id": "d3a64361"
      },
      "source": [
        "The last dictionary example shows a few things:\n",
        "\n",
        "1. We can use a tuple as a key because it is immutable (try using a list)\n",
        "1. Keys can be of mixed types (the other keys were strings)\n",
        "1. We can nest a list inside a dictionary (or another dictionary, or a dictionary in a list)\n",
        "1. A list can have mixed types (here there are two integers and a string)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "602da2d4",
      "metadata": {
        "id": "602da2d4"
      },
      "source": [
        "## Operators\n",
        "\n",
        "Operators are special symbols in Python that are used to perform operations on values or variables. "
      ]
    },
    {
      "cell_type": "markdown",
      "id": "7eaccc3e",
      "metadata": {
        "id": "7eaccc3e"
      },
      "source": [
        "### Arithmetic\n",
        "\n",
        "Here are some of the most common operators for performing arithmetic that are quite similar to the mathematical notation we are all familiar with (with some exceptions):\n",
        "\n",
        "- `+` addition\n",
        "- `-` subtraction (binary) / negation (unary)\n",
        "- `*` multiplication\n",
        "- `/` division\n",
        "- `//` floor division (returns the whole number result of division)\n",
        "- `%` modulus (returns the remainder after division)\n",
        "- `**` exponentiation (raises a number to a power)\n",
        "\n",
        "Now we will go over some examples of using these operators in Python. Note that we are using the variables we defined above, so we have to make sure to run that cell first so that we can reference them. (Try running these first and you'll see errors.)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "1e4e9110",
      "metadata": {
        "id": "1e4e9110"
      },
      "outputs": [],
      "source": [
        "# Addition\n",
        "print(x + y)   # Inputs: 2, 3  # Output: 5"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "b4409637",
      "metadata": {
        "id": "b4409637"
      },
      "outputs": [],
      "source": [
        "# Subtraction\n",
        "print(z - x)   # Inputs: 5, 2  # Output: 3\n",
        "\n",
        "# Negation\n",
        "print (-y)     # Input: 3      # Output: -3"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "68729799",
      "metadata": {
        "id": "68729799"
      },
      "source": [
        "Just like in mathematical notation, the `-` sign acts as expected. There is a slight distinction between the binary operation of subtraction (takes two numbers and computes their difference) and the unary operation of negation (takes one number and results in its negative)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "3e09f608",
      "metadata": {
        "id": "3e09f608"
      },
      "outputs": [],
      "source": [
        "# Multiplication\n",
        "print(x * y)   # Inputs: 2, 3  # Output: 6"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "01edfa30",
      "metadata": {
        "id": "01edfa30"
      },
      "outputs": [],
      "source": [
        "# Division\n",
        "print(z / x)   # Inputs: 5, 2  # Output: 2.5"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "a4d0c7b8",
      "metadata": {
        "id": "a4d0c7b8"
      },
      "source": [
        "What data type was the output of the above division? Try confirming your answer programmatically."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "f4527b63",
      "metadata": {
        "cellView": "form"
      },
      "outputs": [],
      "source": [
        "#@title Reference solution\n",
        "print(type(z / x))  # Output: <class 'float'>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "c5b32e6a",
      "metadata": {
        "id": "c5b32e6a"
      },
      "outputs": [],
      "source": [
        "# Floor Division\n",
        "print(z // x)  # Inputs: 5, 2  # Output: 2"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "bc56634b",
      "metadata": {
        "id": "bc56634b"
      },
      "source": [
        "What data type was the output of the above floor division? Try confirming your answer programmatically."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "ce1ac9a5",
      "metadata": {
        "cellView": "form"
      },
      "outputs": [],
      "source": [
        "#@title Reference solution\n",
        "print(type(z // x))  # Output: <class 'int'>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "6dd570bf",
      "metadata": {
        "id": "6dd570bf"
      },
      "outputs": [],
      "source": [
        "# Modulus\n",
        "print(z % x)   # Inputs: 5, 2  # Output: 1"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "a3cbc698",
      "metadata": {
        "id": "a3cbc698"
      },
      "source": [
        "Think about how the results of the floor division and modulus combine to explain division in elementary school terms.\n",
        "\n",
        "A good example for understanding modulus is the 24-hour clock. Think of a time in the afternoon like 16:20. This corresponds to 4:20 PM. We can get the 4 from the remainder of the division of 16 by 12. 16 ÷ 12 is 1 remainder 4, i.e., one 12-hour period (the AM) plus $\\frac{4}{12}$ of a 12-hour period (stretching beyond noon). In Japan they even have store closing times that go beyond 24:00. If a store closes at 26:00, what time is this in the 12-hour format? Use Python to find the answer, and explain as in the 16:20 example."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "dceadb29",
      "metadata": {
        "cellView": "form"
      },
      "outputs": [],
      "source": [
        "#@ title Reference solution\n",
        "print(26 % 12)  # Output: 2\n",
        "# Note: 26 = 12 * 2 + 2\n",
        "# two 12-hour periods (i.e., AM and PM of one day) have passed, and 2 hours have elapsed\n",
        "# therefore the time is 2:00 AM"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "fd065b8c",
      "metadata": {
        "id": "fd065b8c"
      },
      "outputs": [],
      "source": [
        "# Exponentiation\n",
        "print(x ** y)  # Inputs: 2, 3  # Output: 8"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "5fe15333",
      "metadata": {
        "id": "5fe15333"
      },
      "source": [
        "### Compound\n",
        "\n",
        "In Python, there are compound operators that allow you to perform an arithmetic operation and an assignment in one step. For example, the `+=` operator adds a value to a variable and assigns the result back to the variable. The equivalent code using separate operations would be `x = x + y`.\n",
        "\n",
        "Here is a list of some common compound operators in Python:\n",
        "\n",
        "| Operator | Example | Equivalent |\n",
        "|:--------:|:-------:|:----------:|\n",
        "| `+=`     | `x += y` | `x = x + y` |\n",
        "| `-=`     | `x -= y` | `x = x - y` |\n",
        "| `*=`     | `x *= y` | `x = x * y` |\n",
        "| `/=`     | `x /= y` | `x = x / y` |\n",
        "| `%=`     | `x %= y` | `x = x % y` |\n",
        "| `**=`    | `x **= y`| `x = x ** y`|\n",
        "| `//=`    | `x //= y`| `x = x // y`|\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "3dff244d",
      "metadata": {
        "id": "3dff244d"
      },
      "outputs": [],
      "source": [
        "# Equivalent to x = x + y\n",
        "x += y    # Inputs: 2, 3\n",
        "print(x)  # Output: 5"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "9545b42d",
      "metadata": {
        "id": "9545b42d"
      },
      "source": [
        "Note that since the value of `x` has changed, if we re-run the cells above where we used arithmetic operators, the results will be different.\n",
        "\n",
        "Lists can also be added together. Using the compound addition and assignment operator allows us to append one list to another."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "4143ff13",
      "metadata": {
        "id": "4143ff13"
      },
      "outputs": [],
      "source": [
        "e += [4, 5]  # Input:  [1, 2, 3]\n",
        "print(e)     # Output: [1, 2, 3, 4, 5]"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "5f35d60c",
      "metadata": {
        "id": "5f35d60c"
      },
      "source": [
        "### Comparison\n",
        "\n",
        "Comparison operators are used to compare values in Python. They return a boolean value of `True` or `False` depending on whether the comparison is true or false. Here are the comparison operators in Python:\n",
        "\n",
        "* `==` : Equal to\n",
        "* `!=` : Not equal to\n",
        "* `>` : Greater than\n",
        "* `<` : Less than\n",
        "* `>=` : Greater than or equal to\n",
        "* `<=` : Less than or equal to\n",
        "\n",
        "These operators can be used with all the data types we have covered so far, including integers, floats, strings, and booleans. For example, `5 == 5` would return `True`, while `5 != 5` would return `False`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "0e16105b",
      "metadata": {
        "id": "0e16105b"
      },
      "outputs": [],
      "source": [
        "print(x == z)  # Inputs: 5, 5  # Output: True\n",
        "print(x != z)  # Inputs: 5, 5  # Output: False\n",
        "print(x >  y)  # Inputs: 5, 3  # Output: True\n",
        "print(x <  y)  # Inputs: 5, 3  # Output: False\n",
        "print(x >= z)  # Inputs: 5, 5  # Output: True\n",
        "print(x <= z)  # Inputs: 5, 5  # Output: True"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "1bf20c94",
      "metadata": {
        "id": "1bf20c94"
      },
      "source": [
        "Note that I've put extra spaces in some cases just to make them line up aesthetically. This does not affect the functioning of the program."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "920cef41",
      "metadata": {
        "id": "920cef41"
      },
      "outputs": [],
      "source": [
        "# Inputs: 'apple', 'banana'\n",
        "print(c == g['h'])  # Output: False\n",
        "print(c != g['h'])  # Output: True\n",
        "print(c <  g['h'])  # Output: True\n",
        "print(c >  g['h'])  # Output: False"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "8f31ea70",
      "metadata": {
        "id": "8f31ea70"
      },
      "source": [
        "When comparing strings, alphabetical order is used, so `'a' < 'b'`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "1a9ba6a6",
      "metadata": {
        "id": "1a9ba6a6"
      },
      "outputs": [],
      "source": [
        "# Inputs: True, False\n",
        "print(d == g['i'])  # Output: False\n",
        "print(d != g['i'])  # Output: True\n",
        "print(d >  g['i'])  # Output: True\n",
        "print(d <  g['i'])  # Output: False"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "878947ac",
      "metadata": {
        "id": "878947ac"
      },
      "source": [
        "It may seem counterintuitive that you can compare `True` and `False` in terms of `>` and `<`, but in Python, `True` is considered greater than `False`."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "0eff5d77",
      "metadata": {
        "id": "0eff5d77"
      },
      "source": [
        "### Logical\n",
        "\n",
        "Python has three logical operators: `and`, `or`, and `not`. These operators are used to combine boolean expressions.\n",
        "\n",
        "The `and` operator returns `True` if both expressions are `True`. Otherwise, it returns `False`.\n",
        "\n",
        "| bool1 | bool2 | bool1 and bool2 |\n",
        "|-------|-------|----------------|\n",
        "| True  | True  | True           |\n",
        "| True  | False | False          |\n",
        "| False | True  | False          |\n",
        "| False | False | False          |\n",
        "\n",
        "The `or` operator returns `True` if at least one of the expressions is `True`. Otherwise, it returns `False`. Note that this is an \"inclusive or\" (i.e., it includes the \"and\" condition). This is like \"rain or shine\" in English. We also use this word as an \"exclusive or\" (not how it is used in logic), as in \"soup or salad.\"\n",
        "\n",
        "| bool1 | bool2 | bool1 or bool2 |\n",
        "|-------|-------|---------------|\n",
        "| True  | True  | True          |\n",
        "| True  | False | True          |\n",
        "| False | True  | True          |\n",
        "| False | False | False         |\n",
        "\n",
        "The `not` operator negates the expression. If the expression is `True`, it returns `False`. If the expression is `False`, it returns `True`.\n",
        "\n",
        "| bool | not bool |\n",
        "|------|----------|\n",
        "| True | False    |\n",
        "| False| True     |\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "c46e0905",
      "metadata": {
        "id": "c46e0905"
      },
      "outputs": [],
      "source": [
        "# using and operator\n",
        "print(d and g['i'])     # Inputs: True, False  # Output: False\n",
        "print(d and True)       # Input:  True         # Output: True\n",
        "\n",
        "# using or operator\n",
        "print(d     or g['i'])  # Inputs: True, False  # Output: True\n",
        "print(False or g['i'])  # Input:  False        # Output: False\n",
        "\n",
        "# using not operator\n",
        "print(not g['i'])       # Input:  True         # Output: False\n",
        "print(not g['i'])       # Input:  False        # Output: True"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "bd7a5c3b",
      "metadata": {
        "id": "bd7a5c3b"
      },
      "source": [
        "## Control Structures\n",
        "\n",
        "Some of the most powerful features of programming are to reuse instructions, change what is done based on conditions, and do the same thing over a set of data."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "d5348f4c",
      "metadata": {
        "id": "d5348f4c"
      },
      "source": [
        "### Functions\n",
        "\n",
        "Functions are a way to group a set of statements so they can be run more than once in a program. They can take inputs, perform operations on them, and return outputs. Functions make code reusable, easier to read, and more organized. A function is defined using the following format:\n",
        "\n",
        "```python\n",
        "def function_name(input_variables):\n",
        "  # statement(s)\n",
        "  return output_variables\n",
        "```\n",
        "\n",
        "The syntax is very particular. Brackets, indentation, and the colon are all important. Here's a more generalized version of our \"Hello, World!\" code:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "ca1704d8",
      "metadata": {
        "id": "ca1704d8"
      },
      "outputs": [],
      "source": [
        "def greet(name):\n",
        "  return 'Hello, ' + name + '!'\n",
        "\n",
        "print(greet('World'))  # Output: Hello, World!\n",
        "print(greet('Alice'))  # Output: Hello, Alice!\n",
        "print(greet('Bob'))    # Output: Hello, Bob!"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "d70d21bb",
      "metadata": {
        "id": "d70d21bb"
      },
      "source": [
        "Note that `print()` itself is a function. We are calling the `print()` function on the result of the `greet()` function by nesting brackets. Also note that the `+` operator has a special interpretation when it comes to strings: concatenation. Try sending in different values."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "a12941eb",
      "metadata": {
        "id": "a12941eb"
      },
      "source": [
        "### Conditionals\n",
        "\n",
        "In Python, we can use `if`, `elif`, and `else` statements to create conditional statements that allow our code to make decisions based on certain conditions being `true` or `false`.\n",
        "\n",
        "Here's an example that demonstrates the basic syntax of a conditional statement:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "3298209d",
      "metadata": {
        "id": "3298209d"
      },
      "outputs": [],
      "source": [
        "def number_sign(num):\n",
        "  if   num < 0:\n",
        "    return 'The number is negative'\n",
        "  elif num == 0:\n",
        "    return 'The number is zero'\n",
        "  else:\n",
        "    return 'The number is positive'\n",
        "\n",
        "print(number_sign( a))  # Input: 1    # Output: The number is positive\n",
        "print(number_sign( 0))                # Output: The number is zero\n",
        "print(number_sign(-b))  # Input: 2.5  # Output: The number is negative"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "10c0a26d",
      "metadata": {
        "id": "10c0a26d"
      },
      "source": [
        "In this example, we check the value of the input number and print a message depending on whether it is negative, zero, or positive. Try sending in different values.\n",
        "\n",
        "We can also use logical operators such as `and`, `or`, and `not` to combine multiple conditions in a single `if` statement. For example:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "2d74f602",
      "metadata": {
        "id": "2d74f602"
      },
      "outputs": [],
      "source": [
        "def check_positive_numbers(num1, num2):\n",
        "  if num1 > 0 and num2 > 0:\n",
        "    print('Both numbers are positive')\n",
        "  elif num1 > 0 or num2 > 0:\n",
        "    print('Only one of the numbers is positive') # The `and` case is taken care of above so this becomes an \"exclusive or\"\n",
        "  else:\n",
        "    print('Neither of the numbers is positive')\n",
        "\n",
        "check_positive_numbers(5, 10)   # Output: Both numbers are positive\n",
        "check_positive_numbers(-2, 7)   # Output: Only one of the numbers is positive\n",
        "check_positive_numbers(0, 9)    # Output: Only one of the numbers is positive\n",
        "check_positive_numbers(-3, -6)  # Output: Neither of the numbers is positive"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "282c103b",
      "metadata": {
        "id": "282c103b"
      },
      "source": [
        "In this example, we use the `and` operator to check if both input numbers are positive. We print a message based on the truth value of this combined condition. Note that we don't have to call `print()` on the result of this function because it calls `print()` internally rather than returning a value. Try sending in different values.\n",
        "\n",
        "Here, the order of the conditional statements matters. What would happen if we were to switch the first two? Try it and see what goes wrong."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "17cdbb05",
      "metadata": {
        "cellView": "form"
      },
      "outputs": [],
      "source": [
        "#@title Reference solution\n",
        "def check_positive_numbers(num1, num2):\n",
        "  if num1 > 0 or num2 > 0:\n",
        "    # This will also happen in the `and` case, so the following will never be printed\n",
        "    print('Only one of the numbers is positive')\n",
        "  elif num1 > 0 and num2 > 0:\n",
        "    print('Both numbers are positive')\n",
        "  else:\n",
        "    print('Neither of the numbers is positive')\n",
        "\n",
        "\n",
        "check_positive_numbers(5, 10)   # Output: Only one of the numbers is positive ***(incorrect)***\n",
        "check_positive_numbers(-2, 7)   # Output: Only one of the numbers is positive\n",
        "check_positive_numbers(0, 9)    # Output: Only one of the numbers is positive\n",
        "check_positive_numbers(-3, -6)  # Output: Neither of the numbers is positive\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "9f5bfa1e",
      "metadata": {
        "id": "9f5bfa1e"
      },
      "source": [
        "### Loops\n",
        "Loops are used for repeating a set of instructions until a specific condition is met. Python has two types of loops: the `for` loop and the `while` loop.\n",
        "\n",
        "The `for` loop is used for iterating over a sequence (that is either a list, a tuple, a dictionary, a set, or a string). The loop continues until the sequence is exhausted. The basic syntax of a `for` loop in Python is as follows:\n",
        "\n",
        "```python\n",
        "for variable in sequence:\n",
        "  # statement(s)\n",
        "```\n",
        "\n",
        "The `while` loop is used for executing a set of statements as long as a given condition is true. The basic syntax of a `while` loop in Python is as follows:\n",
        "\n",
        "```python\n",
        "while condition:\n",
        "  # statement(s)\n",
        "```\n",
        "\n",
        "As with functions, be mindful of the colon and the indentation."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "bc023031",
      "metadata": {
        "id": "bc023031"
      },
      "outputs": [],
      "source": [
        "# Loop through a list of numbers and print each number\n",
        "for num in e:  # Input:   [1, 2, 3, 4, 5]\n",
        "  print(num)   # Outputs: 1\n",
        "               #          2\n",
        "               #          3\n",
        "               #          4\n",
        "               #          5"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "73660058",
      "metadata": {
        "id": "73660058"
      },
      "source": [
        "The `for` syntax defines a new variable. Here, `num` refers to the current item in the `e` list."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "dcae6aba",
      "metadata": {
        "id": "dcae6aba"
      },
      "outputs": [],
      "source": [
        "# Print numbers 1 through 5 using a while loop\n",
        "num = 1\n",
        "while num <= z:  # Input:   5\n",
        "  print(num)     # Outputs: 1\n",
        "  num += 1       #          2\n",
        "                 #          3\n",
        "                 #          4\n",
        "                 #          5"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "549c964c",
      "metadata": {
        "id": "549c964c"
      },
      "source": [
        "It's important to be cautious, especially when using `while` loops, as an infinite loop can crash the program or the system. Therefore, it's essential to ensure that the loop will terminate at some point during the program's execution."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "6203ac98",
      "metadata": {
        "id": "6203ac98"
      },
      "source": [
        "## Exercise: Minutes to Hours and Minutes\n",
        "\n",
        "Write a function `convert_minutes` that takes a list of integers representing minutes as input and returns a list of tuples where each tuple represents the corresponding input as (hours, minutes). Your function should have the following signature:\n",
        "\n",
        "```python\n",
        "def convert_minutes(minutes_list):\n",
        "```\n",
        "\n",
        "Your implementation should satisfy the following:\n",
        "\n",
        "- The output should have the same length as the input list\n",
        "- Each element in the output should be a tuple of two integers representing the corresponding input as (hours, minutes)\n",
        "- Your code should not use any external libraries or functions other than those that have already been covered in this tutorial.\n",
        "\n",
        "For example, if the input list is `[123, 50, 360]`, the function should return `[(2, 3), (0, 50), (6, 0)]`.\n",
        "\n",
        "Here are some hints for the concepts we have covered that you will need to employ:\n",
        "\n",
        "- Storing data in variables\n",
        "- Lists and tuples\n",
        "- Floor division and modulus\n",
        "- Appending with compound assignment and addition\n",
        "- Functions\n",
        "- For loops"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "bba31248",
      "metadata": {
        "id": "bba31248"
      },
      "outputs": [],
      "source": [
        "def convert_minutes(minutes_list):\n",
        "  result = []\n",
        "  # Add your code here\n",
        "  return result"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "4f1ef231",
      "metadata": {
        "id": "4f1ef231"
      },
      "source": [
        "Once you have defined your function and executed the cell, execute the following cell to confirm your solution works."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e5a89642",
      "metadata": {
        "id": "e5a89642"
      },
      "outputs": [],
      "source": [
        "input_minutes = [123, 50, 360]\n",
        "output = convert_minutes(input_minutes)\n",
        "print(output)  # Output: [(2, 3), (0, 50), (6, 0)]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "7981dd8d",
      "metadata": {
        "cellView": "form",
        "id": "7981dd8d"
      },
      "outputs": [],
      "source": [
        "#@title Reference solution\n",
        "def convert_minutes(minutes_list):\n",
        "  result = []\n",
        "  for minutes in minutes_list:\n",
        "    hours = minutes // 60\n",
        "    remaining_minutes = minutes % 60\n",
        "    hours_and_minutes = (hours, remaining_minutes)\n",
        "    result += [hours_and_minutes]\n",
        "  return result"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "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.8.10"
    },
    "vscode": {
      "interpreter": {
        "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}