Day_03_Python_Basics_Part3.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Day_3_Python_Basics_with_Code_Implementation_Part3.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyNMKoZplOZhXooht3C00NhK"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "## Python Tuples\n",
        "\n",
        "\n",
        "*   In Python, a tuple is a collection of objects which is ordered and immutable\n",
        "*   Created by placing sequence of elements with round () braces, separated by ','\n",
        "*   Values can be of any datatype\n",
        "*   Concatenation of tuples can be done by the use of '+' operator\n",
        "*   Tuples are just like lists except that the tuples are immutable\n",
        "\n"
      ],
      "metadata": {
        "id": "puIh9uE6DvXp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Tuple with items\n",
        "tup= (10,\"Hello\",3.14,\"a\")\n",
        "print(tup)\n",
        "print(type(tup))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lr5Flf9METdy",
        "outputId": "bb0a3c66-fe04-4c47-8364-695694713eff"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(10, 'Hello', 3.14, 'a')\n",
            "<class 'tuple'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Negative Indexing : index of -1 refers to the last item, -2 to the #second last item and so on\n",
        "tup = (10,\"Hello\",3.14,\"a\")\n",
        "print(tup[-2])\n",
        "\n",
        "# Reverse the tuple\n",
        "print(tup[::-1])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "L_-wMAP6ETb3",
        "outputId": "3686945b-2828-4eb9-c8ee-871b045faa61"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3.14\n",
            "('a', 3.14, 'Hello', 10)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# concatenation using + operator\n",
        "tup = (10,\"Hello\",3.14,\"a\")\n",
        "print(tup + (50,60))\n",
        "\n",
        "# repeat using * operator\n",
        "print(tup * 2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Tdcdz74EETZp",
        "outputId": "3b2115de-1a89-447c-cfce-1f302cfe43a4"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(10, 'Hello', 3.14, 'a', 50, 60)\n",
            "(10, 'Hello', 3.14, 'a', 10, 'Hello', 3.14, 'a')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# membership : check if an item exists in a tuple or not, using the keyword in\n",
        "tup = (10,\"Hello\",3.14,\"a\")\n",
        "print(10 in tup)\n",
        "print(\"World\" in tup)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Vp2vNKzWETKh",
        "outputId": "350b8a2c-10f1-4262-d197-fa7943b0cba1"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Iterate through Tuple : use for loop to iterate through each item in a tuple\n",
        "tup = (10,\"Hello\",3.14,\"a\")\n",
        "for i in tup:\n",
        "    print(i)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "h-zYfXogETHp",
        "outputId": "d78b930b-e12e-4f0d-ccce-b9e6b7e976a0"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10\n",
            "Hello\n",
            "3.14\n",
            "a\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Nested Tuple\n",
        "nest_tup = ((10,\"Hello\",3.14,\"a\"), (70,(8,\"Mike\")))\n",
        "print(nest_tup)\n",
        "\n",
        "a,b = nest_tup\n",
        "print(a)\n",
        "print(b)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "V8P098Q0Ews0",
        "outputId": "394eedec-125b-4d9c-c1f1-c6033de04601"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "((10, 'Hello', 3.14, 'a'), (70, (8, 'Mike')))\n",
            "(10, 'Hello', 3.14, 'a')\n",
            "(70, (8, 'Mike'))\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Enumerate : use enumerate function\n",
        "tup = (10,\"Hello\",3.14,\"a\")\n",
        "for i in enumerate(tup):\n",
        "    print(i)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "djJXC3qREwla",
        "outputId": "89097e92-2612-4515-a7b4-723354a04897"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(0, 10)\n",
            "(1, 'Hello')\n",
            "(2, 3.14)\n",
            "(3, 'a')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Python Sets\n",
        "\n",
        "\n",
        "*   In Python, a set is a collection of objects which is both unindexed and unordered\n",
        "*   Sets make sure that thre are no duplicate elements in the items sequence\n",
        "*   Created by using the built-in set() function with an iterable objects by placing the items inside curly {} braces, separated by ','\n",
        "*   Items can be added to the set by using built-in add() function\n",
        "*   Items can be accessed by looping through the set using loops or using 'in' keyword\n",
        "*   Items can be removed from the set by using built-in remove() function\n"
      ],
      "metadata": {
        "id": "nu-k0qrZDvQJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create Set\n",
        "set_one = {10, 20, 30, 40}\n",
        "print(set_one)\n",
        "\n",
        "# Create set from list using set() \n",
        "set_two = set([10, 20, 30, 40, 30, 20])\n",
        "print(set_two)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nQKaZSnUEwjS",
        "outputId": "2ff95548-d6dc-4054-bc72-ce34fcd7d385"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{40, 10, 20, 30}\n",
            "{40, 10, 20, 30}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Removing elements : Use the methods discard(), pop() and remove()\n",
        "set_one = {100, 70, 40, 10, 80, 20, 60, 30}\n",
        "\n",
        "# discard() method\n",
        "set_one.discard(100)\n",
        "print(\"After discard:\",set_one)\n",
        "\n",
        "# remove() method\n",
        "set_one.remove(40)\n",
        "print(\"After removing element :\", set_one)\n",
        "\n",
        "# pop() method\n",
        "set_one.pop()\n",
        "print(\"After removing element :\", set_one)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6akaIxU2Ewgp",
        "outputId": "03ee7667-3a82-488a-8af8-c1525467b38c"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "After discard: {70, 40, 10, 80, 20, 60, 30}\n",
            "After removing element : {70, 10, 80, 20, 60, 30}\n",
            "After removing element : {10, 80, 20, 60, 30}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Set operations \n",
        "X = {10, 20, 30, 40, 50}\n",
        "Y = {40, 50, 60, 70, 80}\n",
        "Z = {20, 30, 100, 50, 10}\n",
        "\n",
        "# Union : Union of X, Y, Z is a set of all elements from all three sets using | operator or union() method\n",
        "print(\"Set Union:\", X|Y|Z)\n",
        "\n",
        "# Intersection :Intersection of X, Y, Z is a set of all elements from all three sets using & operator or intersection()\n",
        "print(\"Set Intersection:\", X&Y&Z)\n",
        "\n",
        "# Difference : Difference of X, Y is a set of all elements from both sets using - operator or difference()\n",
        "print(\"Set Difference:\", X-Y)\n",
        "\n",
        "# Symmetric Difference : Symmetric Difference of X, Y, Z is a set of all elements from all three sets using ^ operator or symmetric_difference()            \n",
        "print(\"Set Symmetric Difference:\", X^Y^Z)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zI-W7xboGTgh",
        "outputId": "df67fea8-7093-42cf-e48f-352f2347ce09"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Set Union: {100, 70, 40, 10, 80, 50, 20, 60, 30}\n",
            "Set Intersection: {50}\n",
            "Set Difference: {10, 20, 30}\n",
            "Set Symmetric Difference: {80, 50, 100, 70, 60}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# enumerate : Returns an enumerate object which contains the index and value for all the items of the set as a pair\n",
        "set_one = {10, 20, 30, 40, 50, 30}\n",
        "for i in enumerate(set_one):\n",
        "    print(i)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UtxlYHTfGTdy",
        "outputId": "e7e0a618-aabb-4b1a-e2c1-3bfd98dd2b45"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(0, 40)\n",
            "(1, 10)\n",
            "(2, 50)\n",
            "(3, 20)\n",
            "(4, 30)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Frozenset : set which has the characteristics of a set, but its elements cannot be changed once assigned\n",
        "X = frozenset([10, 20, 30, 40, 50])\n",
        "Y = frozenset([40, 50, 60, 70, 80])\n",
        "print(X.union(Y))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Grxun9-QGTap",
        "outputId": "511bd3f3-5cb4-4cbe-bc62-999c5d928af6"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "frozenset({70, 40, 10, 80, 50, 20, 60, 30})\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Loops in Python\n"
      ],
      "metadata": {
        "id": "ry4UwDnhDvCR"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### If, Elif and Else Statements\n",
        "\n",
        "*   In python, If, Elif and Else statements are used to facilitate decision making i.e when we want to execute a code only if a certain condition is satisfied.\n",
        "*   Python interprets non-zero values as True. None and 0 are interpreted as False.\n",
        "*   The if block can have only one else block but there can be multiple elif blocks."
      ],
      "metadata": {
        "id": "68MY_hG4IQay"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# If, Elif and Else one liner\n",
        "x = 200\n",
        "  \n",
        "var = {x < 190: \"Condition one satisfied\", \n",
        "       x != 200: \"Condition two satisfied\"}.get(True, \"Condition third satisfied\")\n",
        "  \n",
        "print(var)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VNxYXkIlGTVR",
        "outputId": "c5ee6ecb-5f19-4798-9f02-73af9c5b1d9e"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Condition third satisfied\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### While Loops\n",
        "\n",
        "*   In python, while loop is used to traverse/iterate over a block of code as long as the test condition is true\n"
      ],
      "metadata": {
        "id": "XfuGTw5wIQPg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# While with else statement\n",
        "i = 1\n",
        "while i < 6:\n",
        "  print(i)\n",
        "  i += 1\n",
        "else:\n",
        "  print(\"i is no longer less than 6\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "s4GHZyxnILjJ",
        "outputId": "65149ab1-cee3-4a1d-bbea-bf3f706c3e1f"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "i is no longer less than 6\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### For Loops and Range Function\n",
        "\n",
        "*   In python, for loop is used to traverse/iterate over a sequence (list, tuple, string etc)\n",
        "*   Range ( range()) is used to generate sequence of numbers where the syntax of range is"
      ],
      "metadata": {
        "id": "mMdREA6XIQJ4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# for loop with range function\n",
        "days =['sunday','monday','tuesday']\n",
        "for i in range(len(days)):\n",
        "    print(\"Today is\", days[i])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eFBvFZvwILgq",
        "outputId": "5ad66c1c-55f0-4634-9063-10b767a9dc82"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Today is sunday\n",
            "Today is monday\n",
            "Today is tuesday\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Break and Continue statement\n",
        "\n",
        "*   In Python, we can use break statement when we want to terminate the current loop without checking test condition\n",
        "*   Once terminated using the break statement, the control of the program goes to the statement immediately after the body of the loop\n",
        "*   In python, we can use continue statement when we want to skip the rest of the code for the current loop iteration\n",
        "\n"
      ],
      "metadata": {
        "id": "IQXOJltFDu_y"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# break statement\n",
        "count = 0\n",
        "while True:\n",
        "    print(count)\n",
        "    count += 1\n",
        "    if count >= 10:\n",
        "        break\n",
        "print('exit')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "W7BrCSjqILei",
        "outputId": "3c0b451d-02c4-44fb-bdb4-fa4705cda1b0"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "7\n",
            "8\n",
            "9\n",
            "exit\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "reAETVRTDjtV",
        "outputId": "e7898f16-6736-4409-aebd-71b6f2a22c60"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "3\n",
            "5\n",
            "7\n",
            "9\n",
            "11\n",
            "13\n"
          ]
        }
      ],
      "source": [
        "# continue statement\n",
        "for x in range(15):\n",
        "    if x % 2 == 0:\n",
        "        continue\n",
        "    print(x)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Input & Output in Python\n",
        "\n",
        "*   In python, there are two built-in functions to read the input from the user\n",
        "\n",
        "    *raw_input() : reads one line from user input and returns it as a string*\n",
        "\n",
        "    *input() : Similar to raw_input, but except it evaluates the user epression*\n",
        "\n",
        "*   For multiple user inputs\n",
        "\n",
        "    *split() method*\n",
        "\n",
        "*   In python, output is using the print() function\n",
        "*   String literals in print() statement are used to format the output\n",
        "*   end keyword is used to print specific content at the end of the execution of the print() function\n",
        "\n"
      ],
      "metadata": {
        "id": "8nONHTnDJhJB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# input\n",
        "num = int(input('Enter a number: '))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3O6357XSKoSe",
        "outputId": "fd546363-4d75-445e-8a10-991996e18e4d"
      },
      "execution_count": 19,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a number: 50\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "num = 5\n",
        "print('The value of num is', num)\n",
        "print(\"The value is %d\" %num)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "V_ROizn2KoPh",
        "outputId": "1f2c7e60-1bd7-44dd-b9a0-921b7d6da4f7"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The value of num is 5\n",
            "The value is 5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Python Object Oriented Programming\n",
        "\n",
        "*   Python is a multi-paradigm programming language and supports Object Oriented programming. In Python everything is a object. An object has two characteristics : Attributes and Behavior\n",
        "*   Principles of object-oriented programming system are\n",
        "\n",
        "    *Class*\n",
        "\n",
        "    *Object*\n",
        "\n",
        "    *Method*\n",
        "\n",
        "    *Inheritance*\n",
        "\n",
        "    *Polymorphism*\n",
        "\n",
        "    *Encapsulation*\n",
        "\n",
        "*   Class and constructor — It’s a blueprint for the object. In python we use the class keyword to define class. Class constructor is used to assign the values to the data members of the class when an object of the class is created.\n",
        "*   Object — It’s an instantiation of a class.\n",
        "*   Method — It’s a function that is associated with an object\n",
        "*   Inheritance — Specifies that the child object acquires all the properties and behaviors of the parent object.\n",
        "*   Polymorphism — Refers to functions having the same names but carrying different functionalities.\n",
        "*   Encapsulation — To prevents data from direct modification, we can restrict access to methods and variables in python\n"
      ],
      "metadata": {
        "id": "ArXGYKiLJhGp"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Attributes and Class in Python\n",
        "\n",
        "*   In Python, a class is a blueprint of the object\n",
        "*   To define a class, we use the keyword \"class\" following the class name and semicolon\n",
        "*   Object - It's an instantiation of a class. The object instance contains real data or value\n",
        "*   Class constructor — to assign the values to the data members of the class when an object of the class is created, we use constructor. The __init__() method is called constructor method\n",
        "*   Instance attributes refer to the attributes inside the constructor method. Class attributes refer to the attributes outside the constructor method\n",
        "*   Method — It’s a function that is associated with an object, used to describe the behavior of the objects\n",
        "\n"
      ],
      "metadata": {
        "id": "UAWa2P9yLzGh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Class implementation\n",
        "class cat: \n",
        "  def __init__(self, cat_name, cat_breed):\n",
        "    self.name = cat_name\n",
        "    self.age = cat_breed"
      ],
      "metadata": {
        "id": "9XQT67qSMWwC"
      },
      "execution_count": 21,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Class attribute and Instance Attribute\n",
        "class emp:\n",
        "  x = 10  # class attribute\n",
        "\n",
        "  def __init__(self):\n",
        "    self.name = 'Steve'\n",
        "    self.salary = 10000\n",
        "  \n",
        "  def display(self):\n",
        "    print(self.name)\n",
        "    print(self.salary)\n",
        "  \n",
        "obj_emp = emp()\n",
        "print(\"Dictionary conversion:\", vars(obj_emp))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "10t3tTuTMf6u",
        "outputId": "b28d6acf-c003-4694-b66b-323764484e68"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Dictionary conversion: {'name': 'Steve', 'salary': 10000}\n"
          ]
        }
      ]
    }
  ]
}