notebooks/python/Lab_1_Introduction_to_Python.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Lab 1 - Introduction to Python.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "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/CBravoR/AdvancedAnalyticsLabs/blob/master/notebooks/python/Lab_1_Introduction_to_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": "LxU4vzkwvrfm"
      },
      "source": [
        "HELLO **THIS IS BOLD TEXT**\n",
        "\n",
        "# THIS IS A TITLE\n",
        "\n",
        "## I'M A SUBTITLE\n",
        "\n",
        "*Now in italics*\n",
        "\n",
        "```\n",
        "1 + 1\n",
        "```\n",
        "\n",
        "$$\n",
        "\\sum_i^n x^i \n",
        "$$"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OmUJUOb-sEkI",
        "outputId": "a0a0f2b5-a5ba-4789-9444-5c2a8292cd1c",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "1 + 1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FnxJLaAasFGz"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2p47TocEO2oN"
      },
      "source": [
        "# Markdown\n",
        "\n",
        "Now we can use cells!\n",
        "\n",
        "This is markdown cell. We can write **augmented html** here. Markdown has *many* options. I suggest reading the tutorial <a href=\"https://www.markdowntutorial.com/\">here</a>.\n",
        "\n",
        "Some basics:\n",
        "\n",
        "- Starting a line with a dash (\"-\") creates a vignetted list.\n",
        "\n",
        "- Writing a sentence between two asteriks (like `**this**`) **bolds it**.\n",
        "\n",
        "- Writing a sentence between one asterisk (like `*this*`)*emphazises it* (italics).\n",
        "\n",
        "- To write verbatim, use \"code\" formatting. Surrounding a sentence with grave accents writes it as you wrote it.  `I can write without getting words *emphasized* nor **bolded**`.\n",
        "\n",
        "- To write a block of code, add three grave accents (```) both at the beginning and the end.\n",
        "\n",
        "```\n",
        "This is a block of code.\n",
        "Many lines can be written verbatim.\n",
        "**no bolding**, *nor emphasis* is applied.\n",
        "```\n",
        "\n",
        "To create an enumeration, simply add the number and a dot.\n",
        "\n",
        "1. I am number one.\n",
        "\n",
        "2. And I number two.\n",
        "\n",
        "3. And me number three.\n",
        "\n",
        "Titles and subtitles are written using multiple hash signs.\n",
        "\n",
        "# Title 1\n",
        "## Title 2\n",
        "### Tittle 3\n",
        "\n",
        "\n",
        "And, remember this is HTML! You can use everything the language offers. Some other useful tricks:\n",
        "\n",
        "- Create a hyperlink: [I link to Google!](http://www.google.com). (Write `[I link to Google!](http://www.google.com)`, or more generally, `[any text you want](any address you want to go to)`)\n",
        "\n",
        "- Add an image:\n",
        "\n",
        "![University logo](https://www.uwo.ca/web_standards/img/logos-faculties-stacked/svg/Western_Logo_F_S_Science_RGB.svg)\n",
        "\n",
        "Write `![University logo](https://www.uwo.ca/web_standards/img/logos-faculties-stacked/svg/Western_Logo_F_S_Science_RGB.svg)` or, more generally, `![alt-text](link-to-figure)`. You can also use relative paths if the figures are local, i.e., `![alt-text](Western_University_Logo.svg)` looks for 'Western_University_Logo.svg' in your own folder.\n",
        "\n",
        "Many more things can be done. A short cheatsheet is available [here](https://github.com/adam-p/markdown-here/wiki/Markdown-Here-Cheatsheet)\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7UvFRehAvqRx"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0fNoXS23PC0i"
      },
      "source": [
        "# Our first program: Python as a calculator\n",
        "\n",
        "We will now start using Python! Python is really simple:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "STKP-xOkzp2D"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LkUC9r_ZO8EC",
        "outputId": "af9554c5-e108-4cec-b12b-3e9c6523d7a2",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "# Comment using the hash sign.\n",
        "# A simple sum.\n",
        "1+1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YLPaH67YPRpO",
        "outputId": "8c8d4737-af4c-4464-a04a-0ba70aeb8110",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "# Variables are assigned using the equal '=' sign.\n",
        "\n",
        "a = 1\n",
        "a"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "och2ak-PPWFK",
        "outputId": "0c02273b-7df3-402b-f890-f1fba31034a4",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 72
        }
      },
      "source": [
        "# Variables can be many things!\n",
        "a = 1\n",
        "b = 'Hi!'\n",
        "c = True\n",
        "\n",
        "\n",
        "# We can show the value of a variable using the \"print\" function.\n",
        "# Functions in general are NAME(VARIABLES)\n",
        "print(a)\n",
        "print(b)\n",
        "print(c)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "Hi!\n",
            "True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KatwR4Va0L5n",
        "outputId": "2c31368a-9971-40de-e5b1-c483ee0d1e23",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        }
      },
      "source": [
        "a + b"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'1Hi!'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "egLJvPrLPlc3",
        "outputId": "4ea28d3c-c9a6-401d-b61b-da1bfe42baf1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        }
      },
      "source": [
        "# You can add variables of the same type! They behave as you would expect\n",
        "# Sum two text variables to concatenate them\n",
        "c = ' How are you?'\n",
        "b + c"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Hi! How are you?'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GkjE5DsRPq_8",
        "outputId": "5bbab0f9-4f6c-43f5-bad8-7d56b311f7c5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        }
      },
      "source": [
        "# You can index using square brackets: []\n",
        "\n",
        "# IMPORTANT: PYTHON INDEXES START AT 0\n",
        "\n",
        "# Let's extract the first letter of our variable 'b'.\n",
        "\n",
        "b[0]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'H'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8xi4RsJ-QJl6",
        "outputId": "ee2c5816-f4ca-41c6-fe7d-bca2b716c676",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        }
      },
      "source": [
        "b[1]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'i'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V_z88wznQK4L",
        "outputId": "4f711cac-cc92-428e-ab4a-ea6de57fab11",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        }
      },
      "source": [
        "b[0] + b[1]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Hi'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fVR_KGl8vj6D"
      },
      "source": [
        "You can use the notation is start:step:stop. If you skip step, the default is 1.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RzbRN9Ho06jH",
        "outputId": "7db6389c-39bc-4d44-d10c-3c72b5aa0530",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        }
      },
      "source": [
        "b[0:3]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Hi!'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kK4kXxGrrwlp"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fR37XoRHQRkQ"
      },
      "source": [
        "Remember: **Indexes start at zero!**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1wadUZS6Qazg"
      },
      "source": [
        "# Lists\n",
        "\n",
        "The basic data structure is a list. A list is simply a collection of things. Let's create a list called 'my_list'"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xj4iqu9ZQaND"
      },
      "source": [
        "my_list = [1, 'Hello!', 3, 4.57, True]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bekH26XAQdg7",
        "outputId": "fcfa565d-7c56-4831-f74f-1bd6d23b8b45",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "my_list[0] + my_list[3]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5.57"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N4WgssQmQjy8",
        "outputId": "7f037f2c-dc42-4434-ba50-ae1a1f25bdfe",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        }
      },
      "source": [
        "my_list[1]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Hello!'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Tf4EIDF3wzVQ",
        "outputId": "cabba9a8-e40e-4d38-c17d-6e3773c88a80",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "my_list[0] + my_list[4] "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EuL2jfjWQwE4"
      },
      "source": [
        "What happens if we add two different types?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2LeXvYqqQlp6",
        "outputId": "efee156c-e39a-4c8d-fa51-afa43d3e7630",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 172
        }
      },
      "source": [
        "my_list[1] + my_list[3]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "ValueError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-18-91542cfce652>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mfloat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmy_list\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mmy_list\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m: could not convert string to float: 'Hello!'"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O6vKfrUfQ0qn"
      },
      "source": [
        "To read the error: always start at the end, it will hint what's wrong. In this case, it is the \n",
        "\n",
        "```\n",
        "TypeError: must be str, not float\n",
        "```\n",
        "That suggests that something (in this case 'my_list[3]') must be a string, not a float (a decimal number). Python does **not** allow for operating over multiple types. We must convert to the same type first. We can't really turn a string into a number, but we can do the opposite.\n",
        "\n",
        "We will use the internal function ```str()``` to turn the number into a string. The full list of internal functions [can be found here](https://docs.python.org/3/library/functions.html)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "36jYc8ZnQnjs"
      },
      "source": [
        "my_list[1] + str(my_list[3])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ud9lWQ1GXEj3"
      },
      "source": [
        "# Making it a bit nicer looking\n",
        "my_list[1] + ' ' + str(my_list[3])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8Jh2IRWAXNR0"
      },
      "source": [
        "Strings can be written surrounding them by either the `\"` symbol or the `'` symbol."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JkJtvqIfXMT-"
      },
      "source": [
        "'I am a string'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k2CnZUuYXIlD"
      },
      "source": [
        "\"I am also a string\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BfQaSx6DXT6T"
      },
      "source": [
        "# Loops:\n",
        "\n",
        "All the traditional looping operators are implemented in Python of course.\n",
        "\n",
        "## While loops\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vSQBUmtwXTGC"
      },
      "source": [
        "current_value = 1\n",
        "while current_value <= 5:\n",
        "    print(current_value)\n",
        "    current_value += 1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gLH9Ae-jXizu"
      },
      "source": [
        "Let's look at the code in detail:\n",
        "```\n",
        "current_value = 1\n",
        "while current_value <= 5:\n",
        "    print(current_value)\n",
        "    current_value += 1\n",
        "```\n",
        "\n",
        "- The line `current_value = 1` simply creates a variable `current_value` and assigns it the value 1.\n",
        "\n",
        "- Then the while loop starts. `while current_value <= 5:`. This line simply says \"do stuff until the value of current_value is 5\".\n",
        "\n",
        "- **Note the indentatation**. Indent is the way we separate blocks in Python. Everything that is indented is part of the while (i.e., the following two lines).\n",
        "\n",
        "- The line `print(current_value)` prints the value of the variable current_value. We can write complex expressions!\n",
        "\n",
        "- the line `current_value += 1` is equivalent to writing `current_value = current_value + 1`. It adds one to current_value. \n",
        "\n",
        "Python allows for many ways to compare variables. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nlhjDpOCXwWk"
      },
      "source": [
        "### Conditional statements\n",
        "\n",
        "We can write conditional statements using the `if... else...` operators.\n",
        "\n",
        "General structure:\n",
        "\n",
        "```\n",
        "if [condition]:\n",
        "    (Operations)\n",
        "elif [other conditions]:\n",
        "    (Other operations)\n",
        "else:\n",
        "    (More operations)\n",
        "```\n",
        "\n",
        "Conditions can be:\n",
        "- Equality comparison: '=='. For example."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ns6y2CZEXiHa",
        "outputId": "41cfd264-681d-426f-a410-39b47581a080",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "a = 'bmw'\n",
        "b = 'audi'\n",
        "a == b"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oAWzrG6uXSZ6",
        "outputId": "331ea379-c243-4faf-8851-77e67b0a8d42",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "a == a"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "41iZa2yrX7oK"
      },
      "source": [
        "- Negation is done with an exclamation sign."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FZUJmfnPX6w_",
        "outputId": "70eaf3ef-baf3-4b25-87ae-ff23e1c60ff4",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "# Not equal to:\n",
        "a != b"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3s8qCnN-YBjs"
      },
      "source": [
        "- Greater than or lower than"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2He9dFSOX4n0"
      },
      "source": [
        "a = 1\n",
        "b = 2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n2J_BCkLYDfr",
        "outputId": "1cd25da5-52dd-4b72-b5d6-afdc35cedf79",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "a < b"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xD0QXeb6YF9M",
        "outputId": "a4c4b231-bc16-4cfa-8bef-740865534bd4",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "a > b"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5x4xIT9WYHaz",
        "outputId": "7ed7b618-1ea0-4215-f46f-ee6023697d55",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "b < a"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hZlWn_cPYLQm"
      },
      "source": [
        "- Greater or equal (>=), lower or equal (<=) "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fQokHe9LYIsr",
        "outputId": "38339065-3ab5-4f2b-98fe-5d718bef164a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "a <= b"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rxD1xKsQYMoa",
        "outputId": "0b58c2aa-60f2-4cb5-95d9-9fd190a1e4b7",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "b - 1 <= a"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oI2K4cXVYN6T",
        "outputId": "e9fcc367-f011-4c7a-f810-7ce691eb2843",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "a + 1 >= b"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SVe6puZqYRqY"
      },
      "source": [
        "Logical operators:\n",
        "\n",
        "- `and`\n",
        "- `or`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MSooZy1qYPFM"
      },
      "source": [
        "a = 1\n",
        "b = 2\n",
        "c = 'BMW'\n",
        "d = 'Audi'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QhgfSQCAYT7c",
        "outputId": "eed331c9-f90b-4164-fda1-1140f208cab2",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "a < b and c == d"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zjzN5ypWYVSE",
        "outputId": "146e3952-dfbe-4500-a866-f31b164200e1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "a < b and c != d"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bYkyFiQIYWcq",
        "outputId": "135c4c05-47f2-4321-8be2-ad17774b6647",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "a < b or c == d"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZALMf5DKYaW-"
      },
      "source": [
        "These can be combined."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ok1cFb6TYZ1Q"
      },
      "source": [
        "(a < b and c == d) or (a + 1 >= b)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NwprQbYdYfxZ"
      },
      "source": [
        "### For loops\n",
        "\n",
        "First, we need to understand the `range()` function. As the name implies, it creates ranges of numbers for iterating on. \n",
        "\n",
        "Important: **It does NOT include the last one**."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "766LhGXZYX0M"
      },
      "source": [
        "my_range = range(1,10)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wKv79dFcYhpT",
        "outputId": "2e6b7e78-7862-45f9-a704-729196b26458",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "my_range[0]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QlZieCH0YjwZ",
        "outputId": "e3925158-94b9-495e-fef5-b26dce9b5cf7",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "my_range[8]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "9"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 39
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "St1rLWPSYk11",
        "outputId": "9d97dda5-ea85-41fe-8651-100ba5403d16",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 191
        }
      },
      "source": [
        "# There is no 10 value. This throws an error.\n",
        "my_range[9]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "IndexError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-40-259fb36b9bed>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# There is no 10 value. This throws an error.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mmy_range\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m9\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mIndexError\u001b[0m: range object index out of range"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m1kdVEvEYo1w"
      },
      "source": [
        "We can now create a \"for\" loop. This one will iterate over a certain value."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vhegBAuZYmfD",
        "outputId": "64512c3b-9bb4-41c4-fa73-00993c45cfe3",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 182
        }
      },
      "source": [
        "for i in range(1, 10):\n",
        "    #print('The current value is: ', i)\n",
        "    print('The current value is: ' + str(i))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The current value is: 1\n",
            "The current value is: 2\n",
            "The current value is: 3\n",
            "The current value is: 4\n",
            "The current value is: 5\n",
            "The current value is: 6\n",
            "The current value is: 7\n",
            "The current value is: 8\n",
            "The current value is: 9\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KBUPoxMU1k7c",
        "outputId": "2dcda608-e79d-49cc-879c-987e072fbce0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "print('The current value is %i' % i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The current value is 9\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZhNdEgAs10Mo",
        "outputId": "cc02def0-c5b0-48ce-924e-e0e718a20110",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "print('The %s value is %i' % ('current', i))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The current value is 9\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZrtPNCJnYtQF"
      },
      "source": [
        "Note that range creates an `ìterator` (something to iterate from). To see the values, list them."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MCMeBauDYqhz",
        "outputId": "0d4764ad-6791-41a0-b1a1-048a33f28d42",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "# Nothing will be printed. The range function returns an iterator.\n",
        "range(0,10)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "range(0, 10)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 45
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hydaUYt-Yx5K",
        "outputId": "2ce6a635-00c9-42af-956a-7a4498152e29",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Turn iterator into list. Now we see the values.\n",
        "list(range(0,10))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 46
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WT-FYm3aY7cX"
      },
      "source": [
        "# Self Study\n",
        "A detailed Python tutorial is available [here](https://docs.python.org/3/tutorial/). Go through it until Chapter 5 (inclusive). Next week we'll continue with modules, packages, and more sophisticated functions!\n",
        "\n",
        "As an exercise, create a program that adds the numbers from 1 to 100, and every 10 numbers prints \"The current value is  `N`\" with `N` the number. (i.e. \"The current value is 10\", \"The current value is 20\", ...)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hzfdCVOkHBfp"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}