1_Python_Fundamentals_Notes.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "MSDS 596 - Week 1 - Lecture Notes - Python Fundamentals 1",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "69AWPcrCHm00"
      },
      "source": [
        "# **Python Fundamentals 1**\n",
        "**What is Python?**\n",
        "\n",
        "Per [wikipedia](https://en.wikipedia.org/wiki/Python_(programming_language))\n",
        "\n",
        "> Python is an interpreted, high-level, general-purpose programming language. Created by Guido van Rossum and first released in 1991, Python's design philosophy emphasizes code readability with its notable use of significant whitespace. Its language constructs and object-oriented approach aim to help programmers write clear, logical code for small and large-scale projects.\n",
        "\n",
        "**Why learn it?**\n",
        "\n",
        "Python has a wide range of use cases to include **data analytics**. As analytics and data science have become more prominent in the past decade, it has quickly become an industry standard. The tools we will be using in this class are all built off of Python.  \n",
        "\n",
        "**What do I need to know before we start?**\n",
        "\n",
        "Python's syntax is **indentation-based**.  This means that white space matters when you are writing Python code.  As a result, Python code becomes formatted neatly and is easier to read.  Don't worry if this doesn't mean anything to you right now, we will get into this shortly.  "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DT6LqbsRsIyH"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OydOcy6ruVEb"
      },
      "source": [
        "# **Comments**\n",
        "\n",
        "Comments are lines of text that are added to code to help explain the code to readers.  Comments are ignored by the interpreter when the code is run.  It is solely for the benefit of the human author and reader of the code.\n",
        "\n",
        "In Python, comments are written by starting a line with the # symbol."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OJ5unGWTvf-9"
      },
      "source": [
        "# This is an example of a comment\n",
        "# Google Colab will use the color green for comments\n",
        "# This is a comment"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WKzjGRD6LYTp"
      },
      "source": [
        "# **Variables and Data Types**\n",
        "\n",
        "Variables are containers for storing values.  \n",
        "You assign values to variables by using ="
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xN0AHVVyLANx"
      },
      "source": [
        "y = 8"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1SCHluo9Mbo8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "96041240-fae3-4ee5-b69c-0492a4a3f0b9"
      },
      "source": [
        "print(x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "8\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lUMLH4QSMoPv"
      },
      "source": [
        "You can overwrite the value of an existing variable by assigning a new value to it in the same way."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MLKNv_d7MgVg"
      },
      "source": [
        "x = 5.1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n8MlfcHkMipw"
      },
      "source": [
        "print(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RGyUhat2N0AD"
      },
      "source": [
        "There are many different types of values that can be stored in variables.  \n",
        "Common scalar data types include:\n",
        "* Integer\n",
        "* Float\n",
        "* String\n",
        "* Boolean \n",
        "* Tuple\n",
        "* List\n",
        "* Set\n",
        "* Dictionary \n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "msdXmKG-s_n9"
      },
      "source": [
        "## Integers and Floats\n",
        "`int` and `float` respectively are types of numeric values.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nIxILeeEMjfx",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b2748256-9098-48cc-b241-f910191284ee"
      },
      "source": [
        "# Integers and Floats\n",
        "radius = 2  # This is an integer\n",
        "pi = 3.14   # This is a float\n",
        "\n",
        "# You can mix integers and floats in calculations\n",
        "area_of_circle = pi * radius * radius\n",
        "print(area_of_circle)\n",
        "type(area_of_circle)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "12.56\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "float"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wHpVYHhDtUW0"
      },
      "source": [
        "## Strings\n",
        "`str` are \"strings\" of text characters"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "06VOn88HPFJ5"
      },
      "source": [
        "# String\n",
        "# A string of text wrapped in single, double, or triple quotes\n",
        "\n",
        "hello = 'Hello' # Single Quotes\n",
        "world = \"World\"  # Double Quotes\n",
        "# Triple Quotes for multi-line strings \n",
        "preamble = \"\"\"\n",
        "We the People of the United States, \n",
        "in Order to form a more perfect Union, \n",
        "establish Justice, ensure domestic Tranquility, \n",
        "provide for the common defence, \n",
        "promote the general Welfare, \n",
        "and secure the Blessings of Liberty to ourselves and our Posterity, \n",
        "do ordain and establish this Constitution for the United States of America.\n",
        "\"\"\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5cil6DkQJ06U",
        "outputId": "f31a1243-c448-402a-e0ab-55e02629e778"
      },
      "source": [
        "asdf = \"Goodbye\"\n",
        "print(asdf)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Goodbye\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "H-reDDvnInH-",
        "outputId": "64e76c79-cae2-4791-9233-a380097b4db2"
      },
      "source": [
        "print(preamble)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "We the People of the United States, \n",
            "in Order to form a more perfect Union, \n",
            "establish Justice, ensure domestic Tranquility, \n",
            "provide for the common defence, \n",
            "promote the general Welfare, \n",
            "and secure the Blessings of Liberty to ourselves and our Posterity, \n",
            "do ordain and establish this Constitution for the United States of America.\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jkSzpgVCALnX"
      },
      "source": [
        "## String concatenation\n",
        "Strings can be \"added\" i.e. concatenated together with other strings"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eVEC2TdGAcwI",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "71a455a1-35a3-4ee5-f987-e1807634f3d4"
      },
      "source": [
        "greeting = hello + ' ' + world\n",
        "print(greeting)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello World\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "guCMoCjtAm3w"
      },
      "source": [
        "However, strings cannot be concatenated to non-strings"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t14m4wYNSbnL",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "752e46c2-ea64-4b81-86c9-fc0582de7e58"
      },
      "source": [
        "love_amount = 3000  # int\n",
        "i_love_python = \"I love Python \" # str\n",
        "# print(i_love_python + love_amount) # error\n",
        "\n",
        "love_amount = str(love_amount)\n",
        "print(love_amount)\n",
        "# print(type(a))\n",
        "print(type(love_amount))\n",
        "print(i_love_python + love_amount)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3000\n",
            "<class 'str'>\n",
            "I love Python 3000\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uNIvfLx5Aw3P"
      },
      "source": [
        "But, we can cast (i.e. convert) variables from one type to another by wrapping the variable name in str() or int() or float() etc."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dPDLAExWTTv7"
      },
      "source": [
        "love_amount_str = str(love_amount)  # Casts from int to str\n",
        "print(i_love_python + love_amount_str)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "MfdKbBRANaC7",
        "outputId": "3cef553a-5ae2-4dea-f7ad-5736a413ac0e"
      },
      "source": [
        "first_letters_of_alphabet = \"abcdefg\"\n",
        "first_letters_of_alphabet[0:3]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'abc'"
            ]
          },
          "metadata": {},
          "execution_count": 45
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cNl32h7TBcgG"
      },
      "source": [
        "## Boolean\n",
        "`bool` is a true or false value"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Jjlp-ZBjQT4Q",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "22e7468a-88ef-4ad0-c639-155355c06aae"
      },
      "source": [
        "t = True\n",
        "f = False\n",
        "\n",
        "# We can combine boolean values (or expressions that evaluate to boolean values)\n",
        "# using logical operators (e.g. and, or, not)\n",
        "\n",
        "print(\"True and False: \", t and f)\n",
        "print(\"True or False: \", t or f)\n",
        "print(\"Not False: \", not f)\n",
        "print(\"True and True: \", t and t)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "True and False:  False\n",
            "True or False:  True\n",
            "Not False:  True\n",
            "True and True:  True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Hz8K63pxK6st"
      },
      "source": [
        "a = 3.6\n",
        "a_integer = int(a)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3f4H4vXfLA7G",
        "outputId": "d09f876b-d03f-41cc-d93e-aff6b26e87ae"
      },
      "source": [
        "print(a_integer)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XowKlytpBsMJ"
      },
      "source": [
        "## Lists\n",
        "`list` are a data structure consisting of a list of ordered, comma-separated values contained within brackets.\n",
        "They can contain different data types."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qBEcX3CUD4yG"
      },
      "source": [
        "my_empty_list = []\n",
        "my_list = [1,2,3,4,5,6,7,8,9]\n",
        "my_str_list = [\"a\",\"b\",\"c\"]\n",
        "my_mixed_list = [\"a\", 1, 2.5, True]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mmQRD5VlCwdF",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3761ef00-23c7-4b79-8f9a-482e7327b2fc"
      },
      "source": [
        "my_list"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3, 4, 5, 6, 7, 8, 9]"
            ]
          },
          "metadata": {},
          "execution_count": 35
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uaJNOt3pB-Ug"
      },
      "source": [
        "Lists are helpful to organize data and process them in order.\n",
        "\n",
        "Data in a list can be accessed using the index (i.e. order number) of the desired element in the list. \n",
        "\n",
        "*   The first element in the list has an index of 0\n",
        "*   The last element in the list has an index of -1\n",
        "*   A \"slice\" of the list can be grabbed by specifying the first (inclusive) and last (exclusive) indices\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0ou165qfEoP6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a151d163-f436-44bf-aaf4-de01762852a7"
      },
      "source": [
        "my_list[0] # the first element of the list"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 36
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9ifMrGPoEvY8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "e3fca8fb-52a9-4d2a-fc17-d200cad76594"
      },
      "source": [
        "my_str_list[2] # the third element of the list"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'c'"
            ]
          },
          "metadata": {},
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZE3mhqmHE2ms",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7c9eb25c-46d4-4be1-9e59-a9c235d74213"
      },
      "source": [
        "my_list[-1] # the last element of the list"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "9"
            ]
          },
          "metadata": {},
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "b6gVTFQHE-q2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "84172bfd-74f6-4ae8-d699-9c6e56e04509"
      },
      "source": [
        "my_list[0:3] # a list containing only the first three items of the list"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3]"
            ]
          },
          "metadata": {},
          "execution_count": 39
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yZI1FEBZMQca"
      },
      "source": [
        "The length of a list can be calculated using `len()`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kvTEPHrKCWK-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ee3d51b6-6f31-4958-eee4-f14b12e0d652"
      },
      "source": [
        "len(my_list)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "9"
            ]
          },
          "metadata": {},
          "execution_count": 40
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mAq1fZ3mMX9P"
      },
      "source": [
        "New items can be added to a list by using `append()`\n",
        "\n",
        "Lists can also be added to each other to concatenate them."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xJAVVrPQMXLM",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e5e66f9f-0c87-460a-a104-4e9eb7f7c3c5"
      },
      "source": [
        "my_list.append(10)\n",
        "my_list[0] = 1000\n",
        "print(my_list) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
        "\n",
        "# We can also add (concatenate) lists\n",
        "a = [1,2,3]\n",
        "b = [4,5,6]\n",
        "c = a + b\n",
        "print(c) # [1, 2, 3, 4, 5, 6]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1000, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 10, 10, 10]\n",
            "[1, 2, 3, 4, 5, 6]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mgs2sieYw6JR"
      },
      "source": [
        "# Tuple\n",
        "\n",
        "Tuples are fixed-length sequences of Python objects.  The elements in a tuple are comma separated and the tuple is defined using parentheses."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FCGXOD-Q8wKV"
      },
      "source": [
        "my_tuple = (1,2,3,4)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WTOjPDhaxZtR",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0d2f283d-47ed-4e4d-8bb4-efa8567e6086"
      },
      "source": [
        "my_tuple[0]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 50
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i2UyT9zYxcBB",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 162
        },
        "outputId": "943dbcb8-1ba4-46bf-a27e-c1804865aa56"
      },
      "source": [
        "my_tuple[0] = 100  # ERROR - Tuples are immutable"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-51-676a8cf67872>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmy_tuple\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m100\u001b[0m  \u001b[0;31m# ERROR - Tuples are immutable\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IK4NhkhRMwSR"
      },
      "source": [
        "## Dictionary\n",
        "\n",
        "A **dictionary** is a key/value map.  That is, **keys** can be used to store and look up **values**."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6vY1AqGiIudc"
      },
      "source": [
        "empty_dictionary = {}\n",
        "student_record = {\n",
        "    \"name\": \"Harry Potter\",\n",
        "    \"school\": \"Hogwarts\",\n",
        "    \"house\": \"Gryffindor\",\n",
        "    \"year\": 1,\n",
        "    \"age\": 11,\n",
        "    \"friends\": [\"Hermione Granger\", \"Ron Weasley\"],\n",
        "    \"speaks_parseltongue\": True\n",
        "}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TL63jlSVMPVX",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2ac897c3-f44c-484e-e516-ca40a325a441"
      },
      "source": [
        "# Values can be accessed using the key name\n",
        "# The key name is wrapped in square brackets or get()\n",
        "print(student_record[\"age\"]) # 11\n",
        "print(student_record.get(\"friends\", \"Error\")) # ['Hermione Granger', 'Ron Weasley']"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "11\n",
            "['Hermione Granger', 'Ron Weasley']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9YDRBvNqNmrP",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "93c19dd4-d0fa-479a-8f17-9cfc8ebde680"
      },
      "source": [
        "# New key/value pairs can always be added to the dictionary\n",
        "student_record[\"enemies\"] = [\"Draco Malfoy\"]\n",
        "print(student_record)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'name': 'Harry Potter', 'school': 'Hogwarts', 'house': 'Gryffindor', 'year': 1, 'age': 11, 'friends': ['Hermione Granger', 'Ron Weasley'], 'speaks_parseltongue': True, 'enemies': ['Draco Malfoy']}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jzoBmElSPqLB",
        "outputId": "6fd23d4d-5f7f-4079-cf53-94cfdb77576f"
      },
      "source": [
        "student_record.items()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dict_items([('name', 'Harry Potter'), ('school', 'Hogwarts'), ('house', 'Gryffindor'), ('year', 1), ('age', 12), ('friends', ['Hermione Granger', 'Ron Weasley']), ('speaks_parseltongue', True), ('enemies', ['Draco Malfoy'])])"
            ]
          },
          "metadata": {},
          "execution_count": 60
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7daZ1klPNshf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "85e0aca7-0ac2-4afd-8aa4-292ea15ea8f6"
      },
      "source": [
        "# Existing values can be updated with new values\n",
        "student_record[\"age\"] = 11.5\n",
        "print(int(student_record[\"age\"]))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "11\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pk5L7XyrM9-s"
      },
      "source": [
        "# **Python Operators**\n",
        "## Arithmetic Operators\n",
        "**\\+** : Addition\n",
        "\n",
        "**\\-** : Subtraction\n",
        "\n",
        "**\\*** : Multiplication\n",
        "\n",
        "**/** : Division\n",
        "\n",
        "**%** : Modulo\n",
        "\n",
        "****** : Exponent\n",
        "\n",
        "## Comparison Operators\n",
        "**==** : equal to\n",
        "\n",
        "**\\>=** : greater than or equal to\n",
        "\n",
        "**\\>**  : greater than\n",
        "\n",
        "**<=** : less than or equal to\n",
        "\n",
        "**<**  : less than\n",
        "\n",
        "**!=** : not equal to\n",
        "\n",
        "## Assignment Operators\n",
        "\n",
        "**\\=** : Assigns a value to a variable\n",
        "\n",
        "**+=** : Adds the value and assigns it to the variable\n",
        "\n",
        "## Logical Operators\n",
        "x **and** y : True if x and y are both True\n",
        "\n",
        "x **or** y : True if at least one of x or y are True\n",
        "\n",
        "**not** x : True if x is False, False if x is True"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LQJ16QwnP7lr",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1d424f0e-444d-4354-dd74-6fd34729dc47"
      },
      "source": [
        "5 == 5"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 63
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J8KWt58BQIUd",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "39bb459a-4cac-4c77-ed4d-c011d60b8f16"
      },
      "source": [
        "1 == 2"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 64
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PILau2BwQNQr",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8f490362-fad8-4d8e-f293-55c1fb3f512a"
      },
      "source": [
        "\"dog\" != \"cat\""
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 65
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qo98Wo3RQXUo",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "69a167e7-9e5c-4754-cd9f-449188051895"
      },
      "source": [
        "1000 > 100"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 66
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HY5Gjrxu7If1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "db1ed2cc-00c5-428f-c36b-6b2768f6053a"
      },
      "source": [
        "8 % 4"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {},
          "execution_count": 68
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zRHLRQP57Koo",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "38b1eb81-7976-4662-e39f-dc82fc45aff7"
      },
      "source": [
        "2 ** 4"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "16"
            ]
          },
          "metadata": {},
          "execution_count": 69
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5c3iHAPeTxkC",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6052f392-8771-495a-83e7-74e81d0cb618"
      },
      "source": [
        "x = 5\n",
        "x += 2 # equivalent to x = x + 2\n",
        "print(x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "7\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N36xFSdnT12c",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2cfa81d6-5508-44d4-cf25-2c8f72c288de"
      },
      "source": [
        "university = \"USF\"\n",
        "course = \"MSDS 596\"\n",
        "\n",
        "print(university == \"USF\" and course == \"MSDS 595\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NQmiPmuMQd6m"
      },
      "source": [
        "## **If statements**\n",
        "\n",
        "We can add if statements to our code, so that code only runs if a certain condition is met.\n",
        "\n",
        "*Note: This is the first time we're seeing the indentation referenced earlier.  All code to be executed when the `if` condition is met should be at the same level of indentation.*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PCR300VoSYpe",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8ddf20cc-9ec5-4a31-de4e-266285db51e6"
      },
      "source": [
        "# Let's go back to our Harry Potter student record\n",
        "print(student_record)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'name': 'Harry Potter', 'school': 'Hogwarts', 'house': 'Gryffindor', 'year': 1, 'age': 11.5, 'friends': ['Hermione Granger', 'Ron Weasley'], 'speaks_parseltongue': True, 'enemies': ['Draco Malfoy']}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k0fFDab-Sh1s",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f3419218-6d41-42c0-a683-0b725c6641c6"
      },
      "source": [
        "if student_record[\"school\"] == \"Hogwarts\":\n",
        "    print(student_record[\"name\"] + \"'s headmaster is Albus Dumbledore\")\n",
        "    print(\"1\")\n",
        "    print(\"2\")\n",
        "print(\"3\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Harry Potter's headmaster is Albus Dumbledore\n",
            "1\n",
            "2\n",
            "3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_FWQzEkyUgpg",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c2c1aa16-5cbf-4851-f667-ce7cd1e05968"
      },
      "source": [
        "# Only 3rd years and above are allowed to go to Hogsmeade. \n",
        "# Let's check this and print whether Harry is allowed to go\n",
        "\n",
        "student_record[\"year\"] = -1\n",
        "if student_record[\"year\"] >= 3:\n",
        "    print(student_record[\"name\"] + \" is permitted to go to Hogsmeade\")\n",
        "elif student_record[\"year\"] >= 0 and student_record[\"year\"] <= 2:\n",
        "    print(student_record[\"name\"] + \" is NOT permitted to go to Hogsmeade\")\n",
        "else:\n",
        "    print(\"Invalid student year\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Invalid student year\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N17Z3_HcWu9m"
      },
      "source": [
        "## **Loops**\n",
        "\n",
        "Loops allow you to iterate over a block of code.\n",
        "\n",
        "See the different types of loops and use cases below.\n",
        "\n",
        "## **`for` loops**\n",
        "\n",
        "Iterates one item at a time through a sequence of items, allowing you to execute code on each item.  This is useful for processing data records, where you want to act on every record in some pre-determined way.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Wbz9z-y6amZA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f5233a2e-7529-406d-8393-063beb2cffed"
      },
      "source": [
        "# Let's look at an example of a simple for loop\n",
        "names = [\"Harry\", \"Ron\", \"Hermione\", \"Draco\"]\n",
        "for name in names:\n",
        "    print(name)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Harry\n",
            "Ron\n",
            "Hermione\n",
            "Draco\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cYh-Rh0dkORl",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "11e76a26-42e1-4027-8e24-fd5dea40e309"
      },
      "source": [
        "# Here's another example, where we iterate through a list of items, look up its price, and update a running total\n",
        "\n",
        "# total_cost will hold the running total. It is initalized to $0.\n",
        "total_cost = 0\n",
        "# price_catalog is a dictionary mapping items to prices\n",
        "price_catalog = {\n",
        "    \"book\": 20,\n",
        "    \"notebook\": 5,\n",
        "    \"pencil\": 1,\n",
        "    \"eraser\": 0.25\n",
        "}\n",
        "# items_in_cart is a list of items we will be purchasing\n",
        "items_in_cart = [\"book\", \"notebook\", \"notebook\", \"pencil\"]\n",
        "\n",
        "for item in items_in_cart:\n",
        "    print(item + \" costs $\" + str(price_catalog[item]))\n",
        "    total_cost += price_catalog[item] # += means take the current value in the variable and add the new value to it\n",
        "    # total_cost = total_cost + price_catalog[item]\n",
        "print(\"The total cost is $\" + str(total_cost))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "book costs $20\n",
            "notebook costs $5\n",
            "notebook costs $5\n",
            "pencil costs $1\n",
            "The total cost is $31\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Qjhu0avqocuK"
      },
      "source": [
        "## **`while` loops**\n",
        "\n",
        "Continue to loop through the code until the provided test expression is no longer true.  Be careful as you can have infinite loops if the test expression never evaluates to false."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-UOVDlLXlnQ4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "810f1290-147c-4355-96dc-8ac9442c126b"
      },
      "source": [
        "# Here is a while loop example\n",
        "\n",
        "num_loops = 3\n",
        "while num_loops > 0:\n",
        "    print(num_loops)\n",
        "    num_loops -= 1 # subtract 1 from num_loops every loop"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3\n",
            "2\n",
            "1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hhe4UvtDqWRi"
      },
      "source": [
        "## **Functions**\n",
        "\n",
        "A function is a block of code that performs a specific action. Functions generally take an input and return an output.  Using functions is good coding practice, as it allows you to break otherwise large, unwieldy blocks of code into smaller, modular pieces that are easier to read/understand and are also reusable."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yS24olqjqCtt"
      },
      "source": [
        "# An example of a function\n",
        "# This statement defines the function.\n",
        "# The syntax is def my_function_name(some,input,variables):\n",
        "# A value can be returned using \"return\"\n",
        "def add_two_numbers(a, b):\n",
        "    return a + b\n",
        "\n",
        "# Now that the function is defined, we can call it.\n",
        "print(add_two_numbers(10, 5))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aGCLSubtP1wS"
      },
      "source": [
        "# Another example of a function\n",
        "def get_average(list_of_numbers):\n",
        "    list_length = len(list_of_numbers)\n",
        "    total = 0\n",
        "    for number in list_of_numbers:\n",
        "        total += number\n",
        "    return total/list_length\n",
        "\n",
        "some_numbers = [1,2,3,4,5,6]\n",
        "print(get_average(some_numbers))"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}