Day_04_Intermediate_Python_Part1.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Day_4_Intermediate_Python_with_Code_Implementation_Part1.ipynb",
      "provenance": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyMQUkcPPksLUGY7XUbyWhXz"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "## Introductoin to Functions in Python\n",
        "In python, functions are a convenient way to divide your cod into useful blocks, allowing us to order our code, make it more readable, reuse it, define interfaces and save a lot of time\n",
        "\n",
        "*   A function can be called multiple times to provide modularity and reusability to the python program\n",
        "*   We can easily track a large python program easily when it is divided into multiple functions\n",
        "*   There are mainly two types of functions\n",
        "\n",
        "    User-define functions - Defined by the user to perform the specific task\n",
        "\n",
        "    Built-in functions - Functions which are pre-defined\n",
        "*   You can define the function using the *def* keyword\n",
        "*   Arguments is the information that’s passed into the function\n",
        "*   The return statement is used to return the value. A function can have only one return\n",
        "*   Once created, we can call the function using the function name followed by the parentheses\n"
      ],
      "metadata": {
        "id": "Z2R3pbhkO-Wj"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Private Variables in Python\n",
        "In python, a variable is a named location used to store or hold the value/data in the memory.\n",
        "\n",
        "*   When we create a variable inside a function, it is local by default\n",
        "*   We create *private* variables by using underscore _ before a named prefix\n",
        "*   This is quite helpful for letting subclasses override methods without breaking intraclass method calls\n",
        "*   __name__ is a special built-in variable which points to the name of the current module"
      ],
      "metadata": {
        "id": "L8LKZk4cO96r"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Private Variable \n",
        "\n",
        "# Single underscore (_)\n",
        "class test:\n",
        "    def __init__(self,num):\n",
        "        self._num= num\n",
        "\n",
        "# _privatemethod private method\n",
        "    def _numfunc(self):\n",
        "        print(\"Hello\")\n",
        "obj=test(156)\n",
        "\n",
        "# _attributes can be accessed as normal variables\n",
        "obj._numfunc()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6f_2p7i2RB5y",
        "outputId": "f6959874-fe9e-4e1b-a39c-8d5b2234ee38"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Private Variable \n",
        "# Double Underscore (__)\n",
        "class test:\n",
        "    def __init__(self, num):\n",
        "        self.__num= num\n",
        "    def Print(self):\n",
        "        print(\"__num = {}\".format(self.__num))\n",
        "obj=test(156)"
      ],
      "metadata": {
        "id": "xmb2OXCTRSVM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Private Variable \n",
        "# Trailing underscore(n_)\n",
        "class Test:\n",
        "    def __init__(self, name):\n",
        "        #To avoid clash with python keyword \n",
        "        self.num_= num"
      ],
      "metadata": {
        "id": "NDx_gJNERSSb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Global and Non Local Variables in Python\n",
        "When we create a variable inside a function, it is local by default. WHen we define a variable outside of a function, it's global by default\n",
        "\n",
        "*   Nonlocal variables are used in nested functions whose local scope isn't defined\n",
        "*   Global variables are those variables which are defined and declared outside a function and we can use them inside the function or we can use **global** keyword to make a variable global inside a function\n",
        "\n"
      ],
      "metadata": {
        "id": "Q3PurDLEO9w8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Local Variable\n",
        "def test():\n",
        "    l = \"local_variable\"\n",
        "    return l\n",
        "    \n",
        "var=test()\n",
        "print(var)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gzposkumTcNz",
        "outputId": "add28d2b-9d56-42ad-de7e-395be5e97874"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "local_variable\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Global Variable\n",
        "var = 10\n",
        "def test():\n",
        "    var = 20\n",
        "    print(\"local variable x:\", var)\n",
        "\n",
        "val=test()\n",
        "print(\"global variable x:\", var)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "maLoCxxrTcfL",
        "outputId": "003bcf0b-02ff-485a-9f39-5fc1c68109a2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "local variable x: 20\n",
            "global variable x: 10\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## First Class functions in Python\n",
        "In Python, a function in Python is First Class Function, if it supports all of the properties of a First Class object such as\n",
        "\n",
        "*   In Python, a function can be assigned as variable which is used without function parentheses\n",
        "*   Functions are objects you can pass them as arguments to other functions\n",
        "*   First-class functions allow you to pass around behavior and abstract\n",
        "*   Closure functions — Functions are be nested and they can carry forward parent function’s state with them\n",
        "\n"
      ],
      "metadata": {
        "id": "MN-_aPcjUdTW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Implementation 2\n",
        "def outer(a):   # Outer function\n",
        "  def inner(b):   # Inner function\n",
        "    return b+10\n",
        "  return inner(a)\n",
        "\n",
        "a = 10\n",
        "var = outer(a) \n",
        "print(var)"
      ],
      "metadata": {
        "id": "nVYRBb0hVCn0",
        "outputId": "6515ecfe-96a7-4246-f2df-afb7b92fdd39",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "20\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **`__import__()` function**\n",
        "In python, the inbuilt `__import__()` function helps to import modules in runtime\n",
        "\n",
        "Syntax\n",
        "\n",
        "    __import__(name, globals, locals, fromlist, level)\n",
        "\n",
        "*   name : Name of the module to import.\n",
        "*   globals : Dictionary of global names used to determine how to interpret the name in a package context.\n",
        "*   locals : Dictionary of local names used to determine how to interpret the name in a package context.\n",
        "*   fromlist : The fromlist gives the names of objects or submodules that should be imported from the module given by name.\n",
        "*   level : level specifies whether to use absolute or relative imports.\n",
        "*   To import a module by name, use `importlib.import_module()`\n"
      ],
      "metadata": {
        "id": "JGPlHdazfJWZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Implementation\n",
        "# fabs() method is defined in the math module which returns the #absolute value of a number\n",
        "math_score = __import__('math', globals(), locals(), [], 0)\n",
        "print(math_score.fabs(-17.4))"
      ],
      "metadata": {
        "id": "lUvgffdpfJD4",
        "outputId": "142a4ede-d482-4f54-a3b6-0a113a8566c8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "17.4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Tuple Unpacking with Python Functions\n",
        "In python, tuples are immutable data types. Python offers a very powerful tuple assignment tool that maps right hand side arguments into left hand side arguments i.e mapping is known as unpacking of a tuple of values into a normal variable.\n",
        "\n",
        "*   During the unpacking of tupe, the total number of variables on the left-hand side shoudl be equivalent to the total number of values in give tuple\n",
        "*   It uses a special syntax to pass optional arguments (*args) for tuple unpacking\n",
        "\n"
      ],
      "metadata": {
        "id": "KpdFU6ragoOb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def result(a, b):\n",
        "    return a + b\n",
        "\n",
        "# function with normal variables\n",
        "print (result(100, 200))\n",
        " \n",
        "# A tuple is created\n",
        "c = (100, 300)\n",
        " \n",
        "# Tuple is passed\n",
        "# function unpacked them\n",
        " \n",
        "print (result(*c))"
      ],
      "metadata": {
        "id": "pdcjY2hohHFQ",
        "outputId": "62ccd439-3eb1-4fbc-a760-354a8a9e756a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "300\n",
            "400\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Static Variables and Methods in Python\n",
        "In Python, Static variables are the variables that belong to the class and not to objects.\n",
        "\n",
        "*   Static variables are shared amongst objects of the class\n",
        "*   Python allows providing same variable name for a class/static variable and an instance variable\n",
        "\n",
        "Static Method\n",
        "\n",
        "*   In Python, Static methods are the methods which are bound to the class rather than an object of the class\n",
        "*   Static Methods are called using the class name and not the objects of the class\n",
        "*   Static methods are bound to the class\n"
      ],
      "metadata": {
        "id": "Vqk0smOmhW64"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class test:\n",
        "  static_variable = 25\n",
        "\n",
        "# Access through class\n",
        "print(test.static_variable) # prints 25\n",
        "\n",
        "# Access through an instance\n",
        "ins = test()\n",
        "print(ins.static_variable) # still 25\n",
        "\n",
        "# Change within an instance\n",
        "ins.static_variable = 14\n",
        "print(ins.static_variable) \n",
        "\n",
        "# Access through class\n",
        "print(test.static_variable)"
      ],
      "metadata": {
        "id": "5MLcMGYBhyGY",
        "outputId": "9280554b-91f3-438e-b5be-0741a0cc9351",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "25\n",
            "25\n",
            "14\n",
            "25\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Static Method : Use @staticmethod\n",
        "class sample_shape:\n",
        "    \n",
        "    @staticmethod\n",
        "    def msgg(msg):\n",
        "        print(msg)\n",
        "        print(\"Triangles\")\n",
        "        \n",
        "sample_shape.msgg(\"Welcome to sample shape class\")"
      ],
      "metadata": {
        "id": "TbyItEHEhxUL",
        "outputId": "1c8ef926-6759-4339-a47f-8b807ba0e6ea",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Welcome to sample shape class\n",
            "Triangles\n"
          ]
        }
      ]
    }
  ]
}