practice_problems.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "practice problems.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7c5MzrbW5Woy"
      },
      "source": [
        "Problems:\n",
        "https://www.programiz.com/python-programming/examples"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "k70OoI91H4Es",
        "outputId": "3a596632-765f-47f9-f511-8d9511c9ed83"
      },
      "source": [
        "from termcolor import colored, cprint\n",
        "\n",
        "print(colored(\"hello! Mim!!!\",'blue'))\n",
        "cprint(\"Hello! Mim!!!\",'red')\n",
        "cprint(\"Hello! Mim!!!\",'yellow')\n",
        "cprint(\"Hello! Mim!!!\",'green')\n",
        "cprint(\"Hello! Mim!!!\",'magenta')\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[34mhello! Mim!!!\u001b[0m\n",
            "\u001b[31mHello! Mim!!!\u001b[0m\n",
            "\u001b[33mHello! Mim!!!\u001b[0m\n",
            "\u001b[32mHello! Mim!!!\u001b[0m\n",
            "\u001b[35mHello! Mim!!!\u001b[0m\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1P6-irr5etm3",
        "outputId": "b4391a5d-2f00-483f-d2c6-20b328f9a371"
      },
      "source": [
        "#add two numbers\n",
        "\n",
        "x = input(\"enter a num:\")\n",
        "y = input(\"enter another num:\")\n",
        "\n",
        "sum = float(x) + float(y)\n",
        "\n",
        "print(\"sum of {0} and {1} is :{2} \".format(x, y, sum))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "enter a num:6\n",
            "enter another num:4\n",
            "sum of 6 and 4 is :10.0 \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4Clgf6Xwft7J",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2122196e-31d0-4e0f-d501-32d3899eaad6"
      },
      "source": [
        "#different method of adding two number  #different printing method\n",
        "\n",
        "print('The sum is %.1f' %(float(input('Enter first number: ')) + float(input('Enter second number: '))))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter first number: 3\n",
            "Enter second number: 5\n",
            "The sum is 8.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3OTpW3Dsi4IG",
        "outputId": "44d8ece4-15b9-4e16-95f3-db0b487b5c49"
      },
      "source": [
        "#adding two numbers   #different printing method\n",
        "\n",
        "x = input(\"num1 : \")\n",
        "y = input(\"num2 : \")\n",
        "sum = float(x) + float(y)\n",
        "\n",
        "print(\"sum is: \", sum)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "num1 : 3\n",
            "num2 : 6\n",
            "sum is:  9.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4xvBQcaamJa9",
        "outputId": "190e7dd1-5213-4e1f-e1e9-35dd89e533f9"
      },
      "source": [
        "#adding numbers and printing in a different method\n",
        "\n",
        "x = input(\"num1 : \")\n",
        "y = input(\"num2 : \")\n",
        "sum = float(x) + float(y)\n",
        "\n",
        "print(\"sum is: %0.2f \"%sum)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "num1 : 2\n",
            "num2 : 8\n",
            "sum is: 10.00 \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pn2ONPFljakg",
        "outputId": "b24a14c8-f590-46c5-cafd-4d794fd392aa"
      },
      "source": [
        "#finding square root of a number\n",
        "\n",
        "x = float(input(\"num: \"))\n",
        "\n",
        "sq_rt = float(x ** 0.5)\n",
        "\n",
        "print(\"square root of {0} is: {1}\".format(x,sq_rt))\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "num: 5\n",
            "square root of 5.0 is: 2.23606797749979\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BMveHqgOkash",
        "outputId": "98ae6491-de35-4f4f-d6d3-bc0f49283abb"
      },
      "source": [
        "#finding the square root a number #trying different printing method\n",
        "\n",
        "x = float(input(\"num: \"))\n",
        "\n",
        "root = float(x ** 0.5)\n",
        "\n",
        "print(\"root of %0.2f is %0.2f\"%(x,root))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "num: 6\n",
            "root of 6.00 is 2.45\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Y_0kXtG_llrT",
        "outputId": "bd0ddc10-c5ff-4a1a-90c2-29eb6a6ae6c8"
      },
      "source": [
        "#finding power of a number\n",
        "\n",
        "x = float(input(\"num: \"))\n",
        "\n",
        "pow = float(x ** 2)\n",
        "\n",
        "print(\"power of %0.2f is %0.2f : \"%(x, pow))\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "num: 9\n",
            "power of 9.00 is 81.00 : \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Uej7h89P1Nl5",
        "outputId": "cc69b87f-14bf-462d-8259-426bd7dd6f88"
      },
      "source": [
        "#multiplication of two numbers\n",
        "\n",
        "x = float(input(\"num1 : \"))\n",
        "y = float(input(\"num2: \"))\n",
        "\n",
        "mul = float(x*y)\n",
        "\n",
        "print(\"%0.2f x %0.2f is %0.2f: \"%(x,y,mul))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "num1 : 12\n",
            "num2: 65\n",
            "12.00 x 65.00 is 780.00: \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5rYSGMXalgP-",
        "outputId": "424822b3-b042-4464-b623-39a575e135db"
      },
      "source": [
        "#area and perimeter of a triangle\n",
        "\n",
        "a = float(input(\"side1 : \"))\n",
        "b = float(input(\"side2 : \"))\n",
        "c = float(input(\"side3 : \"))\n",
        "\n",
        "per = float(a + b + c)\n",
        "s = float(per / 2)\n",
        "area = float((s*(s-a)*(s-b)*(s-c))**2)\n",
        "\n",
        "print(\"area of triangle is: %0.2f\"%area)\n",
        "\n",
        "print(\"perimeter of trianlge is: %0.2f\"%per)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "side1 : 67\n",
            "side2 : 34\n",
            "side3 : 12\n",
            "area of triangle is: 352825976321.19\n",
            "perimeter of trianlge is: 113.00\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "c0ZepQUt4L2O",
        "outputId": "d3799a91-be5e-4582-97de-128c7bdd0b52"
      },
      "source": [
        "#area and perimeter of a square\n",
        "\n",
        "a = float(input(\"side1 : \"))\n",
        "\n",
        "area = float(a**2)\n",
        "per = float(4*a)\n",
        "\n",
        "print(\"area of a square is %0.2f and perimeter is %0.2f\"%(area,per))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "side1 : 33\n",
            "area of a square is 1089.00 and perimeter is 132.00\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SIicR-804v8d",
        "outputId": "7651d966-ea89-4152-b451-019928717821"
      },
      "source": [
        "#quadratic eqn by taking input\n",
        "#ax**2 + bx + c = 0\n",
        "#x = ( -b+- (b ** 2 - 4ac) ** 0.5) / 2a\n",
        "\n",
        "import cmath\n",
        "\n",
        "a = int(input(\"a : \"))\n",
        "b= int(input(\"b : \"))\n",
        "c= int(input(\"c: \"))\n",
        "\n",
        "d = (b**2) - (4*a*c)\n",
        "\n",
        "x1 = (-b+cmath.sqrt(d))/(2*a)\n",
        "x2 = (-b-cmath.sqrt(d))/(2*a)\n",
        "\n",
        "print(\"solution of {0}x^2 + {1}x + {2} is: x is either {3} or {4}\".format(a,b,c,x1,x2))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "a : 54\n",
            "b : 23\n",
            "c: 6\n",
            "solution of 54x^2 + 23x + 6 is: x is either (-0.21296296296296297+0.25643300785418943j) or (-0.21296296296296297-0.25643300785418943j)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ai3zOPvhZkt_",
        "outputId": "31b53cbe-b3c8-4fb7-9762-4a556ab46038"
      },
      "source": [
        "#quadratic equation #complex maths\n",
        "\n",
        "import cmath\n",
        "\n",
        "a = 3\n",
        "b = 6\n",
        "c = 2\n",
        "\n",
        "d = (b**2) - (4*a*c)\n",
        "\n",
        "x1 = (-b+cmath.sqrt(d))/(2*a)\n",
        "x2 = (-b-cmath.sqrt(d))/(2*a)\n",
        "\n",
        "print(\"solution of {0}x^2 + {1}x + {2} is: x is either {3} or {4}\".format(a,b,c,x1,x2))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "solution of 3x^2 + 6x + 2 is: x is either (-0.42264973081037427+0j) or (-1.5773502691896255+0j)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PF5GjA6kb0TI",
        "outputId": "ed728135-ab0f-4ba6-952b-27f0c456f0f7"
      },
      "source": [
        "#swapping two numbers\n",
        "\n",
        "a = input(\"a : \")\n",
        "b= input(\"b : \")\n",
        "\n",
        "temp = a\n",
        "a= b \n",
        "b = temp\n",
        "\n",
        "print(\" after swapping a is {0} and b is {1} \".format(a,b))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "a : 16\n",
            "b : 05\n",
            " after swapping a is 05 and b is 16 \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EWBwom-5cOMq",
        "outputId": "c27d42f6-191c-4266-fbd3-a61f31504405"
      },
      "source": [
        "#another method of swapping\n",
        "\n",
        "a = input(\"a : \")\n",
        "b= input(\"b : \")\n",
        "\n",
        "a,b = b, a \n",
        "\n",
        "print(\" after swapping a is {0} and b is {1} \".format(a,b))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "a : 45\n",
            "b : 24\n",
            " after swapping a is 24 and b is 45 \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9-_zTky5cb8j",
        "outputId": "c45db484-6505-4ccd-ac72-e788ca3bd5cc"
      },
      "source": [
        "#generate random num betn 0 - 9\n",
        "\n",
        "import random\n",
        "\n",
        "x = random.randint(0,9)\n",
        "\n",
        "print(\"first: \", x)\n",
        "\n",
        "print(\"again: \", random.randint(0,9))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "first:  6\n",
            "again:  8\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qd6d2_ePdmG3",
        "outputId": "12e5b837-8a25-4a8f-8b82-802b7b468a90"
      },
      "source": [
        "#generating random number between a given a range\n",
        "\n",
        "a = int(input(\"start range: \"))\n",
        "b = int(input(\"stop range: \"))\n",
        "\n",
        "print(\"num: \",random.randint(a,b))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "start range: 10\n",
            "stop range: 100\n",
            "num:  26\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TkfC71C1e6Ry",
        "outputId": "96d16c51-7849-4479-d79c-d7ae178a06b3"
      },
      "source": [
        "#conversion(km to miles)\n",
        "\n",
        "x = float(input(\"enter num: \"))\n",
        "\n",
        "#1km = 0.621371miles\n",
        "conv_fac = 0.621371\n",
        "i = x * conv_fac\n",
        "\n",
        "print(\"%0.2fkm equals to %0.2fmiles\"%(x,i))\n",
        "print(\"%0.2fkm equals to %0.2fmiles\"%(x,(x*conv_fac)))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "enter num: 237\n",
            "237.00km equals to 147.26miles\n",
            "237.00km equals to 147.26miles\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3G5_Zov4BPcN",
        "outputId": "261cca33-e7a6-4926-f14b-80dc2d07379b"
      },
      "source": [
        "#conversion(cm to ft)\n",
        "\n",
        "n = float(input(\"enter cm: \"))\n",
        "\n",
        "conv = 0.0328084\n",
        "\n",
        "i = n * conv\n",
        "\n",
        "print(n, \"cm = \",i, \"ft\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "enter cm: 3456\n",
            "3456.0 cm =  113.3858304 ft\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "K2736AeLf8eI",
        "outputId": "24ac990c-9970-4b27-f096-90dd2e02854d"
      },
      "source": [
        "#conversion(celsius to fahrenheit)\n",
        "\n",
        "x = float(input(\"enter celsius: \"))\n",
        "\n",
        "tconv_fac = 33.8\n",
        "\n",
        "faren = x * tconv_fac\n",
        "celsius = faren / tconv_fac\n",
        "\n",
        "print(\"%0.1f celsius equals to %0.1f fahrenheit\"%(x,faren))\n",
        "print(\"%0.1f fahrenheit equals to %0.1f celsius\"%(faren,celsius))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "enter celsius: 76\n",
            "76.0 celsius equals to 2568.8 fahrenheit\n",
            "2568.8 fahrenheit equals to 76.0 celsius\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VPVqBT4VCX8N",
        "outputId": "401b0d79-0f41-4b73-f4b5-f39947cb766b"
      },
      "source": [
        "#conversion(celsius to kelvin)\n",
        "\n",
        "n = float(input(\"enter temp: \"))\n",
        "\n",
        "conv_fact = 273.15\n",
        "\n",
        "temp = n + conv_fact\n",
        "\n",
        "print(\"{0} degree celsius is equals to {1} kelvin\".format(n,temp))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "enter temp: 34\n",
            "34.0 degree celsius is equals to 307.15 kelvin\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CT96BZan1a2E",
        "outputId": "75333467-370b-440d-e84d-f479cc576d3c"
      },
      "source": [
        "#check if a Number is Positive, Negative or 0\n",
        "\n",
        "x = float(input(\"num : \"))\n",
        "\n",
        "if x > 0:\n",
        "  print(\"%0.1f is pos\"%x)\n",
        "elif x < 0:\n",
        "  print(\"%0.1f is neg\"%x)\n",
        "else:\n",
        "  print(\"%0.1f is zero\"%x)  "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "num : 89\n",
            "89.0 is pos\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3i4JSbq42aBo",
        "outputId": "85618b48-eb82-4e5e-ed63-51e8a51d76d2"
      },
      "source": [
        "#whether a num is odd or Even\n",
        "\n",
        "x = float(input(\"num: \"))\n",
        "\n",
        "if (x%2==0):\n",
        "  print(\"even\")\n",
        "else:\n",
        "  print(\"odd\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "num: 37\n",
            "odd\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "m3AuxB2W3A0i",
        "outputId": "6c0f0bc5-6284-455a-ea22-937ed0e026ac"
      },
      "source": [
        "#finding which year is a leapyear\n",
        "\n",
        "year = int(input(\"enter year: \"))\n",
        "\n",
        "if (year % 4) == 0:\n",
        "  if (year % 100) == 0:\n",
        "    if (year % 400) == 0:\n",
        "      print(\"leap year\")\n",
        "    else: \n",
        "      print(\"not leap year\")\n",
        "  else: \n",
        "    print(\"leap year\")\n",
        "else: \n",
        "  print(\"not leap year\")  "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "enter year: 1995\n",
            "not leap year\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JaLAxS528dC3",
        "outputId": "c79ca881-846f-430b-fcd1-ff57aeb45cf4"
      },
      "source": [
        "#determining leap year by defining a function\n",
        "\n",
        "def leapyr(year):\n",
        "  if (year%4)==0:\n",
        "    if (year%100)==0:\n",
        "      if (year%400)==0:\n",
        "        return True\n",
        "      else:\n",
        "        return False\n",
        "    else:\n",
        "      return True\n",
        "  else:\n",
        "    return False\n",
        "\n",
        "year = int(input(\"enter year: \")) \n",
        "if leapyr(year):\n",
        "  print(\"leap year\")\n",
        "else:\n",
        "  print(\"not leap year\") "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "enter year: 2020\n",
            "leap year\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e4IgTXti9rbu",
        "outputId": "9656c9ee-9460-4b3d-8151-a827bd75f525"
      },
      "source": [
        "#largest num\n",
        "\n",
        "x = float(input(\"enter num1: \"))\n",
        "y = float(input(\"enter num2: \"))\n",
        "z = float(input(\"enter num3: \"))\n",
        "\n",
        "if (x >= y) and (x>=z):\n",
        "  print(\"%0.1f is largest\"%x)\n",
        "elif (y>=x) and (y>=z):\n",
        "  print(\"%0.1f is largest\"%y)\n",
        "else:\n",
        "  print(\"%0.1f is largest\"%z)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "enter num1: 64\n",
            "enter num2: 28\n",
            "enter num3: 43\n",
            "64.0 is largest\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "F0B-JDyg-h6i",
        "outputId": "6567c345-ff31-4aa4-cbef-414114937a7f"
      },
      "source": [
        "#prime or not prime using for...else\n",
        "\n",
        "x = int(input(\"enter num: \"))\n",
        "\n",
        "if x > 1:\n",
        "  for i in range(2,x):\n",
        "     if (x % i) == 0:\n",
        "       print(\"not prime\")\n",
        "       print(i,\"times\",x//i,\"is\",x)\n",
        "       break\n",
        "  else:\n",
        "    print(\"prime\")\n",
        "  \n",
        "else:\n",
        "  print(\"not prime\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "enter num: 5\n",
            "prime\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "miTF79xaeOyR",
        "outputId": "542ce99b-8f84-43e8-bf06-7e69906a2a4c"
      },
      "source": [
        "#factorial of a number using if_else and for loop\n",
        "\n",
        "num = int(input(\"num: \"))\n",
        "\n",
        "factorial = 1\n",
        "\n",
        "if num < 0:\n",
        "  print(\"neg num\")\n",
        "elif num == 0:\n",
        "  print(\"factorial is 1\")\n",
        "else:\n",
        "  for i in range(1,num+1):    #the range will stop in num\n",
        "    factorial = factorial * i\n",
        "  print(\"factorial of {0} is {1}\".format(num,factorial))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "num: 43\n",
            "factorial of 43 is 60415263063373835637355132068513997507264512000000000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TEh1nP0Jn9Cb",
        "outputId": "2598db16-3fa5-4e3e-db9c-bf2f034f8be6"
      },
      "source": [
        "#finding factorial of a number by defining a function\n",
        "\n",
        "import math\n",
        "\n",
        "def factorial(n):\n",
        "  return (math.factorial(n))\n",
        "\n",
        "num = int(input(\"num: \"))\n",
        "\n",
        "print(\"factorial of {0} is {1}\".format(num, factorial(num)))\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "num: 9\n",
            "factorial of 9 is 362880\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UNgCKuM9ogX7",
        "outputId": "1b77bf8f-b4b6-4936-c746-f186e0fb8eb1"
      },
      "source": [
        "#printing multi_table\n",
        "\n",
        "x = int(input(\"enter num: \"))\n",
        "\n",
        "for i in range(0,11):\n",
        "  print(x, \"x\", i, \"=\", x*i)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "enter num: 16\n",
            "16 x 0 = 0\n",
            "16 x 1 = 16\n",
            "16 x 2 = 32\n",
            "16 x 3 = 48\n",
            "16 x 4 = 64\n",
            "16 x 5 = 80\n",
            "16 x 6 = 96\n",
            "16 x 7 = 112\n",
            "16 x 8 = 128\n",
            "16 x 9 = 144\n",
            "16 x 10 = 160\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nsaiIouWFE1m",
        "outputId": "0bfe5131-69c6-48ca-bce4-01e6f13948f8"
      },
      "source": [
        "#fibonacci series\n",
        "#0, 1, 1, 2, 3, 5, 8\n",
        "\n",
        "terms = int(input(\"terms: \"))\n",
        "\n",
        "n1 = 0\n",
        "n2 = 1\n",
        "count = 0\n",
        "\n",
        "if terms < 0:\n",
        "  print(\"num is neg\")\n",
        "elif terms == 1:\n",
        "  print(n1)\n",
        "else:\n",
        "  print(\"series: \")\n",
        "  while (count<=terms):\n",
        "    print(n1)\n",
        "    x = n1 + n2\n",
        "    n1 = n2\n",
        "    n2 = x\n",
        "    count += 1\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "terms: 7\n",
            "series: \n",
            "0\n",
            "1\n",
            "1\n",
            "2\n",
            "3\n",
            "5\n",
            "8\n",
            "13\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WtlcgIBuITcT",
        "outputId": "71f5476a-f55c-44e8-e674-b3094efe221a"
      },
      "source": [
        "#getting the nth term of the fibonacci series\n",
        "\n",
        "def fib(n):\n",
        "  if n < 0:\n",
        "    print(\"neg\")\n",
        "  elif n == 0:\n",
        "    return 0\n",
        "  elif n == 1 or n == 2:\n",
        "    return 1\n",
        "  else:\n",
        "    return fib(n-1) + fib(n-2)\n",
        "\n",
        "\n",
        "n = int(input(\"enter term \"))\n",
        "print(\" {0} st/rd/th term of series is {1} \".format(n,fib(n)))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "enter term 16\n",
            " 16 st/rd/th term of series is 987 \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7vR7LkFhVrZ2",
        "outputId": "130e10a3-5e80-485f-def8-e1a27d76aced"
      },
      "source": [
        "#armstrong number (means e.g. 1634 = 1*1*1*1 + 6*6*6*6 + 3*3*3*3 + 4*4*4*4)\n",
        "\n",
        "num = int(input(\"num: \"))\n",
        "\n",
        "l = len(str(num))\n",
        "\n",
        "sum = 0\n",
        "\n",
        "temp = num\n",
        "\n",
        "while temp > 0:\n",
        "  d = temp % 10\n",
        "  sum += d ** l\n",
        "  temp //= 10\n",
        "\n",
        "if num == sum:\n",
        "  print(\"armstrong\")\n",
        "else:\n",
        "  print(\"not armstrong\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "num: 16661\n",
            "not armstrong\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "68PsTE_lD3JY",
        "outputId": "e8b7eef7-ffb2-4453-c2e7-93cf00a47fff"
      },
      "source": [
        "#finding the armstrong number between a range\n",
        "\n",
        "range1 = int(input(\"num: \"))\n",
        "range2 = int(input(\"num2: \"))\n",
        "print(\"armstrong num between {0} and {1} are: \".format(range1,range2))\n",
        "for num in range(range1,range2+1):\n",
        "\n",
        "\n",
        "  l = len(str(num))\n",
        "\n",
        "  sum = 0\n",
        "\n",
        "  temp = num\n",
        "\n",
        "  while temp > 0:\n",
        "    d = temp % 10\n",
        "    sum += d ** l\n",
        "    temp //= 10\n",
        "\n",
        "  if num == sum:\n",
        "    print(num)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "num: 10\n",
            "num2: 10000\n",
            "armstrong num between 10 and 10000 are: \n",
            "153\n",
            "370\n",
            "371\n",
            "407\n",
            "1634\n",
            "8208\n",
            "9474\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NfZc9uf1aB2s",
        "outputId": "da67fad0-dbfb-43d8-80b0-7cf42cf0bff6"
      },
      "source": [
        "#sum of natural num using while loop\n",
        "\n",
        "from time import time\n",
        "\n",
        "starting= time()\n",
        "\n",
        "num = float(input(\"num: \"))\n",
        "\n",
        "sum = 0\n",
        "\n",
        "while num > 0:\n",
        "  sum = sum + num\n",
        "  num = num - 1\n",
        "\n",
        "print(sum)\n",
        "\n",
        "ending = time()\n",
        "tt = ending - starting\n",
        "print(\"elapsed time: \",tt)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "num: 87356920\n",
            "3815615779621660.0\n",
            "elapsed time:  24.343109846115112\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TzDxktx2Wrt-",
        "outputId": "fa7bc7b2-8159-47bf-cfd9-39f2a86a50aa"
      },
      "source": [
        "#sum of natural numbers using for loop\n",
        "\n",
        "stt001 = time()\n",
        "\n",
        "num = int(input(\"num: \"))\n",
        "\n",
        "sum = 0\n",
        "\n",
        "for i in range(0,num+1):\n",
        "  sum = sum + i\n",
        "\n",
        "print(sum)\n",
        "\n",
        "end001 = time()\n",
        "\n",
        "time0_1 = end001 - stt001\n",
        "\n",
        "print(\"time: \",time0_1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "num: 87356920\n",
            "3815615779621660\n",
            "time:  15.559194326400757\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "z6B-O8OOcuua",
        "outputId": "bc7a35a4-7506-4a9c-d0ac-677db16837f5"
      },
      "source": [
        "#sum of digits by defining function and using while loop\n",
        "\n",
        "def sum(n):\n",
        "  sum = 0\n",
        "  while (n!=0):\n",
        "    sum = sum + (n%10)\n",
        "    n = n//10\n",
        "  return sum\n",
        "\n",
        "n = int(input(\"num: \"))\n",
        "print(sum(n))\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "num: 23456\n",
            "20\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-B1wXEv0kjgm",
        "outputId": "ead62afe-72f8-4f8e-9def-899528cf4370"
      },
      "source": [
        "#sum of digits by defining function and using for loop\n",
        "\n",
        "def sum(n):\n",
        "  sum = 0\n",
        "  for i in str(n):\n",
        "    sum += int(i)\n",
        "  return sum\n",
        "\n",
        "n = int(input(\"num: \"))\n",
        "print(\"sum: \",sum(n))  \n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "num: 367\n",
            "sum:  16\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tbOpczjhg4dr",
        "outputId": "252ae008-682a-4b8f-acd6-f27a4b5d4108"
      },
      "source": [
        "#power of a number using anonymous function\n",
        "\n",
        "n = int(input(\"terms: \"))\n",
        "\n",
        "pow = list(map(lambda x: 2 ** x,range(n)))\n",
        "\n",
        "for i in range(n):\n",
        "  print(\"2 to the power\", i, \"is: \",pow[i])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "terms: 4\n",
            "2 to the power 0 is:  1\n",
            "2 to the power 1 is:  2\n",
            "2 to the power 2 is:  4\n",
            "2 to the power 3 is:  8\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xCAR8et4s0iU",
        "outputId": "cb57c0ed-b32d-4af5-f252-e0a0d9a77a6f"
      },
      "source": [
        "#printing the powers of a number\n",
        "\n",
        "n = int(input(\"terms: \"))\n",
        "num = int(input(\"num: \"))\n",
        "pow = list(map(lambda x: num ** x,range(n)))\n",
        "\n",
        "for i in range(n):\n",
        "  print(num,\"to the power\", i, \"is: \",pow[i])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "terms: 3\n",
            "num: 3\n",
            "3 to the power 0 is:  1\n",
            "3 to the power 1 is:  3\n",
            "3 to the power 2 is:  9\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "s4eS-6lXtO93",
        "outputId": "d852d297-6e92-491f-fec0-3fd15c30ebc2"
      },
      "source": [
        "#multiplication table\n",
        "\n",
        "#n = input(\"num: \")\n",
        "\n",
        "tab = [lambda x=x: x*2 for x in range(0,11)]\n",
        "\n",
        "for table in tab:\n",
        "  print(table())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0\n",
            "2\n",
            "4\n",
            "6\n",
            "8\n",
            "10\n",
            "12\n",
            "14\n",
            "16\n",
            "18\n",
            "20\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GngBnYakwfVv",
        "outputId": "faffceb9-b071-4070-80a8-43a14a20d2d9"
      },
      "source": [
        "#printmax\n",
        "\n",
        "a = input(\"num1: \")\n",
        "b = input(\"num2: \")\n",
        "\n",
        "ma = lambda a,b: a if (a>b) else b\n",
        "\n",
        "print(ma(a,b))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "num1: 34\n",
            "num2: 65\n",
            "65\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "D1LiikjqY940",
        "outputId": "9135c1f5-eda8-4d72-d781-4805a7082465"
      },
      "source": [
        "#finding max using \"max\" function\n",
        "\n",
        "a = input(\"num1: \")\n",
        "b = input(\"num2: \")\n",
        "\n",
        "print(max(a,b))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "num1: 112\n",
            "num2: 4556\n",
            "4556\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oYs6ujB9Ge2c",
        "outputId": "f9198207-320e-42ab-8f27-4b4becfb41a2"
      },
      "source": [
        "#printmin\n",
        "\n",
        "a = input(\"num1: \")\n",
        "b = input(\"num2: \")\n",
        "\n",
        "mi = lambda a,b: a if(a<b) else b\n",
        "\n",
        "print(mi(a,b))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "num1: 908\n",
            "num2: 453\n",
            "453\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BSkLinnWZDXR",
        "outputId": "dce1429a-afb6-4254-fad2-3140a6b5fd0f"
      },
      "source": [
        "#print min using \"min\" function\n",
        "\n",
        "a = input(\"num1: \")\n",
        "b = input(\"num2: \")\n",
        "\n",
        "print(min(a,b))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "num1: 56\n",
            "num2: 16\n",
            "16\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aU2Fk8uRxTow",
        "outputId": "6bb28c40-66e2-49df-bbd1-ea893dc5ac22"
      },
      "source": [
        "#nums divisible by another num in a particular range\n",
        "\n",
        "n1 = int(input(\"start range: \"))\n",
        "n2 = int(input(\"stop range: \"))\n",
        "x = int(input(\"divisor: \"))\n",
        "print(\"num divisible by\",x,\"from\",n1,\"to\",n2, \"are:\")\n",
        "for i in range(n1,n2+1):\n",
        "  if (i%x) == 0:\n",
        "    print(i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "start range: 10\n",
            "stop range: 100\n",
            "divisor: 4\n",
            "num divisible by 4 from 10 to 100 are:\n",
            "12\n",
            "16\n",
            "20\n",
            "24\n",
            "28\n",
            "32\n",
            "36\n",
            "40\n",
            "44\n",
            "48\n",
            "52\n",
            "56\n",
            "60\n",
            "64\n",
            "68\n",
            "72\n",
            "76\n",
            "80\n",
            "84\n",
            "88\n",
            "92\n",
            "96\n",
            "100\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "30MivcyTKCE6",
        "outputId": "af620182-e626-451f-ec58-02b287aebba1"
      },
      "source": [
        "#numbers divisible by other number\n",
        "\n",
        "list12 = [10,12,34,56,92,45,23,80,30,75,48]\n",
        "\n",
        "d = int(input())\n",
        "div = list(filter(lambda x: (x % d == 0), list12))\n",
        "print(div)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5\n",
            "[10, 45, 80, 30, 75]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SZLJvXyzNAbX",
        "outputId": "c1d14b39-d341-4c94-b368-914f3fac17d2"
      },
      "source": [
        "#finding numbers divisible by another number by taking inputs\n",
        "\n",
        "list1 = []\n",
        "\n",
        "n = int(input(\"enter num of elements to put in list: \"))\n",
        "print(\"list: \")\n",
        "\n",
        "for i in range(0,n):\n",
        "  num = int(input())\n",
        "  list1.append(num) #to insert elements in the list\n",
        "d = int(input(\"enter divisor: \"))\n",
        "div = list(filter(lambda x: (x % d == 0),list1))\n",
        "print(div)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "enter num of elements to put in list: 5\n",
            "list: \n",
            "2\n",
            "5\n",
            "1\n",
            "0\n",
            "5\n",
            "enter divisor: 3\n",
            "[0]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qP1-l-A1R0Xr",
        "outputId": "466fbb22-a7a5-4e21-a95c-6e3711857b00"
      },
      "source": [
        "#creating list\n",
        "\n",
        "my_list = [int(item) for item in input(\"Enter the list items : \").split()]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter the list items : 1 3 5 6\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GieD54NrSKHL",
        "outputId": "2e01cbc7-de3f-4ca9-d7c4-458260c6f109"
      },
      "source": [
        "#dec to bin, hex, oct\n",
        "\n",
        "dec = int(input(\"enter decimal value: \"))\n",
        "\n",
        "b = bin(dec)\n",
        "h = hex(dec)\n",
        "o = oct(dec)\n",
        "\n",
        "print(dec,\"in bin: \",b)\n",
        "print(dec,\"in hex: \",h)\n",
        "print(dec,\"in oct: \",o)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "enter decimal value: 138664\n",
            "138664 in bin:  0b100001110110101000\n",
            "138664 in hex:  0x21da8\n",
            "138664 in oct:  0o416650\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OVgePPS1U-Ei",
        "outputId": "8c192229-6ce7-486a-dcab-c10b3a3643dc"
      },
      "source": [
        "#ascii value\n",
        "\n",
        "n =input()\n",
        "\n",
        "i = ord(n)\n",
        "\n",
        "print(\"ascii value of\",n,\"is: \",i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "t\n",
            "ascii value of t is:  116\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wWFLLVG6dZ5y",
        "outputId": "fd3b9196-7121-4caa-dab6-818723746598"
      },
      "source": [
        "n = 116\n",
        "print(chr(n))\n",
        "\n",
        "print(chr(ord('S')+1))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "t\n",
            "T\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AdwHBpD6WE26",
        "outputId": "4329ba6f-e684-4725-f6c2-c65ad1d71b4b"
      },
      "source": [
        "#ascii\n",
        "\n",
        "for i in range(0,6):\n",
        "  n = input()\n",
        "  asc = ord(n)\n",
        "  print(asc)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "t\n",
            "116\n",
            "a\n",
            "97\n",
            "h\n",
            "104\n",
            "m\n",
            "109\n",
            "i\n",
            "105\n",
            "m\n",
            "109\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GwWrWLusXJYz",
        "outputId": "e67f313a-86f0-44d8-9242-056dfe7a3d4b"
      },
      "source": [
        "#reversing string (color is just for fun)\n",
        "from termcolor import colored\n",
        "\n",
        "i = 'mimi'\n",
        "\n",
        "rev = list(reversed(i))\n",
        "\n",
        "print(colored(rev,'yellow'))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[33m['i', 'm', 'i', 'm']\u001b[0m\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "okcs6-tIdIs2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "97afd14e-a0a7-4988-9061-cbc05e76897c"
      },
      "source": [
        "#HCF\n",
        "\n",
        "import math\n",
        "\n",
        "a = int(input())\n",
        "b = int(input())\n",
        "\n",
        "x = math.gcd(a,b)\n",
        "\n",
        "print(\"HCF of\",a,\"and\",b,\"is:\",x)\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "347\n",
            "987\n",
            "HCF of 347 and 987 is: 1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pXWWlSt-CW6d",
        "outputId": "4f047e02-dee5-41d7-9c29-a7f5fd0161bc"
      },
      "source": [
        "#HCF\n",
        "\n",
        "def hcf(x,y):\n",
        "  if x<y:\n",
        "    sml = x\n",
        "  else:\n",
        "    sml = y\n",
        "  for i in range(1,sml+1):\n",
        "    if(x % i == 0) and (y % i == 0):\n",
        "      res = i\n",
        "  return res\n",
        "\n",
        "#hcf(47,34)\n",
        "a3 = int(input())\n",
        "b3 = int(input())\n",
        "hcf(a3,b3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "56\n",
            "29\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j6g8yLlExylO",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "156c9178-070a-4ad1-eb1f-23e11d7faaea"
      },
      "source": [
        "#LCM\n",
        "\n",
        "def lcm(x,y):\n",
        "  if x>y:\n",
        "    grt = x\n",
        "  else:\n",
        "    grt = y\n",
        "\n",
        "  while(True):\n",
        "    if (grt % x == 0) and (grt % y == 0):\n",
        "      res = grt\n",
        "      break\n",
        "    grt = grt + 1\n",
        "  return res\n",
        "\n",
        "a1 = int(input())\n",
        "b1 = int(input())\n",
        "lcm(a1,b1) \n",
        "#lcm(50,250)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "24\n",
            "56\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "168"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Cya__6UP8Prc",
        "outputId": "6bc4ac0f-4251-4132-d51c-97e7517513c4"
      },
      "source": [
        "#factors\n",
        "\n",
        "num = int(input(\"enter num: \"))\n",
        "print(\"factor of\",num,\"are:\")\n",
        "for i in range(1,num+1):\n",
        "  if (num%i)==0:\n",
        "    print(i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "enter num: 50\n",
            "factor of 50 are:\n",
            "1\n",
            "2\n",
            "5\n",
            "10\n",
            "25\n",
            "50\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vmFSvlHxBNJa",
        "outputId": "5aed5a4a-9969-4d8f-e302-b55853e7562d"
      },
      "source": [
        "#getting the factors of a number by defining a function\n",
        "\n",
        "def factor(num):\n",
        "  for i in range(1,num+1):\n",
        "    if num%i == 0:\n",
        "      print(i)\n",
        "\n",
        "n = int(input(\"Enter num to get factor:\"))\n",
        "factor(n)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter num to get factor:16\n",
            "1\n",
            "2\n",
            "4\n",
            "8\n",
            "16\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2TKAiWlDDkgk",
        "outputId": "a77d2eff-d55f-48ac-d356-1a5dfb62fa54"
      },
      "source": [
        "#calculator\n",
        "from termcolor import colored\n",
        "\n",
        "print(colored(\"***THIS IS A CALCULATOR***\",'red'))\n",
        "print(\"\\n\")\n",
        "print(\"The operators are: \")\n",
        "print(colored(\"ADD:1\",'blue'))\n",
        "print(colored(\"SUB:2\",'green'))\n",
        "print(colored(\"MUL:3\",'yellow'))\n",
        "print(colored(\"DIV:4\",'red'))\n",
        "print(\"\")\n",
        "while True:\n",
        "   x = input(\"Enter an option from (1,2,3,4):\")\n",
        "   print(\"\")\n",
        "   if x in ('1','2','3','4'):\n",
        "     n1 = float(input(\"Enter 1st operand:\"))\n",
        "     n2 = float(input(\"Enter 2nd operand:\"))\n",
        "     print(\" \")\n",
        "\n",
        "     if x == '1':\n",
        "       print(n1,\"+\",n2,\"=\",n1+n2)\n",
        "     elif x == '2':\n",
        "       print(n1,\"-\",n2,\"=\",n1-n2)\n",
        "     elif x == '3':\n",
        "       print(n1,\"*\",n2,\"=\",n1*n2)\n",
        "     elif x == '4':\n",
        "       print(n1,\"/\",n2,\"=\",n1/n2)\n",
        "     break\n",
        "   else:\n",
        "     print(colored(\"err\",'red'))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[31m***THIS IS A CALCULATOR***\u001b[0m\n",
            "\n",
            "\n",
            "The operators are: \n",
            "\u001b[34mADD:1\u001b[0m\n",
            "\u001b[32mSUB:2\u001b[0m\n",
            "\u001b[33mMUL:3\u001b[0m\n",
            "\u001b[31mDIV:4\u001b[0m\n",
            "\n",
            "Enter an option from (1,2,3,4):1\n",
            "\n",
            "Enter 1st operand:5\n",
            "Enter 2nd operand:9\n",
            " \n",
            "5.0 + 9.0 = 14.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kHOJB3A6K6wY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a174ef30-09da-441d-8120-b4f5e0c303e8"
      },
      "source": [
        "#shuffle cards\n",
        "import itertools, random\n",
        "\n",
        "cards = list(itertools.product(range(1,14),['Heart','Diamond','Clubs','Spade'])) #itertools.products will give cartesian products #range(1,14) as it will give the cards in range of only the 13 numbers excluding Ace\n",
        "\n",
        "random.shuffle(cards) #toshufflerandomly\n",
        "\n",
        "#for i in range(3):\n",
        "#  print(cards[i][0], \"of\", cards[i][1])\n",
        "print(cards[i][0], \"of\", cards[i][1])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4 of Diamond\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3u8Qe0n1uToO",
        "outputId": "a781e478-cd9d-4f10-fb35-fbf580b023f1"
      },
      "source": [
        "#calendar\n",
        "import calendar\n",
        "\n",
        "y = 2022\n",
        "m = 2\n",
        "\n",
        "print(calendar.month(y,m))\n",
        "#print(calendar.month(2020,2))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "   February 2022\n",
            "Mo Tu We Th Fr Sa Su\n",
            "    1  2  3  4  5  6\n",
            " 7  8  9 10 11 12 13\n",
            "14 15 16 17 18 19 20\n",
            "21 22 23 24 25 26 27\n",
            "28\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "E2C3IIKOug2o",
        "outputId": "10fda466-14d0-4866-cf6c-cadbfeeabdfc"
      },
      "source": [
        "#fibonacci using recursion\n",
        "# 0 1 1 2 3 5\n",
        "def fib(num):\n",
        "  if num == 0:\n",
        "    return 0\n",
        "  elif num == 1:\n",
        "    return 1\n",
        "  else:\n",
        "    return fib(num-1) + fib(num-2)\n",
        "n = int(input(\"enter no. of terms:\"))\n",
        "for i in range(n):\n",
        "  print(fib(i))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "enter no. of terms:5\n",
            "0\n",
            "1\n",
            "1\n",
            "2\n",
            "3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "k_vtiZBe3jBS",
        "outputId": "ce3d9472-2061-4567-b602-f9e85a857bf3"
      },
      "source": [
        "#sum of numbers using recursion\n",
        "\n",
        "def sum(num):\n",
        "  if num == 0:\n",
        "    return 0\n",
        "  else:\n",
        "    return num + sum(num-1)\n",
        "\n",
        "n = int(input())\n",
        "\n",
        "print(\"sum =\",sum(n))\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "16\n",
            "sum = 136\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lx4uKS6cDYTd",
        "outputId": "64cbba7a-2f27-4005-f14d-2b2caa830f12"
      },
      "source": [
        "#factorial using recursion\n",
        "\n",
        "def fact(num):\n",
        "  if num < 0:\n",
        "    return False\n",
        "  elif num == 0:\n",
        "    return 1\n",
        "  else:\n",
        "    return num * fact(num-1)\n",
        "\n",
        "n = int(input())\n",
        "\n",
        "print(fact(n))\n",
        "  "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "16\n",
            "20922789888000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mi5wyu9gERYG"
      },
      "source": [
        "#dec to bin using recursion\n",
        "\n",
        "def dectobin(num):\n",
        "  \n",
        " \n",
        "n = 34\n",
        "print(dectobin(n))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sODxEfDqKkvH",
        "outputId": "b3f760cd-a647-4514-ad34-f5aa1c4aa4d6"
      },
      "source": [
        "#adding two matrices\n",
        "\n",
        "x = [[1,5],[3,2]]\n",
        "y = [[6,2],[0,7]]\n",
        "res = [[0,0],[0,0]]\n",
        "\n",
        "for i in range(len(x)):\n",
        "  for j in range(len(x[0])):\n",
        "    res[i][j] = x[i][j] + y[i][j]\n",
        "\n",
        "print(res)\n",
        "\n",
        "for r in res:\n",
        "  print(r)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[7, 7], [3, 9]]\n",
            "[7, 7]\n",
            "[3, 9]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5AvQz-ccOx7D"
      },
      "source": [
        "#taking input #this will only give you nxn matrix\n",
        "#r = int(input())\n",
        "\n",
        "#x = []\n",
        "\n",
        "#for i in range(r):\n",
        "#  r1 = []\n",
        "#  for j in range(r):\n",
        "#    c1 = int(input())\n",
        "#    r1.append(c1)\n",
        "#  x.append(r1)\n",
        "#for r in x:\n",
        "#  print(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AaSwQKpkR5s8",
        "outputId": "acff1c12-71d6-405f-c69f-0207a64d8eb0"
      },
      "source": [
        "#multiplying two matrices\n",
        "\n",
        "x = [[1,5],[3,2]]\n",
        "y = [[6,2],[0,7]]\n",
        "res = [[0,0],[0,0]]\n",
        "\n",
        "for i in range(len(x)):                     #iterate through rows of x\n",
        "  for j in range(len(y[0])):                #iterate through columns of y\n",
        "    for k in range(len(y)):                 #itrate through rows of y\n",
        "      res[i][j] = x[i][k] * y[k][j]\n",
        "\n",
        "#print(res)\n",
        "\n",
        "for r in res:\n",
        "  print(r)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0, 35]\n",
            "[0, 14]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QRWncYnPEAzU",
        "outputId": "0675e375-4b4b-4868-e3bb-ec27b2c11b1d"
      },
      "source": [
        "#palindrome str\n",
        "\n",
        "str1 = list(input())\n",
        "str2 = list(reversed(str1))\n",
        "\n",
        "if str1 == str2:\n",
        "  print(\"palindrome\")\n",
        "else:\n",
        "  print(\"not palindrome\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "mim\n",
            "palindrome\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5IXrRD7-K7Wb",
        "outputId": "1f1ccd7a-273a-420f-9b3e-b7a40d5c141a"
      },
      "source": [
        "#just testing things(slicing list)\n",
        "\n",
        "list001 = [1,2,3,4,5,6,7,8,9,10]\n",
        "\n",
        "print(list001[::-1])\n",
        "print(list001[::2])\n",
        "print(list001[::-2])\n",
        "l = len(list001)\n",
        "print(list001[0])\n",
        "print(list001[l-1])\n",
        "print(list001[1:l-1])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]\n",
            "[1, 3, 5, 7, 9]\n",
            "[10, 8, 6, 4, 2]\n",
            "1\n",
            "10\n",
            "[2, 3, 4, 5, 6, 7, 8, 9]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "T8ZEiNqGQHw7",
        "outputId": "ac79e379-7a81-4737-c043-e7610f307a7a"
      },
      "source": [
        "#palindrome str and num\n",
        "\n",
        "def pal(s):\n",
        "  return s == s[::-1]\n",
        "\n",
        "str=input()\n",
        "if pal(str):\n",
        "  print(\"palindrome\")\n",
        "else:\n",
        "  print(\"not\")  "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "mimi\n",
            "not\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9yVuNMRORTFL",
        "outputId": "f76b7de2-8eaf-4773-c870-c49f0246e73c"
      },
      "source": [
        "#palindrome using recursion\n",
        "\n",
        "def palindrome(p):\n",
        "  l = len(p)\n",
        "  if l < 2:\n",
        "    return True\n",
        "  elif  p[0] == p[l-1]:\n",
        "    return p[1:l-1]\n",
        "  else:\n",
        "    return False\n",
        "\n",
        "str1 = input()\n",
        "\n",
        "if (palindrome(str1)):\n",
        "  print(\"palindrome\")\n",
        "else:\n",
        "  print(\"not\")\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "mim\n",
            "palindrome\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "D3nSxEigWi8a",
        "outputId": "36585373-b0b6-4a4c-c12e-888e9bd2015d"
      },
      "source": [
        "#removing punctuation from string\n",
        "\n",
        "punc = ',./[]{}()\":;?><\\!@#$%^&*-+=~`'\n",
        "\n",
        "string = \"hello !!! .... how are you ? .... okay! bye !!!\"\n",
        "n=\"\"\n",
        "for i in string:\n",
        "  if i not in punc:\n",
        "    n = n + i\n",
        "  else:\n",
        "    False\n",
        "\n",
        "print(n)\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "hello   how are you   okay bye \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qSxf0v3sypyx",
        "outputId": "a0bcd4de-50d2-482c-8a68-6fea3c83d04c"
      },
      "source": [
        "#removing punctuation from the string\n",
        "\n",
        "punc = ',./[]{}()\":;?><\\!@#$%^&*-+=~`'\n",
        "\n",
        "string = \"hello !!! .... how are you ? .... okay! bye !!!\"\n",
        "\n",
        "n = \"\"\n",
        "\n",
        "for i in string:\n",
        "  if i in punc:\n",
        "    False\n",
        "  else:\n",
        "    n = n + i\n",
        "print(n)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "hello   how are you   okay bye \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "g1YszEaDzOLL",
        "outputId": "c3723e2e-c83e-4718-8148-d044b3f030ae"
      },
      "source": [
        "#sorting words alphabetically\n",
        "\n",
        "string0 = \"Sorting Ele alphabetically, Let's see\"\n",
        "\n",
        "#so = [words.casefold() for words in string0.split()\n",
        "so = [words.lower() for words in string0.split()]         #we can use casefold() but better is to use lower()\n",
        "so.sort()\n",
        "wo = [string0.split()]\n",
        "wo.sort()\n",
        "\n",
        "print(string0.count('e'))  #counting number of alphabet in the string\n",
        "\n",
        "for s in so:\n",
        "  print(s, end = \" \")\n",
        "print(\"\")\n",
        "for w in wo:\n",
        "  print(w)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5\n",
            "alphabetically, ele let's see sorting \n",
            "['Sorting', 'Ele', 'alphabetically,', \"Let's\", 'see']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0ymPuvu38Zqx",
        "outputId": "0cb3dfb5-570e-4c29-fd98-dc43c5ae4bd9"
      },
      "source": [
        "saw = \"12345667\"\n",
        "saw1 = \"abcdef\"\n",
        "\n",
        "print(saw.isnumeric())  #checking if the string is num or not\n",
        "print(saw1.isnumeric())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_KzFsX3H-gkQ",
        "outputId": "f0955d85-3913-4702-b86a-a7fbf614f653"
      },
      "source": [
        "#set operations\n",
        "\n",
        "A = {'1','3','4','7','2'}\n",
        "B = {'3','9','2'}\n",
        "C = {'3','8','4','1','0','2'}\n",
        "\n",
        "A.add('8')\n",
        "B.add('8')\n",
        "A.remove('3')\n",
        "\n",
        "inter = A & B & C\n",
        "uni = A | B | C\n",
        "\n",
        "\n",
        "print(inter)\n",
        "print(\"\")\n",
        "print(uni)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'2', '8'}\n",
            "\n",
            "{'7', '1', '3', '9', '8', '4', '2', '0'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9SfMBP6zAfeb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4df91624-5ae4-4616-8acb-eb9e7842405b"
      },
      "source": [
        "#count num of vowels\n",
        "\n",
        "vowels = ('aeiou')\n",
        "\n",
        "stro = input().lower()\n",
        "#stro = stro.lower()\n",
        "\n",
        "count = {}.fromkeys(vowels,0)   #fromkeys is a dict func returns the dictionary with key mapped with specific value\n",
        "\n",
        "for s in stro:\n",
        "  if s in count:\n",
        "    count[s] += 1\n",
        "print(count)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "iedrjdbavcouerncgftsjsla\n",
            "{'a': 2, 'e': 2, 'i': 1, 'o': 1, 'u': 1}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GeNfxXGjIsLC",
        "outputId": "2ca0c6dc-2f31-4b24-b0a8-e194471a5c03"
      },
      "source": [
        "#test\n",
        "\n",
        "owels = ('aeiou')\n",
        "cout = {}.fromkeys(owels,0)\n",
        "print(cout)\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'a': 0, 'e': 0, 'i': 0, 'o': 0, 'u': 0}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2b6i3YTWg2Fy"
      },
      "source": [
        "#merge mails\n",
        "\n",
        "with open('name.txt','r',encoding = 'utf-8') as namefile: #\n",
        "  with open('body.txt','r',encoding='utf-8') as bodyfile:\n",
        "    body = bodyfile.read()\n",
        "    for name in namefile:\n",
        "      mail = \"Hello\" + name.strip() + \"\\n\" + body\n",
        "      with open(name.strip()+\".txt\", 'w', encoding='utf-8') as mailfile:\n",
        "                mailfile.write(mail)\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AOGIkrtZyakY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "954a2003-4a4b-45a2-e19d-a2c30cf1e30f"
      },
      "source": [
        "#pillow i.e python imaging library (PIL) is the image processing package in python\n",
        "\n",
        "!pip install pillow\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: pillow in /usr/local/lib/python3.7/dist-packages (7.1.2)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fHWNaRgSUxvc"
      },
      "source": [
        "#all about image\n",
        "\n",
        "from PIL import Image\n",
        "\n",
        "img = Image.open(r\"/content/Screenshot (7).png\")\n",
        "img.show()    #to print/show the img"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eDACd8aiV1JH",
        "outputId": "d5de892b-8289-489a-85d5-62aed7e2ff7c"
      },
      "source": [
        "print(img)    #gives the details of the image\n",
        "print(\"\")\n",
        "print(img.mode)   #getting the color mode of img\n",
        "print(\"\")\n",
        "print(img.size)   #to print the size of img i.e returns a tuple that conains width and height\n",
        "print(\"\")\n",
        "print(img.format)   #to get the format of the img\n",
        "\n",
        "##to rotate the image ->\n",
        "\n",
        "#ang = 40\n",
        "#r_img = img.rotate(ang)\n",
        "#r_img.show()\n",
        "\n",
        "##to resize the image ->\n",
        "\n",
        "#size = (width , height)\n",
        "#sz = (60,90)\n",
        "#s_img = img.resize(sz)\n",
        "#s_img.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<PIL.PngImagePlugin.PngImageFile image mode=RGBA size=1920x1080 at 0x7FAC7C50B550>\n",
            "\n",
            "RGBA\n",
            "\n",
            "(1920, 1080)\n",
            "\n",
            "PNG\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "T90R2QHgY4IS",
        "outputId": "6c629268-5210-4904-83d8-e7975a25745c"
      },
      "source": [
        "#finding the resolution of image\n",
        "\n",
        "img = Image.open(r\"/content/Screenshot (7).png\")\n",
        "\n",
        "w,h=img.size\n",
        "\n",
        "print(w,\"x\",h)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1920 x 1080\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IRqMjFGMZWuR",
        "outputId": "3ae50349-6135-4dc5-9c4a-3b92165f5e81"
      },
      "source": [
        "#another way of finding the resolution of the img\n",
        "\n",
        "w1 = img.size[0]\n",
        "h1 = img.size[1]\n",
        "\n",
        "print(w1,\"x\",h1)    "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1920 x 1080\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7DNcc84nZqD5",
        "outputId": "be8fdf79-0e91-4237-d4ff-f051b8530d5f"
      },
      "source": [
        "#we can also find the resolution of the image using OpenCV\n",
        "\n",
        "import cv2\n",
        "\n",
        "img1 = cv2.imread(\"/content/Screenshot (7).png\")\n",
        "\n",
        "print(img1.shape)   #this returns the size of the img as (h,w)\n",
        "\n",
        "w0 = img1.shape[1]\n",
        "h0 = img1.shape[0]\n",
        "\n",
        "print(\"\")\n",
        "print(w0,\"x\",h0)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(1080, 1920, 3)\n",
            "\n",
            "1920 x 1080\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ew8YLypYbnYj",
        "outputId": "c1a5396a-f7d9-4b83-bf89-33cf4061fd7d"
      },
      "source": [
        "#find hash of a file\n",
        "#we are doing hash type SHA-1 and MD5\n",
        "\n",
        "import hashlib\n",
        "\n",
        "def hash(file):\n",
        "  h1 = hashlib.sha1()\n",
        "\n",
        "  with open(file,'rb') as ffl:\n",
        "\n",
        "    ct = 0\n",
        "    while ct != b'':\n",
        "      ct = ffl.read(1024)\n",
        "      h1.update(ct)\n",
        "    return h1.hexdigest()\n",
        "\n",
        "txt = hash(\"/content/mimimimimi.txt\")\n",
        "print(txt)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "952b1414161e50d2d60b68d0967dfa2cb9ccbc77\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lsxsXyn5i_Fn",
        "outputId": "3fcbf763-5f6d-4354-da4d-985511906a56"
      },
      "source": [
        "def hash1(file1):\n",
        "  h2 = hashlib.md5()\n",
        "\n",
        "  with open(file1,'rb') as f:\n",
        "    ch = 0\n",
        "    while ch != b'':\n",
        "      ch = f.read(1024)\n",
        "      h2.update(ch)\n",
        "    return h2.hexdigest()\n",
        "\n",
        "txt2 = hash1(\"/content/mimimimimi.txt\")\n",
        "print(txt2)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "ef80c209a1070741ba8da3cbdefcaa8a\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gYVkGoPTj94X",
        "outputId": "5dea7470-c301-4069-e299-6413975c2aba"
      },
      "source": [
        "#making pyramid or triangle pattern\n",
        "\n",
        "ro = int(input())\n",
        "\n",
        "for i in range(ro):\n",
        "  for j in range(i+1):\n",
        "    print(\"* \",end = \"\")\n",
        "  print(\"\\n\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n",
            "* \n",
            "\n",
            "* * \n",
            "\n",
            "* * * \n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3mbvkQyAn1h9",
        "outputId": "28755748-b7d4-44af-90c1-9223885cd66d"
      },
      "source": [
        "#printing inverted triangle pattern\n",
        "\n",
        "r4 = int(input())\n",
        "\n",
        "for i in range(r4,0,-1):\n",
        "  for j in range(1,i+1):\n",
        "    print(\"* \",end = \"\")\n",
        "  print(\"\\n\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n",
            "* * * \n",
            "\n",
            "* * \n",
            "\n",
            "* \n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "awojjmlhpWZJ",
        "outputId": "8bb74aef-aec3-4a11-b8dd-80030b609a60"
      },
      "source": [
        "#printing pyramid pattern with alphabets\n",
        "\n",
        "rows = int(input())\n",
        "\n",
        "a = 65\n",
        "\n",
        "for i in range(rows):\n",
        "  for j in range(i+1):\n",
        "    alph = chr(a)\n",
        "    print(alph,end=\"\")\n",
        "  a += 1\n",
        "  print(\"\\n\")\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5\n",
            "A\n",
            "\n",
            "BB\n",
            "\n",
            "CCC\n",
            "\n",
            "DDDD\n",
            "\n",
            "EEEEE\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a4LUjRenEPu-"
      },
      "source": [
        "#printing pyramid pattern\n",
        "\n",
        "rows = int(input())\n",
        "\n",
        "k = 0\n",
        "\n",
        "for i in range(1, rows+1):\n",
        "    for j in range(1, (rows-i)+1):\n",
        "        print(end=\"  \")\n",
        "   \n",
        "    while k!=(2*i-1):\n",
        "        print(\"* \", end=\"\")\n",
        "        k += 1\n",
        "   \n",
        "    k = 0\n",
        "    print()\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w0GMJ0fr2Oko"
      },
      "source": [
        "#printing diamond pattern\n",
        "\n",
        "def pat(row):\n",
        "    n = 0\n",
        "    for i in range(1,row+1):\n",
        "      for j in range(1,(row-i)+1):\n",
        "        print(end= \"  \")\n",
        "\n",
        "      while n != (2*i-1):\n",
        "        print(\"*\",end= \" \")\n",
        "        n = n + 1\n",
        "      n = 0\n",
        "      print()\n",
        "\n",
        "    k = 1\n",
        "    n = 1\n",
        "\n",
        "    for i in range(1,row):\n",
        "      for j in range(1,k+1):\n",
        "        print(end = \"  \")\n",
        "      k = k + 1\n",
        "\n",
        "      while n <= (2*(row-i)-1):\n",
        "        print(\"*\", end = \" \")\n",
        "        n = n + 1\n",
        "      n = 1\n",
        "      print()\n",
        "\n",
        "#r = 4\n",
        "pat(3)    "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HdbXpnrnH9ml",
        "outputId": "c9c7ee33-7ca4-480f-c018-af3a0ec85be5"
      },
      "source": [
        "#merging two dictionaries\n",
        "\n",
        "dict1 = {1 : 'a',2:'b',3:'c',4:'j',5:'g'}\n",
        "dict2 = {2:'t',7:'s',8:'m'}\n",
        "dict3 = {1:'t',4:'y'}\n",
        "\n",
        "print({**dict1, **dict2, **dict3})   # '**' by using this we unpack he dictionaries and then merge them by placing inside the curly brackets{}\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{1: 't', 2: 't', 3: 'c', 4: 'y', 5: 'g', 7: 's', 8: 'm'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "t3C03cY6PqHQ",
        "outputId": "b6f25d14-3c69-4e68-bf97-f26a5862e8e6"
      },
      "source": [
        "#exception handling\n",
        "\n",
        "n0 = [0,1,2]\n",
        "\n",
        "try:\n",
        "  print(n0[1])\n",
        "\n",
        "  print(n0[3])\n",
        "except:\n",
        "  print(\"ERR\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "ERR\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CASa6WW6el59",
        "outputId": "d8adb01c-4509-4fa5-df09-f7bc10d25f44"
      },
      "source": [
        "#try_except\n",
        "\n",
        "try:\n",
        "\n",
        "  a = 0\n",
        "  b = 2\n",
        "  print(b%a)\n",
        "\n",
        "except Exception as e:\n",
        "  print(e)\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "integer division or modulo by zero\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Of6iYOMrnB93",
        "outputId": "f3bf13be-53a6-487d-d2df-d7a8f7c07a82"
      },
      "source": [
        "#exception_handling\n",
        "\n",
        "import sys\n",
        "\n",
        "n01 = ['a',0,2]\n",
        "\n",
        "for i in n01:\n",
        "  try:\n",
        "    print(i)\n",
        "    print(\"reciprocal of\",i,\"is\", 1/int(i))\n",
        "  except:\n",
        "    print(sys.exc_info()[0])    #this will throw an exception error message if the item cannot be divided by int\n",
        "    print()\n",
        "#print(\"reciprocal of\",i,\"is\",rec)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "a\n",
            "<class 'ValueError'>\n",
            "\n",
            "0\n",
            "<class 'ZeroDivisionError'>\n",
            "\n",
            "2\n",
            "reciprocal of 2 is 0.5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Uyo-4m4Xo1wl",
        "outputId": "f6ae6440-2aca-40b4-c09d-c576ea0c4d0b"
      },
      "source": [
        "#exception_handling\n",
        "\n",
        "def num(n1,n2):\n",
        "  if n1>n2:\n",
        "    res = n1/n2\n",
        "  print(res)\n",
        "try:\n",
        "  num(4,5)\n",
        "except:\n",
        "  print(\"ERR\")\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "ERR\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OhJba2aENC8c"
      },
      "source": [
        "#creating nested directory\n",
        "#we can use pathlib.Path.mkdir\n",
        "\n",
        "from pathlib import Path\n",
        "\n",
        "ff10 = Path(\"root/dir1/dir2\").mkdir(parents = True, exist_ok = True)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rS_q7aHSkg49",
        "outputId": "3dcefb44-0678-45c0-c10c-0c486c4aca4b"
      },
      "source": [
        "#access index of a list using for loop\n",
        "#using enumerate() as it returns both the values and index from a list\n",
        "\n",
        "lst22 = [2,3,5,7,1,0,4,10]\n",
        "\n",
        "for i,j in enumerate(lst22):\n",
        "  print(\"index:\",i,\"value:\",j)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "index: 0 value: 2\n",
            "index: 1 value: 3\n",
            "index: 2 value: 5\n",
            "index: 3 value: 7\n",
            "index: 4 value: 1\n",
            "index: 5 value: 0\n",
            "index: 6 value: 4\n",
            "index: 7 value: 10\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pcnnvjJlmlpI",
        "outputId": "db9c444d-3395-4ce9-8b91-886ec32724b2"
      },
      "source": [
        "#without using enumerate\n",
        "\n",
        "lst23 = [1,4,8,2,0,12,10]\n",
        "\n",
        "for v in range(len(lst23)):\n",
        "  j = lst23[v]\n",
        "  print(\"index:\",v,\"value:\",j)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "index: 0 value: 1\n",
            "index: 1 value: 4\n",
            "index: 2 value: 8\n",
            "index: 3 value: 2\n",
            "index: 4 value: 0\n",
            "index: 5 value: 12\n",
            "index: 6 value: 10\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "o57J9t6Qn6K2",
        "outputId": "542d2b9b-44a8-4a43-b511-40501ce1c13a"
      },
      "source": [
        "#make a flattened list from a nested list\n",
        "\n",
        "import itertools\n",
        "\n",
        "lst24 = [[1,2],[10,16,3],[2]]\n",
        "lst25 = []\n",
        "#print(lst24)\n",
        "\n",
        "for val in lst24:\n",
        "  for num in val:\n",
        "    lst25.append(num)\n",
        "print(lst25)\n",
        "\n",
        "flist = list(itertools.chain(*lst24))\n",
        "print(flist)\n",
        "\n",
        "slist = sum(lst24,[])\n",
        "print(slist)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 2, 10, 16, 3, 2]\n",
            "[1, 2, 10, 16, 3, 2]\n",
            "[1, 2, 10, 16, 3, 2]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tCZFoNCovFm_",
        "outputId": "9ba164bc-1f1c-4c0f-db4e-a923c7e4902a"
      },
      "source": [
        "#slice list\n",
        "\n",
        "lst28 = [1,2,3,4,5,6,7,8,9,10]\n",
        "\n",
        "slst = lst28[1:4]   #it will include index 1 but not 4\n",
        "slst1 = lst28[4:]\n",
        "slst2 = lst28[:3]\n",
        "slst3 = lst28[:]\n",
        "print(slst)\n",
        "print(slst1)\n",
        "print(slst2)\n",
        "print(slst3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[2, 3, 4]\n",
            "[5, 6, 7, 8, 9, 10]\n",
            "[1, 2, 3]\n",
            "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "q9qp2rz0wVuF",
        "outputId": "670614b2-82cd-44bf-c689-76003e6949a3"
      },
      "source": [
        "#iterate over dictionaries using for loop\n",
        "#using items()\n",
        "\n",
        "dict12 = {1:'t',2:'a',3:'h'}\n",
        "\n",
        "for i,j in dict12.items():    #items() returns both the key and value\n",
        "  print(i,j)\n",
        "print(\"\")\n",
        "for k in dict12:\n",
        "  print(k)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1 t\n",
            "2 a\n",
            "3 h\n",
            "\n",
            "1\n",
            "2\n",
            "3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eVrDQFZFEbKE",
        "outputId": "ca58b361-12f0-4de5-d62e-a4ef099fa4ac"
      },
      "source": [
        "#iterate over dictionaries\n",
        "\n",
        "dict13= {'a':'aa','b':'bb','c':'cc','d':'dd'}\n",
        "\n",
        "for i in dict13:\n",
        "  print(i,dict13[i])\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "a aa\n",
            "b bb\n",
            "c cc\n",
            "d dd\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "63xX1TqYFnGD",
        "outputId": "62490d8c-319f-4ade-c3d2-dd089c2590e1"
      },
      "source": [
        "#sort a dictionary by value\n",
        "\n",
        "dict14 = {1:'t',2:'a',3:'h',4:'m',5:'i',6:'m'}\n",
        "\n",
        "sdict = sorted(dict14.values())\n",
        "print(sdict)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['a', 'h', 'i', 'm', 'm', 't']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bIf3O9PcJLJC",
        "outputId": "ae686e81-0e92-49b7-d750-528220baa1f9"
      },
      "source": [
        "#sorting dict\n",
        "\n",
        "dict15 = {'t':'twinkle','a':'aurora','h':'honey','m':'mew','i':'icecream','m':'minie'}\n",
        "\n",
        "print(sorted(dict15.values()))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['aurora', 'honey', 'icecream', 'minie', 'twinkle']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PKj7XoKNKO5U",
        "outputId": "46fdf5c4-b5fc-4c7f-ae51-6c0bdfdc4a13"
      },
      "source": [
        "#check if a list is empty\n",
        "\n",
        "lst00 = [2,6,1,0,5]\n",
        "lst001 = []\n",
        "\n",
        "print(\"list 1: \",lst00)\n",
        "if not lst00:\n",
        "  print(\"empty\")\n",
        "else:\n",
        "  print(\"not empty\")\n",
        "\n",
        "print(\"list 2: \",lst001)\n",
        "if lst001 == []:\n",
        "  print(\"empty\")\n",
        "else:\n",
        "  print(\"not empty\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "list 1:  [2, 6, 1, 0, 5]\n",
            "not empty\n",
            "list 2:  []\n",
            "empty\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2qqBV6WIPtxv",
        "outputId": "0275f82e-a6aa-4e12-b760-0446f56720a0"
      },
      "source": [
        "lst00 = [2,6,1,0,5]\n",
        "lst001 = []\n",
        "\n",
        "print(\"list1: \",lst00)\n",
        "if (len(lst00)) == 0:\n",
        "  print(\"empty\")\n",
        "else:\n",
        "  print(\"not empty\")\n",
        "\n",
        "print(\"list2: \",lst001)\n",
        "if not (len(lst001)):\n",
        "  print(\"empty\")\n",
        "else:\n",
        "  print(\"not empty\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "list1:  [2, 6, 1, 0, 5]\n",
            "not empty\n",
            "list2:  []\n",
            "empty\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cmBCPESPPlI5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9d4d2e8a-b4f1-4dab-9095-211f3e4c52ca"
      },
      "source": [
        "#catch multiple exceptions in one line\n",
        "\n",
        "str2 = input()\n",
        "\n",
        "try:\n",
        "  i2 = int(input())\n",
        "  print(str2+i2)\n",
        "\n",
        "except (TypeError, ValueError) as err:\n",
        "  print(err)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "m\n",
            "16\n",
            "can only concatenate str (not \"int\") to str\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RIP_X3miFzIe",
        "outputId": "ad9f6294-306f-4403-ab15-6488bcf9a18e"
      },
      "source": [
        "#catching exceptions\n",
        "\n",
        "try:\n",
        "  f3 = open(\"file.txt\",'w')\n",
        "  f3.write(\"what?\")\n",
        "except IOError:\n",
        "  print(\"file not available\")\n",
        "else:\n",
        "  print(\"file written done\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "file written done\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "05afsqFcH60i",
        "outputId": "d66b3395-92a3-4c52-e0d1-caf40ea05cbb"
      },
      "source": [
        "#exception handling\n",
        "\n",
        "try:\n",
        "  f8 = open(\"text.txt\",\"r\")   #it is reading the file here\n",
        "  f8.write(\"nothing\")     #bt here we are trying to write in the file\n",
        "except IOError:\n",
        "  print(\"err\")\n",
        "else:\n",
        "  print(\"done\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "err\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8NDPirlqHlRB",
        "outputId": "3566aee2-1f4d-4832-f855-d5a978c3cae1"
      },
      "source": [
        "#exception handling\n",
        "\n",
        "try:\n",
        "  inp = int(input())\n",
        "  inp2 = int(input())\n",
        "\n",
        "  div = inp/inp2\n",
        "\n",
        "except ZeroDivisionError:\n",
        "  print(\"ERR\")\n",
        "\n",
        "else:\n",
        "  print(div)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "20\n",
            "0\n",
            "ERR\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aiepBp3VLCUi",
        "outputId": "1c6f35f6-b39a-483e-8391-fb83a6ffe11d"
      },
      "source": [
        "#exception handling\n",
        "\n",
        "try:\n",
        "  inp = int(input())\n",
        "  inp2 = int(input())\n",
        "\n",
        "  div = inp/inp2\n",
        "  print(div)\n",
        "\n",
        "except ZeroDivisionError:\n",
        "  print(\"ERR\")\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "8\n",
            "0\n",
            "ERR\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "L6JgXGApL7PI",
        "outputId": "407e0c7b-c17b-4a51-fe01-4e40fa91920e"
      },
      "source": [
        "#user defined exceptions\n",
        "\n",
        "class Error(Exception):   #base class for other exceptions\n",
        "  pass\n",
        "\n",
        "class NegValueError(Error):    #\n",
        "  pass\n",
        "class BigValueError(Error):\n",
        "  pass\n",
        "\n",
        "try:\n",
        "  inp01 = int(input())\n",
        "  \n",
        "  if (inp01 > 5000):\n",
        "    raise BigValueError\n",
        "\n",
        "  elif (inp01 < 0):\n",
        "    raise NegValueError\n",
        "\n",
        "except BigValueError:\n",
        "  print(\"big value err\")\n",
        "\n",
        "except NegValueError:\n",
        "  print(\"neg value err\")\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "-6\n",
            "neg value err\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RF8D-BhhOy57",
        "outputId": "5048db83-0050-4e2e-bab7-e60c62cb00c9"
      },
      "source": [
        "#another user defined exception\n",
        "\n",
        "class Error(Exception):\n",
        "  pass\n",
        "class LargeValueError(Error):\n",
        "  pass\n",
        "class SmallValueError(Error):\n",
        "  pass\n",
        "\n",
        "num = 50\n",
        "\n",
        "while(True):\n",
        "\n",
        "  try:\n",
        "    inp9 = int(input())\n",
        "\n",
        "    if (inp9>num):\n",
        "      raise LargeValueError\n",
        "    elif (inp9<num):\n",
        "      raise SmallValueError\n",
        "    break\n",
        "\n",
        "  except LargeValueError:\n",
        "    print(\"value too large\")\n",
        "  except SmallValueError:\n",
        "    print(\"Value too small\")\n",
        "\n",
        "print(\"correct\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "15\n",
            "Value too small\n",
            "70\n",
            "value too large\n",
            "36\n",
            "Value too small\n",
            "67\n",
            "value too large\n",
            "40\n",
            "Value too small\n",
            "60\n",
            "value too large\n",
            "50\n",
            "correct\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "i3IuNVf2YwWX",
        "outputId": "cff925aa-a957-4109-f490-7f76123eb492"
      },
      "source": [
        "#exception handling\n",
        "\n",
        "try:\n",
        "  num7 = int(input())\n",
        "except ValueError:\n",
        "  print(\"ERR\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "d\n",
            "ERR\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0z4iQh5zxBkb",
        "outputId": "f80f5ee0-2ef6-4af8-e0ef-16b060b936f8"
      },
      "source": [
        "#exception handling\n",
        "\n",
        "import os\n",
        "\n",
        "try:\n",
        "  makedirs(\"root/dir1/dir2\")\n",
        "except:\n",
        "  print(\"File Exist\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "File Exist\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "eFrvbfffUdrT",
        "outputId": "309f6dce-c09d-4c92-e2d4-029493b319f2"
      },
      "source": [
        "#copy a file\n",
        "#we can copy a file using copyfile(), copy(), copyfileobj()\n",
        "\n",
        "from shutil import copyfile\n",
        "\n",
        "copyfile(\"/content/nop.txt\",\"/content/name.txt\")    #the contents of 1st file will be copied to 2nd file"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'/content/name.txt'"
            ]
          },
          "metadata": {},
          "execution_count": 80
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "M0e-khx7saSi",
        "outputId": "782aca71-9043-4c0b-f4fc-cedba6f83eff"
      },
      "source": [
        "#concatenate two lists\n",
        "#we can use 'list1.extend(list2)' here all the elements of list 2 will be added to list1\n",
        "\n",
        "a = [1,3,7]\n",
        "b = [9,0,17]\n",
        "\n",
        "a.extend(b)\n",
        "print(a)\n",
        "\n",
        "c = ['a','b','c']\n",
        "d = [1,5,10]\n",
        "\n",
        "print(c+d)\n",
        "\n",
        "print(*c,*d)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 3, 7, 9, 0, 17]\n",
            "['a', 'b', 'c', 1, 5, 10]\n",
            "a b c 1 5 10\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "K7OlWtSKuXFy",
        "outputId": "663e0b44-4fce-406a-bc8e-1bd783f2500b"
      },
      "source": [
        "#check if a key is already present in a dict\n",
        "\n",
        "d01 = {1:'m',2:'i',3:'m'}\n",
        "\n",
        "#inp = input()\n",
        "\n",
        "if 2 in d01:      #if the key '2' exists or not in the dict\n",
        "  print(\"exist\")\n",
        "else:\n",
        "  print(\"nop\")  \n",
        "\n",
        "if 'a' in (d01.values()):   #if the value 'a' exists or not in the dict\n",
        "  print(\"ya\")\n",
        "else:\n",
        "  print(\"na\")\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "exist\n",
            "na\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eckqmjwVv7cn",
        "outputId": "501963ee-a211-4051-a0e0-116c7de4a785"
      },
      "source": [
        "#split a list into evenly sized chunks i.e. equal blocks/groups/sets\n",
        "#chunks means blocks\n",
        "\n",
        "import numpy as np\n",
        "\n",
        "l = [1,2,3,4,5,6,7,8,9]\n",
        "\n",
        "a = np.array_split(l,3)     #3 represents the number of split or chunks i want to make\n",
        "print(a)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[array([1, 2, 3]), array([4, 5, 6]), array([7, 8, 9])]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "x5Y2IOda4qPn",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9146bd6d-4816-4d16-ca1b-3f82f2b50c4f"
      },
      "source": [
        "#splitting list by defining a func\n",
        "\n",
        "def sp(lst,chunks):\n",
        "  for i in range(0,len(lst),chunks):   #that means the range will be in between 0 to length of the list and chunks will define the steps\n",
        "    yield lst[i:i+chunks]     #this will return the i-index and the (i + 1)-index of the list  #lst[i:i+chunks] this means that the index of the list from i to i+chunks\n",
        "\n",
        "l1 = [4,7,9,2,0,4,2,12,90]\n",
        "chunks = 2\n",
        "\n",
        "print(list(sp(l1,chunks)))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[4, 7], [9, 2], [0, 4], [2, 12], [90]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "d86oOXQYf9Ik",
        "outputId": "107d2528-78e1-4cab-fe15-24111bcad50b"
      },
      "source": [
        "#parse a string to a float or int\n",
        "\n",
        "#i0 = 10\n",
        "i1 = \"10\"   #here '10' is passed as a str\n",
        "i2 = int(i1)\n",
        "i3 = float(i1)\n",
        "\n",
        "#print(type(i0))\n",
        "print(type(i1))\n",
        "print(type(i2))\n",
        "print(i2)\n",
        "print(type(i3))\n",
        "print(i3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'str'>\n",
            "<class 'int'>\n",
            "10\n",
            "<class 'float'>\n",
            "10.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Orsq3TR5xUxT",
        "outputId": "baabaaa5-79e4-49a0-eb4e-35cba7a14e1d"
      },
      "source": [
        "#print colored text to the terminal\n",
        "\n",
        "from termcolor import colored\n",
        "\n",
        "print(colored(\"mimi\",'blue'))\n",
        "print(colored(\"bye\",'red'))\n",
        "print(colored('not good','yellow'))\n",
        "print(colored(\"ops!\",'green'))\n",
        "print(colored('cash! cash!','magenta'))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[34mmimi\u001b[0m\n",
            "\u001b[31mbye\u001b[0m\n",
            "\u001b[33mnot good\u001b[0m\n",
            "\u001b[32mops!\u001b[0m\n",
            "\u001b[35mcash! cash!\u001b[0m\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "coFdRxjHzBQe",
        "outputId": "3c2a8dc4-7179-4d64-f9bf-537fada57956"
      },
      "source": [
        "#print colored text\n",
        "\n",
        "from termcolor import colored, cprint\n",
        "\n",
        "txt0 = colored(\"yaayy\",'red','on_white', attrs=['bold'])\n",
        "\n",
        "print(txt0)\n",
        "print(colored(\"bye!!!\",'magenta','on_cyan',attrs=['bold']))\n",
        "\n",
        "cprint('hey','red',attrs=['reverse','blink'])\n",
        "cprint(\"bleh\",'yellow')\n",
        "pnp = lambda x: cprint(x,'blue')\n",
        "pnp(\"bye\")\n",
        "\n",
        "pnp2 = lambda y: cprint(y,'green')\n",
        "pnp2(\"lalalla\")\n",
        "pnp2(\"?????\")\n",
        "pp = lambda p: cprint(p,'magenta')\n",
        "pp('good bye')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[1m\u001b[47m\u001b[31myaayy\u001b[0m\n",
            "\u001b[1m\u001b[46m\u001b[35mbye!!!\u001b[0m\n",
            "\u001b[5m\u001b[7m\u001b[31mhey\u001b[0m\n",
            "\u001b[33mbleh\u001b[0m\n",
            "\u001b[34mbye\u001b[0m\n",
            "\u001b[32mlalalla\u001b[0m\n",
            "\u001b[32m?????\u001b[0m\n",
            "\u001b[35mgood bye\u001b[0m\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZkkarwiWH0c_",
        "outputId": "d855c4f9-1b29-4e12-a455-ba3c20e20cd7"
      },
      "source": [
        "#string to datetime\n",
        "from datetime import datetime\n",
        "\n",
        "strng1 = 'Nov 08 2021 12:10PM'\n",
        "\n",
        "dt = datetime.strptime(strng1, '%b %d %Y %I:%M%p')\n",
        "\n",
        "print(dt)\n",
        "\n",
        "strng2 = '12:30PM Nov 11 2021'\n",
        "dt2 = datetime.strptime(strng2, \"%I:%M%p %b %d %Y\")\n",
        "print(dt2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2021-11-08 12:10:00\n",
            "2021-11-11 12:30:00\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1HLHb8dkQbQ9",
        "outputId": "4dc9240f-138b-4ce9-c2be-5864a2614c2b"
      },
      "source": [
        "#string to datetime using parse()\n",
        "\n",
        "from termcolor import colored,cprint\n",
        "from dateutil import parser\n",
        "\n",
        "strng3 = '12:30PM Nov 11 2021'\n",
        "dt3 = parser.parse(strng3)\n",
        "cprint(dt3,'red')\n",
        "\n",
        "print(colored(parser.parse(\"Nov 08 2021 12:37PM\"),'blue'))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[31m2021-11-11 12:30:00\u001b[0m\n",
            "\u001b[34m2021-11-08 12:37:00\u001b[0m\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FtssGyVcRQPl",
        "outputId": "d7f06716-75c8-4889-ce1c-56b15e3cec9c"
      },
      "source": [
        "#get the last element from the list\n",
        "\n",
        "lst11 = [0,1,2,3,4,5,6,7,8,9]\n",
        "\n",
        "print(lst11[-1])    #index counting from backward for the neg \n",
        "#print(lst11[-7])\n",
        "print(lst11[-2])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "9\n",
            "3\n",
            "8\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QvNtFCrFT3tS",
        "outputId": "a811c72e-72b3-4997-e75d-59fe15d8e39c"
      },
      "source": [
        "#get substring of a string\n",
        "#we can use slicing to get the substring\n",
        "\n",
        "strng5 = 'i am nobody'\n",
        "\n",
        "print(list(strng5))\n",
        "print(strng5[2:])\n",
        "print(strng5[5:])\n",
        "print(strng5[:2])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['i', ' ', 'a', 'm', ' ', 'n', 'o', 'b', 'o', 'd', 'y']\n",
            "am nobody\n",
            "nobody\n",
            "i \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lNLdO39VXKoe",
        "outputId": "361ea85d-927c-4306-bd95-d3a2f7599eeb"
      },
      "source": [
        "#print output without a newline\n",
        "\n",
        "print('this is a line.',end=\" \")\n",
        "print('okay bye')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "this is a line. okay bye\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bJBpEu_GXyt6",
        "outputId": "462a2c97-c39b-4069-e4a0-d9b66edd00de"
      },
      "source": [
        "#read a file line by line into a list\n",
        "\n",
        "with open(\"/content/drive/MyDrive/random.csv\") as ff:\n",
        "  lff = list(ff)\n",
        "  print(len(lff))\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10001\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9t2wdcTibYAf",
        "outputId": "635769ca-c602-4fe6-d18d-997fc6b2631b"
      },
      "source": [
        "#read a file line by line into a list\n",
        "\n",
        "with open(\"/content/name.txt\") as ff1:\n",
        "  lff1 = list(ff1.readlines())    #readlines() is used to read a file line by line\n",
        "  print(lff1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['mail file\\n', '\\n', 'dfkjgbdsgf,dgsifykdbvjdbveydagufewkhfksjdvbdhgvikygesfbvwekjfc\\n', '\\n', 'fbehsdbc\\n', 'rekgjerio\\n', 'ocvjfojv\\n']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "X2-EjStGcLeA"
      },
      "source": [
        "#reading file line by line into list using for loop\n",
        "with open(\"/content/name.txt\") as ff2:\n",
        "  "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JhiQIsNap-XN",
        "outputId": "335e18ff-daef-4098-d252-00508102e89d"
      },
      "source": [
        "#randomly select element from list\n",
        "\n",
        "import random\n",
        "\n",
        "lst = []\n",
        "\n",
        "n = 5\n",
        "print(\"Add 5 items in the list: \")\n",
        "for i in range(0,n):\n",
        "  num = int(input())\n",
        "  lst.append(num)\n",
        "\n",
        "x = random.choice(lst)\n",
        "print(\"num:\",x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Add 5 items in the list: \n",
            "1\n",
            "8\n",
            "2\n",
            "5\n",
            "9\n",
            "num: 2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4oi2Sz0Ouw9d",
        "outputId": "ac198b38-5b9c-4f00-9c09-e19c0894a0ed"
      },
      "source": [
        "#if a string is a num\n",
        "\n",
        "def floatnum(x):\n",
        "  try:\n",
        "    float(x)\n",
        "    return True\n",
        "  except ValueError:\n",
        "    return False\n",
        "\n",
        "n = input()\n",
        "print(floatnum(n))\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3475\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZbW4UQtt3o40",
        "outputId": "fc185229-45bc-441b-fa7f-456d34e37b6c"
      },
      "source": [
        "#occurence of items\n",
        "\n",
        "lst00 = [2,2,4,5,16,5,8,17,26,2,16,8,3,90,47,16,95,3,5,9,10,10]\n",
        "\n",
        "n = 5\n",
        "print(\"the list is:\",lst00)\n",
        "#for i in range(0,n):\n",
        "#  num = int(input())\n",
        "#  lst.append(num)\n",
        "x = int(input(\"which item to find:\"))\n",
        "print(x, \"occurs\", lst00.count(x), \"times in the list\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "the list is: [2, 2, 4, 5, 16, 5, 8, 17, 26, 2, 16, 8, 3, 90, 47, 16, 95, 3, 5, 9, 10, 10]\n",
            "which item to find:2\n",
            "2 occurs 3 times in the list\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_bYp7X7x5a2U"
      },
      "source": [
        "#append file\n",
        "\n",
        "f = open(\"/content/mimimimimi.txt\",'a')\n",
        "\n",
        "f.write(\"Hi!!! MiM!!!\")\n",
        "f.write(\"BYE!!!\")\n",
        "\n",
        "f.close()\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GTx4K9_v7rFb",
        "outputId": "eeb3fd4e-a416-4d13-f13b-27bc7be7e9b0"
      },
      "source": [
        "f = open(\"/content/mimimimimi.txt\",'r')\n",
        "\n",
        "print(f.read())\n",
        "\n",
        "f.close()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "pickabooooo !!!Hi!!! MiM!!!BYE!!!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sDe3TIUI8BM6",
        "outputId": "45eb52ed-b2bd-4867-fdd2-682a60df0d97"
      },
      "source": [
        "#del/add/get ele from dict\n",
        "\n",
        "dictionary = {1:'a', 2:'b', 3:'c', 4:'d', 5:'e', 6:'f', 7:'g', 8:'h'}\n",
        "print(dictionary)\n",
        "\n",
        "dictionary.pop(5)\n",
        "#print(dictionary)\n",
        "del dictionary[2]\n",
        "#print(dictionary)\n",
        "dictionary['13'] = 'm'\n",
        "#print(dictionary)\n",
        "dictionary['9'] = 'i'\n",
        "#print(dictionary)\n",
        "dictionary['20'] = 't'\n",
        "del dictionary[6]\n",
        "print(dictionary)\n",
        "\n",
        "print(dictionary.get('13'))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{1: 'a', 2: 'b', 3: 'c', 4: 'd', 5: 'e', 6: 'f', 7: 'g', 8: 'h'}\n",
            "{1: 'a', 3: 'c', 4: 'd', 7: 'g', 8: 'h', '13': 'm', '9': 'i', '20': 't'}\n",
            "m\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SpuUo4IaSl4z",
        "outputId": "e8be4f52-9eb8-41d2-ddd6-fbd353a281cd"
      },
      "source": [
        "#multiline string\n",
        "\n",
        "st = \"blah\" + \"!!!\" + \"\\n\" + \"yo\" + \"!!!\"\n",
        "\n",
        "st1 = (\"behbjkbfwkrfbrkjhfwrejkg\\njefbjhregbjhergb\\nrjgbhrgbjhgbtg\")\n",
        "\n",
        "#st3 = \"nfrjgbekjrhfse,mdfncfvhbrhgmbfbvrmb\"\n",
        "print(st)\n",
        "print(st1)\n",
        "#print(st3, end = '')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "blah!!!\n",
            "yo!!!\n",
            "behbjkbfwkrfbrkjhfwrejkg\n",
            "jefbjhregbjhergb\n",
            "rjgbhrgbjhgbtg\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9o8c41giiecJ",
        "outputId": "8e46db24-7c06-45e6-d5ac-db9c2ea29fbb"
      },
      "source": [
        "#get file extension\n",
        "from pathlib import Path\n",
        "import os\n",
        "\n",
        "f = Path(\"/content/mimimimimi.txt\")\n",
        "f1 = Path(\"mim.bleh\")\n",
        "f2 = os.path.splitext(\"tingting.ting\")\n",
        "\n",
        "print(f.suffix)\n",
        "print(f1.suffix)\n",
        "print(f2[1])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            ".txt\n",
            ".bleh\n",
            ".ting\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AfEDrHK-jTc7",
        "outputId": "634689c5-5b46-473f-a678-c982203ccd89"
      },
      "source": [
        "#list into dict\n",
        "from time import time\n",
        "\n",
        "strt = time()\n",
        "\n",
        "lst010 = []\n",
        "lst020 = []\n",
        "\n",
        "x = 2\n",
        "y = 2\n",
        "\n",
        "for i in range(0,x):\n",
        "  ele1 = input()\n",
        "  lst010.append(ele1)\n",
        "\n",
        "print(lst010)\n",
        "\n",
        "for j in range(0,y):\n",
        "  ele2 = input()\n",
        "  lst020.append(ele2)\n",
        "\n",
        "print(lst020)\n",
        "\n",
        "d = dict(zip(lst010,lst020))\n",
        "print(d)\n",
        "\n",
        "end = time()\n",
        "etime=end-strt\n",
        "print(\"time elapsed: \",etime)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "6\n",
            "3\n",
            "['6', '3']\n",
            "2\n",
            "7\n",
            "['2', '7']\n",
            "{'6': '2', '3': '7'}\n",
            "time elapsed:  12.85547947883606\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KG7A6Ua_sAOE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e8727387-fce6-4ec7-deea-862a64970273"
      },
      "source": [
        "import time\n",
        "\n",
        "time.gmtime()\n",
        "#time.gmtime(0)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "time.struct_time(tm_year=2021, tm_mon=10, tm_mday=28, tm_hour=9, tm_min=59, tm_sec=13, tm_wday=3, tm_yday=301, tm_isdst=0)"
            ]
          },
          "metadata": {},
          "execution_count": 206
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "_EFu5t5S6WDw",
        "outputId": "8002fcec-4e57-4e2e-fff8-89cd00ffd9c2"
      },
      "source": [
        "t = time.time()\n",
        "\n",
        "time.ctime(t)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Thu Oct 28 09:59:15 2021'"
            ]
          },
          "metadata": {},
          "execution_count": 207
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JflWzE8p69DX",
        "outputId": "fca58e1d-2cce-4622-85fc-15e94c4f031b"
      },
      "source": [
        "#elapsed time [end t - start t] {calculates the time needed to run a program}\n",
        "\n",
        "strt = time.time()\n",
        "\n",
        "a = 5\n",
        "b = 16\n",
        "s = a + b\n",
        "\n",
        "end = time.time()\n",
        "etime = end - strt\n",
        "print(etime)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.00016927719116210938\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "elcnV8sD9au7",
        "outputId": "d9d7ed68-1a02-4653-addf-1bcb71394f66"
      },
      "source": [
        "#class\n",
        "\n",
        "class cls:\n",
        "  at1 = 'ting'\n",
        "  at2 = 'tingting'\n",
        "\n",
        "cls1 = cls()  \n",
        "print(cls1.at1)\n",
        "print(cls1.at2)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "ting\n",
            "tingting\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GFu-I5a3SA6P",
        "outputId": "9250140b-361b-4f3a-e904-dbdfcf2bd383"
      },
      "source": [
        "class abc:              \n",
        "  def __bcd__(self,name):\n",
        "    return bcd\n",
        "\n",
        "ab = abc()\n",
        "\n",
        "print(ab.__class__.__name__)    #name attribute is used to return the class name\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "abc\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6bZX67wOa0Ax",
        "outputId": "ffbabcb5-5eba-403f-9fa3-e7a0d5e7846b"
      },
      "source": [
        "#difference of type and instance\n",
        "\n",
        "class bla:\n",
        "  def bb(self):\n",
        "    pass\n",
        "\n",
        "class bla2(bla):\n",
        "  def aa(self):\n",
        "    pass\n",
        "\n",
        "obj1 = bla()\n",
        "obj2 = bla2()\n",
        "\n",
        "print(type(obj1) == bla)\n",
        "print(type(obj1) == bla2)\n",
        "\n",
        "print(isinstance(obj1, bla))\n",
        "print(isinstance(obj2, bla))\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "False\n",
            "True\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dwIOATH6ekx_",
        "outputId": "c4c38e94-57af-48aa-f62c-dd1b28ba9862"
      },
      "source": [
        "#trimming whitespace from string #rstrip(), lstrip(), strip()\n",
        "\n",
        "stt = \" djfn \"\n",
        "\n",
        "print(stt.strip()) #will remove whitespace from both side\n",
        "print(stt.rstrip()) #will remove whitespace from right side\n",
        "print(stt.lstrip()) #will remove whitespace from the left"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "djfn\n",
            " djfn\n",
            "djfn \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ip7DpAT5hdHd"
      },
      "source": [
        "!pip install libarchive"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SVr-cZ7hgm8Y",
        "outputId": "8b593f26-7782-4b48-abe5-77f2b1250f72"
      },
      "source": [
        "#get file name from file path\n",
        "\n",
        "import os\n",
        "#from pathlib import path\n",
        "\n",
        "ff = os.path.basename(\"/content/mimimimimi.txt\")\n",
        "o1 = os.path.splitext(\"tingting.txt\")\n",
        "o2 = os.path.splitext(ff)\n",
        "print(\"filename and extension:\")\n",
        "print(o1,o2)\n",
        "print(\"filename:\",end = \" \")\n",
        "print(o1[0],\"and\",o2[0])\n",
        "print(\"file extension:\", end = \" \")\n",
        "print(o1[1],\"and\",o2[1])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "filename and extension:\n",
            "('tingting', '.txt') ('mimimimimi', '.txt')\n",
            "filename: tingting and mimimimimi\n",
            "file extension: .txt and .txt\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "P6yVzQd0iFw_",
        "outputId": "79e14af0-5c68-4922-a844-a3b6f427d46d"
      },
      "source": [
        "#enum\n",
        "\n",
        "from enum import Enum\n",
        "\n",
        "class col(Enum):\n",
        "  r = 1\n",
        "  g = 2\n",
        "  b = 3\n",
        "\n",
        "print(col.r)\n",
        "print(repr(col.r))\n",
        "print(type(col.r))\n",
        "print(isinstance(col.r,col))\n",
        "\n",
        "for c in col:\n",
        "  print(c)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "col.r\n",
            "<col.r: 1>\n",
            "<enum 'col'>\n",
            "True\n",
            "col.r\n",
            "col.g\n",
            "col.b\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eVkjZiGNzHtP",
        "outputId": "6ee87d39-7db9-40b8-c2ba-d221263fa137"
      },
      "source": [
        "from enum import Enum\n",
        "\n",
        "class movies(Enum):\n",
        "  hp = 1\n",
        "  lotr = 2\n",
        "  narnia = 3\n",
        "\n",
        "for i in movies:\n",
        "  print(i.name,i.value)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "hp 1\n",
            "lotr 2\n",
            "narnia 3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XLv8UIg7Az42",
        "outputId": "484590fb-7e7f-4c75-d5d9-9f45b6d03c58"
      },
      "source": [
        "def nnm():\n",
        "  a1 = 'just testing'\n",
        "  a2 = 'def func'\n",
        "  return (a1,a2)\n",
        "print(nnm())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "('just testing', 'def func')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "umgpYofbC4go",
        "outputId": "ee8d575a-e18a-47bc-d161-e0f23202b2c7"
      },
      "source": [
        "#diff betn pop,remove,del in a list\n",
        "\n",
        "lis3 = [2,6,8,4,3,6,1,7]\n",
        "\n",
        "print(lis3)\n",
        "print(\"pop(3):\",lis3.pop(3))  #removes index 3\n",
        "\n",
        "lis3.remove(8)    #remove the number 8\n",
        "print(\"removing(8):\",lis3)\n",
        "del lis3[1]   #removes index 1\n",
        "print(\"deleting [1]:\",lis3)\n",
        "print(\"\")\n",
        "\n",
        "lis4 = [3,4,5,6,7,8,0,1,2]\n",
        "print(lis4)\n",
        "del lis4[5:]  #deletes the number from the index 5\n",
        "print(lis4)\n",
        "del lis4[:2]  #deletes the number before index 2 (i.e index 0 and 1)\n",
        "print(lis4)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[2, 6, 8, 4, 3, 6, 1, 7]\n",
            "pop(3): 4\n",
            "removing(8): [2, 6, 3, 6, 1, 7]\n",
            "deleting [1]: [2, 3, 6, 1, 7]\n",
            "\n",
            "[3, 4, 5, 6, 7, 8, 0, 1, 2]\n",
            "[3, 4, 5, 6, 7]\n",
            "[5, 6, 7]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O490dLmVFC7S"
      },
      "source": [
        "#find all file with .txt extension inside a directory\n",
        "\n",
        "import os, glob\n",
        "\n",
        "os.getcwd()\n",
        "%cd /content/drive/My\\ Drive/   #changing dir\n",
        "\n",
        "!pwd\n",
        "os.chdir(\"random\")\n",
        "ffile = glob.glob(\"*.txt\")\n",
        "\n",
        "for file in ffile:\n",
        "    print(file)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J2s2z42CoZ_a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "69fda65d-11ef-45e6-feab-e03c234b2628"
      },
      "source": [
        "#file creation and modification date\n",
        "\n",
        "from pathlib import Path\n",
        "import os.path, time\n",
        "\n",
        "dd = Path(\"/content/name.txt\")\n",
        "\n",
        "ddt = time.ctime(os.path.getmtime(dd))    #mtime gives the modification time\n",
        "ddtt = time.ctime(os.path.getctime(dd))   #ctime gives the metadata change time\n",
        "print(ddt)\n",
        "print(ddtt)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mon Nov  1 05:31:15 2021\n",
            "Mon Nov  1 05:31:15 2021\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0kQOpHq7GzRX",
        "outputId": "963ebb1c-a18b-47f8-efff-0764c2e386f9"
      },
      "source": [
        "#full path of current working dir\n",
        "\n",
        "!pwd\n",
        "print(os.getcwd())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/content/drive/My Drive/random\n",
            "/content/drive/My Drive/random\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qQfxSkbHHz9m",
        "outputId": "d0c0bcde-ca24-46f7-dd29-7c9fc2027e12"
      },
      "source": [
        "#iterate through two list in parallel\n",
        "\n",
        "llist1 = [1,2,3,4,5]\n",
        "llist2 = ['a','b','c','d','e','f']\n",
        "\n",
        "#for i in llist1:\n",
        "  #for j in llist2:\n",
        "    #zip(llist1,llist2)\n",
        "    #print(i,j)\n",
        "\n",
        "for i , j in zip(llist1,llist2):\n",
        "  print(i,j)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1 a\n",
            "2 b\n",
            "3 c\n",
            "4 d\n",
            "5 e\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CzNK_x58OYTE",
        "outputId": "14d09e99-c390-45e2-fa41-2a40d6afa078"
      },
      "source": [
        "#to check file size\n",
        "\n",
        "from pathlib import Path \n",
        "\n",
        "noo = Path(\"/content/name.txt\")\n",
        "\n",
        "print(noo.stat().st_size)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "75\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xUB1Y-ui2ejh",
        "outputId": "61a7307f-62a7-4913-8d8c-889324c8682c"
      },
      "source": [
        "#check file size \n",
        "#printing the file name from file path\n",
        "#printing all the items in the current dir\n",
        "\n",
        "import os\n",
        "\n",
        "noo1 = os.stat(\"/content/name.txt\")\n",
        "\n",
        "print(noo1.st_size)\n",
        "\n",
        "print(os.stat(\"/content/name.txt\"))   #os.stat() returns all the info about a file\n",
        "print(os.path.basename(\"/content/name.txt\"))\n",
        "os.listdir()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "75\n",
            "os.stat_result(st_mode=33188, st_ino=6553969, st_dev=51, st_nlink=1, st_uid=0, st_gid=0, st_size=75, st_atime=1635760106, st_mtime=1635759149, st_ctime=1635759149)\n",
            "name.txt\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['.config', 'drive', 'name.txt', 'mimimimimi.txt', 'sample_data']"
            ]
          },
          "metadata": {},
          "execution_count": 36
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GIKPfBJv5G_5",
        "outputId": "4b49c47b-9577-468c-e2f3-f9cfca73f9ec"
      },
      "source": [
        "#reverse number/string\n",
        "\n",
        "numm = '12344667'\n",
        "print(numm)\n",
        "\n",
        "row = list(reversed(numm))\n",
        "print(row)\n",
        "\n",
        "strrinf = 'tahmim'\n",
        "\n",
        "print(strrinf)\n",
        "row1 = list(reversed(strrinf))\n",
        "print(row1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "12344667\n",
            "['7', '6', '6', '4', '4', '3', '2', '1']\n",
            "tahmim\n",
            "['m', 'i', 'm', 'h', 'a', 't']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vcifsAkBFNkx",
        "outputId": "0b42fdc9-8619-4590-dcdb-ff96ec7a1d43"
      },
      "source": [
        "#sorting a num/str both in order and in reverse\n",
        "\n",
        "numinf = input()\n",
        "sow = sorted(numinf,reverse = True)\n",
        "print(sow)\n",
        "\n",
        "sow1 = sorted(numinf)\n",
        "print(sow1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "abcdefghijklmnopqrstuvwxyz\n",
            "['z', 'y', 'x', 'w', 'v', 'u', 't', 's', 'r', 'q', 'p', 'o', 'n', 'm', 'l', 'k', 'j', 'i', 'h', 'g', 'f', 'e', 'd', 'c', 'b', 'a']\n",
            "['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xKyD6GF98jl7",
        "outputId": "1f5ad584-da90-49a5-a3ec-f5cf8d5497d3"
      },
      "source": [
        "#power of a number using pow function\n",
        "\n",
        "import math\n",
        "\n",
        "pew = math.pow(3,2)\n",
        "\n",
        "print(pew)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "9.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KvbhqYaQ-PYA",
        "outputId": "824b738e-c9ff-43db-a64a-9a8f79f3f017"
      },
      "source": [
        "#counting digits in a number\n",
        "\n",
        "numb = 7362290\n",
        "countstr = ('mim')\n",
        "print(len(str(numb)))\n",
        "print(len(countstr))\n",
        "\n",
        "numb1 = int(input())\n",
        "print(len(str(numb1)))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "7\n",
            "3\n",
            "62647483\n",
            "8\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1LPyvo6h_7K3",
        "outputId": "090b5eee-dfd7-48aa-c091-17553581410a"
      },
      "source": [
        "#counting digits using loop\n",
        "\n",
        "numb2 = 2343242002\n",
        "c = 0\n",
        "while numb2 != 0:\n",
        "  numb2 = numb2 // 10\n",
        "  c += 1\n",
        "print(str(c))\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mO4HJLC3Ui0Q",
        "outputId": "721bbb94-713a-4744-9163-916c8929d17d"
      },
      "source": [
        "#testing how sorted and counter func works\n",
        "\n",
        "ex = 'kijanih'\n",
        "\n",
        "print(\"Using Counter: \",Counter(ex))\n",
        "print(\"Using sorted: \",sorted(ex))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Using Counter:  Counter({'i': 2, 'k': 1, 'j': 1, 'a': 1, 'n': 1, 'h': 1})\n",
            "Using sorted:  ['a', 'h', 'i', 'i', 'j', 'k', 'n']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "z22HqqrgBxgp",
        "outputId": "e37772d5-9b33-458e-f737-aaed148adea2"
      },
      "source": [
        "#anagram using sorted()   #anagram means that the letters of a word can be arranged to make another word i.e listen and silent\n",
        "\n",
        "def ana(s1,s2):\n",
        "  if sorted(s1) == sorted(s2):        #the sorted func returns the sorted string and if the string are equal then it is anagram \n",
        "    print(\"yes\")\n",
        "  else:\n",
        "    print(\"no\")\n",
        "\n",
        "ss = input()\n",
        "ss2 = input()\n",
        "ana(ss,ss2)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "mimi\n",
            "miim\n",
            "yes\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FhwQ3_TQGbLr",
        "outputId": "ae8fd163-f549-45a3-9875-2cea38eb43a6"
      },
      "source": [
        "#anagram using Counter()\n",
        "\n",
        "from collections import Counter\n",
        "\n",
        "def anagr(s11,s22):\n",
        "  if Counter(s11) == Counter(s22):    \n",
        "    print(\"yes\")\n",
        "  else:\n",
        "    print(\"no\")\n",
        "\n",
        "ss1 = 'silent'\n",
        "ss21 = 'listen'\n",
        "anagr(ss1,ss21)\n",
        "\n",
        "ss12 = 'bad'\n",
        "ss13 = 'dad'\n",
        "anagr(ss12,ss13)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "yes\n",
            "no\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SDC3J_K3Ifne",
        "outputId": "a099df27-b5b3-41e6-800e-30a6ebb42f49"
      },
      "source": [
        "#capitalize the first letter of a string\n",
        "\n",
        "st0 = 'what is on your mind !!!'\n",
        "\n",
        "cap = st0[0].upper() + st0[1:]\n",
        "print(cap)\n",
        "\n",
        "st1 = 'yo girl, wassup!'\n",
        "print(list(st1))\n",
        "print(st1[9])\n",
        "print(st1[0].upper() + st1[1:9] + st1[9].upper() + st1[10:])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "What is on your mind !!!\n",
            "['y', 'o', ' ', 'g', 'i', 'r', 'l', ',', ' ', 'w', 'a', 's', 's', 'u', 'p', '!']\n",
            "w\n",
            "Yo girl, Wassup!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JQKqGDt8P25I",
        "outputId": "5e5d2179-cda0-4393-d8c1-253202cea908"
      },
      "source": [
        "#finding permutation   #all possible words with the letters in a string\n",
        "\n",
        "from itertools import permutations\n",
        "\n",
        "str09 = 'mim'\n",
        "\n",
        "per001 = permutations(str09)    #or per001 = permutations(str09,2)\n",
        "\n",
        "for i in per001:\n",
        "  #print(list(i))\n",
        "  print(i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "('m', 'i', 'm')\n",
            "('m', 'm', 'i')\n",
            "('i', 'm', 'm')\n",
            "('i', 'm', 'm')\n",
            "('m', 'm', 'i')\n",
            "('m', 'i', 'm')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jj_wr14xUo3X",
        "outputId": "696d0536-57f1-4bf2-cc9a-6c9ab1e25ad8"
      },
      "source": [
        "#permutation using recursion\n",
        "\n",
        "def per(str, i = 0):\n",
        "  if i == len(str):\n",
        "    print(\"\".join(str))\n",
        "  for j in range(i,len(str)):\n",
        "    wor = [w for w in str]    #all the chars will be stored in wor for each loop\n",
        "    wor[i],wor[j] = wor[j], wor[i]    #swapped to get different combinations of the str\n",
        "    per(wor,i+1)\n",
        "\n",
        "pp = per(\"mew\")\n",
        "print(pp)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "mew\n",
            "mwe\n",
            "emw\n",
            "ewm\n",
            "wem\n",
            "wme\n",
            "None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "O4Yk5cW9Vm3Y",
        "outputId": "0518b9ef-6f51-4959-8b0c-714fa83de284"
      },
      "source": [
        "#combinations of string using combination function\n",
        "\n",
        "from itertools import combinations\n",
        "\n",
        "str009 = 'mim'\n",
        "\n",
        "comb = combinations(str009,2)\n",
        "print(comb)\n",
        "for i in comb:\n",
        "  print(i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<itertools.combinations object at 0x7fb4f065c3b0>\n",
            "('m', 'i')\n",
            "('m', 'm')\n",
            "('i', 'm')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9XSCvuP3WRXg",
        "outputId": "96307538-6232-441c-9757-608307e65da9"
      },
      "source": [
        "#printing products\n",
        "\n",
        "from itertools import product\n",
        "\n",
        "pro = product(str009,repeat=2)\n",
        "\n",
        "print(pro)\n",
        "\n",
        "for j in pro:\n",
        "  print(j)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<itertools.product object at 0x7fb4f065ae10>\n",
            "('m', 'm')\n",
            "('m', 'i')\n",
            "('m', 'm')\n",
            "('i', 'm')\n",
            "('i', 'i')\n",
            "('i', 'm')\n",
            "('m', 'm')\n",
            "('m', 'i')\n",
            "('m', 'm')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1Yp5D86_QTye",
        "outputId": "5a1c0fc6-82d7-40c5-999a-fc33bf6a02f2"
      },
      "source": [
        "#countdown timer    \n",
        "#divmod() is a func which takes two parameters i.e. numerator and denominator (x,y) and returns two numbers as quotient and remainder (q,r)\n",
        "\n",
        "import time\n",
        "\n",
        "def countime(t):\n",
        "  \n",
        "  while (t != 0):       #the loop will continue till the time becomes 0\n",
        "    min,sec = divmod(t,60)    #divmod to calculate the num of mins and sec\n",
        "    ctime = '{:2d}:{:2d}'.format(min,sec)   #format of time\n",
        "    print(ctime, end = \"\\r\")    #'/r' cursor will go back to the starting and will overwrite the previous one\n",
        "    time.sleep(1)     #this will make the code wait for a sec i.e the execution time will be delayed by a sec\n",
        "    t = t - 1       \n",
        "  print(\"time over\")\n",
        "  \n",
        "ti = input(\"enter time in sec:\")\n",
        "countime(int(ti))   #we have to pass the input as int as it is a timer"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "enter time in sec:5\n",
            "time over\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oq_a7OrefRuB",
        "outputId": "bfa6c014-55cf-4bf9-e4bd-0a78f47b251b"
      },
      "source": [
        "#testing divmod()\n",
        "\n",
        "print(divmod(17,3))   #(numerator,denominator) result is in (quotient,remainder)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(5, 2)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "a7hR3FcDgalm",
        "outputId": "9073c413-dced-462e-fefc-1120fa647242"
      },
      "source": [
        "#num of occurence of a char in a string\n",
        "\n",
        "chr = input()\n",
        "#print(chr)\n",
        "ii = input(\"enter the item to count \")\n",
        "print(ii,\"is\",chr.count(ii),\"times in the string\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "amarmatha\n",
            "enter the item to count a\n",
            "a is 4 times in the string\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RCtD7aUcxzdf",
        "outputId": "a77dbfff-898f-4bc7-8b50-7097b548a5eb"
      },
      "source": [
        "#using for loop\n",
        "\n",
        "cnt = 0\n",
        "\n",
        "chr1 = 'ttahmim'\n",
        "inp = 't'\n",
        "\n",
        "for i in chr1:\n",
        "  if i == inp:\n",
        "    cnt += 1\n",
        "\n",
        "print(cnt)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "D-C5i2vQzpRJ",
        "outputId": "d548334d-0971-4500-f40a-40279b068214"
      },
      "source": [
        "#remove duplicate element from a string\n",
        "\n",
        "lst_1 = input()\n",
        "#print(lst_1)\n",
        "print(set(lst_1))     #by using set we can remove duplicate char in a string"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "dhfbgwegfwuedhsakjcbxbvbcbd\n",
            "{'u', 'b', 's', 'd', 'w', 'a', 'g', 'v', 'k', 'e', 'c', 'x', 'j', 'h', 'f'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FXnXp7VF4jgY",
        "outputId": "e95d2160-3f7c-40d7-a462-7d6b8ff96ab7"
      },
      "source": [
        "#remove duplicates from two strings\n",
        "\n",
        "lst_2 = input()\n",
        "lst_3 = input()\n",
        "\n",
        "print(sorted(set(lst_2) ^ set(lst_3)))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "dshfgwui\n",
            "cvbdjfkdgks\n",
            "['b', 'c', 'h', 'i', 'j', 'k', 'u', 'v', 'w']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rGgH3gU25Hsy",
        "outputId": "1346a9dd-c160-4d66-f24f-33c1cb5c8dfb"
      },
      "source": [
        "#bytes to string using decode(\"utf-8\")\n",
        "\n",
        "print(b'\\xE2\\x9C\\x85'.decode(\"utf-8\"))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "✅\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uOuwvm6JndY5",
        "outputId": "8b0b0815-1183-4ee5-b492-bf6b975e5397"
      },
      "source": [
        "#bytes to string\n",
        "\n",
        "sen = b'mim'\n",
        "print(sen)\n",
        "print(type(sen))\n",
        "\n",
        "sen1 = sen.decode(\"utf-8\")\n",
        "print(sen1)\n",
        "print(type(sen1))\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "b'mim'\n",
            "<class 'bytes'>\n",
            "mim\n",
            "<class 'str'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Z-LRXlfHkJyx",
        "outputId": "8e74a2b0-ddb4-490d-fde1-0d76fda4fedf"
      },
      "source": [
        "#string utf-8 encode()    #encode() doesn't need any parameter\n",
        "\n",
        "print(\"tähmïm¤\".encode())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "b't\\xc3\\xa4hm\\xc3\\xafm\\xc2\\xa4'\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pvT8yCY_lwkE",
        "outputId": "2f13a0b8-bac5-4a8a-bdba-5eb9de33914f"
      },
      "source": [
        "#string utf-8 encoding\n",
        "\n",
        "cc = 'lÂÑguÀgê pythÕn'\n",
        "print(cc.encode())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "b'l\\xc3\\x82\\xc3\\x91gu\\xc3\\x80g\\xc3\\xaa pyth\\xc3\\x95n'\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lXrQUYAR-_1n",
        "outputId": "227250dc-4157-4deb-f976-ddff2c5045a2"
      },
      "source": [
        "#anagram\n",
        "#i.e. the letters of a word that can be arraned to form another word\n",
        "#e.g fried = fired, silent = listen\n",
        "#there will be two different word bt the letters will be same\n",
        "\n",
        "str110 = input()\n",
        "str120 = input()\n",
        "\n",
        "#print(sorted(str110))\n",
        "\n",
        "if (sorted(str110) == sorted(str120)):\n",
        "  print(\"anagram\")\n",
        "else:\n",
        "  print(\"not anagram\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "life\n",
            "file\n",
            "anagram\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WF47CpOADm9F",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "92892877-4c2c-4e8c-e893-e61c5ad1aced"
      },
      "source": [
        "#lambda function\n",
        "#lambda arguments: expression\n",
        "#lambda x: x*2 is nearly same as def(x): return x*2\n",
        "\n",
        "tt = lambda x,y: x+y\n",
        "\n",
        "tt(3,4)\n",
        "\n",
        "lst22 = [1,4,7,0,4,6,2]\n",
        "\n",
        "tt1 = list(filter(lambda x: x==4, lst22))     #filter() returns the filtered output i.e the values that are true according to the expression\n",
        "\n",
        "print(tt1)\n",
        "\n",
        "lst23 = [10,12,15,18,19,26]\n",
        "\n",
        "tt2 = list(map(lambda x: x*2, lst23))     #map() will return all the values computed according to the expression\n",
        "print(tt2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[4, 4]\n",
            "[20, 24, 30, 36, 38, 52]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RoTHLdVOk0en",
        "outputId": "8df516dd-08c1-4b6d-df66-4c22cd0411fd"
      },
      "source": [
        "#with map()\n",
        "\n",
        "lst101 = [4,6,7,9,8,10]\n",
        "tt = list(map(lambda x: x%2, lst101))\n",
        "print(tt)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0, 0, 1, 1, 0, 0]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Z08-ehWyl-IP",
        "outputId": "be85168f-7820-4755-acc1-72c89971f15c"
      },
      "source": [
        "#without list and map()\n",
        "\n",
        "lst102 = [2,3,6,7,11]\n",
        "\n",
        "tt102 = (lambda x: x%2,lst102)\n",
        "print(tt102)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(<function <lambda> at 0x7fa24c5d07a0>, [2, 3, 6, 7, 11])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "irhW5xQepKk-",
        "outputId": "b9b83110-b8b7-4fe6-828b-773abea5bdf6"
      },
      "source": [
        "#more about lambda function\n",
        "#Filter: filter (lambda parameter: expression, iterable-sequence)\n",
        "#Map: map (lambda parameter: expression, iterable-sequences)\n",
        "#Reduce: reduce (lambda parameter1, parameter2: expression, iterable-sequence)\n",
        "\n",
        "from functools import reduce\n",
        "\n",
        "strlst = ['apple','butterfly','cat','rabbit']\n",
        "nlst = [2,5,7,2]\n",
        "\n",
        "n1 = list(map(lambda x: x.upper(),strlst))\n",
        "n2 = list(filter(lambda x: 'a' in x,strlst))\n",
        "n3 = reduce(lambda x,y: x*y,nlst)   #reduce func is used to calculate all the items and gives the output as a single value #it counts from left to right \n",
        "\n",
        "print(n1)\n",
        "print(n2)\n",
        "print(n3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['APPLE', 'BUTTERFLY', 'CAT', 'RABBIT']\n",
            "['apple', 'cat', 'rabbit']\n",
            "140\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KJ_fnDsVc0m9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "619a597c-4258-4e95-b114-5027f0597f66"
      },
      "source": [
        "#lambda func continued...\n",
        "\n",
        "one = (lambda x: x+2) (5)\n",
        "print(one)\n",
        "two = (lambda x,y: x+y) (5,2)\n",
        "print(two)\n",
        "three = (lambda x, z=1,y=0: x+y+z)(2,y=2) \n",
        "print(three)\n",
        "four = (lambda *args: sum(args)) (1,2,3,6)\n",
        "print(four)\n",
        "five = (lambda **kwargs: sum(kwargs.values()))(a=1,b=4,c=6,d=1,e=3)\n",
        "print(five)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "7\n",
            "7\n",
            "5\n",
            "12\n",
            "15\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kWQXaPXuTsSk",
        "outputId": "6716081f-0c1c-4753-d30f-be20c6f7013b"
      },
      "source": [
        "#printing unicodes\n",
        "\n",
        "#0030-0039 : numbers\n",
        "#0980−09FF : bangla\n",
        "\n",
        "print('\\u0031'+'\\u0036')\n",
        "print('\\u0645','\\n')\n",
        "print('\\u09AE'+'\\u09C0'+'\\u09AE')\n",
        "print('\\u092E'+'\\u094C'+'\\u092E')\n",
        "print('\\u004D'+'\\u0069'+'\\u006D')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "16\n",
            "م \n",
            "\n",
            "মীম\n",
            "मौम\n",
            "Mim\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9nOTKTqQWpUW",
        "outputId": "7dc69b88-7419-49f3-d9ce-9e7933c7951a"
      },
      "source": [
        "#finding mean and standard deviation using numpy\n",
        "\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "from statistics import stdev\n",
        "\n",
        "samp = (1,5,6,7,3,2,9,0,1,2,15)\n",
        "df1 = pd.DataFrame(samp)\n",
        "m = stdev(samp)\n",
        "m2 = df1.mean()\n",
        "std1 = df1.std()\n",
        "\n",
        "print(\"using stdev : \",m)\n",
        "print(\"datframe one: \",m2)\n",
        "print(\"dataframe std : \",std1)\n",
        "\n",
        "df = pd.Series(data = [1,4,6,3,2,8,9,5])\n",
        "m1 = df.mean()\n",
        "print(m1)\n",
        "std = df.std()\n",
        "print(std)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "using stdev :  4.455843966584272\n",
            "datframe one:  0    4.636364\n",
            "dtype: float64\n",
            "dataframe std :  0    4.455844\n",
            "dtype: float64\n",
            "4.75\n",
            "2.815771906346718\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Q8pGEeuZqjm7",
        "outputId": "d47bd77f-83e1-4218-d2ae-186b1e270ece"
      },
      "source": [
        "#.count() method\n",
        "#.find() method\n",
        "\n",
        "samp1 = (2,4,5,6,7,8,1,2,3,4,1,2,3)\n",
        "samp2 = 'how are you ting ting?'\n",
        "print(samp1.count(2))   #returns the number items you want to count\n",
        "print(samp2.find('ting'))   #returns the lowest index in the string where it can find the substring"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n",
            "12\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e6D2h8TO_-vb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2c710d49-747f-47f1-9edb-d29e63bb6421"
      },
      "source": [
        "#random practice\n",
        "\n",
        "st = '127fn46skghr93'\n",
        "\n",
        "res = ''.join([i for i in st if not i.isdigit()])\n",
        "print(res)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "fnskghr\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cuu5Dmx7gcoQ",
        "outputId": "e48f7ef8-0532-49f9-d6e0-cbcc739db00c"
      },
      "source": [
        "for i in range(2432,2559):\n",
        "  j = chr(i)\n",
        "  print(j,end='  ')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "ঀ  ঁ  ং  ঃ  ঄  অ  আ  ই  ঈ  উ  ঊ  ঋ  ঌ  ঍  ঎  এ  ঐ  ঑  ঒  ও  ঔ  ক  খ  গ  ঘ  ঙ  চ  ছ  জ  ঝ  ঞ  ট  ঠ  ড  ঢ  ণ  ত  থ  দ  ধ  ন  ঩  প  ফ  ব  ভ  ম  য  র  ঱  ল  ঳  ঴  ঵  শ  ষ  স  হ  ঺  ঻  ়  ঽ  া  ি  ী  ু  ূ  ৃ  ৄ  ৅  ৆  ে  ৈ  ৉  ৊  ো  ৌ  ্  ৎ  ৏  ৐  ৑  ৒  ৓  ৔  ৕  ৖  ৗ  ৘  ৙  ৚  ৛  ড়  ঢ়  ৞  য়  ৠ  ৡ  ৢ  ৣ  ৤  ৥  ০  ১  ২  ৩  ৪  ৫  ৬  ৭  ৮  ৯  ৰ  ৱ  ৲  ৳  ৴  ৵  ৶  ৷  ৸  ৹  ৺  ৻  ৼ  ৽  ৾  "
          ]
        }
      ]
    }
  ]
}