Python_Basics_8.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyMvQdwUDekc4VQPSA2dn9AH",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Dhinesh-Fedor/Python---Basics/blob/main/Python_Basics_8.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "rawYIIzH3zIn",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8a4ebe4b-338b-46d1-97c3-cc998041373b"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n",
            "three\n"
          ]
        }
      ],
      "source": [
        "#functions continuation\n",
        "\n",
        "def one():\n",
        "  print('one')\n",
        "def two():\n",
        "  print('two')\n",
        "def three():\n",
        "  print('three')\n",
        "\n",
        "a = int(input())\n",
        "if a == 1:\n",
        "  func_call = one\n",
        "elif a == 2:\n",
        "  func_call = two\n",
        "else:\n",
        "  func_call = three\n",
        "\n",
        "\n",
        "func_call()"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#scope of variables\n",
        "# local, global => general scopes\n",
        "# LEGB rule => Local Enclosed Global Built-in\n",
        "\n",
        "\n",
        "x = 1 #global scope => can be accessed from anywhere\n",
        "\n",
        "def a(y):\n",
        "  z = x+y  # y and z are local to this function a(). x is global.\n",
        "  return z\n",
        "\n",
        "result = a(99)\n",
        "print(result)\n",
        "\n",
        "#the entire function is also global\n",
        "\n",
        "\n",
        "x = 2\n",
        "\n",
        "def b():\n",
        "  x = 3  #modifying it locally and doesnot affect globally (ie) modifications exists only inside the function.\n",
        "  print(x)\n",
        "\n",
        "b()  # this will print the modified value\n",
        "print(x) #it will print the global value\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Hh_QiXIi_r5w",
        "outputId": "e7e07a90-3431-40dd-9157-7e889b343dbb"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "100\n",
            "3\n",
            "2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Modifying global variable locally\n",
        "#global keyword is used to modify the global variable locally\n",
        "\n",
        "x = 1\n",
        "def c():\n",
        "  global x\n",
        "  x = 2\n",
        "  print(x)\n",
        "\n",
        "c() #prints the modified value\n",
        "print(x) #prints the modified value"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yA2vJrTQCd0j",
        "outputId": "2334f124-ce2c-4222-b14c-2b6fd8888fce"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n",
            "2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Nested functions\n",
        "\n",
        "x = 1\n",
        "\n",
        "def outside_func():\n",
        "  x = 2 # this x is local to the current function but becomes global to the inside function\n",
        "  def inside_func():\n",
        "    print(x)\n",
        "  inside_func()\n",
        "outside_func()\n",
        "print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "c59NILnADVnO",
        "outputId": "d08543eb-fafc-4f66-f7a3-148f9d39a14d"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n",
            "1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Returning multiple values => python funcs can return multipke values\n",
        "\n",
        "def multi(x,y):\n",
        "  return x,y\n",
        "\n",
        "a,b= multi(1,[1,2,3,4])  #note :  the no. of arguments passed and variables to get the return values should be equal\n",
        "print(a,b)\n",
        "\n",
        "a= multi(1,[1,2,3,4]) #note  : single variable can also be used but when printing it prints as a collection\n",
        "print(a)\n",
        ""
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7U6thAsSE_jd",
        "outputId": "3ef699cc-f091-4b80-bb9c-c5d3cf62bd35"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(1, [1, 2, 3, 4])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Keyword, positional and default arguments\n",
        "\n",
        "def a(b,c,d=0):  #d = 0 is default argument. If d value is not passed then the default value will be 0.\n",
        "  print(b,c,d)\n",
        "\n",
        "a(1,2,3)\n",
        "a(1,d=3,c=2)\n",
        "a(c=2,d=3,b=1)\n",
        "\n",
        "a(1,2) #passing  d value is optional. Default value of d will be 0.\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2WXkXkjxGc29",
        "outputId": "937a7d69-c628-478f-8c7e-9749efc6536b"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1 2 3\n",
            "1 2 3\n",
            "1 2 3\n",
            "1 2 0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Arbitrary arguments\n",
        "#* and ** => support functions to take any number of arguments\n",
        "\n",
        "def func(*args):\n",
        "  print(args) #prints the arguments as a one collection (ie. tuple)\n",
        "\n",
        "func(1,2,3)\n",
        "\n",
        "def func(**args):\n",
        "  print(args)\n",
        "\n",
        "func(a = 1,b = 2, c = 3) # a=1,b=2,c=3 are keyword argumeents. prints the arguments as a one collection (ie. dictionary\n",
        "                         #(requires double astrik(**) inside the parantheses))\n",
        "\n",
        "def func(a,*arg,**args):\n",
        "  print(a,arg,args)\n",
        "\n",
        "func(1,2,3,x=1,y=2)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2eNoyhlxJB3O",
        "outputId": "510c490c-1596-4afc-d90f-e059be5b153b"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(1, 2, 3)\n",
            "{'a': 1, 'b': 2, 'c': 3}\n",
            "1 (2, 3) {'x': 1, 'y': 2}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#unpacking arguments\n",
        "\n",
        "def func(a,b,c,d):\n",
        "  print(a,b,c,d)\n",
        "\n",
        "a = (1,2)\n",
        "a+= (3,4)\n",
        "\n",
        "func(*a)\n",
        "\n",
        "def func(a,b,c):\n",
        "  print(a,b,c)\n",
        "\n",
        "a = {'a':1,'b':2}\n",
        "a['c']= 3\n",
        "\n",
        "func(**a)\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CoHyc5ZiLStl",
        "outputId": "fcf06ef5-dd3d-45cc-a181-37f744f9b67d"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1 2 3 4\n",
            "1 2 3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#OOPS\n",
        "#Classes and Objects\n",
        "\n",
        "class Dog:\n",
        "  #constructor\n",
        "  def __init__(self,name,age):\n",
        "    self.name = name\n",
        "    self.age = age\n",
        "\n",
        "  def dog(self):\n",
        "    print('name = ', self.name)\n",
        "    print('age = ', self.age)\n",
        "    print(\"woof!!\")\n",
        "\n",
        "dog = Dog('bob',2) #dog is an object\n",
        "dog.dog() # class methods can be accessed using dot operator"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fKVzLWgiMog9",
        "outputId": "f455cdcf-e4ac-4b14-88e4-418764e18a0e"
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "name =  bob\n",
            "age =  2\n",
            "woof!!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class Student:\n",
        "  def __init__(self,name,age,Class):\n",
        "    self.name = name\n",
        "    self.age = age\n",
        "    self.Class = Class\n",
        "\n",
        "  def details(self):\n",
        "    print(f\"name : {self.name}\")\n",
        "    print(f\"age : {self.age}\")\n",
        "    print(f\"class : {self.Class}\")\n",
        "\n",
        "o = Student('bob',17,12)\n",
        "o.details()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TkSlwOFBNlFm",
        "outputId": "eb02214f-bab7-41ac-d0bf-b3c3fb548a53"
      },
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "name : bob\n",
            "age : 17\n",
            "class : 12\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Exercises\n",
        "\n",
        "#area of circle\n",
        "r = int(input())\n",
        "\n",
        "def area(r):\n",
        "  return 3.14*r*r\n",
        "\n",
        "result = area(r)\n",
        "print(result)\n",
        "\n",
        "#or\n",
        "\n",
        "def area(r):\n",
        "  x = 3.14 *r*r\n",
        "  print(x)\n",
        "\n",
        "area(r)\n",
        "\n",
        "\n",
        "#simple interest\n",
        "\n",
        "P = int(input())\n",
        "N = int(input())\n",
        "R = int(input())\n",
        "\n",
        "def simpleInterest(P,N,R=0.105):\n",
        "  SI = (P*N*R)/100\n",
        "  return SI\n",
        "\n",
        "simpleInterest(P,N,R)\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NsXrKrG6Ouf9",
        "outputId": "48684814-708e-4436-b8fc-2dc9a606e6aa"
      },
      "execution_count": 32,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2\n",
            "12.56\n",
            "12.56\n",
            "2\n",
            "3\n",
            "4\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.24"
            ]
          },
          "metadata": {},
          "execution_count": 32
        }
      ]
    }
  ]
}