Day_05_Intermediate_Python_Part2.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Day_5_Intermediate_Python_with_Code_Implementation_Part2.ipynb",
      "provenance": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyNDkWGWeZk+EcMGhLjEW6i+"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "## Lambda Functions in Python\n",
        "In python, Lambda is used to create small anonymous functions using “lambda” keyword and can be used wherever function objects are needed.It can any number of arguments but only one expression\n",
        "\n",
        "Syntax\n",
        "\n",
        "    lambda argument(s): expression\n",
        "\n",
        "*   It can be used inside another function\n",
        "*   In python normal functions re defined using the `def` keyword, anonymous functions are defined using the `lambda` keyword\n",
        "*   Wheneer we require a nameless function for a short period of time, we use lambda functions\n",
        "\n"
      ],
      "metadata": {
        "id": "Uu-KUXIsomoD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# A lambda function that adds 10 to the number passed in as an argument, and print the result\n",
        "x = lambda a, b, c : a * b + c\n",
        "\n",
        "print(x(5, 6, 8))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "V1ZUUNmOomNs",
        "outputId": "57110e68-78a1-4fdd-dd76-6dd06f0ae276"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "38\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Map and Filter Functions in Python\n",
        "In python, Map allows you to process and transform the items of the iterables or collections without using a for loop.\n",
        "\n",
        "*   In Python, the map() function applies the given function to each item of a given iterable construct (i.e lists, tuples etc) and returns a map object\n",
        "\n",
        "    `map(function, iterable)`\n",
        "\n",
        "*   In python, filter() function returns an iterator when the items are filtered through a function to test if the item is true or not\n",
        "\n",
        "    `filter(function, iterable)`\n",
        "\n"
      ],
      "metadata": {
        "id": "p90z8RGAomli"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# map\n",
        "numbers = [1,2,3,4,5]\n",
        "strings = ['s', 't', 'x', 'y', 'z']\n",
        "mapped_list = list(map(lambda x, y: (x, y), strings, numbers))\n",
        "print(mapped_list)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "p-JnHh_BomK0",
        "outputId": "f10482ec-49b5-4041-db5c-756786a6b2b0"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[('s', 1), ('t', 2), ('x', 3), ('y', 4), ('z', 5)]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# map implementation\n",
        "days = ['Sunday', 'Monday', 'Tuesday', 'Wednesday']\n",
        "mod_days = list(map(str.swapcase, days))\n",
        "print(mod_days)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JqZx8UrVomIC",
        "outputId": "110ca3d3-badd-4120-86f2-889dd5e7fa7b"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['sUNDAY', 'mONDAY', 'tUESDAY', 'wEDNESDAY']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HJ16m85HogZ3",
        "outputId": "3a225c5d-87d0-4ee7-ab5b-250122eb3c03"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[23]\n"
          ]
        }
      ],
      "source": [
        "# filter function\n",
        "marks = [95, 40, 68, 95, 67, 61, 88, 23, 38, 92]\n",
        "def stud(score):\n",
        "    return score < 33\n",
        "fail_list = list(filter(stud, marks))\n",
        "print(fail_list)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Magic Methods in Python\n",
        "In Python, Magic methods in Python are the special methods that start and end with the double underscores\n",
        "\n",
        "*   Magic methods are not meant to be invoked directly by you, but the invocation happens internally from the class once certain action is performed\n",
        "*   Use the dir() function to see the number of magic methods inherited by a class\n",
        "*   The advantage of using Python’s magic methods is that they provide a simple way to make objects behave like built-in types\n",
        "*   Magic methods can be used to emulate the behavior of built-in types of user-defined objects. Therefore, whenever you find yourself trying to manipulate a user-defined object’s output in a Python class, then use magic methods.\n",
        "\n"
      ],
      "metadata": {
        "id": "C340G7EwvFjb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# __Del__ method\n",
        "from os.path import join\n",
        "\n",
        "class FileObject:\n",
        "  def __init__(self, file_path='~', file_name='test.txt'):\n",
        "    self.file = open(join(file_path, file_name), 'rt')\n",
        "  def __del__(self):\n",
        "    self.file.close()\n",
        "    del self.file"
      ],
      "metadata": {
        "id": "yXVAtoAwvkUq"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# __repr__ method\n",
        "\n",
        "class String:      \n",
        "  def __init__(self, string):\n",
        "    self.string = string\n",
        "  def __repr__(self):\n",
        "    return 'Object: {}'.format(self.string)"
      ],
      "metadata": {
        "id": "gDrqsIX5vjXK"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Inheritance and Polymorphism in Python\n",
        "\n",
        "*   In Python, Inheritance and Polymorphism are very powerful and important concept\n",
        "*   Using inheritance you can use or inherit all the data fields and methods available in the parent class\n",
        "*   On top of it, you can add you own methods and data fields\n",
        "*   Python allows multiple inheritance i.e you can inherit from multiple classes\n",
        "*   Inheritance provides a way to write better organized code and re-use the code\n",
        "*   In Python, Polymorphism allows us to define methods in the child class with the same name as defined in their parent class\n"
      ],
      "metadata": {
        "id": "tFWO0nttvFg7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Inheritance\n",
        "class Vehicle:\n",
        "  def __init__(self, name, color):\n",
        "    self.__name = name      \n",
        "    self.__color = color\n",
        "  def getColor(self):         \n",
        "    return self.__color\n",
        "  def setColor(self, color):  \n",
        "    self.__color = color\n",
        "  def get_Name(self):          \n",
        "    return self.__name\n",
        "\n",
        "class Bike(Vehicle):\n",
        "  def __init__(self, name, color, model):\n",
        "    super().__init__(name, color)       # call parent class\n",
        "    self.__model = model\n",
        "  def get_details(self):\n",
        "    return self.get_Name() + self.__model + \" in \" + self.getColor() + \" color\"\n",
        "\n",
        "b_obj = Bike(\"Cziar\", \"red\", \"TK720\")\n",
        "print(b_obj.get_details())\n",
        "print(b_obj.get_Name())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3XXCzHUtxCM7",
        "outputId": "83cbaa05-551a-4560-ef76-113a6b2d7932"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "CziarTK720 in red color\n",
            "Cziar\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Polymorphism\n",
        "from math import pi\n",
        "\n",
        "class Shape:\n",
        "  def __init__(self, name):\n",
        "    self.name = name\n",
        "  def area(self):\n",
        "    pass\n",
        "\n",
        "class Sqr(Shape):\n",
        "  def __init__(self, length):\n",
        "    super().__init__(\"Square\")\n",
        "    self.length = length\n",
        "  def area(self):\n",
        "    return self.length ** 2\n",
        "\n",
        "class Circle(Shape):\n",
        "  def __init__(self, radius):\n",
        "    super().__init__(\"Circle\")\n",
        "    self.radius = radius\n",
        "  def area(self):\n",
        "    return pi * self.radius ** 2\n",
        "\n",
        "a = Sqr(6)\n",
        "b = Circle(10)\n",
        "print(a.area())\n",
        "print(b.area())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "08vqo0DgxYyh",
        "outputId": "873563f2-a90d-4430-f66e-b4438f111b9c"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "36\n",
            "314.1592653589793\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Errors and Exception Handling in Python\n",
        "In Python, an error can be a syntax error or an exception.\n",
        "When the parser detects an incorrect statement, Syntax errors occur.\n",
        "\n",
        "*   Exceptions errors are raised when an external event occurs which in some way changes the normal flow of the program\n",
        "*   Exception error occurs whenever syntactically correct python code results in an error\n",
        "*   Python comes with various built-in exceptions as well as the user can create user-defined exceptions\n",
        "*   Garbage collection is the memory management feature i.e a process of cleaning shared computer memory\n",
        "\n",
        "Some of python's built-in exceptions\n",
        "\n",
        "    IndexError : When the wrong index of a list is retrieved\n",
        "\n",
        "    ImportError : When an imported module is not found\n",
        "\n",
        "    KeyError : When the key of the dictionary is not found\n",
        "\n",
        "    NameError: When the variable is not defined\n",
        "\n",
        "    MemoryError : When a program run out of memory\n",
        "\n",
        "    TypeError : When a function and operation is applied in an incorrect type\n",
        "\n",
        "    AssertionError : When assert statement fails\n",
        "\n",
        "    AttributeError : When an attribute assignment is failed"
      ],
      "metadata": {
        "id": "GEQYBmR6vFej"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Try and Except in Python\n",
        "\n",
        "*   The block of code which can raise an exception is placed inside the try clause. The code that handles the exceptions is written in the except clause\n",
        "*   In case no exception has occurred, the except block is skipped and program normal flow continues\n",
        "*   A try clause can have any number of except clauses to handle different exceptions but only one will be executed in case the exception occurs\n",
        "*   We can also raise exceptions using the raise keyword\n",
        "*   The try statement in Python can have an optional finally clause which executes regardless of the result of the try- and except blocks\n",
        "*   List item\n"
      ],
      "metadata": {
        "id": "Mn3W_9rdyte-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# try, except, finally\n",
        "try:\n",
        "  print(1 / 0)\n",
        "except:\n",
        "  print(\"Error occurred\")\n",
        "finally:\n",
        "  print(\"Exit\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "REidL-SlzQrp",
        "outputId": "876c46a8-36ae-41ae-c9fb-170c5cbf0e42"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Error occurred\n",
            "Exit\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### User-defined Exceptions\n",
        "In Python, user can create his own error by creaing a new exception class\n",
        "\n",
        "*   Exceptions need to be derived from the Exception class, either directly or indirectly\n",
        "*   Exceptions errors are raised when an external event occurs which in some way changes the normal flow of the program\n",
        "*   User defined exceptions can be implemented by raising an exception explicitly, by using assert statement or by defining custom classes for user defined exceptions\n",
        "*   Use assert statement to implement constraints on the program. When, the condition given in assert statement is not met, the program gives AssertionError in output\n",
        "*   You can raise an existing exception by using the raise keyword and the name of the exception\n",
        "*   To create a custom exception class and define an error message, you need to derive the errors from the Exception class directly\n",
        "*   When creating a module that can raise several distinct errors, a common practice is to create a base class for exceptions defined by that module, and subclass that to create specific exception classes for different error conditions, this is called Hierarchical custom exceptions"
      ],
      "metadata": {
        "id": "9MqDvj4_ytcN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Error(Exception):\n",
        "  pass\n",
        "\n",
        "class TooSmallValueError(Error):\n",
        "  pass\n",
        "\n",
        "number = 100\n",
        "while True:\n",
        "  try:\n",
        "    num = int(input(\"Enter a number: \"))\n",
        "    if num < number:\n",
        "        raise TooSmallValueError\n",
        "    break\n",
        "  except TooSmallValueError:\n",
        "    print(\"Value too small\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kzAagHZ90ds7",
        "outputId": "58ea0d01-9e29-409b-e313-948d4d891adf"
      },
      "execution_count": 11,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a number: 40\n",
            "Value too small\n",
            "Enter a number: 200\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Garbage Collection in Python\n",
        "In Python, Garbage collection is the memory management feature i.e a process of cleaning shared computer memory which is currently being put to use by a running program when that program no longer needs that memory and can be used other programs\n",
        "\n",
        "*   In python, Garbage collection works automatically. Hence, python provides with good memory management and prevents the wastage of memory\n",
        "*   In python, forcible garbage collection can be done by calling `collect()` function of the `gc` module\n",
        "*   In python, when there is no reference left to the object in that case it is automatically destroyed by the Garbage collector of python and `__del__()` method is executed\n"
      ],
      "metadata": {
        "id": "BedfFf_RytaD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# manual garbage collection\n",
        "import sys, gc\n",
        "\n",
        "def test():\n",
        "  list = [18, 19, 20,34,78]\n",
        "  list.append(list)\n",
        "\n",
        "def main():\n",
        "  print(\"Garbage Creation\")\n",
        "  for i in range(5):\n",
        "    test()\n",
        "\n",
        "  print(\"Collecting..\")\n",
        "  n = gc.collect()\n",
        "  print(\"Unreachable objects collected by GC:\", n)\n",
        "  print(\"Uncollectable garbage list:\", gc.garbage)\n",
        "\n",
        "if __name__ == \"__main__\":\n",
        "    main()\n",
        "    sys.exit()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UGmVrwY-1Z-M",
        "outputId": "58bd4a05-570e-490c-e929-667225d2b511"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Garbage Creation\n",
            "Collecting..\n",
            "Unreachable objects collected by GC: 278\n",
            "Uncollectable garbage list: []\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Python Debugger\n",
        "Debugging is the process of locating and solving the errors in the program. In python, pdb which is a part of Python’s standard library is used to debug the code\n",
        "\n",
        "*   `pdb` module internally makes used of `bdb` and `cmd` modules\n",
        "*   It supports setting breakpoints and single stepping at the source line level, inspection of stack frames, source code listing etc\n",
        "*   To set the breakpoints, there is a built-in function called `breakpoint()`\n",
        "\n"
      ],
      "metadata": {
        "id": "5x30gwgSys56"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pdb\n",
        "   \n",
        "def multiply(a, b):\n",
        "  answer = a * b\n",
        "  return answer\n",
        "  \n",
        "pdb.set_trace()\n",
        "a = int(input(\"Enter first number : \"))\n",
        "b = int(input(\"Enter second number : \"))\n",
        "sum = multiply(a, b)"
      ],
      "metadata": {
        "id": "nLmKX9Pk2Ki_"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}