Quick Python.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Python Notes .ipynb",
      "provenance": []
    },
    "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.8.5"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qDl8EJitiFa7"
      },
      "source": [
        "# Notes Python"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CnmaSoLunMZa"
      },
      "source": [
        "About PYTHON\n",
        "* GENERAL PURPOSE \n",
        "* SCRIPTING\n",
        "* DYNAMICALLY TYPEd\n",
        "* OBJECT ORIENTED\n",
        "* FUNCTIONAL pROGRAMING LANGUAGE"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QYqvbixG9jUM"
      },
      "source": [
        "# Mutalbe Unmutable datatypes\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pb8wsmYoiFbG"
      },
      "source": [
        "*  (int, float, bool, str, tuple, unicode) are immutable. Objects of built-in types like (list, set, dict) are mutable"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Eq3km-DZ9jUO"
      },
      "source": [
        "# How is memory managed in Python? "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o9ZYV5i69jUO"
      },
      "source": [
        "\n",
        "* Memory management in python is managed by Python private heap space.\n",
        "All Python objects and data structures are located in a private heap.\n",
        "The programmer does not have access to this private heap. The python interpreter takes care of this instead. \n",
        "• The allocation of heap space for Python objects is done by Python's memory manager.\n",
        "The core API gives access to some tools for the programmer to code. \n",
        "• Python also has an inbuilt garbage collector, which recycles all the unused memory and so that it can be made available to the heap space. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zdf-vD_O9jUP"
      },
      "source": [
        "# Python Compilation "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2MGjDG4jiFbH"
      },
      "source": [
        "Python code compilation :\n",
        "\n",
        "* Source_code -> Compiler which convert code Bytecode /binary code  Not to machine code-> -- python Virtual machine (in this interpretor is available interpreor (Just in time compiler ) ) -> convert bytecode to machine code -> send to operating system\n",
        "\n",
        "* in this just in time compiler ( imprved version of interpretor) because normal  interpertor convert code and send to operatng system and wait till execution is completed but in this, it doesnt wait it convert one by one and store other data for os"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gv4t5UN59jUR"
      },
      "source": [
        "# Class and Object"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gISRFgCWswMF"
      },
      "source": [
        "* Instance object and class object :- class object is created when you write class and when you create the class object that means the instance object is created and init method is called and reference of instance object is passed in class in self keyword"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wG-QLmRn9jUT"
      },
      "source": [
        "# Pass By value / reference"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wjfDf6OEn2BA"
      },
      "source": [
        "* Python support neither “Pass by Value” nor “Pass by Reference” but it is “Pass by Object Reference”.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CtmSxYBb9jUU"
      },
      "source": [
        "# Overloading in Python "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aZ98Q58XqSiI"
      },
      "source": [
        "* Python doesnot support function overloading and also Multiple Inheritance"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "glHmJPuCjMR2"
      },
      "source": [
        "# generator in python"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mu9FSO0E9jUV"
      },
      "source": [
        "* There is a lot of work in building an iterator in Python. We have to implement a class with __iter__() and __next__() method, keep track of internal states, and raise StopIteration when there are no values to be returned.\n",
        "* Simply speaking, a generator is a function that returns an object (iterator) which we can iterate over (one value at a time)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fqEp-L3VivIO",
        "outputId": "7ed000a1-f5bf-4a64-df82-f3537f235cdf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "def gen():\n",
        "    for i in range(20):\n",
        "        yield i\n",
        "generator=gen()\n",
        "next(generator)\n",
        "\n",
        "# generator comp\n",
        "i=(i for i in range(20))\n",
        "next(i)"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {},
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xseVN1s6i4pl"
      },
      "source": [
        "# Iterable iterator"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-O4Y7FF6jHdm"
      },
      "source": [
        "* iterable are those in which  __getitem or __iter is defined"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f210xlQ6M20Y"
      },
      "source": [
        "# Doc String Python"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J4QSPM7sM23b",
        "outputId": "a92de66a-386b-40ad-a539-5efda0dccd8c"
      },
      "source": [
        "def function():\n",
        "  \" this is testing of doc string function\"\n",
        "  return None\n",
        "\n",
        "# get string comment python\n",
        "output=function.__doc__\n",
        "print(output)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            " this is testing of doc string function\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TMpfIjofNI_1",
        "outputId": "3c9bccdb-4811-463d-a19b-45e69e896056"
      },
      "source": [
        "# Lambda Function "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "61mc1hosl3Bw",
        "outputId": "49a431e8-7e06-4bd2-ad95-9476033316ec"
      },
      "source": [
        "# factorial in one line\n",
        "f=lambda n: 1 if n==0 else n*f(n-1)\n",
        "print(f(5))\n",
        "\n",
        "#method 1\n",
        "(lambda a,b: a+b)(1,2)\n",
        "\n",
        "# method 2\n",
        "ss= lambda a,b: a+b\n",
        "ss(1,2)\n",
        "\n",
        "# sorting on the basis of first index\n",
        "lis=[\"ashish\",\"Manish\",\"himanshu\"]\n",
        "lis.sort(key=lambda x:x[1])\n",
        "lis\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "120\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "['Manish', 'himanshu', 'ashish']"
            ]
          },
          "execution_count": 4,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W7EZRKD7nmdj"
      },
      "source": [
        "# MONKEY PATCHING PYTHON"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OODhnBHTnp9Z",
        "outputId": "1a3afdc1-9d4d-4f77-ae36-28140918231f"
      },
      "source": [
        "class monkey:\n",
        "\n",
        "    def __init__(self,):\n",
        "        pass\n",
        "\n",
        "    def get_data(self,):\n",
        "        print(\"getting data in Class function\")\n",
        "    \n",
        "    def call_function(self):\n",
        "        print(\"call function called\")\n",
        "        self.get_data()\n",
        "\n",
        "def monkey_patching(self):\n",
        "    print(\" Monkey _patching !! outside function call in this place ** \")\n",
        "\n",
        "obj=monkey()\n",
        "monkey.get_data=monkey_patching\n",
        "obj.call_function()\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "call function called\n",
            " Monkey _patching !! outside function call in this place ** \n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mwJBd9zdpjUZ"
      },
      "source": [
        "# Name Mingling"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2QROzx_QqjRy",
        "outputId": "9449af39-6492-4b75-eb60-efae88a6deba"
      },
      "source": [
        "class Item:\n",
        "    _x=1\n",
        "    __y=2\n",
        "\n",
        "print(Item._x) # it will give value of _x\n",
        " # but if we try to get _ _Y then is give us error because of name mingling\n",
        " # so in this case\n",
        "Item._Item__y # in __ python automatically change its variable name"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "execution_count": 5,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q8HsexgKpjY-"
      },
      "source": [
        "# Methods to create Static members in class"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2ds96VIhrcN8"
      },
      "source": [
        "class item:\n",
        "    a=5\n",
        "\n",
        "    def __init__(self):\n",
        "        self.x=10 # instance variable\n",
        "        y=4 # local variable\n",
        "        Item.b=6 # static variable\n",
        "    def f1(self):\n",
        "        item.c=7 # static\n",
        "    @staticmethod\n",
        "    def f2():\n",
        "        item.d=8 # static\n",
        "    @classmethod\n",
        "    def f3(cls):\n",
        "        cls.e=9 # static\n",
        "        item.f=10 # static\n",
        "\n",
        "item.g=11 # static variable"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "77fpDSn5pjdV"
      },
      "source": [
        "# Multi Threading"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aCvAK4GIBo6t"
      },
      "source": [
        "import time\n",
        "import threading\n",
        "\n",
        "def calx_square(numbers):\n",
        "    print(\"calculate square\")\n",
        "    for n in numbers:\n",
        "        time.sleep(0.2)\n",
        "        print(\"square\",n*n)\n",
        "            \n",
        "def calc_cube(numbers):\n",
        "    print(\"calculate the cube\")\n",
        "    for n in numbers:\n",
        "        time.sleep(0.2)\n",
        "        print(\"CUBE\",n*n*n)\n",
        "        \n",
        "arr=[2,3,8,9]\n",
        "t=time.time()\n",
        "t1=threading.Thread(target=calx_square,args=(arr,))\n",
        "t2=threading.Thread(target=calc_cube,args=(arr,))\n",
        "t1.start()\n",
        "t2.start()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "di3IBKGDiFbH"
      },
      "source": [
        "## Numpy "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rlS-vP98iFbI"
      },
      "source": [
        "#### Returns: 24 because 1*2*3*4 = 24"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zYtygPnIiFbI",
        "outputId": "c2d90964-ce5c-449d-84f4-b9364493d751"
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([1, 2, 3, 4])\n",
        "\n",
        "x = np.prod(arr)\n",
        "\n",
        "print(x)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "24\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n3ozj4mqiFbK"
      },
      "source": [
        "#### Returns: 40320 because 1*2*3*4*5*6*7*8 = 40320"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uJY4IYSfiFbL",
        "outputId": "ae5496d9-c30d-4b91-db34-5d3855f19b59"
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "arr1 = np.array([1, 2, 3, 4])\n",
        "arr2 = np.array([5, 6, 7, 8])\n",
        "\n",
        "x = np.prod([arr1, arr2])\n",
        "\n",
        "print(x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "40320\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vN5IqvxkiFbM"
      },
      "source": [
        "#### Returns: [24 1680]"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "p85uVzoNiFbM",
        "outputId": "d021f7c0-f484-4a71-c9fd-cdcdd6823da0"
      },
      "source": [
        "import numpy as np\n",
        "arr1 = np.array([1, 2, 3, 4])\n",
        "arr2 = np.array([5, 6, 7, 8])\n",
        "newarr = np.prod([arr1, arr2], axis=1)\n",
        "print(newarr)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[  24 1680]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "A1nXx8kRiFbN"
      },
      "source": [
        "#### Returns: [5 30 210 1680]"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XR7gf7uOiFbN",
        "outputId": "2b12dc6c-8585-49d1-b6d8-77ad4480efa5"
      },
      "source": [
        "import numpy as np\n",
        "arr = np.array([5, 6, 7, 8])\n",
        "newarr = np.cumprod(arr)\n",
        "print(newarr)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[   5   30  210 1680]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GHHc-fiLiFbO"
      },
      "source": [
        "#### Returns: [5 10 -20] because 15-10=5, 25-15=10, and 5-25=-20"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "W24nPSkZiFbO",
        "outputId": "3e182d17-6fd6-417d-91cc-15fc890572cd"
      },
      "source": [
        "import numpy as np\n",
        "arr = np.array([10, 15, 25, 5])\n",
        "newarr = np.diff(arr)\n",
        "print(newarr)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[  5  10 -20]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cJXnbIdkiFbP"
      },
      "source": [
        "#### Returns: [5 -30] because: 15-10=5, 25-15=10, and 5-25=-20 AND 10-5=5 and -20-10=-30"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IPUvn80ZiFbP",
        "outputId": "2dc9a718-4d8d-482d-f9d0-71fdbfd4a843"
      },
      "source": [
        "arr = np.array([10, 15, 25, 5])\n",
        "newarr = np.diff(arr, n=2)\n",
        "print(newarr)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[  5 -30]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yqqE-99riFbP"
      },
      "source": [
        "# Calculating time taken "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0jrpW72siFbQ",
        "outputId": "ab840308-1dc9-4e93-c7e5-f0fbdfcf3870"
      },
      "source": [
        "import time\n",
        "start = time.process_time()\n",
        "time_taken= int(time.process_time() - start)\n",
        "print(time_taken)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zzkYzYVTiFbQ"
      },
      "source": [
        "# Get Size "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V21y-HXmiFbR",
        "outputId": "faf7888f-890b-4f47-b036-df98287ad933"
      },
      "source": [
        "from sys import *\n",
        "getsizeof([2,5,77,45,5])\n",
        "# bytes"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "104"
            ]
          },
          "execution_count": 18,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bkM_jt6OiFbR"
      },
      "source": [
        "# Decorators in  python"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UpcJa1dMiFbS",
        "outputId": "05fc961f-ef32-4128-aa34-4a9ab9e5b606"
      },
      "source": [
        "def deco(function):\n",
        "    def secondary(*args,**kwargs):\n",
        "        function(*args,**kwargs)\n",
        "        print(\"Upper\")\n",
        "        print(\"lowerd\")\n",
        "        return function(*args,**kwargs)\n",
        "    return secondary\n",
        "@deco\n",
        "def main_func(x,y,z):\n",
        "    return x+y,z\n",
        "\n",
        "# run function\n",
        "main_func(2,4,55)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Upper\n",
            "lowerd\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "(6, 55)"
            ]
          },
          "execution_count": 10,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gV0lAO_PiFbS"
      },
      "source": [
        "# *args and **kwargs"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qTdt5rRXiFbT",
        "outputId": "1c08eaa7-a631-4c66-ec7d-dc3bb04c5e38"
      },
      "source": [
        "def argskwargs(*args,**kwargs):\n",
        "    print(type(args))\n",
        "    print(type(kwargs))\n",
        "    print(args)\n",
        "    print(kwargs)\n",
        "argskwargs(5,name=\"ashish\",classe=\"cse\",roll=\"21542\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "<class 'tuple'>\n",
            "<class 'dict'>\n",
            "(5,)\n",
            "{'name': 'ashish', 'classe': 'cse', 'roll': '21542'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Irj3KXweiFbU"
      },
      "source": [
        "#### Sorting Example"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BrXa1c8KiFbU",
        "outputId": "ad52aeb9-be6b-4e1f-b589-546402fcf6e6"
      },
      "source": [
        "def selection_sort(arr):        \n",
        "    for i in range(len(arr)):\n",
        "        minimum = i\n",
        "        for j in range(i + 1, len(arr)):\n",
        "            if arr[j] < arr[minimum]:\n",
        "                minimum = j\n",
        "\n",
        "        arr[minimum], arr[i] = arr[i], arr[minimum]\n",
        "            \n",
        "    return arr\n",
        "ar=[6,8,4,6,2,4,7,6,8,5,2,4,6,2,5]\n",
        "selection_sort(ar)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[2, 2, 2, 4, 4, 4, 5, 5, 6, 6, 6, 6, 7, 8, 8]"
            ]
          },
          "execution_count": 31,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pED09R7tiFbV"
      },
      "source": [
        "# ____Dictionary format____"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vD5qUf3oiFbV",
        "outputId": "a74d288a-c146-406c-c503-b6d1541e1c5a"
      },
      "source": [
        "dic={}\n",
        "y=[\"hu\",\"hi\",\"biee\",\"ehe\",\"there\",\"hi\",\"hu\",\"hi\",\"biee\",\"ehe\",\"there\",\"hi\",]\n",
        "for x in y:\n",
        "    if  x not in dic.keys():\n",
        "        dic[x]=1\n",
        "    else:\n",
        "        dic[x]+=1\n",
        "dic"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{'hu': 2, 'hi': 4, 'biee': 2, 'ehe': 2, 'there': 2}"
            ]
          },
          "execution_count": 21,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zdGkKC5LiFbW",
        "outputId": "885acd3c-ab29-476f-f7f8-e97c120ced49"
      },
      "source": [
        "#dic comph\n",
        "{i:i**2 for i in range (0,9)}"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64}"
            ]
          },
          "execution_count": 12,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UMj-AasYiFbW",
        "outputId": "5632e353-191f-4498-f131-857088ccccf1"
      },
      "source": [
        "a={'name': 'ashish', \"roll no\":32, \"age\":24}\n",
        "a"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{'name': 'ashish', 'roll no': 32, 'age': 24}"
            ]
          },
          "execution_count": 6,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OPcIhyp4iFbX",
        "outputId": "1578a913-7eee-4551-94bf-a6ce403b3425"
      },
      "source": [
        "a=dict(name=\"ashish\", branch= \"cse\", roll=2514332)\n",
        "a"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{'name': 'ashish', 'branch': 'cse', 'roll': 2514332}"
            ]
          },
          "execution_count": 7,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9LVuc7priFbb",
        "outputId": "e0698d71-69b6-4fdf-ebe7-89fcd51a2e90"
      },
      "source": [
        "user_info = {\n",
        "    \n",
        "    \"name\":\"ashish\",\n",
        "    \"rolllno\":2524332,\n",
        "    \"branch\":\"cse\",\n",
        "    \"college\": \"UIET\",\n",
        "    \"movies\":[\"hiixdbbd\",\"dygfgcvoogcud\",\"ccblbvcc\"]    \n",
        "             }\n",
        "print(user_info)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "{'name': 'ashish', 'rolllno': 2524332, 'branch': 'cse', 'college': 'UIET', 'movies': ['hiixdbbd', 'dygfgcvoogcud', 'ccblbvcc']}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vVdHtSc9iFbc"
      },
      "source": [
        "# Accesss data of dictionary"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OuYq9WERiFbc",
        "outputId": "2487275d-45fb-4c9e-87f2-018a33628704"
      },
      "source": [
        "user_info = {\n",
        "    \"name\":\"ashish\",\n",
        "    \"rolllno\":2524332,\n",
        "    \"branch\":\"cse\",\n",
        "    \"college\": \"UIET\",\n",
        "    \"movies\":[\"hiixdbbd\",\"dygfgcvoogcud\",\"ccblbvcc\"]    \n",
        "             }\n",
        "print(user_info[\"movies\"])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "['hiixdbbd', 'dygfgcvoogcud', 'ccblbvcc']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "No9KzKF5iFbc"
      },
      "source": [
        "Get method to access values of key "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HDOEz6YciFbd",
        "outputId": "57327fb9-3661-4ccc-c18d-2409ac8ea081"
      },
      "source": [
        "user_info = {\n",
        "    \"name\":\"ashish\",\n",
        "    \"rolllno\":2524332,\n",
        "    \"branch\":\"cse\",\n",
        "    \"college\": \"UIET\",\n",
        "    \"movies\":[\"hiixdbbd\",\"dygfgcvoogcud\",\"ccblbvcc\"]    \n",
        "             }\n",
        "a=user_info.get(\"branch\")\n",
        "a"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'cse'"
            ]
          },
          "execution_count": 27,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PLGTZ7sdiFbd"
      },
      "source": [
        "# How to add data into dictionary :\n",
        "    "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mRRqby6riFbd",
        "outputId": "8b06bb95-86d0-401b-8b3a-edd1ec420e4b"
      },
      "source": [
        "user_info2={}\n",
        "user_info2[\"name\"]=\"mohit\"\n",
        "user_info2[\"classes\"]= \"cse\"\n",
        "user_info2[\"Roll\"]= 214524\n",
        "user_info2"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{'name': 'mohit', 'classes': 'cse', 'Roll': 214524}"
            ]
          },
          "execution_count": 3,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KaV78ARmiFbe"
      },
      "source": [
        "# Add data to dict"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FfznxqnEiFbe",
        "outputId": "05a3720b-62d3-4675-dfa4-64b67518ff57"
      },
      "source": [
        "user_info2={}\n",
        "user_info2[\"name\"]=\"mohit\"\n",
        "user_info2[\"classes\"]= \"cse\"\n",
        "user_info2[\"Roll\"]= 214524\n",
        "user_info2[\"food\"]=\"rajma chawal\"\n",
        "user_info2\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{'name': 'mohit', 'classes': 'cse', 'Roll': 214524, 'food': 'rajma chawal'}"
            ]
          },
          "execution_count": 14,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sUyh8E48iFbf"
      },
      "source": [
        "POP method in dictionary  (to delete )"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m0auQ_EdiFbf",
        "outputId": "800307cd-304f-484e-8b5e-afab3ca273b1"
      },
      "source": [
        "user_info2={}\n",
        "user_info2[\"name\"]=\"mohit\"\n",
        "user_info2[\"classes\"]= \"cse\"\n",
        "user_info2[\"Roll\"]= 214524\n",
        "d=user_info2.pop(\"Roll\")\n",
        "print(d)\n",
        "user_info2"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "214524\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "{'name': 'mohit', 'classes': 'cse'}"
            ]
          },
          "execution_count": 17,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bK5OrzEbiFbf"
      },
      "source": [
        "UPDATE method "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EOhx5QekiFbg",
        "outputId": "410de094-7d0a-4453-fd29-559b9c0398b8"
      },
      "source": [
        "user_info = {\n",
        "    \"name\":\"ashish\",\n",
        "    \"rolllno\":2524332,\n",
        "    \"branch\":\"cse\",\n",
        "    \"college\": \"UIET\",\n",
        "    \"movies\":[\"hiixdbbd\",\"dygfgcvoogcud\",\"ccblbvcc\"] }\n",
        "user_info \n",
        "user_info2 = { \"other\":\"ashish\",\n",
        "    \"rollln\":2524332,\n",
        "    \"branc\":\"cse\",\n",
        "    \"colleg\": \"UIET\",\n",
        "    \"movie\":[\"hiixdbbd\",\"dygfgcvoogcud\",\"ccblbvcc\"] }\n",
        "\n",
        "user_info.update(user_info2)\n",
        "user_info"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{'name': 'ashish',\n",
              " 'rolllno': 2524332,\n",
              " 'branch': 'cse',\n",
              " 'college': 'UIET',\n",
              " 'movies': ['hiixdbbd', 'dygfgcvoogcud', 'ccblbvcc'],\n",
              " 'other': 'ashish',\n",
              " 'rollln': 2524332,\n",
              " 'branc': 'cse',\n",
              " 'colleg': 'UIET',\n",
              " 'movie': ['hiixdbbd', 'dygfgcvoogcud', 'ccblbvcc']}"
            ]
          },
          "execution_count": 26,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VhBMUg-QiFbg"
      },
      "source": [
        "# Methods in dictionary "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iBmYCKo7iFbg"
      },
      "source": [
        "Clear method"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ppRW_l0fiFbh",
        "outputId": "894bd478-21c6-4cce-f96f-c6adba50eee8"
      },
      "source": [
        "user_info = {\n",
        "    \"name\":\"ashish\",\n",
        "    \"rolllno\":2524332,\n",
        "    \"branch\":\"cse\",\n",
        "    \"college\": \"UIET\",\n",
        "    \"movies\":[\"hiixdbbd\",\"dygfgcvoogcud\",\"ccblbvcc\"] }\n",
        "user_info.clear()\n",
        "user_info"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{}"
            ]
          },
          "execution_count": 31,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z-bQ3ValiFbh"
      },
      "source": [
        "Copy of dictionary"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "loJBfqBmiFbh",
        "outputId": "1bc7bd91-bee1-457d-b74c-59fa120a5f68"
      },
      "source": [
        "user_info = {\n",
        "    \"name\":\"ashish\",\n",
        "    \"rolllno\":2524332,\n",
        "    \"branch\":\"cse\",\n",
        "    \"college\": \"UIET\",\n",
        "    \"movies\":[\"hiixdbbd\",\"dygfgcvoogcud\",\"ccblbvcc\"] }\n",
        "user_info\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{'name': 'ashish',\n",
              " 'rolllno': 2524332,\n",
              " 'branch': 'cse',\n",
              " 'college': 'UIET',\n",
              " 'movies': ['hiixdbbd', 'dygfgcvoogcud', 'ccblbvcc']}"
            ]
          },
          "execution_count": 51,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xykR8k8biFbi",
        "outputId": "d19ec703-f7a5-4266-9676-d67734384f60"
      },
      "source": [
        "a=user_info.copy()\n",
        "a"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{'name': 'ashish',\n",
              " 'rolllno': 2524332,\n",
              " 'branch': 'cse',\n",
              " 'college': 'UIET',\n",
              " 'movies': ['hiixdbbd', 'dygfgcvoogcud', 'ccblbvcc']}"
            ]
          },
          "execution_count": 52,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oKz3yoJIiFbi"
      },
      "source": [
        "Code to find cubes in dictionary "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nlJ1casxiFbi",
        "outputId": "09e665bf-9a57-424d-e133-2f907d1a204b"
      },
      "source": [
        "def cube(n):\n",
        "    cubes={}\n",
        "    for i in range (1, n+1):\n",
        "        cubes[i]=i**3\n",
        "    return cubes\n",
        "cube(3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{1: 1, 2: 8, 3: 27}"
            ]
          },
          "execution_count": 54,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tv4tceyKiFbj"
      },
      "source": [
        "example"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "509DfGfNiFbj",
        "outputId": "bdf69291-44fc-4ad0-908e-3528e23b1c84"
      },
      "source": [
        "def cout(n):\n",
        "    count={}\n",
        "    for char in n :\n",
        "        count[char]=n.count(char)\n",
        "    return count\n",
        "cout(\"ashish\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{'a': 1, 's': 2, 'h': 2, 'i': 1}"
            ]
          },
          "execution_count": 59,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QUwaIZxDiFbk"
      },
      "source": [
        "____Dictionary from user input data and to store it in a empty dictionary____"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KFb8HmwziFbk",
        "outputId": "c0ff727c-3be4-466b-89dd-36ce461f5b04"
      },
      "source": [
        "dictionary = {}\n",
        "name= input(\" enter your name \")\n",
        "clas= input(\" enter your class \")\n",
        "roll= input(\" enter your rollno \")\n",
        "hobbies= input(\" enter your hobbies with , \").split(\",\")\n",
        "movies= input(\" enter your movies with , \").split(\",\")\n",
        "dictionary [\"name\"]=name\n",
        "dictionary [\"clas\"]=clas\n",
        "dictionary [\"roll\"]=roll\n",
        "dictionary [\"hobbies\"]=hobbies\n",
        "dictionary [\"movies\"]=movies\n",
        "dictionary "
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            " enter your name ashish\n",
            " enter your class cse\n",
            " enter your rollno 41034\n",
            " enter your hobbies with , sfsgsv,cvficvw\n",
            " enter your movies with , cvwfdiewv,xbviwcfc\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "{'name': 'ashish',\n",
              " 'clas': 'cse',\n",
              " 'roll': '41034',\n",
              " 'hobbies': ['sfsgsv', 'cvficvw'],\n",
              " 'movies': ['cvwfdiewv', 'xbviwcfc']}"
            ]
          },
          "execution_count": 63,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c24pSCOeiFbl"
      },
      "source": [
        "#  SET's {}"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0-XORUB7iFbl",
        "outputId": "f03cbe08-27d6-431b-d73d-c5201913deed"
      },
      "source": [
        "a={1,5,8,9,8,9,8,9,9,7,7,5,4,6,9,7,8,2,8,9,7}\n",
        "a.add(2222)\n",
        "a\n",
        "a.remove (5)\n",
        "a\n",
        "a.discard(10) \n",
        "a\n",
        "b=a.copy()\n",
        "b"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{1, 2, 4, 6, 7, 8, 9, 2222}"
            ]
          },
          "execution_count": 75,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_UV29hYtiFbl"
      },
      "source": [
        "Remove duplicacy in set"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cxrx1QF0iFbm",
        "outputId": "8e809517-16cd-4692-9084-5254eebefd3f"
      },
      "source": [
        "a={1,5,8,9,8,9,8,9,9,7,7,5,4,6,9,7,8,2,8,9,7}\n",
        "b=set(a)\n",
        "b"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{1, 2, 4, 5, 6, 7, 8, 9}"
            ]
          },
          "execution_count": 74,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Qp8qnqq9iFbm"
      },
      "source": [
        "UNION in set's"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wkiCorrtiFbm",
        "outputId": "67f0e5fb-e90b-4005-b40e-919fd6811964"
      },
      "source": [
        "a={1,5,8,9,8,9,8,9,9,7,7,5,4,6,9,7,8,2,8,9,7}\n",
        "b={1,5,9,8,9,9,7,7,5,4,6,9,7,8,2,8,9,7}\n",
        "c=a|b\n",
        "c"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{1, 2, 4, 5, 6, 7, 8, 9}"
            ]
          },
          "execution_count": 83,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Pr5Ze9GviFbn",
        "outputId": "bea53acc-be91-479e-9b30-8f180f98ebae"
      },
      "source": [
        "\n",
        "a={1,5,8,9,8,9,8,9,9,7,7,5,4,6,9,7,8,2,8,9,7}\n",
        "b={1,5,9,8,9,9,7,7,5,4,6,9,7,8,2,8,9,7}\n",
        "d=( a & b )\n",
        "d"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{1, 2, 4, 5, 6, 7, 8, 9}"
            ]
          },
          "execution_count": 85,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ylnBOOi2iFbo"
      },
      "source": [
        "# pass statment :\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rdi0MEjBiFbo"
      },
      "source": [
        "a=18\n",
        "if a<= 18:\n",
        "    pass"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W2uhpFzFiFbp"
      },
      "source": [
        "#  and operator to check two condition:\n",
        "    "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2H_z8q7giFbp",
        "outputId": "10275a45-8af0-4405-ba57-cccbab602f77"
      },
      "source": [
        "\n",
        "a=str(input(\"enter name \"))\n",
        "n=int(input(\"enter age \"))\n",
        "age = 18 \n",
        "name=( \"ashish\")\n",
        "if a==name and n==age :\n",
        "    print(\" both true\")\n",
        "else:\n",
        "    print (\" error \")\n",
        "    \n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "enter name ashish\n",
            "enter age 15\n",
            " error \n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7KufDZwTiFbq"
      },
      "source": [
        "# or statment \n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6A-EPZxRiFbq",
        "outputId": "054c6c06-d109-41fe-d934-c754d718b2bc"
      },
      "source": [
        "\n",
        "a=str(input(\"enter name strting with a or A  \"))\n",
        "n=int(input(\"enter age less then 18 \\t \"))\n",
        "age = 18 \n",
        "name=(\"a\" or \"A\")\n",
        "if ( a[0]==name or a[0]==name ) and n <= age :\n",
        "    print(\" both true\")\n",
        "else:\n",
        "    print (\" error \")\n",
        "    "
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "enter name strting with a or A  a\n",
            "enter age less then 18 \t 14\n",
            " both true\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "A5FkPIwWiFbq"
      },
      "source": [
        "# if and elif condition \n",
        "( in if it will check all the statments but in elif when it ges first true statment it runs that )\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AZUf8a3GiFbr",
        "outputId": "5a5a338f-c0dd-4a32-f9f2-a4e570faada7"
      },
      "source": [
        "a=int(input(\"enter no \"))\n",
        "if a<15: \n",
        "    print(\"less then 15...\")\n",
        "if a<=16 :\n",
        "    print(\" greater then 16....\")\n",
        "if a<=20:\n",
        "    print(\"greater then 20...\")\n",
        "    "
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "enter no 15\n",
            " greater then 16....\n",
            "greater then 20...\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xm917BzViFbr",
        "outputId": "99da952b-2d2c-4a2f-8333-2a8edfae64fe"
      },
      "source": [
        "a=int(input(\"enter no \"))\n",
        "if a<15: \n",
        "    print(\"less then 15...\")\n",
        "elif a<=16 :\n",
        "    print(\" greater then 16....\")\n",
        "elif a<=20:\n",
        "    print(\"greater then 20...\")\n",
        "    \n",
        "    "
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "enter no 14\n",
            "less then 15...\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V4Qij2S4iFbs"
      },
      "source": [
        "#  in statment"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FeGkFcsEiFbs",
        "outputId": "106a033e-ca17-4aca-cfc2-d221282b2046"
      },
      "source": [
        "a= (\"ashish\")\n",
        "z=input(\" input \")\n",
        "if z in a:\n",
        "    print(\"present\")\n",
        "else:\n",
        "    print (\"not present \")\n",
        "    "
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            " input ashish\n",
            "present\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HsuKyoSziFbs"
      },
      "source": [
        "#  to check a list is empty or not "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0Rrltb93iFbt",
        "outputId": "7ee699a6-eace-4ea3-b37a-8c93b74e99b4"
      },
      "source": [
        "a=input((\" input or remain empty \"))\n",
        "if a:\n",
        "    print(\" sometning in it\")\n",
        "else:\n",
        "    print(\"empty\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            " input or remain empty \n",
            "empty\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6g8-uI8HiFbt"
      },
      "source": [
        "#  looping concept (while loop)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ECpFvSZkiFbt"
      },
      "source": [
        "how it works? \n",
        "1. where to start \n",
        "2. where to stop  or (condition)\n",
        "3. what to do ?\n",
        "4.  how to do ?\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "M-zsjJaLiFbu",
        "outputId": "58bda7b9-e68a-474c-b4c7-5ca33b17f13b"
      },
      "source": [
        "i=1                                            # strting point ?\n",
        "while i<=5:                                    #condition when we have to stop loop ?\n",
        "    print(i, end=\" \")                          #what to do ?\n",
        "    i=i+1                                      # how to do ?\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1 2 3 4 5 "
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rF0wDU0jiFbu"
      },
      "source": [
        "_____Example to sum 1 to 10_____"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XLLd6AGGiFbu",
        "outputId": "0296707b-cf48-4db0-a470-787e8cd5edc5"
      },
      "source": [
        "data=0\n",
        "a=1\n",
        "while a<=10:\n",
        "    print(data, end=\" \")\n",
        "    data=data+a\n",
        "    a=a+1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "0 1 3 6 10 15 21 28 36 45 "
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DOEIOVYuiFbv"
      },
      "source": [
        "_____example to sum from user input_____"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Vuh8_RXZiFbv",
        "outputId": "6a582998-fd0e-4c56-950a-ec27e21f401b"
      },
      "source": [
        "data=0\n",
        "z=int(input( ))\n",
        "a=1\n",
        "while a <=z:\n",
        "    print(data, end=\" \")\n",
        "    data=data+a\n",
        "    a=a+1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "44\n",
            "0 1 3 6 10 15 21 28 36 45 55 66 78 91 105 120 136 153 171 190 210 231 253 276 300 325 351 378 406 435 465 496 528 561 595 630 666 703 741 780 820 861 903 946 "
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Jqr94t1SiFbv"
      },
      "source": [
        "_____example of adding sum of all numbers as string from user_____"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wDdZSM-_iFbw"
      },
      "source": [
        "tut (55)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RCHMsfDciFbw",
        "outputId": "2102512d-fff0-4d3c-848a-f02878ff94b5"
      },
      "source": [
        "number= input(\" \")\n",
        "total=0\n",
        "i=0\n",
        "while i<len(number):\n",
        "    total+=int(number[i])\n",
        "    i+=1\n",
        "print(total)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            " 1\n",
            "1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PDylsS8fiFbw"
      },
      "source": [
        "_____Example_____  "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AEMZl5beiFbw"
      },
      "source": [
        "output should be \n",
        "    a:1 \n",
        "    b:2\n",
        "    c:3\n",
        "    d:4\n",
        "    e:5\n",
        "    f:6\n",
        "        \n",
        "        "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "glA_V9j5iFbx",
        "outputId": "eff59384-6a1d-4968-9169-7ec200c3c956"
      },
      "source": [
        "name=input(\" \")\n",
        "temp_var= \" \"\n",
        "i=0\n",
        "while i< len (name):\n",
        "    if name [i] not in temp_var:\n",
        "        temp_var+=name[i]\n",
        "        print(f\"{name[i],name.count(name[i]) }\")\n",
        "        i+=1\n",
        "        "
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            " ashish\n",
            "('a', 1)\n",
            "('s', 2)\n",
            "('h', 2)\n",
            "('i', 1)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DsQATiuoiFbx"
      },
      "source": [
        "# infinite loop \n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bShLE0rWiFbx"
      },
      "source": [
        "while True :\n",
        "    print(\"hi\", end=\"\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MfrTG_F1iFby"
      },
      "source": [
        "# Examples of for loop "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UI6MWYxsiFby",
        "outputId": "c07437b6-5015-451e-ada2-4ad4a0c5f966"
      },
      "source": [
        "for i in range (5,10):\n",
        "    print(\"hellow\")\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "hellow\n",
            "hellow\n",
            "hellow\n",
            "hellow\n",
            "hellow\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DFkud_HsiFby",
        "outputId": "4eba1531-ce83-4dae-a0e8-ff44c2bf128a"
      },
      "source": [
        "total=0\n",
        "for i in range (1,44):\n",
        "    total+=i\n",
        "print(total)\n",
        "\n",
        "    "
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "946\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YqoE2TI5iFbz"
      },
      "source": [
        "# Diffrent Types of ways to write programe through diffrent methods"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rEyb7OBIiFbz"
      },
      "source": [
        "____Break and continue statment_____"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fXxrIg9LiFbz"
      },
      "source": [
        "break statment "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Nd0AzSQPiFbz",
        "outputId": "169d05c8-15b3-4df6-d553-02867a8ae969"
      },
      "source": [
        "for i in range (10,20):\n",
        "    if i == 18:\n",
        "        break \n",
        "    print(i, end=\" \")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "10 11 12 13 14 15 16 17 "
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3HU7gzdKiFb0"
      },
      "source": [
        "continue statment\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pbSX6km8iFb0",
        "outputId": "04f5e046-498f-4ede-bded-26dd2ec133f7"
      },
      "source": [
        "for i in range(10,20):\n",
        "    if i ==18:\n",
        "        continue\n",
        "    print(i, end=\" \")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "10 11 12 13 14 15 16 17 19 "
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5PXDR-8NiFb1",
        "outputId": "5314fb52-20ae-455f-f263-70e48674733d"
      },
      "source": [
        "def funct (int1,int2):\n",
        "    add=int1=int2\n",
        "    multiply =int1*int2\n",
        "    return add, multiply\n",
        "add, multiply = funct (2,3)\n",
        "print(add)\n",
        "print(multiply)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "3\n",
            "9\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c-eeAKsCiFb1"
      },
      "source": [
        "# Exception Handling"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "THze49EliFb2"
      },
      "source": [
        "while True:\n",
        "    try:\n",
        "        age=int(input(\"enter age\"))\n",
        "        break\n",
        "    except ValueError:\n",
        "        print(\"value error\")\n",
        "    except:\n",
        "        prnt(\"other\")\n",
        "if age<18:\n",
        "    \n",
        "    print(\"cant\")\n",
        "else:\n",
        "    print(\"yes\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "96yb1xiaiFb2"
      },
      "source": [
        "# Raise Error"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mf6hV06OiFb2",
        "outputId": "b96de527-1a36-4649-9b78-4d3b7b84f0d3"
      },
      "source": [
        "def add(a,b):\n",
        "    if (type(a) is int) and (type(b) is int):\n",
        "        return (a+b)\n",
        "    raise TypeError (\"please pass integers as a abd b\")\n",
        "a=add(2,2)\n",
        "a"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "4"
            ]
          },
          "execution_count": 13,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C_SyZKjjiFb3"
      },
      "source": [
        "def add(a,b):\n",
        "    if (type(a) is int) and (type(b) is int):\n",
        "        return (a+b)\n",
        "    raise TypeError (\"please pass integers as a abd b\")\n",
        "a=add(2,\"i\")\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qTHWqgGtiFb3"
      },
      "source": [
        "#  step Argument"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iCXr3JGtiFb3",
        "outputId": "ed44b5aa-963a-4374-ce76-e0e2afe0e059"
      },
      "source": [
        "for i in range (10,20,2):\n",
        "    print(i, end=\" \")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "10 12 14 16 18 "
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AIWxrejXiFb4",
        "outputId": "d9b1b752-8f32-4984-85a6-62f2843645c9"
      },
      "source": [
        "for i in range (10,1,-2):\n",
        "    print(i, end=\" \")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "10 8 6 4 2 "
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "huZugo5miFb4",
        "outputId": "1960e71b-675c-4b16-f0e0-5471f2f13b8f"
      },
      "source": [
        "for i in range (1,-10,-2):\n",
        "    print(i, end=\" \")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1 -1 -3 -5 -7 -9 "
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4ZZq-N0GiFb5"
      },
      "source": [
        "# Functions In Python\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RA4I3TXSiFb5",
        "outputId": "dceca5ce-4b7d-42c4-f49a-61d36b3d6fa9"
      },
      "source": [
        "def addit(a,b):\n",
        "        return a+b\n",
        "x=addit(2,4)\n",
        "x"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "6"
            ]
          },
          "execution_count": 1,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uYYME9o2iFb5"
      },
      "source": [
        " _____subscriptable error  : means that you have to pass string and you are passig integer value____\n",
        "    "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oujSwm3HiFb5"
      },
      "source": [
        "#  function without using else statmet"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P_zsc8HRiFb6",
        "outputId": "f163095b-fd59-42bc-f75f-cff78d49dd38"
      },
      "source": [
        "def adding (int):\n",
        "    if int%2==0:\n",
        "        return True\n",
        "    return False\n",
        "adding(4)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "execution_count": 4,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KApMWXWkiFb6",
        "outputId": "e94319e3-1858-4535-ff85-5e18c147dd77"
      },
      "source": [
        "def greater (a,b):\n",
        "    if a<b:\n",
        "        return a\n",
        "    return b\n",
        "greater (2,3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "execution_count": 5,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QtCIg_GmiFb6",
        "outputId": "89ebdb22-a34c-47cc-f260-af4970f9b7bd"
      },
      "source": [
        "def greater (a,b):\n",
        "    if a<b:\n",
        "        return a\n",
        "    return b\n",
        "\n",
        "def greatest (a,b,c):\n",
        "    if a>b and a>c :\n",
        "        return a \n",
        "    elif b<a and b<c :\n",
        "        return b \n",
        "    else :\n",
        "        return c \n",
        "\n",
        "def new_greatest (a,b,c):\n",
        "        bigger =greater (a,b)\n",
        "        return greater (bigger,c)\n",
        "new_greatest(3,2,5)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "execution_count": 6,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GLzw9ijbiFb7"
      },
      "source": [
        "#  to reverse a string\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m-n0C6TViFb7",
        "outputId": "c5d9f160-9480-4b76-93d0-f34dc889ff8e"
      },
      "source": [
        "\n",
        "a=(\"ashish\")\n",
        "print(a[: : -1 ])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "hsihsa\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sPFzGuJeiFb7"
      },
      "source": [
        "# Default parameters "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8_-EuK1fiFb8"
      },
      "source": [
        "none unknown and others "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "efkE5ZqSiFb8"
      },
      "source": [
        "None : this is used as default parameter for integer value, when we dont want to pass anything in it just want to leave empty"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XxAlqeDyiFb8",
        "outputId": "9560b962-26ff-4f31-8011-76a0d9183d1a"
      },
      "source": [
        "def ashish ( age= None, name = \"Unknown\"):\n",
        "    print(age,name)\n",
        "ashish()\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "None Unknown\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a66sU8rOiFb9",
        "outputId": "779d57c9-93eb-4a42-cd42-74386fc48916"
      },
      "source": [
        "def ashish ( name=\"rajat\",age= None, secondname = \"ashish\"):\n",
        "    print(name,age,secondname)\n",
        "ashish(\"ayush\",\"param\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "ayush param ashish\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6X0my7UciFb9"
      },
      "source": [
        "# Scope of functions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FuES28cliFb9"
      },
      "source": [
        "#  How to change values of list"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "R3Q7_5cBiFb-",
        "outputId": "c032275c-2682-4fba-ca94-f13aae8151d3"
      },
      "source": [
        "list=[\"ashish\",22,55,85.52,\"rajat\"]\n",
        "list[2]=88\n",
        "print(list)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "['ashish', 22, 88, 85.52, 'rajat']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zYsl4KVViFb-"
      },
      "source": [
        "#  Add data to list "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0k7DN70CiFb-"
      },
      "source": [
        "Append function will add the data only in last of list"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xN9PMNBAiFb_",
        "outputId": "03196558-22b6-4647-ab3d-4b2e1cfcdeb1"
      },
      "source": [
        "list=[\"ashish\",22,55,85.52,\"rajat\"]\n",
        "list.append(\"manish\")\n",
        "print(list)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "['ashish', 22, 55, 85.52, 'rajat', 'manish']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Aro6qY4TiFb_"
      },
      "source": [
        "Add elements in blank list (append)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AMt3PqLFiFb_",
        "outputId": "fbfb1059-d4ed-4c05-8dad-0ad2cad4fb59"
      },
      "source": [
        "a= []\n",
        "a.append(\"ashish\")\n",
        "a.append(\"ashish\")\n",
        "a.append(\"ashish\")\n",
        "a.append(\"ashish\")\n",
        "a"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "['ashish', 'ashish', 'ashish', 'ashish']"
            ]
          },
          "execution_count": 18,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kNEvSsajiFcA"
      },
      "source": [
        "how to insetr element is any position of list (insert )"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vkt7cLgFiFcA",
        "outputId": "d3e7f554-47e5-40d2-de87-1ff20982734d"
      },
      "source": [
        "a=[\"ashish\",\"rajat\",\"himanshu\"]\n",
        "a.insert(1,\"Manish\")\n",
        "a"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "['ashish', 'Manish', 'rajat', 'himanshu']"
            ]
          },
          "execution_count": 20,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CLivcNZJiFcA"
      },
      "source": [
        "To add two strings (+)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a6Ou3lF0iFcB",
        "outputId": "b8682426-492f-4a2c-eaeb-5d3c7e38865f"
      },
      "source": [
        "a=[\"ashish\",\"rajat\",\"himanshu\"]\n",
        "b=[\"ash\",\"rat\",\"hima\"]\n",
        "c=a+b\n",
        "c"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "['ashish', 'rajat', 'himanshu', 'ash', 'rat', 'hima']"
            ]
          },
          "execution_count": 22,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8uLEowHciFcB"
      },
      "source": [
        "To add a list into a list we use (append)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rDazjN1WiFcB",
        "outputId": "79a89dda-32b9-405c-ab18-3b972ea29cbf"
      },
      "source": [
        "a=[\"ashish\",\"rajat\",\"himanshu\"]\n",
        "b=[\"ash\",\"rat\",\"hima\"]\n",
        "a.append(b)\n",
        "a"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "['ashish', 'rajat', 'himanshu', ['ash', 'rat', 'hima']]"
            ]
          },
          "execution_count": 24,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9q0ZVpYziFcC"
      },
      "source": [
        "how to use ( extend )\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F9hCS1hIiFcC",
        "outputId": "b3178415-5497-451d-963c-9af7a15d12be"
      },
      "source": [
        "a=[\"ashish\",\"rajat\",\"himanshu\"]\n",
        "b=[\"ash\",\"rat\",\"hima\"]\n",
        "a.extend(b)\n",
        "a"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "['ashish', 'rajat', 'himanshu', 'ash', 'rat', 'hima']"
            ]
          },
          "execution_count": 26,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s5g-vhP8iFcC"
      },
      "source": [
        "# To delete Data from list"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iyD54KzDiFcC"
      },
      "source": [
        "pop function to delete some element from list , it will delete element from last by default and also from given index ( POP )"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N53srT-5iFcD",
        "outputId": "1ab10cd8-9865-420c-f1a4-822732da23f7"
      },
      "source": [
        "a=[\"ashish\",\"rajat\",\"himanshu\",\"ash\",\"rat\",\"hima\"]\n",
        "a.pop(2)\n",
        "a"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "['ashish', 'rajat', 'ash', 'rat', 'hima']"
            ]
          },
          "execution_count": 29,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YIGBjaX4iFcD"
      },
      "source": [
        "To remove a specific element from list ( Remove)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MEq7XZSgiFcD",
        "outputId": "cae7b86d-3843-4abb-ed5a-b1cf21e7707e"
      },
      "source": [
        "a=[\"ashish\",\"rajat\",\"himanshu\",\"ash\",\"rat\",\"hima\"]\n",
        "a.remove(\"rajat\")\n",
        "a"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "['ashish', 'himanshu', 'ash', 'rat', 'hima']"
            ]
          },
          "execution_count": 31,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l787B98TiFcE"
      },
      "source": [
        "____To add data we use ( append, extend , insert )     \n",
        "to delete data we use ( pop , remove ) ____"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jET-g2uwiFcE"
      },
      "source": [
        "_____to check whether an element is present in list or not we use ( in ) _____"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vFC5MmD1iFcE",
        "outputId": "2046c110-c54a-4417-de72-7ddb0d9fd315"
      },
      "source": [
        "a=[\"ashish\",\"rajat\",\"himanshu\"]\n",
        "if \"ashish\" in a:\n",
        "    print (\"yes\")\n",
        "else:\n",
        "    print(\"no \")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "yes\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hzwySTaViFcF"
      },
      "source": [
        "#  More strings methods "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G9WSh9fdiFcF"
      },
      "source": [
        "     count\n",
        "     sort\n",
        "     reverse\n",
        "     copy     "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eWY6ferEiFcF",
        "outputId": "8fe50eea-cb75-43a2-888b-dffdb934b06f"
      },
      "source": [
        "a=[\"ashish\",\"rajat\",\"himanshu\"]\n",
        "a.count(\"ashish\")\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "execution_count": 37,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O4t-SRrAiFcG",
        "outputId": "573c5176-227f-41b4-a9fa-ce53c17de6c7"
      },
      "source": [
        "a=[55,85,77,1,5,6,8,55]\n",
        "a.sort()\n",
        "a"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[1, 5, 6, 8, 55, 55, 77, 85]"
            ]
          },
          "execution_count": 38,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GFLyrC8siFcG",
        "outputId": "b744e244-7cc0-40dc-da17-992e596f6eab"
      },
      "source": [
        "a=[55,85,77,1,5,6,8,5]\n",
        "a.reverse()\n",
        "a"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[5, 8, 6, 5, 1, 77, 85, 55]"
            ]
          },
          "execution_count": 39,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5XD8N-aaiFcH",
        "outputId": "5972d985-7ec4-4a0d-b1af-cfc592d03bb7"
      },
      "source": [
        "a=[55,85,77,1,5,6,8,55]\n",
        "a.clear()\n",
        "a"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[]"
            ]
          },
          "execution_count": 40,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ME6M9-Nj9jUu"
      },
      "source": [
        "# sorted fnction"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fHpUSwbV9jUu",
        "outputId": "aeb1c263-b88c-4ff0-e4ea-34ebac8dbcdd"
      },
      "source": [
        "a=[55,85,77,1,5,6,8,55]\n",
        "data=a.sort() # it will do sorting the orignal list\n",
        "print(data)\n",
        "\n",
        "\n",
        "a=[55,85,77,1,5,6,8,55]\n",
        "data=sorted(a) # it will Not do sorting the orignal list\n",
        "print(data)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "None\n",
            "[1, 5, 6, 8, 55, 55, 77, 85]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aAFSfJpTiFcH"
      },
      "source": [
        "slicing "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mnL2ZarbiFcH"
      },
      "source": [
        "\n",
        "A=(\"fbfobdbd\")\n",
        "print(A[3]) \n",
        "print(A[-2]) # it print s of ashish \n",
        "print(A[2,-2]) #from 2 to -2 index\n",
        "print(A[2:]) # it print from 2nd index to n\n",
        "print(A[: 2]) #.. from strting to 2nd  index"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NJ_XYkBAiFcI"
      },
      "source": [
        "\n",
        "String Method ( )\n",
        " a=\"ashish\" \n",
        "len (\"ashish\")  : ans= 6\n",
        "b=len(a) : ans = 6  \n",
        "print(a.lower()) := print all letters in lowercase\n",
        "print(a.upper()) ;= print all letter in uppercase\n",
        "print(a.title())   : first letter capital and other in lower case\n",
        "Print(a.count(“h”)) : it counts that how many times h occurs in ashish"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vbemwB6ViFcI"
      },
      "source": [
        "Remove Spaces In string ( )\n",
        "A= ”                   ashish            ”\n",
        "To remove lefr space we have                               print (a.lstrip ())\n",
        "Tpo remove right we have                                      print (a.rstrip())\n",
        "To remove space from both sides we have            print (a strip())\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N97BdB1FiFcJ"
      },
      "source": [
        "\n",
        "Replace ( )\n",
        "a= (\"hey how r uh .. r uh in college?\")\n",
        "print(a.replace (\"r\",\"are\"))\n",
        "result = hey how are uh. are uh in college?\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SNS3INSiiFcJ"
      },
      "source": [
        "h=(\"hellow,how r uh . where r u going . what r uh doing . what r your hobbies\")\n",
        ">>> print(h.replace(\"r\",\"are\"))\n",
        "hellow,how are uh . whearee are u going . what are uh doing . what are youare hobbies\n",
        ">>> print(h.replace(\"r\",\"are\",3))\n",
        "hellow,how are uh . whearee are u going . what r uh doing . what r your hobbies\n",
        "\n",
        "print(h.find(\"r\"))\n",
        "11"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-XP1CKzRiFcJ"
      },
      "source": [
        "\n",
        "Print *************\n",
        "\n",
        "a=\"ashish\"\n",
        ">>> print(a.center(22,\"*\"))\n",
        "********ashish********\n",
        "a=input(str(\"hi\"))\n",
        "print(a.center(22,\"*\"))\n",
        "print(a.center(len(a) +44 ,\"*\"))\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gbti9j4qiFcJ"
      },
      "source": [
        "# split method (split)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0h34ajRJiFcK"
      },
      "source": [
        "split method (split)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BwvXSq0RiFcK",
        "outputId": "898aa489-d1a2-4bfb-9ea9-2a8fbdf30e35"
      },
      "source": [
        "a=\"gdwvbkcdbbcec c&bicvebcbieccboebccbc=end\"\n",
        "b=a.split(\"&\")\n",
        "b "
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "['gdwvbkcdbbcec c', 'bicvebcbieccboebccbc=end']"
            ]
          },
          "execution_count": 43,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L0chohl0iFcK"
      },
      "source": [
        "Join method"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VXTW3jcEiFcL",
        "outputId": "30f87686-433b-445e-fdf7-bed5d5f80efe"
      },
      "source": [
        "a=[\"ashish\", \"24\"]\n",
        "print(\",\".join(a))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "ashish,24\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LoWKvcqsiFcL"
      },
      "source": [
        "strings are immutable but lists are mutable     ,\n",
        "we have to make new string to change in string but in list the function will change the orignal list\n",
        "ex     \n",
        " it wil capatilize the first letter of string"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i8soFgJkiFcL",
        "outputId": "d7a0a75b-8b52-410b-fe62-4e24630a17fb"
      },
      "source": [
        "a=\"ashishkumar\"\n",
        "b=a.title()\n",
        "b"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'Ashishkumar'"
            ]
          },
          "execution_count": 47,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MZoIXbOWiFcM"
      },
      "source": [
        "#  _____To access List in List_____"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_VzR4OrZiFcM",
        "outputId": "af9ec9e2-3dfe-4d7f-9dd8-fc554453bde4"
      },
      "source": [
        "a= [[12,33,55],[41,84,99,78],[75,84,45,52,99,74]]\n",
        "for i in a:\n",
        "    for j in i:\n",
        "        print(j)\n",
        "    "
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "12\n",
            "33\n",
            "55\n",
            "41\n",
            "84\n",
            "99\n",
            "78\n",
            "75\n",
            "84\n",
            "45\n",
            "52\n",
            "99\n",
            "74\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k5A9GPTgiFcM",
        "outputId": "24582c80-6934-41e5-c92c-26fe1855dcd6"
      },
      "source": [
        "a= [[12,33,55],[41,84,99,78],[75,84,45,52,99,74]]\n",
        "for i in a:\n",
        "    for j in i:\n",
        "        print(i)\n",
        "   "
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[12, 33, 55]\n",
            "[12, 33, 55]\n",
            "[12, 33, 55]\n",
            "[41, 84, 99, 78]\n",
            "[41, 84, 99, 78]\n",
            "[41, 84, 99, 78]\n",
            "[41, 84, 99, 78]\n",
            "[75, 84, 45, 52, 99, 74]\n",
            "[75, 84, 45, 52, 99, 74]\n",
            "[75, 84, 45, 52, 99, 74]\n",
            "[75, 84, 45, 52, 99, 74]\n",
            "[75, 84, 45, 52, 99, 74]\n",
            "[75, 84, 45, 52, 99, 74]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0xeAKGE0iFcN",
        "outputId": "4c4cefcf-ef3e-4b25-e6e7-591b7ffef4bd"
      },
      "source": [
        "a= [[12,33,[75,84,45,52,99,74]],[41,84,99,78],[75,84,45,52,99,74]]\n",
        "print(a[0][2])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[75, 84, 45, 52, 99, 74]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8eLdgf2fiFcN"
      },
      "source": [
        "example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hMBJ1K0siFcN",
        "outputId": "5b1a6441-07f4-4243-a29b-04985b3cca6d"
      },
      "source": [
        "def mylist ( ):\n",
        "    a=[range(10,20)]\n",
        "    print(a[: : -1])\n",
        "    \n",
        "mylist()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[range(10, 20)]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9I7ELJ13iFcO"
      },
      "source": [
        "method 2: "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uvQHfx58iFcO",
        "outputId": "ac7db167-2c0f-41d8-d9fd-3646b286f88a"
      },
      "source": [
        "def hey():\n",
        "    a=[range(10,20)]\n",
        "    a.reverse()\n",
        "    return a\n",
        "hey()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[range(10, 20)]"
            ]
          },
          "execution_count": 80,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r5xHNRHgiFcO"
      },
      "source": [
        "ex:\n",
        "    "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fmiaEMAIiFcP",
        "outputId": "b68a3d6c-d503-43eb-825b-ba645379a3af"
      },
      "source": [
        "def example(ex):\n",
        "    elements=[]\n",
        "    for i in ex:\n",
        "        elements.append(i[: : -1])\n",
        "    return elements\n",
        "ex=[\"ashish\",\"rajat\",\"naveen\"]\n",
        "example(ex)\n",
        "    "
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "['hsihsa', 'tajar', 'neevan']"
            ]
          },
          "execution_count": 62,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pytldQJ-iFcP"
      },
      "source": [
        "Example to filter odd and even numbers in list and then to manage them in difrent-diffrent list....."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6jLm8ESWiFcP",
        "outputId": "1896057e-c764-4273-a8c3-71c3a2b97d01"
      },
      "source": [
        "def filter_odd_even(nums):\n",
        "    odd=[]\n",
        "    even=[]\n",
        "    for i in nums:\n",
        "        if i%2==0:\n",
        "            even.append(i)\n",
        "        else:\n",
        "            odd.append(i)\n",
        "    output=[odd,even]\n",
        "    return output\n",
        "nums=[1,5,8,8,7,9,6,7,5,2,2,0,6,3]\n",
        "print(filter_odd_even(nums))\n",
        "        "
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[1, 5, 7, 9, 7, 5, 3], [8, 8, 6, 2, 2, 0, 6]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5Tp_m17piFcQ"
      },
      "source": [
        "Example: pass two list and collect same numbers from both list and make a new list and store them :....."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EPSluOEniFcQ",
        "outputId": "683668b3-7f18-4639-8640-c6d8c0439b24"
      },
      "source": [
        "def common_finder(list1,list2):\n",
        "    output=[]\n",
        "    for i in list1:\n",
        "        for i in list2:\n",
        "            output.append(i)\n",
        "        return output\n",
        "common_finder([1,7,5],[1,7,2])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[1, 7, 2]"
            ]
          },
          "execution_count": 66,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Yd6gJb2XiFcQ"
      },
      "source": [
        "# Minmum and Maximum function :- ................ ( MIN, MAX )"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mvsWvQ0hiFcQ",
        "outputId": "b92aa8b5-8c76-4df3-80be-eb685cd93f0e"
      },
      "source": [
        "\n",
        "aa=[range(10,30)]\n",
        "cc=min(aa)\n",
        "dd=max(aa)\n",
        "cc,dd"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(range(10, 30), range(10, 30))"
            ]
          },
          "execution_count": 76,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qSNonDaWiFcR"
      },
      "source": [
        "sorting acc to min and max function"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eMTueH5DiFcR",
        "outputId": "109b0ed9-2db2-4de5-e32a-bfcbb8960479"
      },
      "source": [
        "guitars=[ {\"model\": \"indian \", \"price\":5000},\n",
        "         {\"model\": \"chinese \", \"price\":1100},\n",
        "         {\"model\": \"german \", \"price\":45000},\n",
        "         {\"model\": \"korean \", \"price\":7000},\n",
        "         {\"model\": \"american\", \"price\":800000} ]\n",
        "a=(sorted(guitars,key=lambda d:d[\"price\"], reverse = False ))\n",
        "b=(sorted(guitars,key=lambda d:d[\"price\"], reverse = True ))\n",
        "a, b"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "([{'model': 'chinese ', 'price': 1100},\n",
              "  {'model': 'indian ', 'price': 5000},\n",
              "  {'model': 'korean ', 'price': 7000},\n",
              "  {'model': 'german ', 'price': 45000},\n",
              "  {'model': 'american', 'price': 800000}],\n",
              " [{'model': 'american', 'price': 800000},\n",
              "  {'model': 'german ', 'price': 45000},\n",
              "  {'model': 'korean ', 'price': 7000},\n",
              "  {'model': 'indian ', 'price': 5000},\n",
              "  {'model': 'chinese ', 'price': 1100}])"
            ]
          },
          "execution_count": 11,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5hallIMpiFcR"
      },
      "source": [
        "# TUPPLES"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "esYKzZkhiFcS"
      },
      "source": [
        "Tupples are immutabe, we use tupple when we dont want to change our value:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "toDHDHt5iFcS",
        "outputId": "855cc596-ed26-4770-baf6-5512efd66bc5"
      },
      "source": [
        "a=(4,5,2,5)\n",
        "type(a)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tuple"
            ]
          },
          "execution_count": 71,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vH0350R0iFcS"
      },
      "source": [
        "# Map Function \n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3cIqe_i8iFcT",
        "outputId": "f165d72d-0c32-42f2-a0dc-c5861f289264"
      },
      "source": [
        "a=[1,2,3,5,8]\n",
        "def ashish(a):\n",
        "    return a**2\n",
        "z=list(map(ashish,a))\n",
        "z"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[1, 4, 9, 25, 64]"
            ]
          },
          "execution_count": 20,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U2OlzZO-iFcT"
      },
      "source": [
        "# Zip Function"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tj6zXsSAiFcU",
        "outputId": "c9b22709-663f-46e4-8246-7dca01ca22fe"
      },
      "source": [
        "a=[\"ashish\",\"rajat\",\"naveen\"]\n",
        "b=[\"cse\", \"ece\", \"mech\"]\n",
        "c=list(zip(a,b))\n",
        "c"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[('ashish', 'cse'), ('rajat', 'ece'), ('naveen', 'mech')]"
            ]
          },
          "execution_count": 4,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jS8RodgaiFcU",
        "outputId": "3eb6abc3-94c6-4e7c-8d14-c5e544a8e818"
      },
      "source": [
        "a=[('ashish', 'cse'), ('rajat', 'ece'), ('naveen', 'mech')]\n",
        "b,c=list(zip(*a))\n",
        "b,c"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(('ashish', 'rajat', 'naveen'), ('cse', 'ece', 'mech'))"
            ]
          },
          "execution_count": 8,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-XIyyxQRiFcU"
      },
      "source": [
        "# To find Help and doc function"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jKk0O1FBiFcV",
        "outputId": "45a5b31d-b2ca-4c15-ce39-0d76e6ef9984"
      },
      "source": [
        "def ashish(a):\n",
        "    return a*2\n",
        "ashish(a.__doc__)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'Built-in mutable sequence.\\n\\nIf no argument is given, the constructor creates a new empty list.\\nThe argument must be an iterable if specified.Built-in mutable sequence.\\n\\nIf no argument is given, the constructor creates a new empty list.\\nThe argument must be an iterable if specified.'"
            ]
          },
          "execution_count": 17,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "juJaY3ORiFcV",
        "outputId": "07402e69-1ed6-42a0-daa1-84c11827e1b1"
      },
      "source": [
        "print=help(sum)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Help on built-in function sum in module builtins:\n",
            "\n",
            "sum(iterable, start=0, /)\n",
            "    Return the sum of a 'start' value (default: 0) plus an iterable of numbers\n",
            "    \n",
            "    When the iterable is empty, return the start value.\n",
            "    This function is intended specifically for use with numeric values and may\n",
            "    reject non-numeric types.\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I2hNJh0-iFcV"
      },
      "source": [
        "# Pass Function as argument"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LdQjMVYGiFcW",
        "outputId": "77548349-ce34-41c7-d45f-55c2ec5b747a"
      },
      "source": [
        "def square (a):\n",
        "    return a**2\n",
        "\n",
        "l=[1,5,5,6,3]\n",
        "\n",
        "def my_map(func, l):\n",
        "    new_list=[]\n",
        "    for item in l:\n",
        "        new_list.append(func(item))\n",
        "    return new_list\n",
        "\n",
        "z=my_map(square,l)\n",
        "z"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[1, 25, 25, 36, 9]"
            ]
          },
          "execution_count": 33,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pGcIOPe4iFcX"
      },
      "source": [
        "# Function returning function"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NdzperVSiFcX"
      },
      "source": [
        "def outer_func():\n",
        "    def inner_func():\n",
        "        print(\"inside inner func\")\n",
        "    return inner_func\n",
        "def outer_func2(msg):\n",
        "    def inner_func2():\n",
        "        print(\" message is hiii\")\n",
        "    return inner_func2\n",
        "var=outer_func2(\"hii m ashish\")\n",
        "var()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UQwKF874iFcX"
      },
      "source": [
        "                                                                UNIX\n",
        "UNIX COMMANDS \n",
        "1.\tPWD – public work directory (shows the current directory where we r)\n",
        "2.\tCd – change directory (to change directory) \n",
        "3.\tCd  .. – to come back (back command)\n",
        "4.\tCd “folder name” – to enter in any folder\n",
        "5.\tLs – list command, (it shows all the object in that directory or folder)\n",
        "6.\tmkdir - make directory (to make folders)\n",
        "7.\tTouch - to make files (ashish.txt ashish.py or other)\n",
        "8.\tRm “filename.txt” – to remove file or delete\n",
        "9.\tRm -rf “folder name” - remove folder (to remove folder)\n",
        "10.\tClear – to clear screen\n",
        "11.\tCode “filename.py” – to open file in >>> (we can directly use this code to create and open file in >>>)\n",
        "12.\tmv first file name.py   rename.py – to rename files\n",
        "13.\tcp file.py ./newfolder/ - to copy file\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f-WlFHQ8iFcY"
      },
      "source": [
        "# PATTERN Making"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sFafUiw1iFcY",
        "outputId": "bda53e3f-ff8d-4b7e-ae8b-20f08e287547"
      },
      "source": [
        "for row in range (7):\n",
        "    for col in range (5 ):\n",
        "        if (col==0 or col == 4) or (( row==0 or row ==3) and (col >0 and col<4)):\n",
        "            print(\"*\",end=\" \") \n",
        "        else:\n",
        "            print(end=\"  \")\n",
        "    print()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "* * * * * \n",
            "*       * \n",
            "*       * \n",
            "* * * * * \n",
            "*       * \n",
            "*       * \n",
            "*       * \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Edm2IkJ9iFcY",
        "outputId": "24bab6bf-47e5-45ff-c148-a0e1bdcde441"
      },
      "source": [
        "for row in range ( 7):\n",
        "    for col in range (5 ):\n",
        "        if                        (col ==0) or (col==4 and (row!=0 and row!=6)) or ((row==0 or row==6) and (col>0 and col<4)):\n",
        "            print( \"*\",end=\" \")\n",
        "        else:\n",
        "            print(end=\"  \")\n",
        "    print()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "* * * *   \n",
            "*       * \n",
            "*       * \n",
            "*       * \n",
            "*       * \n",
            "*       * \n",
            "* * * *   \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5Ay-h-YkiFcZ",
        "outputId": "9a1b549a-04e2-4e79-feef-d906b7a7dc79"
      },
      "source": [
        "for row in range (7):\n",
        "    for column in range (5 ):\n",
        "        if                      (column == 1 or ((row == 0 or row == 3) and column > 0 and column < 5)\n",
        "            \n",
        "            or\n",
        "            \n",
        "                                 ((column == 5 or column == 1) and (row == 1 or row == 2))):\n",
        "            print( \"*\",end=\" \")\n",
        "        else:\n",
        "            print(end=\"  \")\n",
        "    print()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "  * * * * \n",
            "  *       \n",
            "  *       \n",
            "  * * * * \n",
            "  *       \n",
            "  *       \n",
            "  *       \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QVO2MjUSiFcb",
        "outputId": "a9e48ce0-49aa-45f7-ea92-6db28913c457"
      },
      "source": [
        "result_str=\"\";    \n",
        "for row in range(0,7):    \n",
        "    for column in range(0,7):     \n",
        "        if (((row == 0 or row == 3 or row == 6) and column > 1 and column < 5) or (column == 1 and (row == 1 or row == 2 or row == 6)) or (column == 5 and (row == 0 or row == 4 or row == 5))):  \n",
        "            result_str=result_str+\"*\"    \n",
        "        else:      \n",
        "            result_str=result_str+\" \"    \n",
        "    result_str=result_str+\"\\n\"    \n",
        "print(result_str);"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "  **** \n",
            " *     \n",
            " *     \n",
            "  ***  \n",
            "     * \n",
            "     * \n",
            " ****  \n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yRCRUWhBiFcc",
        "outputId": "30aea7b7-3436-45bf-cf53-a83e7a803756"
      },
      "source": [
        "result_str=\"\";    \n",
        "for row in range(0,7):    \n",
        "    for column in range(0,7):     \n",
        "        if (column == 1 or column == 5 or (row == 2 and (column == 2 or column == 4)) or (row == 3 and column == 3)):  \n",
        "            result_str=result_str+\"* \"    \n",
        "        else:      \n",
        "            result_str=result_str+\"  \"    \n",
        "    result_str=result_str+\"\\n\"    \n",
        "print(result_str);\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "  *       *   \n",
            "  *       *   \n",
            "  * *   * *   \n",
            "  *   *   *   \n",
            "  *       *   \n",
            "  *       *   \n",
            "  *       *   \n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zdMnSs-CiFcd",
        "outputId": "78e4934f-93bb-466d-97b7-6155cdaf118b"
      },
      "source": [
        "result_str=\"\";    \n",
        "for row in range(0,7):    \n",
        "    for column in range(0,7):     \n",
        "        if (column == 1 or ((row == 0 or row == 3) and column > 0 and column < 5) or ((column == 5 or column == 1) and (row == 1 or row == 2))):  \n",
        "            result_str=result_str+\"*\"    \n",
        "        else:      \n",
        "            result_str=result_str+\" \"    \n",
        "    result_str=result_str+\"\\n\"    \n",
        "print(result_str);"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            " ****  \n",
            " *   * \n",
            " *   * \n",
            " ****  \n",
            " *     \n",
            " *     \n",
            " *     \n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0ARRE_1iiFcd",
        "outputId": "acd73e00-2b24-470c-88db-e0e1b226b590"
      },
      "source": [
        "result_str=\"\";    \n",
        "for row in range(0,7):    \n",
        "    for column in range(0,7):     \n",
        "        if (column == 1 or ((row == 0 or row == 3) and column > 1 and column < 5) or (column == 5 and row != 0 and row < 3) or (column == row - 1 and row > 2)):  \n",
        "            result_str=result_str+\"*\"    \n",
        "        else:      \n",
        "            result_str=result_str+\" \"    \n",
        "    result_str=result_str+\"\\n\"    \n",
        "print(result_str);"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            " ****  \n",
            " *   * \n",
            " *   * \n",
            " ****  \n",
            " * *   \n",
            " *  *  \n",
            " *   * \n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gwGnaeEdiFce",
        "outputId": "78ff15d5-ed3a-4994-fcf2-9535c7cca8a9"
      },
      "source": [
        "result_str=\"\";    \n",
        "for row in range(0,7):    \n",
        "    for column in range(0,7):     \n",
        "        if (((column == 1 or column == 5) and row != 6) or (row == 6 and column > 1 and column < 5)):  \n",
        "            result_str=result_str+\"*\"    \n",
        "        else:      \n",
        "            result_str=result_str+\" \"    \n",
        "    result_str=result_str+\"\\n\"    \n",
        "print(result_str);"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            " *   * \n",
            " *   * \n",
            " *   * \n",
            " *   * \n",
            " *   * \n",
            " *   * \n",
            "  ***  \n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cgebf7U0iFce",
        "outputId": "b288a09d-9253-4d42-f0d6-236c7e86799a"
      },
      "source": [
        "result_str=\"\";    \n",
        "for row in range(0,7):    \n",
        "    for column in range(0,7):     \n",
        "        if (((row == 0 or row == 6) and column >= 0 and column <= 6) or row+column==6):  \n",
        "            result_str=result_str+\"*\"    \n",
        "        else:      \n",
        "            result_str=result_str+\" \"    \n",
        "    result_str=result_str+\"\\n\"    \n",
        "print(result_str);\n",
        "    "
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "*******\n",
            "     * \n",
            "    *  \n",
            "   *   \n",
            "  *    \n",
            " *     \n",
            "*******\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AebqBxrsiFcf"
      },
      "source": [
        "#                 PYTHON ( OOPS )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MSEvVBoNiFcf"
      },
      "source": [
        "..."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dMaKH42ZiFcf",
        "outputId": "f8c3827c-fbba-4773-a02e-703a136fc2c3"
      },
      "source": [
        "class Person:\n",
        "    def __init__(self,first_name,last_name,age):\n",
        "        self.first_name = first_name\n",
        "        self.last_name=last_name\n",
        "        self.age= age\n",
        "\n",
        "one=Person(\"ashsih\",\"kumar\",24)\n",
        "two=Person(\"paramjeet\",\"singh\",23)\n",
        "print(one.first_name)\n",
        "print(two.first_name)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "ashsih\n",
            "paramjeet\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qm48-NGFiFcg",
        "outputId": "bea175c2-8712-4942-aaef-d21391d27ea8"
      },
      "source": [
        "class Car:\n",
        "    def __init__ (self, model_name, price,brand ):\n",
        "        self.model_name=model_name\n",
        "        self.price=price\n",
        "        self.brand= brand\n",
        "        self.overall= (self.model_name,self.price,self.brand)\n",
        "        \n",
        "car1= Car(\"city\",1000000,\"honda\")\n",
        "print(car1.overall)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "('city', 1000000, 'honda')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gLzbdZmziFcg",
        "outputId": "942151e6-d853-451c-a704-ad7bdef7db60"
      },
      "source": [
        "class Car:\n",
        "    def __init__ (self, model_name, price,brand ):\n",
        "        self.model_name=model_name\n",
        "        self.price=price\n",
        "        self.brand= brand\n",
        "        self.overall= (self.model_name,self.price,self.brand)\n",
        "        \n",
        "car1= Car(\"city\",1000000,\"honda\")\n",
        "print(car1.overall)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "('city', 1000000, 'honda')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_HHxxbniiFcg"
      },
      "source": [
        "# inheritance"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BFhouoZXiFch"
      },
      "source": [
        "use super keywoard ( super().init)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Y8Bg1zr8iFch",
        "outputId": "7ab2d4ee-8b21-4da1-b137-1bf08f68b3cc"
      },
      "source": [
        "class Car:\n",
        "    def __init__ (self, model_name, price,brand ):\n",
        "        self.model_name=model_name\n",
        "        self.price=price\n",
        "        self.brand= brand\n",
        "        self.overall= (self.model_name,self.price,self.brand)\n",
        "    \n",
        "class Big_car(Car):\n",
        "    def __init__ (self,model_name,price,brand,colour,height,weight,engine):\n",
        "        super().__init__ (model_name, price,brand )\n",
        "        self.colour=colour\n",
        "        self.height=height\n",
        "        self.weight=weight\n",
        "        self.engine=engine\n",
        "        self.fullspec=(model_name,price,brand,colour,height,weight,engine)\n",
        "car1= Big_car(\"city\",1000000,\"honda\",\"white\",1500,\"5 meter\",\"100cc\")\n",
        "car1.fullspec\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "('city', 1000000, 'honda', 'white', 1500, '5 meter', '100cc')"
            ]
          },
          "execution_count": 4,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_e8JsipUiFci",
        "outputId": "bc179bc8-7b1e-479b-dd3e-a9c12a8ea855"
      },
      "source": [
        "class Laptop:\n",
        "    def __init__(self, processor,model,colour,year):\n",
        "        self.processor=processor\n",
        "        self.model=model\n",
        "        self.colour=colour\n",
        "        self.year=year\n",
        "first=Laptop(\"pentum\",\"khz\",\"white\",2009)\n",
        "print(first.processor)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "pentum\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iVNIxxFOiFci",
        "outputId": "1ab6a749-ecb9-4cbf-e8c7-ee4277ce5fe6"
      },
      "source": [
        "class Person:\n",
        "    def __init__(self,first_name,last_name,age):\n",
        "        self.first_name = first_name\n",
        "        self.last_name=last_name\n",
        "        self.age= age\n",
        "    def full_name(self):\n",
        "        return (self.first_name, self.last_name)\n",
        "p1=Person(\"ashish\",\"kumar\",24)\n",
        "print(p1.full_name())\n",
        "    \n",
        "    "
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "('ashish', 'kumar')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sOiJOG5MiFci",
        "outputId": "9e6f6f91-aefa-48f8-d4df-f35bca156b2c"
      },
      "source": [
        "class Laptop:\n",
        "    def __init__(self,brand,model,price):\n",
        "        self.brand=brand\n",
        "        self.model=model\n",
        "        self.price=price\n",
        "        self.laptop_name=brand +\" \" + model\n",
        "    def apply_discount(self,num):\n",
        "        off_price=(num/100)*self.price\n",
        "        return (self.price - off_price)\n",
        "    \n",
        "laptop1=Laptop(\"hp\",\"e series\",50000)\n",
        "print(laptop1.apply_discount(5))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "47500.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5lbA45otiFcj",
        "outputId": "4882a038-6062-4c8e-d545-b5078989d8f9"
      },
      "source": [
        "class Laptop:\n",
        "    discount_percentage=10\n",
        "    def __init__(self,brand,model_name,price):\n",
        "        self.brand=brand\n",
        "        self.name=model_name\n",
        "        self.price=price\n",
        "        self.laptop_name=brand+ \" \"+ model_name\n",
        "    def apply_discount(self):\n",
        "        off_price =(Laptop.discount_percentage/100)*self.price\n",
        "        return self.price -off_price\n",
        "laptop1=Laptop(\"hp\",\"bcbc\",52545)\n",
        "laptop2=Laptop(\"apple\",\"mackbook\", 222222)\n",
        "print(laptop1.apply_discount())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "47290.5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9VKehfHhiFcj",
        "outputId": "2656d37d-8c00-417c-a327-b4f0bdad9a1e"
      },
      "source": [
        "class Laptop:\n",
        "    discount_percent=10\n",
        "    def __init__(self,brand,model_name,price):\n",
        "        self.brand=brand\n",
        "        self.name=model_name\n",
        "        self.price=price\n",
        "        self.laptop_name=brand+ \" \"+ model_name\n",
        "    def apply_discount(self):\n",
        "        off_price =(Laptop.discount_percent/100)*self.price\n",
        "        return self.price -off_price\n",
        "    \n",
        "laptop1=Laptop(\"hp\",\"bcbc\",63000)\n",
        "laptop2=Laptop(\"apple\",\"mackbook\", 23000)\n",
        "laptop2.discount_percent=50 \n",
        "print(laptop2.__dict__)\n",
        "print(laptop2.apply_discount())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "{'brand': 'apple', 'name': 'mackbook', 'price': 23000, 'laptop_name': 'apple mackbook', 'discount_percent': 50}\n",
            "20700.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vihd9AKeiFcj",
        "outputId": "bba96103-d1f4-445e-f12e-2177be6e70c9"
      },
      "source": [
        "class Person:\n",
        "    count_instance=1\n",
        "    def __init__(self,first_name,last_name,age):\n",
        "        self.first_name = first_name\n",
        "        self.last_name=last_name\n",
        "        self.age= age\n",
        "        \n",
        "p1=Person(\"ashish\",\"kumar\",24)\n",
        "print(Person.count_instance)\n",
        "    \n",
        "    "
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NkCkPPr1iFck",
        "outputId": "dedeaf06-66ef-47a0-c065-2fc849ac7c38"
      },
      "source": [
        "class Person:\n",
        "    count_instance=0\n",
        "    def __init__(self,first_name,last_name,age):\n",
        "        Person.count_instance += 1\n",
        "        self.first_name = first_name\n",
        "        self.last_name=last_name\n",
        "        self.age= age\n",
        "       \n",
        "    @classmethod\n",
        "    def from_string(cls,string):\n",
        "        first,last,age=string.split(\",\")\n",
        "        return cls(first,last,age)\n",
        "    @classmethod\n",
        "    \n",
        "    \n",
        "    def count_instances(cls):\n",
        "        print(\"you have created\",cls.count_instance,\"of\", cls.__name__)\n",
        "    def full_name(self):\n",
        "        return self.first_name, self.last_name\n",
        "    def is_above_18(self):\n",
        "        return self.age>18\n",
        "    \n",
        "p1=Person(\"ashish\",\"kumar\",24)\n",
        "p2=Person(\"rajat\",\"bakshi\",29)\n",
        "p3=Person.from_string(\"ashish,kumar,24\")\n",
        "print(p3.full_name())\n",
        "    \n",
        "    "
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "('ashish', 'kumar')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YYx5LE8CiFck",
        "outputId": "b456b0ab-fcfe-481e-ac45-9f6e6e9821d4"
      },
      "source": [
        "class Person:\n",
        "    count_instance=0\n",
        "    def __init__(self,first_name,last_name,age):\n",
        "        Person.count_instance += 1\n",
        "        self.first_name = first_name\n",
        "        self.last_name=last_name\n",
        "        self.age= age\n",
        "       \n",
        "    @classmethod\n",
        "    def from_string(cls,string):\n",
        "        first,last,age=string.split(\",\")\n",
        "        return cls(first,last,age)\n",
        "    \n",
        "    @staticmethod\n",
        "    def hello():\n",
        "        print(\"hellow this is static method\")\n",
        "    \n",
        "    @classmethod\n",
        "    \n",
        "    \n",
        "    def count_instances(cls):\n",
        "        print(\"you have created\",cls.count_instance,\"of\", cls.__name__)\n",
        "    def full_name(self):\n",
        "        return self.first_name, self.last_name\n",
        "    def is_above_18(self):\n",
        "        return self.age>18\n",
        "    \n",
        "p1=Person(\"ashish\",\"kumar\",24)\n",
        "p2=Person(\"rajat\",\"bakshi\",29)\n",
        "p3=Person.from_string(\"ashish,kumar,24\")\n",
        "print(p3.full_name())\n",
        "\n",
        "Person.hello()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "('ashish', 'kumar')\n",
            "hellow this is static method\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3SjUYFJZiFcl"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}