Step_1__1_Introduction_and_Operators.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "anaconda-cloud": {},
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.1"
    },
    "colab": {
      "name": "Step_1 _1_Introduction_and_Operators.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "hLDBuvpyaEhM",
        "Fn_NrHDBaEhQ",
        "l_2Z9uZFaEhR",
        "_r8bfbV6aEhX",
        "0Ai6iFv7aEhe",
        "loK3HgbXaEhh",
        "w6kf5QDkaEhl",
        "4sENFJzCaEhs",
        "nlVQ-JcxaEhx"
      ],
      "toc_visible": true,
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Haydarjammoul/course-collaboration-travel-plans/blob/master/Step_1__1_Introduction_and_Operators.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vOasMpnwaEgP",
        "colab_type": "text"
      },
      "source": [
        "#### My First Python program"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bjHrPwA3aEgS",
        "colab_type": "code",
        "outputId": "15c7871b-1b72-4445-9f8d-2080caa20196",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "print(\"Hello, Python World!\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello, Python World!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1hHl0I6faEgb",
        "colab_type": "text"
      },
      "source": [
        "#### Script Mode Programming:\n",
        "\n",
        "You can put the above code into a notepad, save the file with extension .py (say script.py) and run it from command line interface using below command.\n",
        "\n",
        "python script.py"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H48UdLQUaEgc",
        "colab_type": "text"
      },
      "source": [
        "#### Python Identifier:\n",
        "\n",
        "Identifier is the name given to entities like class, functions, variables etc. in Python. It helps differentiating one entity from another.\n",
        "\n",
        "Rules for writing identifiers in Python:\n",
        "\n",
        "•\tIdentifiers can be a combination of letters in lowercase (a to z) or uppercase (A to Z) or digits (0 to 9) or an underscore (_). Names like myClass, var_1 and print_this_to_screen, all are valid example.\n",
        "•\tAn identifier cannot start with a digit. 1variable is invalid, but variable1 is perfectly fine.\n",
        "•\tKeywords cannot be used as identifiers.\n",
        "•\tWe cannot use special symbols like !, @, #, $, % etc. in our identifier"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GoQRAVYuaEgd",
        "colab_type": "code",
        "outputId": "fb4ce947-0732-422b-c419-fd63ee011564",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 129
        }
      },
      "source": [
        "# variable name can not start with digit in front, 1variable will through syntax error\n",
        "1variable = 'Identifier can not start with number'"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "error",
          "ename": "SyntaxError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-2-b63cba1f1bc2>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    1variable = 'Identifier can not start with number'\u001b[0m\n\u001b[0m            ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YgZRP7bQaEgg",
        "colab_type": "code",
        "outputId": "235606b3-9ee4-4784-e431-8b17c8c201cc",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 146
        }
      },
      "source": [
        "# using keywords as variable name will through error\n",
        "class = 1"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "error",
          "ename": "SyntaxError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-2-0251f39d4826>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    class = 1\u001b[0m\n\u001b[0m          ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
          ]
        },
        {
          "output_type": "stream",
          "text": [
            "ERROR! Session/line number was not unique in database. History logging moved to new session 59\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "82iz79ZyaEgk",
        "colab_type": "code",
        "outputId": "b81e7e72-bcb0-486d-d01b-12e637d778d4",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 146
        }
      },
      "source": [
        "# using special symbols as variable name will through error\n",
        "x@gmail = 'm.s@gmail.com'"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "error",
          "ename": "SyntaxError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-2-83c26af462ad>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    x@gmail = 'm.s@gmail.com'\u001b[0m\n\u001b[0m                             ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m can't assign to operator\n"
          ]
        },
        {
          "output_type": "stream",
          "text": [
            "ERROR! Session/line number was not unique in database. History logging moved to new session 60\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eVqYW0auaEgp",
        "colab_type": "text"
      },
      "source": [
        "#### Basic Objec Types"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OfwZh7dyaEgq",
        "colab_type": "code",
        "outputId": "248f28a5-d7d9-42c5-b01b-da43e0131e99",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 272
        }
      },
      "source": [
        "none = None # singleton null object\n",
        "boolean = bool(True)\n",
        "integer = 1\n",
        "Long = 3.14\n",
        "\n",
        "# float\n",
        "Float = 3.14\n",
        "Float_inf = float('inf')\n",
        "Float_nan = float('nan')\n",
        "\n",
        "# complex object type, note the usage of letter j\n",
        "Complex = 2+8j \n",
        "\n",
        "# string can be enclosed in single or double quote\n",
        "string = 'this is a string'\n",
        "me_also_string = \"also me\"\n",
        "\n",
        "List = [1, True, 'ML'] # Values can be changed\n",
        "\n",
        "Tuple = (1, True, 'ML') # Values can not be changed\n",
        "\n",
        "Set = set([1,2,2,2,3,4,5,5]) # Duplicates will not be stored\n",
        "\n",
        "# Use a dictionary when you have a set of unique keys that map to values\n",
        "Dictionary = {'a':'A', 2:'AA', True:1, False:0}\n",
        "\n",
        "# lets print the object type and the value\n",
        "print(type(none), none)\n",
        "print(type(boolean), boolean)\n",
        "print(type(integer), integer)\n",
        "print(type(Long), Long)\n",
        "print(type(Float), Float)\n",
        "print(type(Float_inf), Float_inf)\n",
        "print(type(Float_nan), Float_nan)\n",
        "print(type(Complex), Complex)\n",
        "print(type(string), string)\n",
        "print(type(me_also_string), me_also_string)\n",
        "print(type(Tuple), Tuple)\n",
        "print(type(List), List)\n",
        "print(type(Set), Set)\n",
        "print(type(Dictionary), Dictionary)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'NoneType'> None\n",
            "<class 'bool'> True\n",
            "<class 'int'> 1\n",
            "<class 'float'> 3.14\n",
            "<class 'float'> 3.14\n",
            "<class 'float'> inf\n",
            "<class 'float'> nan\n",
            "<class 'complex'> (2+8j)\n",
            "<class 'str'> this is a string\n",
            "<class 'str'> also me\n",
            "<class 'tuple'> (1, True, 'ML')\n",
            "<class 'list'> [1, True, 'ML']\n",
            "<class 'set'> {1, 2, 3, 4, 5}\n",
            "<class 'dict'> {'a': 'A', 2: 'AA', True: 1, False: 0}\n",
            "ERROR! Session/line number was not unique in database. History logging moved to new session 61\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "758i7pgdaEgu",
        "colab_type": "text"
      },
      "source": [
        "#### Comments in Python\n",
        "\n",
        "•\tAll characters after the # and up to the physical line end are part of the comment and the Python interpreter ignores them\n",
        "•\tComments spanning more than one line are achieved by inserting a multi-line string (with \"\"\" as the delimiter one each end) that is not used in assignment or otherwise evaluated, but sits in between other statements"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-DgCuviCaEgv",
        "colab_type": "code",
        "outputId": "cbb64f88-5689-4847-8be3-d74e86ff3167",
        "colab": {}
      },
      "source": [
        "# This is a comment in Python\n",
        "print(\"Hello Python World\") # This is also a comment in Python\n",
        "\n",
        "\"\"\" This is an example of a multi line\n",
        "comment that spans multiple lines.\n",
        "Everything that is in between is considered as comments\n",
        "\"\"\""
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello Python World\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "' This is an example of a multi line\\ncomment that spans multiple lines.\\nEverything that is in between is considered as comments\\n'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_XixOhvxaEgz",
        "colab_type": "text"
      },
      "source": [
        "#### Multiple statementson a single line"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GDrMHKd9aEg0",
        "colab_type": "code",
        "outputId": "69bbc288-1dde-463d-ee1f-c92bfe82330d",
        "colab": {}
      },
      "source": [
        "import sys; x = 'foo'; print(x)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "foo\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": true,
        "id": "_qIJGV8ZaEg8",
        "colab_type": "text"
      },
      "source": [
        "##### Code Blocks\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0-abz16laEg9",
        "colab_type": "code",
        "outputId": "29ac7e27-79e3-4ed6-c8c7-7e6d4e8439ab",
        "colab": {}
      },
      "source": [
        "# Correct indentation\n",
        "print (\"Programming is an important skill for Data Science\")\n",
        "print (\"Statistics is an imporant skill for Data Science\")\n",
        "print (\"Business domain knowledge is a important skill for Data Science\")\n",
        "\n",
        "# Correct indentation, note that if statement here is an example of suites\n",
        "x = 1\n",
        "if x == 1:\n",
        "    print ('x has a value of 1')\n",
        "else:\n",
        "    print ('x does NOT have a value of 1')"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Programming is an important skill for Data Science\n",
            "Statistics is an imporant skill for Data Science\n",
            "Business domain knowledge is a important skill for Data Science\n",
            "x has a value of 1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ueSPQJKJaEhD",
        "colab_type": "code",
        "outputId": "284f5b6c-84d3-4f34-c3d7-2655634bb532",
        "colab": {}
      },
      "source": [
        "# incorrect indentation, program will generate a syntax error \n",
        "# due to the space character inserted at the beginning of second line\n",
        "print (\"Programming is an important skill for Data Science\")\n",
        " print (\"Statistics is an important skill for Data Science\")\n",
        "print (\"Business domain knowledge is a important skill for Data Science\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "error",
          "ename": "IndentationError",
          "evalue": "unexpected indent (<ipython-input-9-863530c036aa>, line 4)",
          "traceback": [
            "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-9-863530c036aa>\"\u001b[1;36m, line \u001b[1;32m4\u001b[0m\n\u001b[1;33m    print (\"Statistics is an important skill for Data Science\")\u001b[0m\n\u001b[1;37m    ^\u001b[0m\n\u001b[1;31mIndentationError\u001b[0m\u001b[1;31m:\u001b[0m unexpected indent\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "p9f5IRmTaEhI",
        "colab_type": "code",
        "outputId": "6fe34617-d154-478a-fc96-ef892118c7df",
        "colab": {}
      },
      "source": [
        "# incorrect indentation, program will generate a syntax error\n",
        "# due to the wrong indentation in the else statement\n",
        "x = 1\n",
        "if x == 1:\n",
        "    print ('x has a value of 1')\n",
        "else:\n",
        " print ('x does NOT have a value of 1')"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "x has a value of 1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hLDBuvpyaEhM",
        "colab_type": "text"
      },
      "source": [
        "#### Milti-line statements\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6SfekBFVaEhN",
        "colab_type": "code",
        "outputId": "d8f9a441-a4b5-4d3d-dc3c-14c83efaedcc",
        "colab": {}
      },
      "source": [
        "# Example of implicit line continuation\n",
        "x = ('1' + '2' + \n",
        "    '3' + '4')\n",
        "\n",
        "# Example of explicit line continuation\n",
        "y = '1' + '2' + \\\n",
        "    '11' + '12'\n",
        "    \n",
        "weekdays = ['Monday', 'Tuesday', 'Wednesday', \n",
        "            'Thursday', 'Friday']\n",
        "\n",
        "weekend = {'Saturday',\n",
        "           'Sunday'}\n",
        "\n",
        "print ('x has a value of', x)\n",
        "print ('y has a value of', y)\n",
        "print (weekdays)\n",
        "print (weekend)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "x has a value of 1234\n",
            "y has a value of 121112\n",
            "['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']\n",
            "{'Saturday', 'Sunday'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Fn_NrHDBaEhQ",
        "colab_type": "text"
      },
      "source": [
        "#### Basic Operators"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l_2Z9uZFaEhR",
        "colab_type": "text"
      },
      "source": [
        "#### Arithmetic operators\n",
        "\n",
        "Arithmetic operators are used to perform mathematical operations like addition, subtraction, multiplication etc."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LKv4aFuyaEhR",
        "colab_type": "code",
        "outputId": "19e09926-f1ba-4aa4-e2d0-3a1b66677dbb",
        "colab": {}
      },
      "source": [
        "# Variable x holds 10 and variable y holds 5\n",
        "x = 10\n",
        "y = 5\n",
        "\n",
        "# Addition\n",
        "print (\"Addition, x(10) + y(5) = \", x + y)\n",
        "\n",
        "# Subtraction\n",
        "print (\"Subtraction, x(10) - y(5) = \", x - y)\n",
        "\n",
        "# Multiplication\n",
        "print (\"Multiplication, x(10) * y(5) = \", x * y) \n",
        "\n",
        "# Division\n",
        "print (\"Division, x(10) / y(5) = \", x / y)\n",
        "\n",
        "# Modulus\n",
        "print (\"Modulus, x(10) % y(5) = \", x % y)\n",
        "\n",
        "# Exponent\n",
        "print (\"Exponent, x(10)**y(5) = \", x**y)\n",
        "\n",
        "# Integer division rounded towards minus infinity\n",
        "print (\"Floor Division, x(10)//y(5) = \", x//y)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Addition, x(10) + y(5) =  15\n",
            "Subtraction, x(10) - y(5) =  5\n",
            "Multiplication, x(10) * y(5) =  50\n",
            "Division, x(10) / y(5) =  2.0\n",
            "Modulus, x(10) % y(5) =  0\n",
            "Exponent, x(10)**y(5) =  100000\n",
            "Floor Division, x(10)//y(5) =  2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_r8bfbV6aEhX",
        "colab_type": "text"
      },
      "source": [
        "#### Comparison operators\n",
        "\n",
        "Comparison operators are used to compare values. It either returns True or False according to the condition."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "piZgsefCaEha",
        "colab_type": "code",
        "outputId": "7b18e184-cee9-43f0-c39e-23b88a74a8e1",
        "colab": {}
      },
      "source": [
        "# Variable x holds 10 and variable b holds 5\n",
        "# Equal check operation\n",
        "print (\"Equal check, x(10) == y(5) \", x == y)\n",
        "\n",
        "# Not Equal check operation\n",
        "print (\"Not Equal check, x(10) != y(5) \", x != y)\n",
        "\n",
        "# Less than check operation\n",
        "print (\"Less than check, x(10) < y(5) \", x < y)\n",
        "\n",
        "# Greater check operation\n",
        "print (\"Greater than check, x(10) > y(5) \", x > y)\n",
        "\n",
        "# Less than or equal check operation\n",
        "print (\"Less than or equal to check, x(10) <= y(5) \", x <= y)\n",
        "\n",
        "# Greater than or equal to check operation\n",
        "print (\"Greater than or equal to check, x(10) >= y(5) \", x >= y)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Equal check, x(10) == y(5)  False\n",
            "Not Equal check, x(10) != y(5)  True\n",
            "Less than check, x(10) < y(5)  False\n",
            "Greater than check, x(10) > y(5)  True\n",
            "Less than or equal to check, x(10) <= y(5)  False\n",
            "Greater than or equal to check, x(10) >= y(5)  True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0Ai6iFv7aEhe",
        "colab_type": "text"
      },
      "source": [
        "#### Assignment operations\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fjAHSY62aEhf",
        "colab_type": "code",
        "outputId": "d9f82d86-6fdd-4626-8e87-4e35a0fd7a21",
        "colab": {}
      },
      "source": [
        "# Variable x holds 10 and variable y holds 5\n",
        "x = 5\n",
        "y = 10\n",
        "\n",
        "x += y\n",
        "print (\"Value of a post x+=y is \", x)\n",
        "\n",
        "x *= y\n",
        "print (\"Value of a post x*=y is \", x) \n",
        "\n",
        "x /= y \n",
        "print (\"Value of a post x/=y is \", x)\n",
        "\n",
        "x %= y\n",
        "print (\"Value of a post x%=y is \", x)\n",
        "\n",
        "x **= y\n",
        "print (\"Value of x post x**=y is \", x)\n",
        "\n",
        "x //= y\n",
        "print (\"Value of a post x//=y is \", x)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Value of a post x+=y is  15\n",
            "Value of a post x*=y is  150\n",
            "Value of a post x/=y is  15.0\n",
            "Value of a post x%=y is  5.0\n",
            "Value of x post x**=y is  9765625.0\n",
            "Value of a post x//=y is  976562.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "loK3HgbXaEhh",
        "colab_type": "text"
      },
      "source": [
        "#### Bitwise operations\n",
        "\n",
        "Bitwise operators act on operands as if they were string of binary digits. As the name suggest, it operates bit by bit."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4yqdzYYiaEhi",
        "colab_type": "code",
        "outputId": "2f2b3971-e560-4dbd-d926-8e8a01a2cb1c",
        "colab": {}
      },
      "source": [
        "# Basic six bitwise operations\n",
        "# Let x = 10 (0000 1010 in binary) and y = 4 (0000 0100 in binary)\n",
        "x = 10\n",
        "y = 4\n",
        "\n",
        "print (x >> y)  # Right Shift\n",
        "print (x << y)  # Left Shift\n",
        "print (x & y)   # Bitwise AND\n",
        "print (x | y)   # Bitwise OR\n",
        "print (x ^ y) # Bitwise XOR\n",
        "print (~x)    # Bitwise NOT"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0\n",
            "160\n",
            "0\n",
            "14\n",
            "14\n",
            "-11\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w6kf5QDkaEhl",
        "colab_type": "text"
      },
      "source": [
        "#### Logical operators\n",
        "\n",
        "Logical operators are the and, or, not operators."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w_E-qqTjaEhm",
        "colab_type": "code",
        "outputId": "1497a06b-be3b-4253-a35a-2c442db386a8",
        "colab": {}
      },
      "source": [
        "var1 = True\n",
        "var2 = False\n",
        "print('var1 and var2 is',var1 and var2)\n",
        "print('var1 or var2 is',var1 or var2)\n",
        "print('not var1 is',not var1)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "var1 and var2 is False\n",
            "var1 or var2 is True\n",
            "not var1 is False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4sENFJzCaEhs",
        "colab_type": "text"
      },
      "source": [
        "#### Membership operators\n",
        "\n",
        "in and not in are the membership operators in Python. They are used to test whether a value or variable is found in a sequence (string, list, tuple, set and dictionary). In a dictionary we can only test for presence of key, not the value"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "W7-8OCIQaEhu",
        "colab_type": "code",
        "outputId": "d921c13d-e65f-446c-cfdc-418ee5f365ee",
        "colab": {}
      },
      "source": [
        "var1 = 'Hello world'          # string\n",
        "var2 = {1:'a',2:'b'}          # dictionary\n",
        "print('H' in var1)\n",
        "print('hello' not in var1)\n",
        "print(1 in var2)\n",
        "print('a' in var2)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "True\n",
            "True\n",
            "True\n",
            "False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nlVQ-JcxaEhx",
        "colab_type": "text"
      },
      "source": [
        "#### Identity operatros\n",
        "\n",
        "is and is not are the identity operators in Python. They are used to check if two values (or variables) are located on the same part of the memory. Two variables that are equal do not imply that they are identical"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "D5Du55g3aEhy",
        "colab_type": "code",
        "outputId": "681afabe-458e-40d4-cc3a-80a190851392",
        "colab": {}
      },
      "source": [
        "var1 = 5\n",
        "var1 = 5\n",
        "var2 = 'Hello'\n",
        "var2 = 'Hello'\n",
        "var3 = [1,2,3]\n",
        "var3 = [1,2,3]\n",
        "print(var1 is not var1)\n",
        "print(var2 is var2)\n",
        "print(var3 is var3)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "False\n",
            "True\n",
            "True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TsKA0zWtaEh1",
        "colab_type": "text"
      },
      "source": [
        "## Control structures¶\n",
        "\n",
        "A control structure is the basic decision-making process in computing. It is a block of programming that analyzes variables and chooses a direction in which to go based on given parameters"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Oc3mwtIwaEh2",
        "colab_type": "code",
        "outputId": "8982f2c8-94b5-4522-9a82-57f10b8d7194",
        "colab": {}
      },
      "source": [
        "var = -1\n",
        "if var < 0:\n",
        "    print (var)\n",
        "    print (\"the value of var is negative\")\n",
        "    \n",
        "# If the suite of an if clause consists only of a single line, it may go on the same line as the header statement\n",
        "if ( var  == -1 ) : print (\"the value of var is negative\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "-1\n",
            "the value of var is negative\n",
            "the value of var is negative\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-PNaTl8HaEh8",
        "colab_type": "code",
        "outputId": "8762beda-f3c6-43be-f88d-c62fc0fc737a",
        "colab": {}
      },
      "source": [
        "var = 1\n",
        "\n",
        "if var < 0:\n",
        "    print (\"the value of var is negative\")\n",
        "    print (var)\n",
        "else:\n",
        "    print (\"the value of var is positive\")\n",
        "    print (var)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "the value of var is positive\n",
            "1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "H4sFaYmjaEh_",
        "colab_type": "code",
        "outputId": "f6e47349-e073-45c0-9d42-3b785123f0f2",
        "colab": {}
      },
      "source": [
        "score = 95\n",
        "\n",
        "if score >= 99:\n",
        "    print('A')\n",
        "elif score >=75:\n",
        "    print('B')\n",
        "elif score >= 60:\n",
        "    print('C')\n",
        "elif score >= 35:\n",
        "    print('D')\n",
        "else:\n",
        "    print('F')"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "B\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BPr6bwtLaEiC",
        "colab_type": "code",
        "outputId": "b232fee9-d0cd-42f6-e859-8d5996242be7",
        "colab": {}
      },
      "source": [
        "# First Example\n",
        "print (\"First Example\")\n",
        "for item in [1,2,3,4,5]:    \n",
        "    print ('item :', item)\n",
        "\n",
        "# Second Example    \n",
        "print (\"Second Example\")\n",
        "letters = ['A', 'B', 'C']\n",
        "for letter in letters:        \n",
        "    print ('First loop letter :', letter)\n",
        "\n",
        "# Third Example - Iterating by sequency index\n",
        "print (\"Third Example\")\n",
        "for index in range(len(letters)):\n",
        "    print ('First loop letter :', letters[index])\n",
        "\n",
        "# Fourth Example - Using else statement\n",
        "print (\"Fourth Example\")\n",
        "for item in [1,2,3,4,5]:    \n",
        "    print ('item :', item)    \n",
        "else:\n",
        "    print ('looping over item complete!')"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "First Example\n",
            "item : 1\n",
            "item : 2\n",
            "item : 3\n",
            "item : 4\n",
            "item : 5\n",
            "Second Example\n",
            "First loop letter : A\n",
            "First loop letter : B\n",
            "First loop letter : C\n",
            "Third Example\n",
            "First loop letter : A\n",
            "First loop letter : B\n",
            "First loop letter : C\n",
            "Fourth Example\n",
            "item : 1\n",
            "item : 2\n",
            "item : 3\n",
            "item : 4\n",
            "item : 5\n",
            "looping over item complete!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8Q17thDMaEiI",
        "colab_type": "code",
        "outputId": "af9c892b-e0be-4309-9f5b-0d4ba851cd59",
        "colab": {}
      },
      "source": [
        "count = 0\n",
        "while (count < 5):\n",
        "    print ('The count is:', count)\n",
        "    count = count + 1"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The count is: 0\n",
            "The count is: 1\n",
            "The count is: 2\n",
            "The count is: 3\n",
            "The count is: 4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "on95wkm9aEiM",
        "colab_type": "code",
        "outputId": "57568863-77a0-4001-f7e6-4870901172ff",
        "colab": {}
      },
      "source": [
        "count = 0\n",
        "while count < 5:\n",
        "    print (count, \" is  less than 5\")\n",
        "    count = count + 1\n",
        "else:\n",
        "    print (count, \" is not less than 5\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0  is  less than 5\n",
            "1  is  less than 5\n",
            "2  is  less than 5\n",
            "3  is  less than 5\n",
            "4  is  less than 5\n",
            "5  is not less than 5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KpWgcNyjaEiQ",
        "colab_type": "code",
        "outputId": "1a3b68b8-8e6c-4eb4-eb0b-82a2f5047e72",
        "colab": {}
      },
      "source": [
        "# simple function to add two numbers\n",
        "def sum_two_numbers(a, b):\n",
        "    return a + b\n",
        "\n",
        "# after this line x will hold the value 3!\n",
        "x = sum_two_numbers(1,2)\n",
        "print (x)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-9l-ZCSOaEiU",
        "colab_type": "code",
        "outputId": "5c683060-d192-46c3-d01b-e45c5677e5b0",
        "colab": {}
      },
      "source": [
        "def sum_two_numbers(a, b = 10):\n",
        "    return a + b\n",
        "\n",
        "print (sum_two_numbers(10))\n",
        "print (sum_two_numbers(10, 5))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "20\n",
            "15\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S5TEe23GaEiY",
        "colab_type": "code",
        "outputId": "12d72053-8c2c-44df-be6f-6bb6e128d929",
        "colab": {}
      },
      "source": [
        "def foo(*args):\n",
        "    for a in args:\n",
        "        print (a)\n",
        "\n",
        "foo(1,2,3)        "
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "2\n",
            "3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jxh7sKzEaEic",
        "colab_type": "code",
        "outputId": "c6bcf8cf-b9b9-4b94-c185-35c0358f08b8",
        "colab": {}
      },
      "source": [
        "def bar(**kwargs):\n",
        "    for a in kwargs:\n",
        "        print (a, kwargs[a])\n",
        "        \n",
        "bar(name='one', age=27)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "name one\n",
            "age 27\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "--ZU-K4TaEig",
        "colab_type": "text"
      },
      "source": [
        "### Module\n",
        "\n",
        "A module is a logically organized multiple independent but related set of codes or functions or classes. The key principle behind module creating is it's easier to understand, use and efficient maintainability.\n",
        "\n",
        "When you import a module, it's loaded only once, regardless of the number of times it is imported. You can also import specific elements (functions, classes etc) from your module into the current namespace. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lTjqPBdbaEih",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Import all functions from a module\n",
        "import os                         # Method 1\n",
        "from os import *                  # Method 2"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "owiRuKoPaEij",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Import a function named abc from the module os\n",
        "from os import abc"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OoFa2ADwaEim",
        "colab_type": "text"
      },
      "source": [
        "dir() is a built-in function of module os, running this will return a sorted list of strings containing the names of all the modules, variables and functions that are defined in a module"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qK11zmI6aEim",
        "colab_type": "code",
        "outputId": "60eb0883-2df6-4e31-c7da-055ee9014296",
        "colab": {}
      },
      "source": [
        "import os\n",
        "\n",
        "content = dir(os)\n",
        "\n",
        "print (content)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['DirEntry', 'F_OK', 'MutableMapping', 'O_APPEND', 'O_BINARY', 'O_CREAT', 'O_EXCL', 'O_NOINHERIT', 'O_RANDOM', 'O_RDONLY', 'O_RDWR', 'O_SEQUENTIAL', 'O_SHORT_LIVED', 'O_TEMPORARY', 'O_TEXT', 'O_TRUNC', 'O_WRONLY', 'P_DETACH', 'P_NOWAIT', 'P_NOWAITO', 'P_OVERLAY', 'P_WAIT', 'PathLike', 'R_OK', 'SEEK_CUR', 'SEEK_END', 'SEEK_SET', 'TMP_MAX', 'W_OK', 'X_OK', '_Environ', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_execvpe', '_exists', '_exit', '_fspath', '_get_exports_list', '_putenv', '_unsetenv', '_wrap_close', 'abc', 'abort', 'access', 'altsep', 'chdir', 'chmod', 'close', 'closerange', 'cpu_count', 'curdir', 'defpath', 'device_encoding', 'devnull', 'dup', 'dup2', 'environ', 'error', 'execl', 'execle', 'execlp', 'execlpe', 'execv', 'execve', 'execvp', 'execvpe', 'extsep', 'fdopen', 'fsdecode', 'fsencode', 'fspath', 'fstat', 'fsync', 'ftruncate', 'get_exec_path', 'get_handle_inheritable', 'get_inheritable', 'get_terminal_size', 'getcwd', 'getcwdb', 'getenv', 'getlogin', 'getpid', 'getppid', 'isatty', 'kill', 'linesep', 'link', 'listdir', 'lseek', 'lstat', 'makedirs', 'mkdir', 'name', 'open', 'pardir', 'path', 'pathsep', 'pipe', 'popen', 'putenv', 'read', 'readlink', 'remove', 'removedirs', 'rename', 'renames', 'replace', 'rmdir', 'scandir', 'sep', 'set_handle_inheritable', 'set_inheritable', 'spawnl', 'spawnle', 'spawnv', 'spawnve', 'st', 'startfile', 'stat', 'stat_result', 'statvfs_result', 'strerror', 'supports_bytes_environ', 'supports_dir_fd', 'supports_effective_ids', 'supports_fd', 'supports_follow_symlinks', 'symlink', 'sys', 'system', 'terminal_size', 'times', 'times_result', 'truncate', 'umask', 'uname_result', 'unlink', 'urandom', 'utime', 'waitpid', 'walk', 'write']\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}