0-Review-of-Python-Concepts.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/jessespencersmith/2019-04-23-Nashville-DSI/blob/gh-pages/0-Review-of-Python-Concepts.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oAfH9aSaZC_R"
      },
      "source": [
        "# Overview of Python Concepts"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kKYmex0BZC_V"
      },
      "source": [
        "Tutorial adapted from: A Whirlwind Tour of Python by Jake VanderPlas (O’Reilly). Copyright 2016 O’Reilly Media, Inc., 978-1-491-96465-1.\n",
        "\n",
        "More information about these and many other topics can be found at: https://github.com/jakevdp/WhirlwindTourOfPython"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uyX1TzTZZC_V"
      },
      "source": [
        "## Variables and Variable Types"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NK_vgACjZC_W"
      },
      "source": [
        "In this section, we will learn about variables, how to declare them, and the types that are associated with them. \n",
        "\n",
        "For more information on topics covered in this section, visit https://github.com/jakevdp/WhirlwindTourOfPython/blob/master/03-Semantics-Variables.ipynb for a deeper look at many of the same concepts"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zd85QKlPZC_W"
      },
      "source": [
        "### Declaring a Variable"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f-G9pAOOZC_W"
      },
      "source": [
        "In Python, declaring a variable is as easy as putting the name of a variable you want to create, an ``=`` sign, and then something for that variable name to be equal to.\n",
        "\n",
        "For example:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "TynCxkQEZC_X"
      },
      "outputs": [],
      "source": [
        "var = 4 # The variable Var now equals 4"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X053A0BsZC_Y"
      },
      "source": [
        "Checking this, we can use the ``print()`` function, give it the name of the variable, and Python will return it for us to see."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "YsjxJ_mVZC_Y",
        "outputId": "0cf2e1b5-9cbe-462e-8ef0-c0eb27a65363"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "4\n"
          ]
        }
      ],
      "source": [
        "print(var)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "elGdPCsXZC_Z"
      },
      "source": [
        "To test this out, you can change the '4' in the first piece of code to something else, run it, and then when you run the second block, you'll see that the variable has been updated."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YO05ig7qZC_a"
      },
      "source": [
        "### Variable Types"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tWgtZUnJZC_a"
      },
      "source": [
        "Everything in Python has a type, including any variables you declare, even though you don't explictly tell Python the type of variable you are creating.\n",
        "\n",
        "There are a few ways you can go about finding these types, the first of which that we'll look at is the ``type()`` method.\n",
        "When we call ``type(input)``, Python will return the type of whatever it is that we input.\n",
        "\n",
        "Here are a few examples:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QxwYCHkwZC_a",
        "outputId": "97462d5c-5176-4bda-bf55-b90af278d2eb"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "int"
            ]
          },
          "execution_count": null,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "i = 4\n",
        "type(i) # i is an integer"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "M7QBsqZrZC_a",
        "outputId": "84fdf8ee-0531-4c3f-9c1c-435a52e0bf81"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "str"
            ]
          },
          "execution_count": null,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "s = 'Hello'\n",
        "type(s) # s is a string"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yObXXWNXZC_b",
        "outputId": "2e934baf-5094-42bd-d7b1-9bde5473d175"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "float"
            ]
          },
          "execution_count": null,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "f = 3.14159\n",
        "type(f) # f is a float"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qQHiZ9LdZC_b",
        "outputId": "2f602c5d-f063-4ad8-b4d4-71375d1e64b7"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "str"
            ]
          },
          "execution_count": null,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "#Try it out yourself! Replace the input below and then run this block a few times\n",
        "#to see if you can recreate the three types above!\n",
        "example = 'Replace Me!'\n",
        "type(example)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nzZY57J7ZC_b"
      },
      "source": [
        "## Arithmetic, Comparison, and Boolean Operators"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sE-p7-rCZC_c"
      },
      "source": [
        "In this section, we'll learn how to use operators to perform actions on and with the variables we learned to create in the previous section.\n",
        "\n",
        "For more information on the topics covered in this section, visit https://github.com/jakevdp/WhirlwindTourOfPython/blob/master/04-Semantics-Operators.ipynb for a more advanced look at operators and the things you can do with them"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AjGDaZRlZC_c"
      },
      "source": [
        "### Arithmetic Operators"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "82IiemCFZC_c"
      },
      "source": [
        "The first type of operator we'll look at are the most basic of arithmetic operators ``+``,``-``,``*``, and ``/``\n",
        "\n",
        "Let's look at some examples of how to use them."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "OgPUatxMZC_c"
      },
      "outputs": [],
      "source": [
        "#First, we need some variables to use!\n",
        "A = 2\n",
        "B = 5\n",
        "C = 10.5\n",
        "D = 3.14159\n",
        "E = 'String'"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "CPQBiBH8ZC_c",
        "outputId": "fd047137-a9d1-4c0b-9bf3-bb0ca87811d8"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "7\n"
          ]
        }
      ],
      "source": [
        "print(A + B) # Addition"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "MrbHIs-lZC_d",
        "outputId": "013ab98d-8bd9-4948-b225-667458a23b03"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "7.35841\n"
          ]
        }
      ],
      "source": [
        "print(C - D) # Subtraction"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6xqP71HQZC_d",
        "outputId": "4c8da8e1-ad9c-4408-ba2d-03c22f64a5ec"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "21.0\n"
          ]
        }
      ],
      "source": [
        "print(A * C) # Multiplication"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "13Ds7iA9ZC_d",
        "outputId": "9489d8d4-6abd-4aef-cdcc-e342fad5bbee"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2.5\n"
          ]
        }
      ],
      "source": [
        "print(B / A) # Division"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pDr2is5kZC_d",
        "outputId": "401ec18f-07cd-4407-d58c-c95acb2a28d1"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "13.679205\n"
          ]
        }
      ],
      "source": [
        "#We can also combine as many as we want in a line\n",
        "print((A * B) + ((C - D) / A))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "P0-XP-UZZC_e",
        "outputId": "09d30728-371a-401b-a55f-0c9de6edbbe7"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "StringString\n"
          ]
        }
      ],
      "source": [
        "#This can even work with strings!\n",
        "print(A * E)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3O1_7Nw6ZC_e",
        "outputId": "60b47b0e-5081-48da-fd82-07b982a26da5"
      },
      "outputs": [
        {
          "ename": "TypeError",
          "evalue": "unsupported operand type(s) for /: 'int' and 'str'",
          "output_type": "error",
          "traceback": [
            "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[1;32m<ipython-input-59-64be5c9498e4>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;31m#error you might get if you attempt operations that Python doesn't know how to do\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mA\u001b[0m \u001b[1;33m/\u001b[0m \u001b[0mE\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m# Think about it, does it make sense to divide 2 by a string? Not really\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for /: 'int' and 'str'"
          ]
        }
      ],
      "source": [
        "# Be careful though when operating on two variable of different types! The code below will produce an example of an\n",
        "# error you might run into if you attempt operations that Python doesn't know how to execute\n",
        "\n",
        "print(A / E) # Think about it, does it make sense to divide 2 by a word? Not really\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zl5Po_DnZC_e"
      },
      "source": [
        "In addition, Python offers a few more advanced arithmetic operations:\n",
        "\n",
        "``//`` Will do standard division but chop off the remainder\n",
        "\n",
        "``%`` Will give the integer remainder after division of the first variable by the second\n",
        "\n",
        "``**`` Will raise the first variable to the power of the second variable\n",
        "\n",
        "Here are some examples:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "YqY7DZ0gZC_e",
        "outputId": "baf943b0-8f43-4d11-82f8-e3e73de686cd"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2.5\n"
          ]
        }
      ],
      "source": [
        "print(B / A) # Here is the result of normal division"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "aAR3ItY4ZC_e",
        "outputId": "d2f45e95-75c2-4d47-90a4-94cd9ff4348e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2\n"
          ]
        }
      ],
      "source": [
        "print(B // A) # You can see the remainder from the previous line is chopped off"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kIyHZePxZC_f",
        "outputId": "5b8ba418-e6a1-4180-9b00-bc9a5eda230b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1\n"
          ]
        }
      ],
      "source": [
        "print(B % A) # 5 divided by 2 is 2 with a remainder of 1, so % returns a 1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "plKJBIf_ZC_f",
        "outputId": "17895cb8-b2de-48e9-cea6-b16faf759866"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "25\n"
          ]
        }
      ],
      "source": [
        "print(B ** A) # This becomes 5^2 which is 25"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q2QAK3rHZC_f"
      },
      "source": [
        "Feel free to play around with these arithmetic operators in the code spaces below. As a challenge, see if you can find the correct combinations using the basic and advanced arithmetic operators using the A,B, and C variables above!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "HDj5DUrfZC_f",
        "outputId": "c13c9649-b8e1-4909-c8d0-c10d5b849463"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n"
          ]
        }
      ],
      "source": [
        "#Using only the basic arithmetic operators (+,-,*,/)\n",
        "#Goal Result: 1.0\n",
        "print() "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p62xIoidZC_f"
      },
      "source": [
        "<details><summary> <u> Click here for solution </u> </summary>\n",
        "    <pre>\n",
        "    Solution: A * (C - B - B)\n",
        "    </pre>\n",
        "   </details>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "NmhpnzhPZC_g",
        "outputId": "658a927c-40cd-4357-87b1-3eed3cc8d1f4"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n"
          ]
        }
      ],
      "source": [
        "#Using any combination of arithmetic operators (+,-,*,/,//,%,**)\n",
        "#Goal Result: 17.0\n",
        "print()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vlzDRfhOZC_g"
      },
      "source": [
        "<details><summary> <u> Click here for solution </u> </summary>\n",
        "    <pre>\n",
        "    Solution: ((A ** A) * C) - (B ** A)\n",
        "    </pre>\n",
        "   </details>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "A83pYrslZC_g"
      },
      "source": [
        "### Comparison Operators"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dixvRwWnZC_g"
      },
      "source": [
        "Another type of operation which can be very useful is comparison of different values. In Python, there are 6 comparison operators that all return either ``True`` or ``False``. \n",
        "\n",
        "Here is a list of the comparison operators:\n",
        "\n",
        "``==`` Returns ``True`` if the values on either side are equal, and ``False`` otherwise\n",
        "\n",
        "``<`` Returns ``True`` if the value on the left is less than the one on the right, and ``False`` otherwise\n",
        "\n",
        "``<=`` Returns ``True`` if the value on the left is less than or equal to the one on the right, and ``False`` otherwise\n",
        "\n",
        "``>`` Returns ``True`` if the value on the left is greater than the one on the right, and ``False`` otherwise\n",
        "\n",
        "``>=`` Returns ``True`` if the value on the left is greater than or equal to the one on the right, and ``False`` otherwise\n",
        "\n",
        "``!=`` Returns ``True`` if the values on either side are NOT equal, and ``False`` otherwise"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "JBVooRW-ZC_g"
      },
      "outputs": [],
      "source": [
        "# First, let's make some variables\n",
        "A = 2\n",
        "B = 5\n",
        "C = 10.5"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xMfNFp5pZC_g",
        "outputId": "c6b652e3-5cd5-4292-937e-8221a571278c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "True\n"
          ]
        }
      ],
      "source": [
        "print(A == 2) # Returns True because A is equal to 2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "JUA4RjNpZC_g",
        "outputId": "a7dd3352-23af-4caa-fc30-dd04457f712c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "True\n"
          ]
        }
      ],
      "source": [
        "print(C != 2) # Returns True becuase C is NOT equal to 2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "47kmeTWWZC_g",
        "outputId": "2c49271b-f684-422e-d709-62c49b650d9e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "True\n"
          ]
        }
      ],
      "source": [
        "print(B > A) # Returns True because B which is 5 is greater than A which is 2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "JE-9mJvjZC_h",
        "outputId": "64202252-3864-4762-96be-74dff240d328"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "False\n"
          ]
        }
      ],
      "source": [
        "print(B > 5) # Returns False because B is not greater than 5, this would return True if we used the >= operator instead"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Dtp2IcOTZC_h",
        "outputId": "636b4566-d9cd-4cf6-b538-eab5550a9a03"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "True\n"
          ]
        }
      ],
      "source": [
        "print(B >= 5) # We can see it now returns True"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Ut8CyN_pZC_h",
        "outputId": "70ce3c5b-8aac-4332-c140-a200e3777fd1"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "True\n"
          ]
        }
      ],
      "source": [
        "print(B <= 5) # This operator also returns True for the same statement"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P5LwBuUXZC_h"
      },
      "source": [
        "Like the Arithmetic operators, you can combine many of these comparison as well as arithmetic operators together to make long logical statements if you so need.\n",
        "\n",
        "Here's an example, and then an empty code line below it for you to experiment creating your own statements:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "EK0QvmAPZC_h",
        "outputId": "ebafabfa-5081-4bea-f238-4fe8bc203fcd"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "False\n"
          ]
        }
      ],
      "source": [
        "print((A + C) >= (B ** A)) # Returns False because A + C is 12.5, and B ** A is 25, \n",
        "                           # and then 12.5 is not greater than or equal to 25"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "WC06nkFHZC_h",
        "outputId": "c9409080-1baf-4712-e478-5965585e8d86"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n"
          ]
        }
      ],
      "source": [
        "# Here's some space to try your own! Fill in a statement with a comparison operator inside the print function, \n",
        "# and try to see if you can guess what the result will be before you run it.\n",
        "print()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sg_jmy80ZC_h"
      },
      "source": [
        "### Boolean Operators"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pBZyQpQcZC_i"
      },
      "source": [
        "The final type of operator we will look at in this notebook is Boolean operators. This refers to the logical operations ``and``, ``or``, and ``not`` that operate on values of ``True`` and ``False``. \n",
        "\n",
        "``and`` Returns ``True`` if the values on BOTH sides of the operator are True, and ``False`` otherwise\n",
        "\n",
        "``or`` Returns ``True`` if the values on EITHER side of the operator is True, and ``False`` otherwise\n",
        "\n",
        "``not`` Returns ``True`` if the value it is given is False, and returns ``False`` if the value it is given is True\n",
        "\n",
        "Here are some examples of how they work:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9OEXYYovZC_i"
      },
      "outputs": [],
      "source": [
        "# Let's re-declare our variables so we can keep them in mind as we work through these examples\n",
        "A = 2\n",
        "B = 5\n",
        "C = 10.5"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ceIY93pWZC_i",
        "outputId": "9360267f-e5e0-4e53-829e-7a1408a8bf16"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "False\n"
          ]
        }
      ],
      "source": [
        "print(A == B and A == 2) # This will return False because while A is equal to 2, it is not equal to B, and\n",
        "                         # the 'and' operator requires both to be True to return True"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "SFTGqAugZC_i",
        "outputId": "21323690-b10e-47f9-a0db-8d3524d67125"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "True\n"
          ]
        }
      ],
      "source": [
        "print(A == B or A == 2) # Replacing the 'and' with 'or' in the same statement however does produce a result of True\n",
        "                        # Remember that this is because 'or' requires only one of the two to be True to return True"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DeLAHA6kZC_i",
        "outputId": "a73fc685-b172-4597-f592-fe812841f94c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "False\n"
          ]
        }
      ],
      "source": [
        "print(not(A == 2)) # This returns False because A == 2 is True, and not(True) returns 'False'"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1-NabZdJZC_i"
      },
      "source": [
        "## What we've covered"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O6gPwxjvZC_i"
      },
      "source": [
        "Upon completion of this notebook, you should be familiar with the following:\n",
        "\n",
        "- Variables and how to declare them\n",
        "- Types of variables and how you could find that type\n",
        "- Using Arithmetic operators to do simple and advanced arithmetic\n",
        "- Using Comparison operators to compare values\n",
        "- Using Boolean operators to evaluate logical statement involving 'True' and 'False' values"
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "colab": {
      "name": "0-Review-of-Python-Concepts.ipynb",
      "provenance": [],
      "include_colab_link": true
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}