Code_Practice.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "a7d2b17b-0223-4cfc-a328-f9d629f99976",
   "metadata": {},
   "source": [
    "# `PYTHON NOTES: V25.01.08 `"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb8eaedd-941d-46a6-bfbc-caab7ea1e750",
   "metadata": {},
   "source": [
    "## `Print() Function:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "49178466-1a88-4286-9653-8d21d2a8a9a0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Pratik\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello Pratik\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1cd27b1f-f308-421d-9419-883acbde97fd",
   "metadata": {},
   "source": [
    "## `Input() Function:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "eccc2005-d496-419d-8234-2532168543f1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a Value:  23\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23\n"
     ]
    }
   ],
   "source": [
    "value = input(\"Enter a Value: \")\n",
    "print(value)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc9583de-efc8-4b78-89f7-9f6f5015ff01",
   "metadata": {},
   "source": [
    "## `Type() Function:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "3f73114f-920f-4e68-bd8f-d137a0099a5e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(type(24))\n",
    "type(24)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5394a185-7433-44fb-a3a7-3b4c59d5b9b2",
   "metadata": {},
   "source": [
    "## `Data Types: V25.01.08`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92600a77-1df0-44ce-9a81-cfbb0c908e90",
   "metadata": {},
   "source": [
    "1. `Numeric Data Type`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "2bcde15e-ad05-49a2-98b2-0ca8e51f2212",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Numeric Data Type\n",
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'complex'>\n"
     ]
    }
   ],
   "source": [
    "print(\"Numeric Data Type\")\n",
    "print(type(23))\n",
    "print(type(23.5))\n",
    "print(type(2+2j))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "774f658a-1629-446a-87a0-d8ec60641004",
   "metadata": {},
   "source": [
    "2. `Sequential Data Type`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "bb63d28b-2381-400b-80db-ba0242a66547",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sequential Data Type\n",
      "<class 'list'>\n",
      "<class 'tuple'>\n",
      "<class 'set'>\n",
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "print(\"Sequential Data Type\")\n",
    "print(type([22,22.3,2+2j]))\n",
    "print(type((22,22.3,2+2j)))\n",
    "print(type(set(\"aabbccdd\")))\n",
    "print(type({\"name\":\"Pratik\" ,\"age\":22}))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de2178d0-d39b-4843-82d0-9202144bb88a",
   "metadata": {},
   "source": [
    "3. `String Data Type`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "06ec8efa-b4cc-43a4-bdd0-5285533cae4b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "print(\"String Data Type\")\n",
    "print(type(\"Pratik\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a206a8cd-6d83-4a8e-97c9-2dfe15d7497f",
   "metadata": {},
   "source": [
    "4. `Boolean Data Type`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "df7bbea8-5831-42e9-8184-87df7c7677e3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "print(\"Boolean Data Type\")\n",
    "print(type(True))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98d03efc-c471-4fd5-b35d-e03d0f970d37",
   "metadata": {},
   "source": [
    "## Operators: V25.01.09 -  V25.01.10"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "644e6eee-1337-4453-ae41-2c1fedf1b27b",
   "metadata": {},
   "source": [
    "1. `Assignment Arithmatic Operator`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c95864e7-1c6f-4ca7-a619-a3e504936aaf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Assignment Arithmatic Operator\n",
      "Addition of two Number is:  4\n",
      "Subtraction of two Number is:  2\n",
      "Multiplication of two Number is:  4\n",
      "Division of two Number is:  2.0\n",
      "Floor Division of two Number is:  1.0\n",
      "Power of two Number is:  1.0\n"
     ]
    }
   ],
   "source": [
    "print(\"Assignment Arithmatic Operator\")\n",
    "num1 = int(input(\"Enter 1st Number: \"))\n",
    "num2 = int(input(\"Enter 2nd Number: \"))\n",
    "num1+=num2\n",
    "print(\"Addition of two Number is: \",num1)\n",
    "num1-=num2\n",
    "print(\"Subtraction of two Number is: \",num1)\n",
    "num1*=num2\n",
    "print(\"Multiplication of two Number is: \",num1)\n",
    "num1/=num2\n",
    "print(\"Division of two Number is: \",num1)\n",
    "num1//=num2\n",
    "print(\"Floor Division of two Number is: \",num1)\n",
    "num1**=num2\n",
    "print(\"Power of two Number is: \",num1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78c3b662-2f47-46da-ae8d-b5fd5aaa2f8f",
   "metadata": {},
   "source": [
    "2. `Relational Operator`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "1ec4b6b7-a689-4460-bc95-b7807f7b25d8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter 1st Number:  7\n",
      "Enter 2nd Number:  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n",
      "False\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(\"Relational Operator\")\n",
    "print(num1>=num2)\n",
    "print(num1<=num2)\n",
    "print(num1==num2)\n",
    "print(num1!=num2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4493998-343a-4726-b34e-9b5040b705cc",
   "metadata": {},
   "source": [
    "3. `Logical Operator V25.01.10`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "2d941016-da7f-4d0c-b96a-4418e3694e67",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Logical Operator\n",
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(\"Logical Operator\")\n",
    "print(44>=33 and 44>=22)\n",
    "print(22<=22 or 33<=33)\n",
    "print(not True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "580f29f0-a26e-402c-995d-ff34b57bb02a",
   "metadata": {},
   "source": [
    "4. `Bitwise Operator`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "8555f1fa-e03e-489b-ac05-625bcf972fe0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0b1111\n",
      "11\n",
      "15\n",
      "4\n",
      "-12\n",
      "0b11\n",
      "0b111100\n",
      "3\n",
      "60\n"
     ]
    }
   ],
   "source": [
    "print(\"Bitwise Operator\")\n",
    "print(bin(15))\n",
    "print(1 & 1)\n",
    "print(15 | 11)\n",
    "print(15 ^ 11)\n",
    "print(~11)\n",
    "print(bin(15>>2))\n",
    "print(bin(15<<2))\n",
    "print(15>>2)\n",
    "print(15<<2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "765a4393-841e-44a0-b820-db19f9d36b9a",
   "metadata": {},
   "source": [
    "5. `Membership Operator`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "b7dc5b1e-a981-430b-b1f2-0fdb1269b2fe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Membership Operator:\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(\"Membership Operator:\")\n",
    "a = \"ABCD\"\n",
    "print(\"A\" in a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a79760c-6d90-440a-a04c-350f01817f72",
   "metadata": {},
   "source": [
    "6. `Identity Operator`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "72758bd4-46be-4a91-b01c-0791ef73bf1e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Identity Operator:\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(\"Identity Operator:\")\n",
    "a = \"ABCD\"\n",
    "b = \"ABCD\"\n",
    "print(a is b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96067119-e311-4763-b722-e2386bb967eb",
   "metadata": {},
   "source": [
    "## `Jupyter Installation: V25.01.13`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16f1655a-a2a2-4d73-a653-367589d5e94c",
   "metadata": {},
   "source": [
    "## `Control Statement: V25.01.14`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60210376-0297-4b69-9a5c-158f8157ed0c",
   "metadata": {},
   "source": [
    "1. `IF Statement`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d58e4ea5-bf7d-4460-8317-7ec2e3e09aa3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome Guys!!\n"
     ]
    }
   ],
   "source": [
    "if True:\n",
    "    print(\"Welcome Guys!!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "146b2228-f1c4-449d-85a3-b18eaa3b042b",
   "metadata": {},
   "outputs": [],
   "source": [
    "if False:\n",
    "    print(\"Welcome Guys!!\")\n",
    "    # Blanck!!  Print Nothing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "5f472418-cdf6-430e-8d97-d23583c3e9b7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome Guys!!\n"
     ]
    }
   ],
   "source": [
    "if 1:\n",
    "    print(\"Welcome Guys!!\")\n",
    "    # Truth Value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "4b739df3-4bbf-4338-a71a-d8a6cc909ea2",
   "metadata": {},
   "outputs": [],
   "source": [
    "if 0:\n",
    "    print(\"Welcome Guys!!\")\n",
    "    # Blanck!!  Print Nothing. Falsy Value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "9443d50c-4601-4ee6-a8cb-ff6a2ef90eb5",
   "metadata": {},
   "outputs": [],
   "source": [
    "if -0:\n",
    "    print(\"Welcome Guys!!\")\n",
    "    # Blanck!!  \n",
    "    # Print Nothing. \n",
    "    # Falsy Value\n",
    "    # Entity : Something that exist.\n",
    "    # -0 : Technicaly Wrong. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bfe07cfa-0151-462e-bedf-2d1198a9a920",
   "metadata": {},
   "source": [
    "2. `If-Else Statement`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "534f45dd-f9b6-4fba-ae08-7c8931f6a107",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome Guys!!\n"
     ]
    }
   ],
   "source": [
    "if True:\n",
    "    print(\"Welcome Guys!!\")\n",
    "else:\n",
    "    print(\"Bhaag...\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19abad6f-9095-47fc-aaec-607f485ce900",
   "metadata": {},
   "source": [
    "- `Question:` Accept a no from user and check if it is Even or Odd."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "8e8d7207-7a7c-4059-9609-af8ace7457db",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Print Even or Odd Numbers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a Number:  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5  is a Odd Number.\n"
     ]
    }
   ],
   "source": [
    "print(\"Print Even or Odd Numbers.\")\n",
    "num = int(input(\"Enter a Number: \"))\n",
    "if num%2 == 0 :\n",
    "    print(num,\" is a Even Number.\")\n",
    "else:\n",
    "    print(num,\" is a Odd Number.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "173f25d8-bdb0-4c5b-b2b4-fb30d90d97bb",
   "metadata": {},
   "source": [
    "- `Question:` Accept a no from user and check if it is divisible by 7 or 13."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "4a2f4c57-eb23-480b-a871-83457eb472f9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Check a number divisible by 7 or 13.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a Number:  14\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14  is divisible.\n"
     ]
    }
   ],
   "source": [
    "print(\"Check a number divisible by 7 or 13.\")\n",
    "num = int(input(\"Enter a Number: \"))\n",
    "if num%7 == 0 or num%13 ==0 :\n",
    "    print(num,\" is divisible.\")\n",
    "else:\n",
    "    print(num,\" is not divisible.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16121976-2847-47f5-9e91-5f8cd270c40b",
   "metadata": {},
   "source": [
    "3. If-Elif Statement | If-Elif Ladder"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f90ee59-d978-4478-b54f-597e75dbacd4",
   "metadata": {},
   "source": [
    "- `Question:` Accept a no from user and check if it is Greater, Smaller or Equal to 23. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "e20372ea-94a3-45bf-83d6-24438928d80b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Check a Number is Greater, Smaller or Equal.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a Number:  23\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23  is a Equal to 23.\n"
     ]
    }
   ],
   "source": [
    "print(\"Check a Number is Greater, Smaller or Equal.\")\n",
    "num = int(input(\"Enter a Number: \"))\n",
    "if num>23:\n",
    "    print(num,\" is a Greater than 23.\")\n",
    "elif num==23:\n",
    "    print(num,\" is a Equal to 23.\")\n",
    "else:\n",
    "    print(num,\" is a Smaller than 23.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ab3920e-e596-4767-af82-04e0f18b7079",
   "metadata": {},
   "source": [
    "- `Question:` Accept a Budget from User. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "6cd95b2c-c127-4f4c-b541-37ab4c5c9cd4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your Budget:  1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gully Trip.\n"
     ]
    }
   ],
   "source": [
    "budget = int(input(\"Enter your Budget: \"))\n",
    "if budget>=300 and budget<=500:\n",
    "    print(\"International Trip.\")\n",
    "elif budget>=200 and budget<=299:\n",
    "    print(\"National Trip.\")\n",
    "elif budget>=100 and budget<=199:\n",
    "    print(\"City Trip.\")\n",
    "elif budget>=50 and budget<=99:\n",
    "    print(\"Local Trip.\")\n",
    "elif budget>=1 and budget<=49:\n",
    "    print(\"Gully Trip.\")\n",
    "else:\n",
    "    print(\"Undefine Budget.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c913704-c671-4d3f-9e4f-3a9d34fbc590",
   "metadata": {},
   "source": [
    "- `Question:` Accept a Designation from User and print is they apply for senior Position. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "542800fe-6fc6-4ba7-951e-d23dd4abe5ce",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter what Designationyou are Applying? Manager or Executive Executive\n",
      "Are you applying for Senior Position? Yes or No: No\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25K Sallary.\n"
     ]
    }
   ],
   "source": [
    "designation = input(\"Enter what Designationyou are Applying? Manager or Executive\")\n",
    "if \"Manager\" == designation:\n",
    "    senior = input(\"Are you  applying for Senior Position? Yes or No:\")\n",
    "    if \"yes\" == senior:\n",
    "        print(\"2Lakh Sallary.\")\n",
    "    else:\n",
    "        print(\"1Lakh Sallary.\")\n",
    "elif \"Executive\" == designation:\n",
    "    senior = input(\"Are you applying for Senior Position? Yes or No:\")\n",
    "    if \"yes\" == senior:\n",
    "        print(\"70K Sallary.\")\n",
    "    else:\n",
    "        print(\"25K Sallary.\")\n",
    "else:\n",
    "    print(\"Undefined Designation.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5741bc02-e0ce-473b-9d45-c89bb0baf635",
   "metadata": {},
   "source": [
    "4. `Match Case`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "14168cdb-d5c5-4bec-85c6-a56def814a42",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Label 3\n"
     ]
    }
   ],
   "source": [
    "value = 3\n",
    "match value:\n",
    "    case 1:\n",
    "        print(\"Label 1\")\n",
    "    case 2:\n",
    "        print(\"Label 2\")\n",
    "    case 3:\n",
    "        print(\"Label 3\")\n",
    "    case _:\n",
    "        print(\"Default Case \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e99fb546",
   "metadata": {},
   "source": [
    "## `Loops: V25.01.15`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13800d47-d35d-4236-b929-01a23dc72a45",
   "metadata": {},
   "source": [
    "### `For Loop - Repetition`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "c6fe2044-0248-44e3-b54c-a8c8578edd79",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for i in range(1,10):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "d4ed6f2e-c057-4035-b428-211e99b6b7ac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "for i in range(11):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "4efc9641-f26e-4123-b67f-e0e4fc7c5a77",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "for i in range(1,11):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "f14459e6-f498-4768-8105-b510c1a07b21",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 6 7 8 9 10 "
     ]
    }
   ],
   "source": [
    "for i in range(1,11):\n",
    "    print(i, end=\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "94b5919a-51dd-4f46-bbbe-25253c4e4a1d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 "
     ]
    }
   ],
   "source": [
    "for i in range(20,41):\n",
    "    print(i, end=\" \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9381562f-e568-4094-bebf-fe70b1989868",
   "metadata": {},
   "source": [
    "- `Question: Print Even Numbers 1 to 100`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "7e08649f-fcce-4778-95e7-98d0c8f7412b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40 42 44 46 48 50 52 54 56 58 60 62 64 66 68 70 72 74 76 78 80 82 84 86 88 90 92 94 96 98 100 "
     ]
    }
   ],
   "source": [
    "for i in range(1,101):\n",
    "    if i%2==0:\n",
    "        print(i, end=\" \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a643f05a-ebbd-4dea-8fc8-f85842a70f78",
   "metadata": {},
   "source": [
    "- `Question: Display Number Divisible by 2 & 5 from 1 to 100.`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "5c64006e-9ac5-4008-a34d-61349ace8b79",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 20 30 40 50 60 70 80 90 100 "
     ]
    }
   ],
   "source": [
    "for i in range(1, 101):\n",
    "    if i%2==0 and i%5==0:\n",
    "        print(i, end=\" \")c"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d179fed5-f29f-497f-a442-0d0491470ba2",
   "metadata": {},
   "source": [
    "- `Question: Display Number Divisible by 13,17 from 1 to 100.`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "0145567d-a7fd-448f-be4a-0149924a2f64",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 20 30 40 50 60 70 80 90 100 "
     ]
    }
   ],
   "source": [
    "for i in range(1, 101):\n",
    "    if i%13==0 and i%17==0:\n",
    "        print(i, end=\" \")c"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec11d436-3eac-4ffc-b63e-807cc1e8bee2",
   "metadata": {},
   "source": [
    "- `Patterns:`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dbce35a2-4f1d-418d-a65f-eded0bf18bf7",
   "metadata": {},
   "source": [
    "- `Square Row Number Patterns:`\n",
    "- `11111`\n",
    "- `22222`\n",
    "- `33333`\n",
    "- `44444`\n",
    "- `55555`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "6849e957-9e94-4733-92c6-18a019476810",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1 1 1 1 \n",
      "2 2 2 2 2 \n",
      "3 3 3 3 3 \n",
      "4 4 4 4 4 \n",
      "5 5 5 5 5 \n"
     ]
    }
   ],
   "source": [
    "for i in range(1,6):\n",
    "    for j in range(1,6):\n",
    "        print(i, end=\" \")\n",
    "    print(\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6e1f83a-6250-4517-b4e3-eaf1d6679dc5",
   "metadata": {},
   "source": [
    "- `Square Column Number Patterns:`\n",
    "- `12345`\n",
    "- `12345`\n",
    "- `12345`\n",
    "- `12345`\n",
    "- `12345`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "cf899fdf-187f-429b-9a9c-5cc5552dbd7d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 \n",
      "1 2 3 4 5 \n",
      "1 2 3 4 5 \n",
      "1 2 3 4 5 \n",
      "1 2 3 4 5 \n"
     ]
    }
   ],
   "source": [
    "for i in range(1,6):\n",
    "    for j in range(1,6):\n",
    "        print(j, end=\" \")\n",
    "    print(\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "362c781c-c367-45fb-8935-6d9d2470e3b5",
   "metadata": {},
   "source": [
    "- `Right Half Increasing Pyramid Column Number Patterns:`\n",
    "- `1`\n",
    "- `12`\n",
    "- `123`\n",
    "- `1234`\n",
    "- `12345`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "b35b5c40-57a0-43e3-9ff4-32db6d71d6d7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 \n",
      "1 2 \n",
      "1 2 3 \n",
      "1 2 3 4 \n",
      "1 2 3 4 5 \n"
     ]
    }
   ],
   "source": [
    "for i in range(1,6):\n",
    "    for j in range(1,6):\n",
    "        if i>=j:\n",
    "            print(j, end=\" \")\n",
    "    print(\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b004daed-b7d8-4138-8fa4-0b7550a070e8",
   "metadata": {},
   "source": [
    "- `Right Half Decreasing Pyramid Column Number Patterns:`\n",
    "- `12345`\n",
    "- `1234`\n",
    "- `123`\n",
    "- `12`\n",
    "- `1`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "c6732eb6-ed51-4b2e-99df-24307a378b0f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 \n",
      "1 2 3 4 5 \n",
      "1 2 3 4 5 \n",
      "1 2 3 4 5 \n",
      "1 2 3 4 5 \n"
     ]
    }
   ],
   "source": [
    "for i in range(1, 6):\n",
    "    for j in range(1, 6):\n",
    "        print(j, end=\" \")\n",
    "    print(\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ca4491c-3f88-49de-8b27-818e8c1ce425",
   "metadata": {},
   "source": [
    "- `Decreasing Pyramid Patterns:`\n",
    "- `12345`\n",
    "- `2345`\n",
    "- `345`\n",
    "- `45`\n",
    "- `5`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "ae8e4435-f03c-453c-9eb9-33dc70cbe867",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 \n",
      "2 3 4 5 \n",
      "3 4 5 \n",
      "4 5 \n",
      "5 \n"
     ]
    }
   ],
   "source": [
    "for i in range(1,6):\n",
    "    for j in range(1,6):\n",
    "        if i<=j:\n",
    "            print(j, end=\" \")\n",
    "    print(\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50a54529-4128-40b4-9dc7-63de4b4234e6",
   "metadata": {},
   "source": [
    "- `Star Square Patterns:`\n",
    "- `* * * * *`\n",
    "- `* * * * *`\n",
    "- `* * * * *`\n",
    "- `* * * * *`\n",
    "- `* * * * *`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "83a5e99b-d3a2-46ab-9589-a9e6c56ad0b1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* * * * * \n",
      "* * * * * \n",
      "* * * * * \n",
      "* * * * * \n",
      "* * * * * \n"
     ]
    }
   ],
   "source": [
    "for i in range(1,6):\n",
    "    for j in range(1,6):\n",
    "        print(\"*\", end=\" \")\n",
    "    print(\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db09acea-a8cb-49c5-936f-434991bb264c",
   "metadata": {},
   "source": [
    "- `Right Half Pyramid Patterns:`\n",
    "- `*`\n",
    "- `* *`\n",
    "- `* * *`\n",
    "- `* * * *`\n",
    "- `* * * * *`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "0c4bb880-2d85-45f2-b3d3-f22b7fcd4123",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* \n",
      "* * \n",
      "* * * \n",
      "* * * * \n",
      "* * * * * \n"
     ]
    }
   ],
   "source": [
    "for i in range(1,6):\n",
    "    for j in range(1,6):\n",
    "        if i>=j:\n",
    "            print(\"*\", end=\" \")\n",
    "    print(\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "745d3d77-8aef-4c0f-a818-8d2c8c830298",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "* \n",
      "* * \n",
      "* * * \n",
      "* * * * \n",
      "* * * * * \n"
     ]
    }
   ],
   "source": [
    "for i in range(6):\n",
    "    for j in range(i):\n",
    "        print(\"*\",end=\" \")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "745bbe88-9bc5-41ad-a6a1-d33a70bb2543",
   "metadata": {},
   "source": [
    "- `Left Half Pyramid Patterns:`\n",
    "- `* * * * *`\n",
    "- `* * * *`\n",
    "- `* * *`\n",
    "- `* *`\n",
    "- `*`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "7aeb265a-9542-4abb-a4bf-75534da313de",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* * * * * \n",
      "* * * * \n",
      "* * * \n",
      "* * \n",
      "* \n"
     ]
    }
   ],
   "source": [
    "for i in range(1,6):\n",
    "    for j in range(1,6):\n",
    "        if i<=j:\n",
    "            print(\"*\", end=\" \")\n",
    "    print(\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "ade36134-41c7-4d96-a89d-78f90f7526e0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* * * * * \n",
      "* * * * \n",
      "* * * \n",
      "* * \n",
      "* \n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    for j in range(5-i):\n",
    "        print(\"*\",end=\" \")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d5ed9d1-7aa6-4438-b7c1-bef913a635ad",
   "metadata": {},
   "source": [
    "- `Space & Half Pyrmid Pattern` `V25.01.26`\n",
    "- `    *`\n",
    "- `   **`\n",
    "- `  ***`\n",
    "- ` ****`\n",
    "- `*****`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "d01ac921-741a-4b21-9617-2e4567c75198",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     *\n",
      "    **\n",
      "   ***\n",
      "  ****\n",
      " *****\n"
     ]
    }
   ],
   "source": [
    "for i in range(1,6):\n",
    "    for j in range(5,0,-1):\n",
    "        if j>=i:\n",
    "            print(\" \",end=\"\")\n",
    "    for k in range(1,6):\n",
    "        if k<=i:\n",
    "            print(\"*\",end=\"\")  \n",
    "    print(\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b21847a-4a11-4a98-ae9e-7d066c622cf9",
   "metadata": {},
   "source": [
    "- `Space & Half Pyrmid Pattern`\n",
    "- `*****`\n",
    "- ` ****`\n",
    "- `  ***`\n",
    "- `   **`\n",
    "- `    *`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "33443013-0df8-44a6-9af6-d05c96be1189",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " *****\n",
      "  ****\n",
      "   ***\n",
      "    **\n",
      "     *\n"
     ]
    }
   ],
   "source": [
    "for i in range(1,6):\n",
    "    for j in range(1,6):\n",
    "        if j<=i:\n",
    "            print(\" \",end=\"\")\n",
    "    for k in range(5,0,-1):\n",
    "        if k>=i:\n",
    "            print(\"*\",end=\"\")  \n",
    "    print(\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a40ed254-9fdc-45c8-8bf1-27672094c908",
   "metadata": {},
   "source": [
    "- `Space & Pyramid Pattern`\n",
    "- `    **`\n",
    "- `   ****`\n",
    "- `  ******`\n",
    "- ` ********`\n",
    "- `**********`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "5b299dd4-4767-4553-b7c3-92feb5a2a7d4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     **\n",
      "    ****\n",
      "   ******\n",
      "  ********\n",
      " **********\n"
     ]
    }
   ],
   "source": [
    "for i in range(1,6):\n",
    "    for j in range(5,0,-1):\n",
    "        if j>=i:\n",
    "            print(\" \",end=\"\")\n",
    "    for k in range(1,6):\n",
    "        if k<=i:\n",
    "            print(\"*\",end=\"\")\n",
    "    for k in range(1,6):\n",
    "        if k<=i:\n",
    "            print(\"*\",end=\"\")  \n",
    "    print(\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a83bf3f-06b6-4c8d-a781-74ffa74b9f97",
   "metadata": {},
   "source": [
    "- `Space & Pyramid Pattern`\n",
    "- `    *`\n",
    "- `   ***`\n",
    "- `  *****`\n",
    "- ` *******`\n",
    "- `*********`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "01dc230e-1a3a-4bf1-aa90-352618b29927",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     *\n",
      "    ***\n",
      "   *****\n",
      "  *******\n",
      " *********\n"
     ]
    }
   ],
   "source": [
    "for i in range(1,6):\n",
    "    for j in range(5,0,-1):\n",
    "        if j>=i:\n",
    "            print(\" \",end=\"\")\n",
    "    for k in range(1,6):\n",
    "        if k<=i:\n",
    "            print(\"*\",end=\"\")\n",
    "    for k in range(2,6):\n",
    "        if k<=i:\n",
    "            print(\"*\",end=\"\")  \n",
    "    print(\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf0d1204-e499-4f34-abc0-d99244ccd4f0",
   "metadata": {},
   "source": [
    "- `Space & Pyramid Pattern`\n",
    "- `**********`\n",
    "- ` ********`\n",
    "- `  ******`\n",
    "- `   ****`\n",
    "- `    **`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "7a4fee36-8440-4918-8551-28e400ab433f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " **********\n",
      "  ********\n",
      "   ******\n",
      "    ****\n",
      "     **\n"
     ]
    }
   ],
   "source": [
    "for i in range(1,6):\n",
    "    for j in range(1,6):\n",
    "        if j<=i:\n",
    "            print(\" \",end=\"\")\n",
    "    for k in range(5,0,-1):\n",
    "        if k>=i:\n",
    "            print(\"*\",end=\"\")\n",
    "    for k in range(5,0,-1):\n",
    "        if k>=i:\n",
    "            print(\"*\",end=\"\")  \n",
    "    print(\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1566a116-5ad2-413a-91be-9834c68d16b9",
   "metadata": {},
   "source": [
    "- `Space & Pyramid Pattern`\n",
    "- `*********`\n",
    "- ` *******`\n",
    "- `  *****`\n",
    "- `   ***`\n",
    "- `    *`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "9c92ebb3-f99b-43e8-81c5-5536026157d5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " *********\n",
      "  *******\n",
      "   *****\n",
      "    ***\n",
      "     *\n"
     ]
    }
   ],
   "source": [
    "for i in range(1,6):\n",
    "    for j in range(1,6):\n",
    "        if j<=i:\n",
    "            print(\" \",end=\"\")\n",
    "    for k in range(5,0,-1):\n",
    "        if k>=i:\n",
    "            print(\"*\",end=\"\")\n",
    "    for k in range(4,0,-1):\n",
    "        if k>=i:\n",
    "            print(\"*\",end=\"\")  \n",
    "    print(\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2731770b-4b56-4e6e-b681-5ed00f63fa8a",
   "metadata": {},
   "source": [
    "- `Diamond Pattern`\n",
    "- `    *`\n",
    "- `   ***`\n",
    "- `  *****`\n",
    "- ` *******`\n",
    "- `*********`\n",
    "- `*********`\n",
    "- ` *******`\n",
    "- `  *****`\n",
    "- `   ***`\n",
    "- `    *`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "5ecc5d7b-9704-41ad-9254-a99369c50ca8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     *\n",
      "    ***\n",
      "   *****\n",
      "  *******\n",
      " *********\n",
      "  *******\n",
      "   *****\n",
      "    ***\n",
      "     *\n"
     ]
    }
   ],
   "source": [
    "for i in range(1,6):\n",
    "    for j in range(5,0,-1):\n",
    "        if j>=i:\n",
    "            print(\" \",end=\"\")\n",
    "    for k in range(1,6):\n",
    "        if k<=i:\n",
    "            print(\"*\",end=\"\")\n",
    "    for k in range(2,6):\n",
    "        if k<=i:\n",
    "            print(\"*\",end=\"\")  \n",
    "    print(\"\")\n",
    "for i in range(1,5):\n",
    "    for j in range(0,5):\n",
    "        if j<=i:\n",
    "            print(\" \",end=\"\")\n",
    "    for k in range(4,0,-1):\n",
    "        if k>=i:\n",
    "            print(\"*\",end=\"\")\n",
    "    for k in range(3,0,-1):\n",
    "        if k>=i:\n",
    "            print(\"*\",end=\"\")  \n",
    "    print(\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6315971-6ca7-4bdc-b79d-4920db9c5816",
   "metadata": {},
   "source": [
    "## `Function: V25.01.20`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9afc961c-cf60-4baa-86d5-f4f63b0bc69b",
   "metadata": {},
   "source": [
    "- Block of code which executes targeted Logic."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b003e431-e2f7-42b4-a178-14a978d8c3eb",
   "metadata": {},
   "source": [
    "## `Non-paametrise Function`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "8a4d4bae-a02e-4a39-96fb-141424ee873b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello I.T.\n"
     ]
    }
   ],
   "source": [
    "def Info():\n",
    "    print(\"Hello I.T.\")\n",
    "Info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "ad397e59-dee7-49e8-89d2-71559ecefbe9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello I.T.\n"
     ]
    }
   ],
   "source": [
    "def Name():\n",
    "    print(\"Hello Pratik..!\")\n",
    "Info()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a8a1ef9-ccb9-4b1a-a388-354f119d5513",
   "metadata": {},
   "source": [
    "- `return keyword` : `Returns to Function Call Value.`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "0a9ca742-1789-438b-bdf6-e600ede85168",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a Number:  55\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Number is:  55\n"
     ]
    }
   ],
   "source": [
    "def Data():\n",
    "    a = int(input(\"Enter a Number: \"))\n",
    "    return a;\n",
    "Num = Data()\n",
    "print(\"Enter Number is: \",Num)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55d2a5d1-b6f3-494b-9b76-f61dafbdbd83",
   "metadata": {},
   "source": [
    "- `Question: Accept two values from User and return there Addition, Subtraction, Multiplication, Division.`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "715e26cc-efb3-441f-8a5d-32f05f4dbf7d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1'st Number:  5\n",
      "Enter 2'nd Number:  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Addition of two Numbers is:  10\n"
     ]
    }
   ],
   "source": [
    "def add():\n",
    "    a = int(input(\"Enter 1'st Number: \"))\n",
    "    b = int(input(\"Enter 2'nd Number: \"))\n",
    "    return a+b;\n",
    "result = add()\n",
    "print(\"Addition of two Numbers is: \",result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "f7acc331-4398-4b34-a7ff-baac0b023cbb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1'st Number:  6\n",
      "Enter 2'nd Number:  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Subtraction of two Numbers is:  1\n"
     ]
    }
   ],
   "source": [
    "def sub():\n",
    "    a = int(input(\"Enter 1'st Number: \"))\n",
    "    b = int(input(\"Enter 2'nd Number: \"))\n",
    "    return a-b;\n",
    "result = sub()\n",
    "print(\"Subtraction of two Numbers is: \",result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "bdfb7245-c152-494f-a7ab-93483b747b2f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1'st Number:  5\n",
      "Enter 2'nd Number:  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Multiplication of two Numbers is:  25\n"
     ]
    }
   ],
   "source": [
    "def mul():\n",
    "    a = int(input(\"Enter 1'st Number: \"))\n",
    "    b = int(input(\"Enter 2'nd Number: \"))\n",
    "    return a*b;\n",
    "result = mul()\n",
    "print(\"Multiplication of two Numbers is: \",result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "cd456cf3-e4df-46c9-88ca-188c8113a8bc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1'st Number:  5\n",
      "Enter 2'nd Number:  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Division of two Numbers is:  1.0\n"
     ]
    }
   ],
   "source": [
    "def div():\n",
    "    a = int(input(\"Enter 1'st Number: \"))\n",
    "    b = int(input(\"Enter 2'nd Number: \"))\n",
    "    return a/b;\n",
    "result = div()\n",
    "print(\"Division of two Numbers is: \",result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "cdd27509-f95b-4a9d-bde8-cc92e1e1d10b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1'st Number:  5\n",
      "Enter 2'nd Number:  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Modulos of two Numbers is:  0\n"
     ]
    }
   ],
   "source": [
    "def mod():\n",
    "    a = int(input(\"Enter 1'st Number: \"))\n",
    "    b = int(input(\"Enter 2'nd Number: \"))\n",
    "    return a%b;\n",
    "result = mod()\n",
    "print(\"Modulos of two Numbers is: \",result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "c128c4ad-4dc8-41e0-a729-4f8c6347f929",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1'st Number:  5\n",
      "Enter 2'nd Number:  2\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Power of two Numbers is:  25\n"
     ]
    }
   ],
   "source": [
    "def expo():\n",
    "    a = int(input(\"Enter 1'st Number: \"))\n",
    "    b = int(input(\"Enter 2'nd Number: \"))\n",
    "    return a**b;\n",
    "result = expo()\n",
    "print(\"Power of two Numbers is: \",result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fba9ce1d-415e-4dfa-b272-8c153074edb1",
   "metadata": {},
   "source": [
    "- `break keyword is part of loop`  -> `Terminates the Execution of Code.`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "d2c16858-73dd-4eee-9fab-a6509facb0dc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 "
     ]
    }
   ],
   "source": [
    "def loop1():\n",
    "    for i in range(1,11):\n",
    "        if i == 5:\n",
    "            break\n",
    "        else:\n",
    "            print(i,end=\" \")\n",
    "loop1()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5309588e-339e-45e0-8652-6744cd314733",
   "metadata": {},
   "source": [
    "- `continue keyword is part of loop` -> `Omits Perticular Situation.`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "86521a8f-3757-4ea4-afbf-ad289293ffd2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 6 7 8 9 10 "
     ]
    }
   ],
   "source": [
    "def loop1():\n",
    "    for i in range(1,11):\n",
    "        if i == 5:\n",
    "            continue\n",
    "        else:\n",
    "            print(i,end=\" \")\n",
    "loop1()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "075fa557-8868-4f99-a7b7-e133d640d1d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 6 8 9 10 "
     ]
    }
   ],
   "source": [
    "def loop1():\n",
    "    for i in range(1,11):\n",
    "        if i == 7:\n",
    "            continue\n",
    "        else:\n",
    "            print(i,end=\" \")\n",
    "loop1()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "2f956e2d-f6ae-4d8f-ad5c-147c89b8ffcf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 6 7 8 9 10 "
     ]
    }
   ],
   "source": [
    "def loop1():\n",
    "    for i in range(1,11):\n",
    "        if i == 7:\n",
    "            print(i,end=\" \")\n",
    "            continue\n",
    "        else:\n",
    "            print(i,end=\" \")\n",
    "loop1()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "47657536-26c8-4942-b7d2-398d6b3ecb42",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "def data():\n",
    "    a = 5\n",
    "    return a\n",
    "print(data())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "41806129-7df0-4dc4-92b9-ba5a70b20e39",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25\n"
     ]
    }
   ],
   "source": [
    "def data():\n",
    "    a = 5\n",
    "    return a * 5\n",
    "print(data())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "98b97d58-74b9-4b2d-8149-f01cbbf8711f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Value of Int is: 25 Value of String is: Pratik\n"
     ]
    }
   ],
   "source": [
    "def data1():\n",
    "    a = 5\n",
    "    return a * 5\n",
    "def data2():\n",
    "    a = \"Pratik\"\n",
    "    return a\n",
    "print(\"Value of Int is:\",data1(),\"Value of String is:\",data2())\n",
    "# Single Python Code has Mutiple Funtions.\n",
    "# function name should be Unique.\n",
    "# Multiple Python Function can be call in single print function."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73bdc995-93a6-4fe9-b915-0147d248a32b",
   "metadata": {},
   "source": [
    "### `Parametrise Function` \n",
    "- `Compatible - Same Data Type`\n",
    "- `No. of Argument should Match with No. of Parameters. `"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "844181c9-7dc4-4382-9f5a-be15db2b53c8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Addition of two Number is 39\n"
     ]
    }
   ],
   "source": [
    "def add(a,b,c):\n",
    "    return a+b+c\n",
    "print(\"Addition of two Number is\",add(12,13,14))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "d3eb80db-3e14-4bc6-bace-5d8b7aa1d1a8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Addition of two Number is 39\n"
     ]
    }
   ],
   "source": [
    "def add(a,b,c):\n",
    "    return a+b+c\n",
    "# print(\"Addition of two Number is\",add(12,13,14))\n",
    "def add(a,b,c):\n",
    "    return a+b+c\n",
    "print(\"Addition of two Number is\",add(12,13,14))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "bbc6bf3c-4ab6-4fc9-bfc5-907a092b2054",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Addition of two Number is 39\n"
     ]
    }
   ],
   "source": [
    "def add(a,b):\n",
    "    return a+b+c\n",
    "# print(\"Addition of two Number is\",add(12,13,14))\n",
    "def add(a,b,c):\n",
    "    return a+b+c\n",
    "print(\"Addition of two Number is\",add(12,13,14))\n",
    "# Processor Executes Closer Function. jo sabse close hoga use execute karega. means here is : def add(a,b,c):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "10cdbf81-9b59-4027-a587-075f8298208e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Block 2\n",
      "Addition of two Number is 39\n"
     ]
    }
   ],
   "source": [
    "def add(a,b):\n",
    "    print(\"Block 1\")\n",
    "    return a+b+c\n",
    "# print(\"Addition of two Number is\",add(12,13,14))\n",
    "def add(a,b,c):\n",
    "    print(\"Block 2\")\n",
    "    return a+b+c\n",
    "print(\"Addition of two Number is\",add(12,13,14))\n",
    "# Processor Executes Closer Function. jo sabse close hoga use execute karega. means here is : def add(a,b,c):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "0c6397e2-f578-4153-8eec-bb314ae2e3ef",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "add() missing 1 required positional argument: 'c'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[47], line 8\u001b[0m\n\u001b[0;32m      6\u001b[0m     \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mBlock 2\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m      7\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m a\u001b[38;5;241m+\u001b[39mb\u001b[38;5;241m+\u001b[39mc\n\u001b[1;32m----> 8\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mAddition of two Number is\u001b[39m\u001b[38;5;124m\"\u001b[39m,\u001b[43madd\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m12\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m13\u001b[39;49m\u001b[43m)\u001b[49m)\n\u001b[0;32m      9\u001b[0m \u001b[38;5;66;03m# Processor Executes Closer Function. jo sabse close hoga use execute karega. means here is : def add(a,b):\u001b[39;00m\n",
      "\u001b[1;31mTypeError\u001b[0m: add() missing 1 required positional argument: 'c'"
     ]
    }
   ],
   "source": [
    "def add(a,b):\n",
    "    print(\"Block 1\")\n",
    "    return a+b+c\n",
    "# print(\"Addition of two Number is\",add(12,13,14))\n",
    "def add(a,b,c):\n",
    "    print(\"Block 2\")\n",
    "    return a+b+c\n",
    "print(\"Addition of two Number is\",add(12,13))\n",
    "# Creates Ambiguity : Multiple Functions has same name. Mis-match Function. priority has closest one Function.  \n",
    "# Processor Executes Closer Function. jo sabse close hoga use execute karega. means here is : def add(a,b):"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9a86a44-fd15-4f32-8083-775457bd2c60",
   "metadata": {},
   "source": [
    "- `Arithmatic Operatios`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "3ccd67ce-f58f-4645-971b-03d3d61e2548",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1'st Number:  5\n",
      "Enter 2nd Number:  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Addition of two Number is  25\n"
     ]
    }
   ],
   "source": [
    "def add(num1,num2):\n",
    "    return num1+num2;\n",
    "num1 = int(input(\"Enter 1'st Number: \"))\n",
    "num2 = int(input(\"Enter 2nd Number: \"))\n",
    "print(\"Addition of two Number is \",add(num1,num2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "9f65db59-1580-4640-adcd-6319947e8c07",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1'st Number:  6\n",
      "Enter 2nd Number:  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Subtraction of two Number is  -1\n"
     ]
    }
   ],
   "source": [
    "def sub(num1,num2):\n",
    "    return num1-num2;\n",
    "num1 = int(input(\"Enter 1'st Number: \"))\n",
    "num2 = int(input(\"Enter 2nd Number: \"))\n",
    "print(\"Subtraction of two Number is \",sub(num1,num2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "c2bbe5fc-2003-4e7b-ac15-b167232af165",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1'st Number:  5\n",
      "Enter 2nd Number:  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Multiplication of two Number is  25\n"
     ]
    }
   ],
   "source": [
    "def mul(num1,num2):\n",
    "    return num1*num2;\n",
    "num1 = int(input(\"Enter 1'st Number: \"))\n",
    "num2 = int(input(\"Enter 2nd Number: \"))\n",
    "print(\"Product of two Number is \",sub(num1,num2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "4279aef7-f208-4f57-ba75-f9028ac68259",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1'st Number:  5\n",
      "Enter 2nd Number:  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Divesion of two Number is  1.0\n"
     ]
    }
   ],
   "source": [
    "def div(num1,num2):\n",
    "    return num1/num2;\n",
    "num1 = int(input(\"Enter 1'st Number: \"))\n",
    "num2 = int(input(\"Enter 2nd Number: \"))\n",
    "print(\"Questiont of two Number is \",div(num1,num2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "71438589-7d3f-46a3-adef-7ec64c2f7e81",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1'st Number:  5\n",
      "Enter 2nd Number:  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Floor of two Number is  1\n"
     ]
    }
   ],
   "source": [
    "def floor(num1,num2):\n",
    "    return num1//num2;\n",
    "num1 = int(input(\"Enter 1'st Number: \"))\n",
    "num2 = int(input(\"Enter 2nd Number: \"))\n",
    "print(\"Base Integer value of two Number is \",floor(num1,num2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "f085395c-81bf-43bd-a894-efab25c06632",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1'st Number:  6\n",
      "Enter 2nd Number:  6\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Remainder of two Number is  0\n"
     ]
    }
   ],
   "source": [
    "def mod(num1,num2):\n",
    "    return num1%num2;\n",
    "num1 = int(input(\"Enter 1'st Number: \"))\n",
    "num2 = int(input(\"Enter 2nd Number: \"))\n",
    "print(\"Remainder of two Number is \",mod(num1,num2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "3f96c42e-9262-4fa2-81de-282dacb4b733",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1'st Number:  5\n",
      "Enter 2nd Number:  3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Power of two Number is  125\n"
     ]
    }
   ],
   "source": [
    "def expo(num1,num2):\n",
    "    return num1**num2;\n",
    "num1 = int(input(\"Enter 1'st Number: \"))\n",
    "num2 = int(input(\"Enter 2nd Number: \"))\n",
    "print(\"Power of two Number is \",expo(num1,num2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3473454c-8817-417d-8f54-081841ed5856",
   "metadata": {},
   "source": [
    "- `Bitwise Operatios`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "e2a8cc22-b47d-43a1-8b42-ff6f9d6cb3ef",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bitwise Operator\n",
      "0b1111\n",
      "1\n",
      "15\n",
      "4\n",
      "-12\n",
      "0b11\n",
      "0b111100\n",
      "3\n",
      "60\n"
     ]
    }
   ],
   "source": [
    "print(\"Bitwise Operator\")\n",
    "print(bin(15))\n",
    "print(1 & 1)\n",
    "print(15 | 11)\n",
    "print(15 ^ 11)\n",
    "print(~11)\n",
    "print(bin(15>>2))\n",
    "print(bin(15<<2))\n",
    "print(15>>2)\n",
    "print(15<<2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "72822ceb-1b49-47bc-a479-d1f4ca07a1b4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1'st Number:  1\n",
      "Enter 2nd Number:  0\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "And of two Number is  0\n"
     ]
    }
   ],
   "source": [
    "def aand(num1,num2):\n",
    "    return num1 & num2;\n",
    "num1 = int(input(\"Enter 1'st Number: \"))\n",
    "num2 = int(input(\"Enter 2nd Number: \"))\n",
    "result = aand(num1,num2)\n",
    "print(\"And of two Number is \",result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "e10d64f3-1546-4d7c-8a4a-ee894c09803a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1'st Number:  1\n",
      "Enter 2nd Number:  0\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Or of two Number is  1\n"
     ]
    }
   ],
   "source": [
    "def oor(num1,num2):\n",
    "    return num1 | num2;\n",
    "num1 = int(input(\"Enter 1'st Number: \"))\n",
    "num2 = int(input(\"Enter 2nd Number: \"))\n",
    "result = oor(num1,num2)\n",
    "print(\"Or of two Number is \",result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "d720e4c3-c3b0-4325-8e46-e0b2f99dee92",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1'st Number:  15\n",
      "Enter 2nd Number:  12\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ex-Or of two Number is  3\n"
     ]
    }
   ],
   "source": [
    "def exor(num1,num2):\n",
    "    return num1 ^ num2;\n",
    "num1 = int(input(\"Enter 1'st Number: \"))\n",
    "num2 = int(input(\"Enter 2nd Number: \"))\n",
    "result = exor(num1,num2)\n",
    "print(\"Ex-Or of two Number is \",result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "1ebc9e1c-1036-4d61-9c48-2063d54602e4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1'st Number:  1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ex-Or of two Number is  -2\n"
     ]
    }
   ],
   "source": [
    "def exor(num1):\n",
    "    return ~num1;\n",
    "num1 = int(input(\"Enter 1'st Number: \"))\n",
    "result = exor(num1)\n",
    "print(\"Ex-Or of two Number is \",result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "fbab1b20-43d3-482d-be0a-44256b1ef0cc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1'st Number:  15\n",
      "Enter 2nd Number:  2\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ex-Or of two Number is  60\n"
     ]
    }
   ],
   "source": [
    "def lso(num1,num2):\n",
    "    return num1 << num2;\n",
    "num1 = int(input(\"Enter 1'st Number: \"))\n",
    "num2 = int(input(\"Enter 2nd Number: \"))\n",
    "result = lso(num1,num2)\n",
    "print(\"Ex-Or of two Number is \",result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "58894d9e-bbda-424a-9c7e-14c0dbb30b01",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1'st Number:  15\n",
      "Enter 2nd Number:  2\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ex-Or of two Number is  3\n"
     ]
    }
   ],
   "source": [
    "def rso(num1,num2):\n",
    "    return num1 >> num2;\n",
    "num1 = int(input(\"Enter 1'st Number: \"))\n",
    "num2 = int(input(\"Enter 2nd Number: \"))\n",
    "result = rso(num1,num2)\n",
    "print(\"Ex-Or of two Number is \",result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "6fb9ad2c-4434-41bd-ad1f-864e6d4276ac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1'st Number:  15\n",
      "Enter 2nd Number:  2\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0b1111\n",
      "Ex-Or of two Number is  0b11\n",
      "Ex-Or of two Number is  3\n"
     ]
    }
   ],
   "source": [
    "def rso(num1,num2):\n",
    "    return num1 >> num2;\n",
    "num1 = int(input(\"Enter 1'st Number: \"))\n",
    "num2 = int(input(\"Enter 2nd Number: \"))\n",
    "result = rso(num1,num2)\n",
    "print(bin(num1))\n",
    "print(\"Ex-Or of two Number is \",bin(result))\n",
    "print(\"Ex-Or of two Number is \",result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "f0f7f72e-228a-44a0-a0f5-1dce0a04bd07",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1'st Number:  15\n",
      "Enter 2nd Number:  2\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0b1111\n",
      "Ex-Or of two Number is  0b111100\n",
      "Ex-Or of two Number is  60\n"
     ]
    }
   ],
   "source": [
    "def lso(num1,num2):\n",
    "    return num1 << num2;\n",
    "num1 = int(input(\"Enter 1'st Number: \"))\n",
    "num2 = int(input(\"Enter 2nd Number: \"))\n",
    "result = lso(num1,num2)\n",
    "print(bin(num1))\n",
    "print(\"Ex-Or of two Number is \",bin(result))\n",
    "print(\"Ex-Or of two Number is \",result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd856877-3837-4d4f-b1d8-28fdf9b9cc96",
   "metadata": {},
   "source": [
    "### `OOP's: Object Oriented Programming V25.01.21`\n",
    "- `Identation`\n",
    "- `Class`\n",
    "- `Constructor`\n",
    "- `Class Constructor`\n",
    "- `Method`\n",
    "- `Object`\n",
    "- `Refrence Variable`\n",
    "- `Instance Variable`\n",
    "- `Local Variable`\n",
    "- `Self keyword`\n",
    "- `Self parameter` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ec39fffc-1a77-4905-a4d2-28e36de28c00",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python Programming!!\n"
     ]
    }
   ],
   "source": [
    "class DataInformation:\n",
    "    def Data(self):\n",
    "        print(\"Python Programming!!\")\n",
    "obj = DataInformation()\n",
    "obj.Data()        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "75421d81-5f7e-4486-90e0-0183da774996",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Method1\n",
      "Method2\n",
      "num1 is  21\n",
      "Method3\n",
      "num1 is  31\n",
      "num2 is  41\n"
     ]
    }
   ],
   "source": [
    "class Data:\n",
    "    def Method1(self):\n",
    "        print(\"Method1\")\n",
    "    def Method2(self,num1):\n",
    "        print(\"Method2\")\n",
    "        print(\"num1 is \",num1)\n",
    "    def Method3(self,num1,num2):\n",
    "        print(\"Method3\")\n",
    "        print(\"num1 is \",num1)\n",
    "        print(\"num2 is \",num2)\n",
    "obj = Data()\n",
    "obj.Method1()\n",
    "obj.Method2(21)\n",
    "obj.Method3(31,41)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "22a8b61b-67ee-45df-a85c-b050505ff14c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 6 7 8 9 10 "
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "while(a<11):\n",
    "    print(a,end=\" \")\n",
    "    a=a+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "7e54430a-ab45-4904-8c26-d73b35c120c4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 9 8 7 6 5 4 3 2 1 "
     ]
    }
   ],
   "source": [
    "a = 10\n",
    "while(a>0):\n",
    "    print(a,end=\" \")\n",
    "    a=a-1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "626aff9c-624b-48c1-9ee7-74a574315763",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "1 2 3 4 5 6 7 8 9 10 \n",
      "10 9 8 7 6 5 4 3 2 1 "
     ]
    }
   ],
   "source": [
    "class Iteration:\n",
    "    def Loop1(self):\n",
    "        a = 1\n",
    "        while(a<11):\n",
    "            print(a,end=\" \")\n",
    "            a = a+1\n",
    "    print()\n",
    "    def Loop2(self):\n",
    "        a = 10\n",
    "        while(a>0):\n",
    "            print(a,end=\" \")\n",
    "            a = a-1\n",
    "obj = Iteration()\n",
    "obj.Loop1()\n",
    "print()\n",
    "obj.Loop2()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8197cecc-305a-40e6-b6e6-c4048cb61d44",
   "metadata": {},
   "source": [
    "- `Armstrong Number: 153` `A Number whose Summation of Cube of Each Digit is the same Number.`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "1957d9d7-e0a0-461e-ab06-ebcc4e52e637",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a Number 121\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "121 is not an Armstrong Number.\n"
     ]
    }
   ],
   "source": [
    "class Armstrong:\n",
    "    def Evaluate(self):\n",
    "        num = int(input(\"Enter a Number\"))\n",
    "        temp = num\n",
    "        sum = 0\n",
    "        while(num>0):\n",
    "            rem = num % 10\n",
    "            sum = sum + (rem*rem*rem)\n",
    "            num = num // 10\n",
    "        if sum == temp:\n",
    "            print(sum,\"is an Armstrong Number.\")\n",
    "        else:\n",
    "            print(temp,\"is not an Armstrong Number.\")\n",
    "obj = Armstrong()\n",
    "obj.Evaluate()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a1e38ea-aeb6-43dc-91b2-343d7805010f",
   "metadata": {},
   "source": [
    "- `Palindrome Number: 121` `A Number Whose Reverce is the same Number.`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "f45090c5-6169-4f68-8f30-57f4d7440ef2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a Number:  232\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "232 is a Palindrom Number.\n"
     ]
    }
   ],
   "source": [
    "class Palindrome:\n",
    "    def Evaluate(self):\n",
    "        num = int(input(\"Enter a Number: \"))\n",
    "        temp = num\n",
    "        sum = 0\n",
    "        while(num>0):\n",
    "            rem = num % 10\n",
    "            sum = (sum *10) + rem\n",
    "            num = num // 10\n",
    "        if sum == temp:\n",
    "            print(sum, \"is a Palindrom Number.\")\n",
    "        else:\n",
    "            print(temp, \"is not a Palindrome Number.\")\n",
    "obj = Palindrome()\n",
    "obj.Evaluate()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8ae0d74-1ed7-4b56-adae-db0f328c0459",
   "metadata": {},
   "source": [
    "- `Factorial Number: 5!` `Consider fact = 1 and multiply with ( i ) till the range is satisfy`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "9468fa50-f250-4887-a6a2-9e6ce82e7e67",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a Number:  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Factorial of  5 is  120\n"
     ]
    }
   ],
   "source": [
    "class Factorial:\n",
    "    def Evaluate(self):\n",
    "        fact = 1\n",
    "        num = int(input(\"Enter a Number: \"))\n",
    "        for i in range(1,num+1):\n",
    "            fact = fact*i\n",
    "        print(\"Factorial of \",num,\"is \",fact)\n",
    "obj = Factorial()\n",
    "obj.Evaluate()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05a6beea-97c1-4741-822d-861ce57ff573",
   "metadata": {},
   "source": [
    "- `Fibonacci Series: 0 1 1 2 3 5 8` `Addition of Privious two Numbers.` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "5c764ea8-0ad0-480b-81e7-0d5c5b119621",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the Range:  10\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0  1  1  2  3  5  8  13  21  34  "
     ]
    }
   ],
   "source": [
    "class Fibonacci:\n",
    "    def Evaluate(self):\n",
    "        p1 = 0\n",
    "        p2 = 1\n",
    "        num = int(input(\"Enter the Range: \"))\n",
    "        print(p1,\"\",p2,\" \",end=\"\")\n",
    "        for i in range(2,num):\n",
    "            p3 = p1 + p2\n",
    "            print(p3,\" \",end=\"\")\n",
    "            p1 = p2\n",
    "            p2 = p3\n",
    "obj = Fibonacci()\n",
    "obj.Evaluate()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "382ce032-9663-4ae7-bbbd-e8b44715b72f",
   "metadata": {},
   "source": [
    "- `Constructor`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "013ce597-5e3a-4ce8-932e-f670e15121ca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Constructor..\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<__main__.Data at 0x271adbdd3d0>"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Data:\n",
    "    a = 10\n",
    "    b = 20\n",
    "    def __init__(self):\n",
    "        print(\"Constructor..\")\n",
    "Data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "e529deca-03d1-4fa0-91c6-10ec3a379327",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Constructor..\n",
      "Method1\n",
      "Method2\n",
      "num1 is:  30\n",
      "Method3\n",
      "num1 is:  40\n",
      "num2 is:  50\n"
     ]
    }
   ],
   "source": [
    "class Data:\n",
    "    num1 = 10\n",
    "    num2 = 20\n",
    "    def __init__(self):\n",
    "        print(\"Constructor..\")\n",
    "    def Method1(self):\n",
    "        print(\"Method1\")\n",
    "    def Method2(self,num1):\n",
    "        print(\"Method2\")\n",
    "        print(\"num1 is: \",num1)\n",
    "    def Method3(self,num1,num2):\n",
    "        print(\"Method3\")\n",
    "        print(\"num1 is: \",num1)\n",
    "        print(\"num2 is: \",num2)\n",
    "obj = Data()\n",
    "obj.Method1()\n",
    "obj.Method2(30)\n",
    "obj.Method3(40,50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "34fe7c60-be43-45d3-8090-aa0e6e196f1e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Constructor..\n",
      "Method1\n",
      "Method2\n",
      "num1 is:  30\n",
      "Method3\n",
      "num1 is:  10\n",
      "num2 is:  20\n"
     ]
    }
   ],
   "source": [
    "class Data:\n",
    "    num1 = 10\n",
    "    num2 = 20\n",
    "    def __init__(self):\n",
    "        print(\"Constructor..\")\n",
    "    def Method1(self):\n",
    "        print(\"Method1\")\n",
    "    def Method2(self,num1):\n",
    "        print(\"Method2\")\n",
    "        print(\"num1 is: \",num1)\n",
    "    def Method3(self,num1,num2):\n",
    "        print(\"Method3\")\n",
    "        print(\"num1 is: \",self.num1)\n",
    "        print(\"num2 is: \",self.num2)\n",
    "obj = Data()\n",
    "obj.Method1()\n",
    "obj.Method2(30)\n",
    "obj.Method3(40,50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "29296bb2-1bf1-487c-8288-8553da675392",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Constructor..\n",
      "Method_3\n",
      "num1 is:  10\n",
      "num2 is:  20\n",
      "Method_2\n",
      "num1 is:  10\n",
      "Method_1\n"
     ]
    }
   ],
   "source": [
    "class Data:\n",
    "    num1 = 10\n",
    "    num2 = 20\n",
    "    def __init__(self):\n",
    "        print(\"Constructor..\")\n",
    "    def Method1(self):\n",
    "        self.Method2(30)\n",
    "        print(\"Method_1\")\n",
    "    def Method2(self,num1):\n",
    "        self.Method3(40,50)\n",
    "        print(\"Method_2\")\n",
    "        print(\"num1 is: \",self.num1)\n",
    "    def Method3(self,num1,num2):\n",
    "        print(\"Method_3\")\n",
    "        print(\"num1 is: \",self.num1)\n",
    "        print(\"num2 is: \",self.num2)\n",
    "obj = Data()\n",
    "obj.Method1()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "eabf6061-bef9-4b65-ada3-caec52406075",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Constructor..\n",
      "num1 is:  100\n",
      "num2 is:  200\n",
      "Method1\n",
      "Method2\n",
      "num1 is:  30\n",
      "Method3\n",
      "num1 is:  10\n",
      "num2 is:  20\n"
     ]
    }
   ],
   "source": [
    "class Data:\n",
    "    num1 = 10\n",
    "    num2 = 20\n",
    "    def __init__(self,num1,num2):\n",
    "        print(\"Constructor..\")\n",
    "        print(\"num1 is: \",num1)\n",
    "        print(\"num2 is: \",num2)\n",
    "    def Method1(self):\n",
    "        print(\"Method1\")\n",
    "    def Method2(self,num1):\n",
    "        print(\"Method2\")\n",
    "        print(\"num1 is: \",num1)\n",
    "    def Method3(self,num1,num2):\n",
    "        print(\"Method3\")\n",
    "        print(\"num1 is: \",self.num1)\n",
    "        print(\"num2 is: \",self.num2)\n",
    "obj = Data(100,200)\n",
    "obj.Method1()\n",
    "obj.Method2(30)\n",
    "obj.Method3(40,50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "413a6e04-87ec-44b0-8285-68119db16e20",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Constructor..\n",
      "num1 is:  10\n",
      "num2 is:  20\n",
      "Method1\n",
      "Method2\n",
      "num1 is:  30\n",
      "Method3\n",
      "num1 is:  10\n",
      "num2 is:  20\n"
     ]
    }
   ],
   "source": [
    "class Data:\n",
    "    num1 = 10\n",
    "    num2 = 20\n",
    "    def __init__(self,num1,num2):\n",
    "        print(\"Constructor..\")\n",
    "        print(\"num1 is: \",self.num1)\n",
    "        print(\"num2 is: \",self.num2)\n",
    "    def Method1(self):\n",
    "        print(\"Method1\")\n",
    "    def Method2(self,num1):\n",
    "        print(\"Method2\")\n",
    "        print(\"num1 is: \",num1)\n",
    "    def Method3(self,num1,num2):\n",
    "        print(\"Method3\")\n",
    "        print(\"num1 is: \",self.num1)\n",
    "        print(\"num2 is: \",self.num2)\n",
    "obj = Data(100,200)\n",
    "obj.Method1()\n",
    "obj.Method2(30)\n",
    "obj.Method3(40,50)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5c534f4-9429-4140-9dbb-252a0725d949",
   "metadata": {},
   "source": [
    "- `Lambda Function: V25.01.23` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "8d949795-327a-4ef7-8f5e-ef843b984ba1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "35\n"
     ]
    }
   ],
   "source": [
    "value = lambda a: a+10\n",
    "print(value(25))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e55155f6-c752-4644-b1b8-69193dcbea22",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "315\n"
     ]
    }
   ],
   "source": [
    "a = lambda c,d,e: c*d*e\n",
    "print(a(5,7,9))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60214f5c-cbd5-41dd-bf9e-c95e02de9283",
   "metadata": {},
   "source": [
    "- `Nested function (Inner Function):`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "bc5c13de-8d29-4967-978d-480a0e554490",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Addition is  12\n",
      "Subtraction is  -1\n",
      "Multiplication is  6000\n",
      "Division is  2.0\n"
     ]
    }
   ],
   "source": [
    "def Add(a,b):\n",
    "    print(\"Addition is \",(a+b))\n",
    "    def Sub(a,b):\n",
    "        print(\"Subtraction is \",(a-b))\n",
    "        def Mul(a,b,c):\n",
    "            print(\"Multiplication is \",(a*b*c))\n",
    "            def Div(a,b):\n",
    "                print(\"Division is \",(a/b))\n",
    "            Div(10,5)\n",
    "        Mul(10,20,30)\n",
    "    Sub(10,11)\n",
    "Add(5,7)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb260915-121b-4e26-a0ea-ac3b20b8874b",
   "metadata": {},
   "source": [
    "### `String & It's functions:`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b892ec39-0723-4aaa-b569-59972449088d",
   "metadata": {},
   "source": [
    "- `isalnum:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "0d8d4f8e-613f-41fb-b42d-74d9b6e6e40d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "data = \"Python12345\"\n",
    "print(data.isalnum())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "6374f8c8-f32a-45cc-8b40-08b62439070b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "data = \"Python 12345\"\n",
    "print(data.isalnum())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "350ec2f5-89ff-4310-956c-c3f951f12787",
   "metadata": {},
   "source": [
    "- `isalpha:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "f17df4f5-4170-48c0-ab2d-0af6a2593cb9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "data = \"ABCD\"\n",
    "print(data.isalpha())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "5ec4ff69-6e01-4dd7-8e2f-7e611a97f9d7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "data = \"1ABCD\"\n",
    "print(data.isalpha())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5a51292-a2e4-45af-b00d-ca107a1addee",
   "metadata": {},
   "source": [
    "- `isupper:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "b95dfc70-cce0-44ea-88df-51f43a8d3603",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "data = \"ABCD\"\n",
    "print(data.isupper())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1eb25347-3735-4405-a56a-37e77b620095",
   "metadata": {},
   "source": [
    "- `islower:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "5d29a50f-ff7f-4e8b-a7ba-f0c1e2ce0968",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "data = \"ABCD\"\n",
    "print(data.islower())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "db67cc7c-3ea3-4076-aad4-e70bbd0dba9c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "data = \"pqrs\"\n",
    "print(data.islower())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "c1c403bf-e229-4fb8-862f-e0eb25c3ee4f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "data = \"pqrs\"\n",
    "print(data.isupper())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90de6671-2c6d-4ff3-82c4-ed7a931c6615",
   "metadata": {},
   "source": [
    "- `isdigit:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "b883443c-0323-4461-8cb2-7023c876a9b4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "data = \"1234\"\n",
    "print(data.isdigit())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "3b13f25a-ab72-42e9-aec6-25df0583adc3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "data = \"1234 \"\n",
    "print(data.isdigit())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "ed709914-74b5-4447-9166-1d0db59dc921",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "data = \"1234A\"\n",
    "print(data.isdigit())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f767d40d-8982-4406-8215-8be8cd520a17",
   "metadata": {},
   "source": [
    "- `Concatination:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "6b221124-7c29-4b93-9f91-6505c3248bbd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hi, How are you?\n"
     ]
    }
   ],
   "source": [
    "a = \"hi,\"\n",
    "b = \" How are you?\"\n",
    "result = a+b\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "da71b368-dc97-418b-88f3-287969d8e81a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hi, How are you?\n"
     ]
    }
   ],
   "source": [
    "a = \"hi,\"\n",
    "b = \"How are you?\"\n",
    "result = a+\" \"+b\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "daa56d36-8509-43cc-8893-8115452deca4",
   "metadata": {},
   "source": [
    "- `join:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "ce1bb277-e5d8-4862-a975-df719cacabe5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H sad a sad p sad p sad y\n"
     ]
    }
   ],
   "source": [
    "s1 = \" sad \"\n",
    "s2 = \"Happy\"\n",
    "result = s1.join(s2)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "77d05326-ec57-4a45-b7ee-891dd0af6ac0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s Happy a Happy d\n"
     ]
    }
   ],
   "source": [
    "s1 = \"sad\"\n",
    "s2 = \" Happy \"\n",
    "result = s2.join(s1)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd50d47d-55e1-487a-9458-bc3e0b5db238",
   "metadata": {},
   "source": [
    "- `lower:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "732006ea-a019-466f-9aaa-73218c95f014",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "happy\n"
     ]
    }
   ],
   "source": [
    "s3 = \"HAPPY\"\n",
    "print(s3.lower())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c7ca62b-bd3f-4335-b65a-099b798c732f",
   "metadata": {},
   "source": [
    "- `upper:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "0f3ff02c-3a9c-459c-9f4c-c0d2a8b4bc5c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HAPPY\n"
     ]
    }
   ],
   "source": [
    "s3 = \"happy\"\n",
    "print(s3.upper())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "15e0208e-cc49-4518-948b-555a8c4b3251",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ABCD\n"
     ]
    }
   ],
   "source": [
    "s3 = \"AbCd\"\n",
    "print(s3.upper())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "b0e32d8b-d697-4a54-8356-ed63f5539a77",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abcd\n"
     ]
    }
   ],
   "source": [
    "s3 = \"AbCd\"\n",
    "print(s3.lower())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d15f6b01-66f8-495e-b1bf-0dafcc18da5e",
   "metadata": {},
   "source": [
    "- `swapcase:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "3c62aaef-bc0a-447c-a5bb-13830304d2a0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "aBcD\n"
     ]
    }
   ],
   "source": [
    "s3 = \"AbCd\"\n",
    "print(s3.swapcase())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87583da1-b725-49c5-af5c-4488f200b255",
   "metadata": {},
   "source": [
    "- `title:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "01a7c96a-168a-4c5d-874a-ce28ce521aa6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Coading Is Cool When You Understand It.\n"
     ]
    }
   ],
   "source": [
    "s3 = \"coading is cool when you understand it.\"\n",
    "print(s3.title())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da6b7b9a-b9a6-40cd-9e67-9e812118c681",
   "metadata": {},
   "source": [
    "- `Format Specifier:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "493ad427-a4f8-46ae-b64a-d5f5b53c65bb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Id is 731, name is Pandu, Percentage are 73.900000\n"
     ]
    }
   ],
   "source": [
    "id = 731\n",
    "name = \"Pandu\"\n",
    "percentage = 73.9\n",
    "print(\"Id is %d, name is %s, Percentage are %f\"%(id,name,percentage))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "4ad8064a-1833-4af6-94eb-6e5e7552ca3b",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "%d format: a real number is required, not str",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[45], line 4\u001b[0m\n\u001b[0;32m      2\u001b[0m name \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mPandu\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m      3\u001b[0m percentage \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m73.9\u001b[39m\n\u001b[1;32m----> 4\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mId is \u001b[39;49m\u001b[38;5;132;43;01m%d\u001b[39;49;00m\u001b[38;5;124;43m, name is \u001b[39;49m\u001b[38;5;132;43;01m%s\u001b[39;49;00m\u001b[38;5;124;43m, Percentage are \u001b[39;49m\u001b[38;5;132;43;01m%f\u001b[39;49;00m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;241;43m%\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mname\u001b[49m\u001b[43m,\u001b[49m\u001b[38;5;28;43mid\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43mpercentage\u001b[49m\u001b[43m)\u001b[49m)\n",
      "\u001b[1;31mTypeError\u001b[0m: %d format: a real number is required, not str"
     ]
    }
   ],
   "source": [
    "id = 731\n",
    "name = \"Pandu\"\n",
    "percentage = 73.9\n",
    "print(\"Id is %d, name is %s, Percentage are %f\"%(name,id,percentage))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "d2f4272f-03a5-4220-8ec2-ed84ed6a9924",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Roll No is 731, Name is Pratik, Percentage are 80.000000\n"
     ]
    }
   ],
   "source": [
    "rollno = 731\n",
    "name = \"Pratik\"\n",
    "percentage = 80.0\n",
    "print(\"Roll No is %d, Name is %s, Percentage are %f\"%(rollno,name,percentage))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c67435b-e7fe-430b-bda6-4248b11d0263",
   "metadata": {},
   "source": [
    "- `replace:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "4e901580-3a6a-4a18-a0ce-a8ef5759e513",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pandu is a good boy.\n"
     ]
    }
   ],
   "source": [
    "s3 = \"Pandu is a bad boy.\"\n",
    "print(s3.replace(\"bad\",\"good\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06306917-7556-486a-81e9-77e0f5a39501",
   "metadata": {},
   "source": [
    "- `find:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "e99315c7-e812-4274-881b-297f2a21fa89",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "s3 = \"abcdefgh\"\n",
    "print(s3.find(\"b\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "b557ee5b-2ac5-4f82-a13e-26b0b0c51a4b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "s3 = \"abcdefgh\"\n",
    "print(s3.find(\"abc\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "54f03ae0-8dda-4fe4-bc04-7815c58ef253",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1\n"
     ]
    }
   ],
   "source": [
    "s3 = \"abcdefgh\"\n",
    "print(s3.find(\"z\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e8f705b-dcfb-4589-99de-721ce1d0a238",
   "metadata": {},
   "source": [
    "- `index:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "123f7ff7-de2f-45f0-972b-f5cd49137e0e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "s3 = \"abcdefgh\"\n",
    "print(s3.index(\"c\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "c1448af6-a5da-4d81-b728-53b9cdd43684",
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "substring not found",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[58], line 2\u001b[0m\n\u001b[0;32m      1\u001b[0m s3 \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mabcdefgh\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m----> 2\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43ms3\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mindex\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mz\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m)\n",
      "\u001b[1;31mValueError\u001b[0m: substring not found"
     ]
    }
   ],
   "source": [
    "s3 = \"abcdefgh\"\n",
    "print(s3.index(\"z\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a51d155a-5218-45b3-bd0b-f2d9d2bb07f1",
   "metadata": {},
   "source": [
    "## `List: V25.01.24`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67047d99-9a3f-40a2-8d10-60ae81110611",
   "metadata": {},
   "source": [
    "- `append: Add the element at the end of the list.`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "8fc9c56f-1b51-4eec-b8c5-aa1423b1e735",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[22, 23, 'Python', (4+9j), 'hello']\n",
      "[22, 23, 'Python', (4+9j), 'hello', [22, 23, 'Python', (4+9j)]]\n"
     ]
    }
   ],
   "source": [
    "# append element: full element add\n",
    "a = [22,23,\"Python\",4+9j]\n",
    "a.append(\"hello\")\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "94faa749-227f-4336-a664-f89429a27215",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[22, 23, 'Python', (4+9j), 'hello']\n",
      "[22, 23, 'Python', (4+9j), 'hello', [22, 23, 'Python', (4+9j)]]\n"
     ]
    }
   ],
   "source": [
    "# append list into the another list: \n",
    "a = [22,23,\"Python\",4+9j]\n",
    "a.append(\"hello\")\n",
    "print(a)\n",
    "b = [22,23,\"Python\",4+9j]\n",
    "a.append(b)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "13313142-f5f3-4a19-b109-78d6b545eb1b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[22, 23, 'Python', (4+9j), 'hello']\n",
      "[22, 23, 'Python', (4+9j), 'hello', [22, 23, 'Python', (4+9j)]]\n",
      "[22, 23, 'Python', (4+9j), 'hello', [22, 23, 'Python', (4+9j)], (11, 22, 33, 44)]\n"
     ]
    }
   ],
   "source": [
    "# append tuple into the list:\n",
    "a = [22,23,\"Python\",4+9j]\n",
    "a.append(\"hello\")\n",
    "print(a)\n",
    "b = [22,23,\"Python\",4+9j]\n",
    "a.append(b)\n",
    "print(a)\n",
    "c = (11,22,33,44)\n",
    "a.append(c)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9229750-b750-4dc8-8301-acb2e80afa8d",
   "metadata": {},
   "source": [
    "- `extend: merge new iteration into the current list.`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "9b179d9d-f08e-4c70-a52a-1111b54af0cb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[22, 23, 'Python', (4+9j), 'hello']\n",
      "[22, 23, 'Python', (4+9j), 'hello', [22, 23, 'Python', (4+9j)]]\n",
      "[22, 23, 'Python', (4+9j), 'hello', [22, 23, 'Python', (4+9j)], (11, 22, 33, 44)]\n",
      "[22, 23, 'Python', (4+9j), 'hello', [22, 23, 'Python', (4+9j)], (11, 22, 33, 44), 'happy', 'sad', 'nuteral']\n"
     ]
    }
   ],
   "source": [
    "# extend list: means mearge with exissting list:\n",
    "a = [22,23,\"Python\",4+9j]\n",
    "a.append(\"hello\")\n",
    "print(a)\n",
    "b = [22,23,\"Python\",4+9j]\n",
    "a.append(b)\n",
    "print(a)\n",
    "c = (11,22,33,44)\n",
    "a.append(c)\n",
    "print(a)\n",
    "d2 = [\"happy\", \"sad\",\"nuteral\"]\n",
    "a.extend(d2)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "8e5e9eef-2f50-46e6-8638-96d66369a635",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[22, 23, 'Python', (4+9j), 'hello']\n",
      "[22, 23, 'Python', (4+9j), 'hello', [22, 23, 'Python', (4+9j)]]\n",
      "[22, 23, 'Python', (4+9j), 'hello', [22, 23, 'Python', (4+9j)], (11, 22, 33, 44)]\n",
      "[22, 23, 'Python', (4+9j), 'hello', [22, 23, 'Python', (4+9j)], (11, 22, 33, 44), 'happy', 'sad', 'nuteral']\n",
      "[22, 23, 'Python', (4+9j), 'hello', [22, 23, 'Python', (4+9j)], (11, 22, 33, 44), 'happy', 'sad', 'nuteral', 55, 66, 77, 88]\n"
     ]
    }
   ],
   "source": [
    "# extend with tuple: \n",
    "a = [22,23,\"Python\",4+9j]\n",
    "a.append(\"hello\")\n",
    "print(a)\n",
    "b = [22,23,\"Python\",4+9j]\n",
    "a.append(b)\n",
    "print(a)\n",
    "c = (11,22,33,44)\n",
    "a.append(c)\n",
    "print(a)\n",
    "d2 = [\"happy\", \"sad\",\"nuteral\"]\n",
    "a.extend(d2)\n",
    "print(a)\n",
    "d3 = (55,66,77,88)\n",
    "a.extend(d3)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "d106f14f-deaf-403b-b927-072a3de74dec",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[22, 23, 'Python', (4+9j), 'hello']\n",
      "[22, 23, 'Python', (4+9j), 'hello', [22, 23, 'Python', (4+9j)]]\n",
      "[22, 23, 'Python', (4+9j), 'hello', [22, 23, 'Python', (4+9j)], (11, 22, 33, 44)]\n",
      "[22, 23, 'Python', (4+9j), 'hello', [22, 23, 'Python', (4+9j)], (11, 22, 33, 44), 'happy', 'sad', 'nuteral']\n",
      "[22, 23, 'Python', (4+9j), 'hello', [22, 23, 'Python', (4+9j)], (11, 22, 33, 44), 'happy', 'sad', 'nuteral', 'B', 'y', 'e']\n"
     ]
    }
   ],
   "source": [
    "# extend element: one by one single charecter in the element added in list\n",
    "a = [22,23,\"Python\",4+9j]\n",
    "a.append(\"hello\")\n",
    "print(a)\n",
    "b = [22,23,\"Python\",4+9j]\n",
    "a.append(b)\n",
    "print(a)\n",
    "c = (11,22,33,44)\n",
    "a.append(c)\n",
    "print(a)\n",
    "d2 = [\"happy\", \"sad\",\"nuteral\"]\n",
    "a.extend(d2)\n",
    "print(a)\n",
    "a.extend(\"Bye\")\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b691157f-63e4-4c8a-9b48-90f63261e1bc",
   "metadata": {},
   "source": [
    "- `insert: It is use to add element at specific index position inside a list.`\n",
    "- `remove: It will remove 1'st occurance of the specific element.`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "83555f2c-18fa-4e20-ac6d-c11aa1fb2bda",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Hello', (9+8j), 'Guido', 'Coding', 4.7]\n",
      "[(9+8j), 'Guido', 'Logic', 'Coding', 4.7]\n",
      "[(9+8j), 'Logic', 'Coding', 4.7]\n",
      "[(9+8j), 'Logic', 'Coding', '4.7', 4.7]\n",
      "[(9+8j), 'Logic', 'Coding', '4.7']\n",
      "4.7\n",
      "[(9+8j), 'Logic', 'Coding']\n",
      "Logic\n",
      "[(9+8j), 'Coding']\n",
      "0\n",
      "1\n",
      "1\n",
      "3\n",
      "[(9+8j), 'Coding', 'Coding', 'Coding']\n",
      "['Coding', 'Coding', 'Coding', (9+8j)]\n"
     ]
    }
   ],
   "source": [
    "# insert: insert at specific index position\n",
    "b2 = [9+8j,\"Guido\", \"Coding\", 4.7]\n",
    "b2.insert(0,\"Hello\")\n",
    "print(b2)\n",
    "b2 = [9+8j,\"Guido\", \"Coding\", 4.7]\n",
    "b2.insert(2,\"Logic\")\n",
    "print(b2)\n",
    "# remove: remove 1st occurance of the element\n",
    "b2.remove(\"Guido\")\n",
    "print(b2)\n",
    "b2.insert(3,\"4.7\")\n",
    "print(b2)\n",
    "b2.remove(4.7)\n",
    "print(b2)\n",
    "# pop: specific index position element will be poped out\n",
    "print(b2.pop())\n",
    "print(b2)\n",
    "print(b2.pop(1))\n",
    "print(b2)\n",
    "# index: It will return the index value of the specific element\n",
    "print(b2.index(9+8J))\n",
    "print(b2.index(\"Coding\"))\n",
    "# count: it will return the no of occurance of the specific element\n",
    "print(b2.count(\"Coding\"))\n",
    "b2.insert(1, \"Coding\")\n",
    "b2.insert(4, \"Coding\")\n",
    "print(b2.count(\"Coding\"))\n",
    "print(b2)\n",
    "# reverse: reverse the order of your list\n",
    "b2.reverse()\n",
    "print(b2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "d2ddefff-91b9-434f-b8a8-e5e495b74d5b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 4, 5, 7, 9, 13, 48]\n",
      "[48, 13, 9, 7, 5, 4, 3, 1]\n",
      "[48, 13, 9, 7, 5, 4, 3, 1]\n"
     ]
    }
   ],
   "source": [
    "# Sort in asending order: \n",
    "b3 = [9,4,13,1,48,3,7,5]\n",
    "b3.sort()\n",
    "print(b3)\n",
    "# sort in descending order: it is use to return list in descending order. \n",
    "b3.sort(reverse=True)\n",
    "print(b3)\n",
    "# clear: return empty list. delete all element in the list.\n",
    "# b3.clear()\n",
    "# print(b3)\n",
    "# copy: copy's list in another destination.\n",
    "b4 = b3.copy()\n",
    "print(b4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "9901f0ac-b905-4ad7-8a50-c071692135ad",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 1.2, (2+3j), 'Python', 'Coding', 'Coding', 'Coding', 'Pratik']\n",
      "[1, 1.2, (2+3j), 'Python', 'Coding', 'Coding', 'Coding', 'Pratik', 'B', 'y', 'e']\n",
      "[1, 1.2, (2+3j), 5, 'Python', 'Coding', 'Coding', 'Coding', 'Pratik', 'B', 'y', 'e']\n",
      "[1, 1.2, (2+3j), 5, 'Coding', 'Coding', 'Coding', 'Pratik', 'B', 'y', 'e']\n",
      "[1, 1.2, (2+3j), 'Coding', 'Coding', 'Coding', 'Pratik', 'B', 'y', 'e']\n",
      "0\n",
      "3\n",
      "['e', 'y', 'B', 'Pratik', 'Coding', 'Coding', 'Coding', (2+3j), 1.2, 1]\n",
      "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
      "[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]\n",
      "[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "# append\n",
    "a = [1,1.2,2+3j,\"Python\",\"Coding\",\"Coding\",\"Coding\"] \n",
    "a.append(\"Pratik\")\n",
    "print(a)\n",
    "\n",
    "# extend\n",
    "a.extend(\"Bye\")\n",
    "print(a)\n",
    "\n",
    "# insert\n",
    "a.insert(3,5)\n",
    "print(a)\n",
    "\n",
    "# remove\n",
    "a.remove(\"Python\")\n",
    "print(a)\n",
    "\n",
    "# pop\n",
    "a.pop(3)\n",
    "print(a)\n",
    "\n",
    "# index\n",
    "print(a.index(1))\n",
    "\n",
    "# count\n",
    "print(a.count(\"Coding\"))\n",
    "\n",
    "# reverse\n",
    "a.reverse()\n",
    "print(a)\n",
    "\n",
    "# sort -> only Numbers in ascending order\n",
    "b =[1,2,3,4,5,6,7,8,9,10]\n",
    "b.sort() \n",
    "print(b)\n",
    "\n",
    "# sort in reverse -> reverse=True\n",
    "b.sort(reverse=True)\n",
    "print(b)\n",
    "\n",
    "# copy\n",
    "c = b.copy()\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3e92689-11b7-41ec-b0ec-fa6520f2733e",
   "metadata": {},
   "source": [
    "- `Dictionary`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "122eac50-244a-48dc-990f-72656454fd5d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 'Python', 2: 'Class', 3: (4+9j), 4: 9.3, 5: 'Code'}\n",
      "Python\n",
      "9.3\n",
      "dict_items([(1, 'Python'), (2, 'Class'), (3, (4+9j)), (4, 9.3), (5, 'Code')])\n",
      "dict_keys([1, 2, 3, 4, 5])\n",
      "dict_values(['Python', 'Class', (4+9j), 9.3, 'Code'])\n",
      "{1: 'Python', 2: 'Class', 3: (4+9j), 4: 9.3, 5: 'Code'}\n",
      "{1: 'Python', 2: 'Class', 3: (4+9j), 4: 9.3, 5: 'Code'}\n",
      "{1: 'Python', 2: 'Class', 3: (4+9j), 4: 9.3, 5: 'Code', 6: 'Object'}\n",
      "{1: 'Guido', 2: 'Class', 3: (4+9j), 4: 9.3, 5: 'Code', 6: 'Object'}\n",
      "{1: 'Guido', 3: (4+9j), 4: 9.3, 5: 'Code', 6: 'Object'}\n",
      "{1: 'Guido', 3: (4+9j), 4: 9.3, 5: 'Code'}\n",
      "{}\n"
     ]
    }
   ],
   "source": [
    "data1 = {1:\"Python\", 2:\"Class\",3:4+9j,4:9.3,5:\"Code\"}\n",
    "print(data1)\n",
    "\n",
    "# get\n",
    "print(data1.get(1))\n",
    "print(data1.get(4))\n",
    "\n",
    "# items -> Tuple Format\n",
    "print(data1.items())\n",
    "\n",
    "# keys -> Tuple Format\n",
    "print(data1.keys())\n",
    "\n",
    "# values -> Tuple Format\n",
    "print(data1.values())\n",
    "\n",
    "# a = (1,2,3)\n",
    "# b = \"India\"\n",
    "# data2.fromkeys(a,b)\n",
    "\n",
    "# copy\n",
    "data2 = data1.copy()\n",
    "print(data1)\n",
    "print(data2)\n",
    "\n",
    "# update\n",
    "data1.update({6:\"Object\"})\n",
    "print(data1)\n",
    "data1.update({1:\"Guido\"})\n",
    "print(data1)\n",
    "\n",
    "# pop -> by default remove the last key:value pair.\n",
    "data1.pop(2)\n",
    "print(data1)\n",
    "\n",
    "# by default not remove without key\n",
    "# data1.pop()\n",
    "# print(data1)\n",
    "\n",
    "# popitem -> not popitems\n",
    "data1.popitem()\n",
    "print(data1)\n",
    "\n",
    "# clear\n",
    "data1.clear()\n",
    "print(data1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bdb4376e-7f0d-4e6e-81c6-a61f2b9bb942",
   "metadata": {},
   "source": [
    "### `Inheritance: When The Object of child class aquires properties of object of parent class is called Inheritance. When One Child class aquires the properties of parent class is called Inheritance. V25.01.27`\n",
    "- `It is Object Oriented Concept.`\n",
    "- `Parent Class: Parent calss|Child Class|Super Class.`\n",
    "- `Child Class: Child Class|Derived Class|Sub Class.`\n",
    "- `It is Not mendatory to always say object word in the types of Inheritance defination.`\n",
    "### `Types of Inheritance:`\n",
    "- `Single Level Inheritance: When Object of One Child class aquries the properties of object of One Parent class.`\n",
    "- `Multilevel Inheritance: When One child class is the parent of another child class such inheritance is called as multilevel inheritance`\n",
    "- `Multiple Inheritance: When One child class inherited the properties of multiple parent class such inheritance is called as Multiple Inheritance.`\n",
    "- `Hybrid Inheritance: `"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "5c262dc7-ba74-4a39-855e-35e342154d72",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Child Method.\n",
      "Parent Method.\n",
      "[<class '__main__.Child'>, <class '__main__.Parent'>, <class 'object'>]\n"
     ]
    }
   ],
   "source": [
    "# Single Level Inheritance.\n",
    "class Parent:\n",
    "    def parent_method(self):\n",
    "        print(\"Parent Method.\")\n",
    "class Child(Parent):\n",
    "    def child_method(self):\n",
    "        print(\"Child Method.\")\n",
    "obj = Child()\n",
    "obj.child_method()\n",
    "obj.parent_method()\n",
    "print(Child.mro())\n",
    "# By default Constructor call in python when object is created.\n",
    "# Two Types Calling:\n",
    "# 1. Child() -> by Default -> Implicit \n",
    "# 2. obj.Child() -> By Own Hand -> Explicit\n",
    "# Constructor creates Object(Memory) by default.\n",
    "# By default Object created Constructor Implictly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e4b623da-cdad-447d-bf44-88f4ad4f54a2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Painting..\n",
      "Driving..\n",
      "Coading..\n",
      "Reading..\n",
      "[<class '__main__.Babli'>, <class '__main__.Bablu'>, <class '__main__.Pandi'>, <class '__main__.Pandu'>, <class 'object'>]\n"
     ]
    }
   ],
   "source": [
    "# Multilevel Inheritance.\n",
    "class Pandu:\n",
    "    def read(self):\n",
    "        print(\"Reading..\")\n",
    "class Pandi(Pandu):\n",
    "    def code(self):\n",
    "        print(\"Coading..\")\n",
    "class Bablu(Pandi):\n",
    "    def drive(self):\n",
    "        print(\"Driving..\")\n",
    "class Babli(Bablu):\n",
    "    def painting(self):\n",
    "        print(\"Painting..\")\n",
    "obj = Babli()\n",
    "obj.painting()\n",
    "obj.drive()\n",
    "obj.code()\n",
    "obj.read()\n",
    "print(Babli.mro())\n",
    "# mro() -> Method Resolution Order. It is nothing but scequence of properties in Inheritance. -> Proritywise.\n",
    "# Babli, Bunty, Pandi, Pandu, Object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "11d3350d-c943-48c8-975d-9eb6c68bcae0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter First Number:  5\n",
      "Enter Second Number:  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Remainder of two Numbers is 0\n",
      "Questiont of two Numbers is 1.0\n",
      "Product of two Numbers is 25\n",
      "Subtraction of two Numbers is 0\n",
      "Addition of two Numbers is 10\n",
      "[<class '__main__.Mod'>, <class '__main__.Div'>, <class '__main__.Mul'>, <class '__main__.Sub'>, <class '__main__.Add'>, <class 'object'>]\n"
     ]
    }
   ],
   "source": [
    "# Another Example of Multilevel Inheritance.\n",
    "class Add:\n",
    "    def addition(self, num1, num2):\n",
    "        print(\"Addition of two Numbers is\",num1+num2)\n",
    "class Sub(Add):\n",
    "    def subtraction(self, num1, num2):\n",
    "        print(\"Subtraction of two Numbers is\",num1-num2)\n",
    "class Mul(Sub):\n",
    "    def mutiplication(self, num1, num2):\n",
    "        print(\"Product of two Numbers is\",num1*num2)\n",
    "class Div(Mul):\n",
    "    def division(self, num1, num2):\n",
    "        print(\"Questiont of two Numbers is\",num1/num2)\n",
    "class Mod(Div):\n",
    "    def modulos(self, num1, num2):\n",
    "        print(\"Remainder of two Numbers is\",num1%num2)\n",
    "num1 = int(input(\"Enter First Number: \"))\n",
    "num2 = int(input(\"Enter Second Number: \"))\n",
    "obj = Mod()\n",
    "obj.modulos(num1,num2)\n",
    "obj.division(num1,num2)\n",
    "obj.mutiplication(num1,num2)\n",
    "obj.subtraction(num1,num2)\n",
    "obj.addition(num1,num2)\n",
    "print(Mod.mro())\n",
    "# Mod, Div, Mul, Sub, Add, Object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "8a93eac0-afef-41cc-babd-991125656035",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "D\n",
      "C\n",
      "B\n",
      "A\n",
      "[<class '__main__.D'>, <class '__main__.A'>, <class '__main__.B'>, <class '__main__.C'>, <class 'object'>]\n"
     ]
    }
   ],
   "source": [
    "# Multiple Inheritance.\n",
    "class A:\n",
    "    def m1(self):\n",
    "        print(\"A\")\n",
    "class B:\n",
    "    def m2(self):\n",
    "        print(\"B\")\n",
    "class C:\n",
    "    def m3(self):\n",
    "        print(\"C\")\n",
    "class D(A,B,C):\n",
    "    def m4(self):\n",
    "        print(\"D\")\n",
    "obj = D()\n",
    "obj.m4()\n",
    "obj.m3()\n",
    "obj.m2()\n",
    "obj.m1()\n",
    "print(D.mro())\n",
    "# D, A, B, C, Object. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce7b8937-0bda-4954-9b54-a1ddc012fd00",
   "metadata": {},
   "source": [
    "- Diffreance Between Multilevel and Multiple Inheritance."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bcedfd96-ca53-4cf5-9903-82deed349e03",
   "metadata": {},
   "source": [
    "- `Super Keyword:`\n",
    "1. It is keyword.\n",
    "2. Super Keyword Access the Imediate parent class properties.\n",
    "3. It is Time Efficient.\n",
    "4. Act's as an object of parent class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b7155bea-3509-4fc9-ac17-0a76fd5184ae",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C\n",
      "B\n",
      "A\n",
      "[<class '__main__.D'>, <class '__main__.A'>, <class '__main__.B'>, <class '__main__.C'>, <class 'object'>]\n"
     ]
    }
   ],
   "source": [
    "# Accessing the Element of Class B element from Class C and class A element from class B.\n",
    "class A:\n",
    "    def m1(self):\n",
    "        print(\"A\")\n",
    "class B(A):\n",
    "    def m2(self):\n",
    "        print(\"B\")\n",
    "        super().m1()\n",
    "        # Call Imediate Parent Class.\n",
    "class C(B):\n",
    "    def m3(self):\n",
    "        print(\"C\")\n",
    "        super().m2()\n",
    "        # Call Imediate Parent Class.\n",
    "obj = C()\n",
    "obj.m3()\n",
    "print(D.mro())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "ed196a72-69cb-493d-873a-cb0591e2b3de",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C\n",
      "A\n",
      "[<class '__main__.D'>, <class '__main__.A'>, <class '__main__.B'>, <class '__main__.C'>, <class 'object'>]\n"
     ]
    }
   ],
   "source": [
    "# Accessing the Class A Elements from the Class C.\n",
    "class A:\n",
    "    def m1(self):\n",
    "        print(\"A\")\n",
    "class B(A):\n",
    "    def m2(self):\n",
    "        print(\"B\")\n",
    "class C(B):\n",
    "    def m3(self):\n",
    "        print(\"C\")\n",
    "        super().m1()\n",
    "        # C->A\n",
    "        # Call Imediate Parent Class. Still Implimented this Concept Beacouse, \n",
    "        # It Accessing the elements of Parent calss B which is inherited from the Parent calss A. \n",
    "        # Beacouse of Inheritance Still it can access the m1 method into the B class. \n",
    "obj = C()\n",
    "obj.m3()\n",
    "print(D.mro())\n",
    "# C, A, Object."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f800fbd-703b-42cd-aa41-943d6210f991",
   "metadata": {},
   "source": [
    "- `Call Imediate Parent Class. Still Implimented this Concept Beacouse, It Accessing the elements of Parent calss B which is inherited from the Parent calss A. Beacouse of Inheritance Still it can access the m1 method into the B class.`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66376a50-b76e-48e2-9f8e-9b31779640ea",
   "metadata": {},
   "source": [
    "# `Test V25.01.29`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "95e21f93-d25d-40a4-8c06-52761b08f629",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a Fibonacci Series Range:  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0   1  1  2  5 is Palindrom Number.\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a Factorial Number:  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Factorial of  5 is 120\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a Palindrome Number:  121\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "121 is Palindrome Number.\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a Armstrong Number:  153\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "153  is Armstrong Number.\n"
     ]
    }
   ],
   "source": [
    "# Armstrong\n",
    "class Armstrong:\n",
    "    def armstrong(self):\n",
    "        num = int(input(\"Enter a Armstrong Number: \"))\n",
    "        temp = num\n",
    "        sum = 0\n",
    "        while(num>0):\n",
    "            rem = num % 10\n",
    "            sum = sum + (rem * rem *rem)\n",
    "            num = num//10\n",
    "        if sum == temp:\n",
    "            print(sum,\" is Armstrong Number.\")\n",
    "        else:\n",
    "            print(temp, \"is not armstrong Nnumber.\")\n",
    "\n",
    "# Palindrome\n",
    "class Palindrome():\n",
    "    def palindrome(self):\n",
    "        num = int(input(\"Enter a Palindrome Number: \"))\n",
    "        temp = num\n",
    "        sum = 0\n",
    "        while(num>0):\n",
    "            rem = num % 10\n",
    "            sum = (sum * 10) + rem            \n",
    "            num = num // 10\n",
    "        if sum == temp:\n",
    "            print(sum,\"is Palindrome Number.\")\n",
    "        else:\n",
    "            print(temp,\"is not Palindrome Number.\")\n",
    "            \n",
    "# Factorial\n",
    "class Factorial():\n",
    "    def factorial(self):\n",
    "        num = int(input(\"Enter a Factorial Number: \"))\n",
    "        fact = 1\n",
    "        for i in range(1,num+1):\n",
    "            fact = fact*i\n",
    "        print(\"Factorial of \",num,\"is\",fact)\n",
    "\n",
    "# Fibonacci\n",
    "class Fibonacci():\n",
    "    def fibonacci(self):\n",
    "        num = int(input(\"Enter a Fibonacci Series Range: \"))\n",
    "        temp = num\n",
    "        p1 = 0\n",
    "        p2 = 1\n",
    "        print(p1,\" \",p2,end=\"  \")\n",
    "        for i in range(2,num-1):\n",
    "            p3 = p1 + p2\n",
    "            print(p3,\" \",end=\"\")\n",
    "            p1 = p2\n",
    "            p2 = p3\n",
    "        if num == temp:\n",
    "            print(num,\"is Palindrom Number.\")\n",
    "        else:\n",
    "            print(temp,\"is not palindrome number.\")  \n",
    "\n",
    "# Multilevel Inheritance\n",
    "class Evaluate(Armstrong, Palindrome, Factorial, Fibonacci):\n",
    "    def evaluate(self):\n",
    "        super().fibonacci()\n",
    "        super().factorial()\n",
    "        super().palindrome()\n",
    "        super().armstrong()\n",
    "\n",
    "obj = Evaluate()\n",
    "obj.evaluate()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "f31ed04a-9351-4723-afc7-1860ebde2b0a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pyramid: \n",
      "     *\n",
      "    ***\n",
      "   *****\n",
      "  *******\n",
      " *********\n",
      "\n",
      "Reverse Pyramid: \n",
      " *********\n",
      "  *******\n",
      "   *****\n",
      "    ***\n",
      "     *\n",
      "\n",
      "Diamond: \n",
      "     *\n",
      "    ***\n",
      "   *****\n",
      "  *******\n",
      " *********\n",
      "  *******\n",
      "   *****\n",
      "    ***\n",
      "     *\n"
     ]
    }
   ],
   "source": [
    "# Pyramid\n",
    "class Pyramid:\n",
    "    def pyramid(self):\n",
    "        print(\"Pyramid: \")\n",
    "        for i in range(1,6):\n",
    "            for j in range(5,0,-1):\n",
    "                if j>=i:\n",
    "                    print(\" \",end=\"\")\n",
    "            for k in range(1,6):\n",
    "                if k<=i:\n",
    "                    print(\"*\",end=\"\")\n",
    "            for l in range(1,6):\n",
    "                if l<=i-1:\n",
    "                    print(\"*\",end=\"\")\n",
    "            print()\n",
    "\n",
    "# Reverse Pyramid\n",
    "class ReversePyramid(Pyramid):\n",
    "        def reversePyramid(self):\n",
    "            super().pyramid()\n",
    "            print()\n",
    "            print(\"Reverse Pyramid: \")\n",
    "            for i in range(1,6):\n",
    "                for j in range(1,6):\n",
    "                    if j<=i:\n",
    "                        print(\" \",end=\"\")\n",
    "                for k in range(5,0,-1):\n",
    "                    if k>=i:\n",
    "                        print(\"*\",end=\"\")\n",
    "                for l in range(4,0,-1):\n",
    "                    if l>=i:\n",
    "                        print(\"*\",end=\"\")\n",
    "                print()\n",
    "\n",
    "# Diamond\n",
    "class Diamond(ReversePyramid):\n",
    "    def diamond(self):\n",
    "        super().reversePyramid()\n",
    "        print()\n",
    "        print(\"Diamond: \")\n",
    "        for i in range(1,6):\n",
    "            for j in range(5,0,-1):\n",
    "                if j>=i:\n",
    "                    print(\" \",end=\"\")\n",
    "            for k in range(1,6):\n",
    "                if k<=i:\n",
    "                    print(\"*\",end=\"\")\n",
    "            for l in range(1,6):\n",
    "                if l<=i-1:\n",
    "                    print(\"*\",end=\"\")\n",
    "            print()\n",
    "        for i in range(1,5):\n",
    "            for j in range(1,6):\n",
    "                if j<=i+1:\n",
    "                    print(\" \",end=\"\")\n",
    "            for k in range(4,0,-1):\n",
    "                if k>=i:\n",
    "                    print(\"*\",end=\"\")\n",
    "            for l in range(3,0,-1):\n",
    "                if l>=i:\n",
    "                    print(\"*\",end=\"\")\n",
    "            print()\n",
    "                \n",
    "obj3 = Diamond()\n",
    "obj3.diamond()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "7eaaa4c4-d453-4860-ae54-59eeaa0da8bb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List Functions:\n",
      "[1, 2, 3, 4, 5, [6, 7, 8, 9, 10]]\n",
      "[1, 2, 3, 4, 5, [6, 7, 8, 9, 10], 6, 7, 8, 9, 10]\n",
      "[1, 2, 3, 4, 5, [6, 7, 8, 9, 10], 6, 7, 8, 9, 11, 10]\n",
      "\n",
      "String Functions:\n",
      "True\n",
      "True\n",
      "False\n",
      "\n",
      "List Functions:\n",
      "5\n",
      "2\n",
      "1\n",
      "\n",
      "String Functions:\n",
      "False\n",
      "False\n",
      "Pratik Majage\n",
      "\n",
      "List Functions:\n",
      "[2, 3, 4, 5]\n",
      "[5, 4, 3, 2]\n",
      "[]\n",
      "\n",
      "String Functions:\n",
      "PRATIK\n",
      "pratik\n",
      "Pratik\n",
      "\n",
      "List Functions:\n",
      "[1, 2, 3, 4, 5]\n",
      "[5, 4, 3, 2, 1]\n",
      "[5, 4, 3, 2, 1]\n",
      "\n",
      "String Functions:\n",
      "Pratik is good boy\n",
      "4\n",
      "4\n",
      "P-r-a-t-i-k\n"
     ]
    }
   ],
   "source": [
    "# List:\n",
    "# 1. `append:` \n",
    "# 2. `extend:` \n",
    "# 3. `insert:`\n",
    "# 4. `remove:`\n",
    "# 5. `pop:`\n",
    "# 6. `index:`\n",
    "# 7. `count:`\n",
    "# 8. `reverse:`\n",
    "# 9. `sort:` & `sort:` `reverse=True`\n",
    "# 10. `clear:`\n",
    "# 11.  `copy:`\n",
    "\n",
    "# String:\n",
    "# 1. isalnum\n",
    "# 2. isalpha\n",
    "# 3. isdigit\n",
    "# 4. islower\n",
    "# 5. isupper\n",
    "# 6. Concatination\n",
    "# 7. join\n",
    "# 8. upper\n",
    "# 9. lower\n",
    "# 10. title\n",
    "# 11. swapcase\n",
    "# 12. replace\n",
    "# 13. index\n",
    "# 14. find\n",
    "\n",
    "class ListStringMethods1:\n",
    "    def method1(self):\n",
    "\n",
    "        print(\"List Functions:\")\n",
    "        data1 = [1,2,3,4,5]\n",
    "        data2 = [6,7,8,9,10]\n",
    "        \n",
    "        data1.append(data2)\n",
    "        print(data1)\n",
    "        \n",
    "        data1.extend(data2)\n",
    "        print(data1)\n",
    "        \n",
    "        data1.insert(10,11)\n",
    "        print(data1)\n",
    "\n",
    "        print()\n",
    "        print(\"String Functions:\")\n",
    "        name = \"Pratik\"\n",
    "        print(name.isalnum())\n",
    "        print(name.isalpha())\n",
    "        print(name.isdigit())\n",
    "\n",
    "class ListStringMethods2(ListStringMethods1):\n",
    "    def method2(self):\n",
    "\n",
    "        super().method1()\n",
    "        print()\n",
    "        \n",
    "        print(\"List Functions:\")\n",
    "        data1 = [1,2,3,4,5]\n",
    "        data2 = [6,7,8,9,10]\n",
    "        \n",
    "        print(data1.pop())\n",
    "\n",
    "        print(data1.index(3))\n",
    "    \n",
    "        print(data1.count(3))\n",
    "\n",
    "        print()\n",
    "        print(\"String Functions:\")\n",
    "        name = \"Pratik\"\n",
    "        print(name.isupper())\n",
    "        print(name.islower())\n",
    "        print(name +\" \" + \"Majage\")\n",
    "\n",
    "class ListStringMethods3(ListStringMethods2):\n",
    "    def method3(self):\n",
    "\n",
    "        super().method2()\n",
    "        print()\n",
    "        \n",
    "        print(\"List Functions:\")\n",
    "        data1 = [1,2,3,4,5]\n",
    "\n",
    "        data1.remove(1)\n",
    "        print(data1)\n",
    "\n",
    "        data1.reverse()\n",
    "        print(data1)\n",
    "\n",
    "        data1.clear()\n",
    "        print(data1)\n",
    "\n",
    "        print()\n",
    "        print(\"String Functions:\")\n",
    "        name = \"pratik\"\n",
    "        print(name.upper())\n",
    "        print(name.lower())\n",
    "        print(name.title())\n",
    "\n",
    "class ListStringMethods4(ListStringMethods3):\n",
    "    def method4(self):\n",
    "\n",
    "        super().method3()\n",
    "        print()\n",
    "\n",
    "        print(\"List Functions:\")\n",
    "        data1 = [1,2,3,4,5]\n",
    "\n",
    "        data1.sort()\n",
    "        print(data1)\n",
    "\n",
    "        data1.sort(reverse=True)\n",
    "        print(data1)\n",
    "\n",
    "        data2 = data1.copy()\n",
    "        print(data2)\n",
    "\n",
    "        print()\n",
    "        print(\"String Functions:\")\n",
    "        q1 = \"Pratik is bad boy\"\n",
    "        print(q1.replace(\"bad\",\"good\"))\n",
    "        w1 = \"aabbccdd\"\n",
    "        print(w1.find(\"c\"))\n",
    "        print(w1.index(\"c\"))\n",
    "        name = \"Pratik\"\n",
    "        string = \"-\"\n",
    "        print(string.join(name))\n",
    "\n",
    "\n",
    "obj = ListStringMethods4()\n",
    "obj.method4()  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c60ad65e-f4ba-420a-8280-0b868a266611",
   "metadata": {},
   "source": [
    "- `Math Functions`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "67c62a56-41df-46a3-be77-52c90e4f43f0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.0\n",
      "5\n",
      "6\n",
      "9.0\n",
      "3.141592653589793\n",
      "2.718281828459045\n",
      "5.0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1024.0"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Telusko:\n",
    "import math\n",
    "print(math.sqrt(25))\n",
    "print(math.floor(5.9))\n",
    "print(math.ceil(5.1))\n",
    "print(math.pow(3,2))\n",
    "print(math.pi)\n",
    "print(math.e)\n",
    "# allice:\n",
    "import math as m\n",
    "print(m.sqrt(25))\n",
    "from math import sqrt, pow\n",
    "sqrt(9)\n",
    "pow(4,5)\n",
    "# help(\"math\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46640f2f-0690-4c4e-8274-5309b4f71bdb",
   "metadata": {},
   "source": [
    "### `Regular Expression: V25.01.30`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7289666-e820-4f66-bb0f-e441095b5348",
   "metadata": {},
   "source": [
    "- `DateTime:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "b8b5820c-f74b-4347-8ccc-4c84a924166d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2025-02-08 12:36:36.515547\n",
      "----------------\n",
      "Sat\n",
      "Saturday\n",
      "----------------\n",
      "08\n",
      "02/08/25\n",
      "----------------\n",
      "Feb\n",
      "February\n",
      "----------------\n",
      "25\n",
      "2025\n",
      "----------------\n",
      "6\n",
      "05\n",
      "----------------\n",
      "02\n",
      "36\n",
      "----------------\n",
      "Feb\n",
      "12\n",
      "36\n",
      "515547\n",
      "----------------\n",
      "Sat Feb  8 12:36:36 2025\n",
      "20\n",
      "06\n",
      "----------------\n",
      "PM\n",
      "12\n",
      "02/08/25\n",
      "12:36:36\n"
     ]
    }
   ],
   "source": [
    "import datetime\n",
    "a = datetime.datetime.now()\n",
    "print(a) # current full date and time \n",
    "print(\"----------------\")\n",
    "print(a.strftime(\"%a\")) # shortform day\n",
    "print(a.strftime(\"%A\")) # fullform day\n",
    "print(\"----------------\")\n",
    "print(a.strftime(\"%d\")) # shortform date\n",
    "print(a.strftime(\"%D\")) # fullform day\n",
    "print(\"----------------\")\n",
    "print(a.strftime(\"%b\")) # shortform month\n",
    "print(a.strftime(\"%B\")) # fullform day\n",
    "print(\"----------------\")\n",
    "print(a.strftime(\"%y\")) # shortform year\n",
    "print(a.strftime(\"%Y\")) # fullform year\n",
    "print(\"----------------\")\n",
    "print(a.strftime(\"%w\")) # Scequence number of weeks\n",
    "print(a.strftime(\"%W\")) # Scequence number of weeks\n",
    "print(\"----------------\")\n",
    "print(a.strftime(\"%m\")) # month\n",
    "print(a.strftime(\"%M\")) # Minute\n",
    "print(\"----------------\")\n",
    "print(a.strftime(\"%h\")) # month\n",
    "print(a.strftime(\"%H\")) # Hours\n",
    "print(a.strftime(\"%S\")) # Seconds\n",
    "print(a.strftime(\"%f\")) # microseconds in 6 digits\n",
    "print(\"----------------\")\n",
    "print(a.strftime(\"%c\")) #day month date time year\n",
    "print(a.strftime(\"%C\"))\n",
    "print(a.strftime(\"%V\")) # week date start from sunday sometime in other calenders monday\n",
    "print(\"----------------\")\n",
    "print(a.strftime(\"%p\")) # PM | AM\n",
    "print(a.strftime(\"%I\")) # 12 Hours Format \n",
    "print(a.strftime(\"%x\")) # date\n",
    "print(a.strftime(\"%X\")) # Time"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8f27601-ec91-4a91-9f91-ad8db54d8f81",
   "metadata": {},
   "source": [
    "- `Meta Charecters:- (Regular Expression.)`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4b35adb-9295-4789-ba70-d1cf8575ed12",
   "metadata": {},
   "source": [
    "- `search()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "8f3b4fcd-dc51-425b-b9a3-ef3fcb285f21",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<re.Match object; span=(0, 5), match='Pandu'>\n",
      "Found.\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "data = \"Pandu is good boy\" \n",
    "a = re.search(\"^Pandu\",data)\n",
    "print(a)\n",
    "if a:\n",
    "    print(\"Found.\")\n",
    "else:\n",
    "    print(\"Not Found.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "1ed57412-7b26-4caf-9b57-f0c95dd2cbdc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<re.Match object; span=(14, 17), match='boy'>\n",
      "Found.\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "data = \"Pandu is good boy\" \n",
    "a = re.search(\"boy$\",data)\n",
    "print(a)\n",
    "if a:\n",
    "    print(\"Found.\")\n",
    "else:\n",
    "    print(\"Not Found.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "e0f0925e-68e3-48ca-9afd-4d4b3c4eb9b6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<re.Match object; span=(0, 17), match='Pandu is good boy'>\n",
      "Found.\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "data = \"Pandu is good boy\" \n",
    "a = re.search(\"^Pandu.*boy$\",data)\n",
    "print(a)\n",
    "if a:\n",
    "    print(\"Found.\")\n",
    "else:\n",
    "    print(\"Not Found.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "846ec286-9726-4b5c-9c0a-8ec5cbf7b3a7",
   "metadata": {},
   "source": [
    "- `foundall()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "cd8daacc-5f6e-4d53-b8b5-2d1779631372",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['ain', 'ain']\n",
      "Found.\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "data = \"No Pain No Gain\" \n",
    "a = re.findall(\"ain\",data)\n",
    "print(a)\n",
    "if a:\n",
    "    print(\"Found.\")\n",
    "else:\n",
    "    print(\"Not Found.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "1234ec6b-70c7-4a76-b021-5bf4732b3228",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Pain']\n",
      "Found.\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "data = \"No Pain No Gain\" \n",
    "a = re.findall(\"Pain\",data)\n",
    "print(a)\n",
    "if a:\n",
    "    print(\"Found.\")\n",
    "else:\n",
    "    print(\"Not Found.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "31e0dbd4-fd78-4d4d-9082-8bb517904a00",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Hello']\n",
      "Found.\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "data = \"Hello Pandu, how are you?\" \n",
    "a = re.findall(\"H...o\",data)\n",
    "print(a)\n",
    "if a:\n",
    "    print(\"Found.\")\n",
    "else:\n",
    "    print(\"Not Found.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "ffb6eff6-3440-456e-b29e-5680806a397a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n",
      "Not Found.\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "data = \"Hello Pandu, how are you?\" \n",
    "a = re.findall(\"H...p\",data)\n",
    "print(a)\n",
    "if a:\n",
    "    print(\"Found.\")\n",
    "else:\n",
    "    print(\"Not Found.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "c5d11868-5fad-4903-ad86-2e3770ce858d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n",
      "Not Found.\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "data = \"Hello Pandu, how are you?\" \n",
    "a = re.findall(\"H..o\",data)\n",
    "print(a)\n",
    "if a:\n",
    "    print(\"Found.\")\n",
    "else:\n",
    "    print(\"Not Found.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "e0edc7cf-71ad-44ad-b40c-9febd7ff5837",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Hello Pandu, how are yo']\n",
      "Found.\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "data = \"Hello Pandu, how are you?\" \n",
    "a = re.findall(\"H.*o\",data)\n",
    "print(a)\n",
    "if a:\n",
    "    print(\"Found.\")\n",
    "else:\n",
    "    print(\"Not Found.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "f7575c8c-3cba-49ea-b187-88d300b5d788",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Hello']\n",
      "Found.\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "data = \"Hello Pandu, how are you?\" \n",
    "a = re.findall(\"H.{3}o\",data)\n",
    "print(a)\n",
    "if a:\n",
    "    print(\"Found.\")\n",
    "else:\n",
    "    print(\"Not Found.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "dd1e4327-c0b8-4fb7-a94c-e3903e378990",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n",
      "Not Found.\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "data = \"Hello Pandu, how are you?\" \n",
    "a = re.findall(\"H.{4}o\",data)\n",
    "print(a)\n",
    "if a:\n",
    "    print(\"Found.\")\n",
    "else:\n",
    "    print(\"Not Found.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "506726e4-e20e-485b-ad13-d77078f97de2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Hello Pandu, how are yo']\n",
      "Found.\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "data = \"Hello Pandu, how are you?\" \n",
    "a = re.findall(\"H.+o\",data)\n",
    "print(a)\n",
    "if a:\n",
    "    print(\"Found.\")\n",
    "else:\n",
    "    print(\"Not Found.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "a1d62472-0864-44d1-a3f1-7614eb6f56d1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Hel']\n",
      "Found.\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "data = \"Hello Pandu, how are you?\" \n",
    "a = re.findall(\"H.?l\",data)\n",
    "print(a)\n",
    "if a:\n",
    "    print(\"Found.\")\n",
    "else:\n",
    "    print(\"Not Found.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "7943051d-2c2e-4e0f-b421-6212ea446639",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n",
      "Not Found.\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "data = \"Hello Pandu, how are you?\" \n",
    "a = re.findall(\"H.?o\",data)\n",
    "print(a)\n",
    "if a:\n",
    "    print(\"Found.\")\n",
    "else:\n",
    "    print(\"Not Found.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "2df68aad-2a13-497f-9cea-5f5fb7d25f46",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Pandu']\n",
      "Found.\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "data = \"Hello Pandu, how are you?\" \n",
    "a = re.findall(\"Pandu|Pandi\",data)\n",
    "print(a)\n",
    "if a:\n",
    "    print(\"Found.\")\n",
    "else:\n",
    "    print(\"Not Found.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "aefb91e5-c977-40f6-b933-5bb0e8f96df5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n",
      "Not Found.\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "data = \"Hello Pandu, how are you?\" \n",
    "a = re.findall(\"Bunty|Pandi\",data)\n",
    "print(a)\n",
    "if a:\n",
    "    print(\"Found.\")\n",
    "else:\n",
    "    print(\"Not Found.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3751af3f-5a30-48be-8d0d-9d3d15f8b350",
   "metadata": {},
   "source": [
    "- `sub()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "f8be8ee5-b0b2-4a57-919f-47cd8c44377b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No Power No Gain\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "data = \"No Pain No Gain\" \n",
    "a = re.sub(\"Pain\",\"Power\",data)\n",
    "print(a)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b2b6696-34a3-4276-a145-535841e051ed",
   "metadata": {},
   "source": [
    "- `split()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "dbc48772-0e6a-4ac6-828f-6d107417f099",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['No', 'Pain', 'No', 'Gain']\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "data = \"No Pain No Gain\" \n",
    "a = re.split(\" \",data)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "07143770-c581-44e7-904a-6effd3e9a960",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['No P', 'in No G', 'in']\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "data = \"No Pain No Gain\" \n",
    "a = re.split(\"a\",data)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "70e57b9a-7c8a-4b4b-9ced-e2896911ab92",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['', 'N', 'o', ' Pain No Gain']\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "data = \"No Pain No Gain\" \n",
    "a = re.split(\"\",data,3)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c20b3a73-c027-4eba-b513-ea0ea2cbd855",
   "metadata": {},
   "source": [
    "- `Special Scequence:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "ddaa63e1-a338-493d-9b34-b6fdc9437f53",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<>:2: SyntaxWarning: invalid escape sequence '\\A'\n",
      "<>:2: SyntaxWarning: invalid escape sequence '\\A'\n",
      "C:\\Users\\majag\\AppData\\Local\\Temp\\ipykernel_7892\\36357980.py:2: SyntaxWarning: invalid escape sequence '\\A'\n",
      "  a = re.findall(\"\\ANo\",data)\n"
     ]
    }
   ],
   "source": [
    "data = \"No Pain No Gain\"\n",
    "a = re.findall(\"\\ANo\",data)\n",
    "if a:\n",
    "    print(\"Found.\")\n",
    "else:\n",
    "    print(\"Not Found.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "03e470b3-4894-47d6-b70f-550472785701",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found.\n"
     ]
    }
   ],
   "source": [
    "data = \"No Pain No Gain\"\n",
    "a = re.findall(r\"Gain\\b\",data)\n",
    "if a:\n",
    "    print(\"Found.\")\n",
    "else:\n",
    "    print(\"Not Found.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "2fb6afd0-4fcc-493a-b337-8d10bdf2a51f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found.\n"
     ]
    }
   ],
   "source": [
    "data = \"No Pain No Gain\"\n",
    "a = re.findall(r\"ain\\b\",data)\n",
    "if a:\n",
    "    print(\"Found.\")\n",
    "else:\n",
    "    print(\"Not Found.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "c0814969-2c59-4add-9d0b-5364fff93c13",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Not Found.\n"
     ]
    }
   ],
   "source": [
    "data = \"No Pain No Gain\"\n",
    "a = re.findall(r\"\\BGain\",data)\n",
    "if a:\n",
    "    print(\"Found.\")\n",
    "else:\n",
    "    print(\"Not Found.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "6c6d5395-525f-4d5b-b18d-beb4b95fb18c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found.\n"
     ]
    }
   ],
   "source": [
    "data = \"No Pain No Gain\"\n",
    "a = re.findall(r\"\\Bain\",data)\n",
    "if a:\n",
    "    print(\"Found.\")\n",
    "else:\n",
    "    print(\"Not Found.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "9c061d68-8397-42aa-89ae-9187fafbc864",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['1', '2', '3', '4']\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<>:2: SyntaxWarning: invalid escape sequence '\\d'\n",
      "<>:2: SyntaxWarning: invalid escape sequence '\\d'\n",
      "C:\\Users\\majag\\AppData\\Local\\Temp\\ipykernel_7892\\2613430423.py:2: SyntaxWarning: invalid escape sequence '\\d'\n",
      "  a = re.findall(\"\\d\",data1)\n"
     ]
    }
   ],
   "source": [
    "data1 = \"abcd1234\"\n",
    "a = re.findall(\"\\d\",data1)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "e8c5f318-536a-4cde-8417-05e42855b9fd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'c', 'd']\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<>:2: SyntaxWarning: invalid escape sequence '\\D'\n",
      "<>:2: SyntaxWarning: invalid escape sequence '\\D'\n",
      "C:\\Users\\majag\\AppData\\Local\\Temp\\ipykernel_7892\\2706297881.py:2: SyntaxWarning: invalid escape sequence '\\D'\n",
      "  a = re.findall(\"\\D\",data1)\n"
     ]
    }
   ],
   "source": [
    "data1 = \"abcd1234\"\n",
    "a = re.findall(\"\\D\",data1)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "2bb285fa-826c-4719-92b5-23a98626a7b7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[' ', ' ', ' ']\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<>:2: SyntaxWarning: invalid escape sequence '\\s'\n",
      "<>:2: SyntaxWarning: invalid escape sequence '\\s'\n",
      "C:\\Users\\majag\\AppData\\Local\\Temp\\ipykernel_7892\\4111360370.py:2: SyntaxWarning: invalid escape sequence '\\s'\n",
      "  a = re.findall(\"\\s\",data2)\n"
     ]
    }
   ],
   "source": [
    "data2 = \"Pandu is Good Boy\"\n",
    "a = re.findall(\"\\s\",data2)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "a94f6578-b12d-4cd6-b7e0-899cd089fffd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['P', 'a', 'n', 'd', 'u', 'i', 's', 'G', 'o', 'o', 'd', 'B', 'o', 'y']\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<>:2: SyntaxWarning: invalid escape sequence '\\S'\n",
      "<>:2: SyntaxWarning: invalid escape sequence '\\S'\n",
      "C:\\Users\\majag\\AppData\\Local\\Temp\\ipykernel_7892\\2385974374.py:2: SyntaxWarning: invalid escape sequence '\\S'\n",
      "  a = re.findall(\"\\S\",data2)\n"
     ]
    }
   ],
   "source": [
    "data2 = \"Pandu is Good Boy\"\n",
    "a = re.findall(\"\\S\",data2)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "3decff7c-f461-4ed2-91c3-3cf932a3996f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[' ', ' ', ' ', ' ', '$', '*', '&', '!']\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<>:2: SyntaxWarning: invalid escape sequence '\\W'\n",
      "<>:2: SyntaxWarning: invalid escape sequence '\\W'\n",
      "C:\\Users\\majag\\AppData\\Local\\Temp\\ipykernel_7892\\2233658347.py:2: SyntaxWarning: invalid escape sequence '\\W'\n",
      "  a = re.findall(\"\\W\",data3)\n"
     ]
    }
   ],
   "source": [
    "data3 = \"Pandu is Good Boy $*&!\"\n",
    "a = re.findall(\"\\W\",data3)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "15c40c51-600c-49d5-9659-7ce007b79081",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['P', 'a', 'n', 'd', 'u', 'i', 's', 'G', 'o', 'o', 'd', 'B', 'o', 'y']\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<>:2: SyntaxWarning: invalid escape sequence '\\w'\n",
      "<>:2: SyntaxWarning: invalid escape sequence '\\w'\n",
      "C:\\Users\\majag\\AppData\\Local\\Temp\\ipykernel_7892\\3781952730.py:2: SyntaxWarning: invalid escape sequence '\\w'\n",
      "  a = re.findall(\"\\w\",data3)\n"
     ]
    }
   ],
   "source": [
    "data3 = \"Pandu is Good Boy $*&!\"\n",
    "a = re.findall(\"\\w\",data3)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "34034a5c-de0d-43a4-aaeb-5f9c4b7b61d3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Rossum']\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<>:2: SyntaxWarning: invalid escape sequence '\\Z'\n",
      "<>:2: SyntaxWarning: invalid escape sequence '\\Z'\n",
      "C:\\Users\\majag\\AppData\\Local\\Temp\\ipykernel_7892\\3953898632.py:2: SyntaxWarning: invalid escape sequence '\\Z'\n",
      "  a = re.findall(\"Rossum\\Z\",data4)\n"
     ]
    }
   ],
   "source": [
    "data4 = \"Gudi Van Rossum\"\n",
    "a = re.findall(\"Rossum\\Z\",data4)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad1c42b7-77b5-4e05-909a-f3fea55cde08",
   "metadata": {},
   "source": [
    "### `❌ V25.01.31 File Handling -> OFF`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "79aa176a-4298-4d89-8a96-dd5bb081b83c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<_io.TextIOWrapper name='Pratik.txt' mode='a+' encoding='cp1252'>\n"
     ]
    }
   ],
   "source": [
    "obj = open(\"Pratik.txt\",\"a+\")\n",
    "print(obj)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "29977267-7524-4ad8-b8bf-1514e21d044c",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj = open(\"Code.pdf\",\"w\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "bac61a88-4b01-4cc5-9979-b7207f59d634",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj = open(\"Code2.xlsx\",\"w\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "febdfee0-8a5b-49ed-9fc9-de04fc0daeb2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi, I am Pratik.\n",
      "It's pleasure to meet you.\n",
      "love from Pune.\n"
     ]
    }
   ],
   "source": [
    "obj = open(\"Pratik.txt\",\"r\")\n",
    "data = obj.read()\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "f79fd52c-acc6-4c32-b750-9bbb319fabc8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi, I am Pratik.\n",
      "It's pleasure to meet you.\n",
      "love from Pune.\n"
     ]
    }
   ],
   "source": [
    "obj = open(\"Pratik.txt\",\"r\")\n",
    "data = obj.read()\n",
    "print(data)\n",
    "obj.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "id": "917d5c88-f49d-4fb7-bda2-f32dd1f04ec0",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj = open(\"Ramesh.txt\",\"w\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "id": "d3aade73-f991-4c10-8d4f-72bca954de31",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj = open(\"Nupur.txt\",\"w\")\n",
    "obj.write(\"Hello Nupur, How are you?\")\n",
    "obj.write(\"\\nWhere are you heading?\")\n",
    "obj.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "id": "a68c7053-f653-4c64-a5fa-3ad1bf74e303",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Nupur, How are you?\n",
      "Where are you heading?\n"
     ]
    }
   ],
   "source": [
    "obj = open(\"Nupur.txt\",\"r\")\n",
    "data = obj.read()\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "7a8c80bb-5815-4491-80b3-0372e4f1a99f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " you?\n",
      "Where are you heading?\n"
     ]
    }
   ],
   "source": [
    "obj = open(\"Nupur.txt\",\"r+\")\n",
    "obj.write(\"\\nYou still love me?\")\n",
    "data = obj.read()\n",
    "print(data)\n",
    "obj.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "id": "45dd359e-0b01-416d-9234-a8a5964385d1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OOP\n",
      "Practice..\n",
      "Scalable..\n",
      "OOP\n",
      "Practice..\n",
      "Scalable..\n",
      "High Package..\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj = open(\"DataFile.txt\",\"w+\")\n",
    "obj.write(\"OOP\")\n",
    "obj.write(\"\\nPractice..\")\n",
    "obj.write(\"\\nScalable..\")\n",
    "obj.seek(0)\n",
    "data = obj.read()\n",
    "print(data)\n",
    "obj.write(\"\\nHigh Package..\")\n",
    "obj.seek(0)\n",
    "data = obj.read()\n",
    "print(data)\n",
    "obj.seek(0)\n",
    "obj.tell()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "id": "b45582e3-cdd5-4718-97c5-198fdd3f64f4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OOP\n",
      "Practice..\n",
      "Scalable..\n",
      "High Package..\n",
      "Inheritance..\n",
      "Inheritance..\n"
     ]
    }
   ],
   "source": [
    "obj = open(\"DataFile.txt\",\"a\")\n",
    "obj.write(\"\\nInheritance..\")\n",
    "obj.close()\n",
    "obj = open(\"DataFile.txt\",\"r\")\n",
    "data = obj.read()\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "id": "653751db-f03f-4c62-96ca-a0539830002b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OOP\n",
      "Practice..\n",
      "Scalable..\n",
      "High Package..\n",
      "Inheritance..\n",
      "Inheritance..\n",
      "File Handling..\n",
      "Again File Handling\n",
      "File Handling..\n",
      "Again File Handling\n",
      "File Handling..\n",
      "Again File Handling\n"
     ]
    }
   ],
   "source": [
    "obj = open(\"DataFile.txt\",\"a+\")\n",
    "obj.write(\"\\nFile Handling..\")\n",
    "obj.write(\"\\nAgain File Handling\")\n",
    "obj.seek(0)\n",
    "data = obj.read()\n",
    "print(data)\n",
    "obj.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b31fe84-022c-4efd-84b1-762f74f1cd4c",
   "metadata": {},
   "source": [
    "### `Numpy V25.02.03`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "06a64287-3f65-4661-bb5f-0e691a1edf7d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Defaulting to user installation because normal site-packages is not writeable\n",
      "Requirement already satisfied: numpy in c:\\users\\majag\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.12_qbz5n2kfra8p0\\localcache\\local-packages\\python312\\site-packages (1.26.4)\n",
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "[notice] A new release of pip is available: 24.2 -> 25.0\n",
      "[notice] To update, run: C:\\Users\\majag\\AppData\\Local\\Microsoft\\WindowsApps\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\python.exe -m pip install --upgrade pip\n"
     ]
    }
   ],
   "source": [
    "pip install numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e5ffba28-bf50-484d-8d9f-3fb136cbf1ee",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Defaulting to user installation because normal site-packages is not writeable\n",
      "Requirement already satisfied: numpy in c:\\users\\majag\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.12_qbz5n2kfra8p0\\localcache\\local-packages\\python312\\site-packages (1.26.4)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "[notice] A new release of pip is available: 24.2 -> 25.0\n",
      "[notice] To update, run: C:\\Users\\majag\\AppData\\Local\\Microsoft\\WindowsApps\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\python.exe -m pip install --upgrade pip\n"
     ]
    }
   ],
   "source": [
    "!pip install numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "5a739599-0752-4221-abbc-e8b6b0c8735d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List:  [1, 2, 3, 4, 5]\n",
      "<class 'list'>\n",
      "Array:  [1 2 3 4 5]\n",
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "# List in python\n",
    "a = [1,2,3,4,5]\n",
    "print(\"List: \", a)\n",
    "print(type(a))\n",
    "# Array in python\n",
    "num  = np.array([1,2,3,4,5])\n",
    "print(\"Array: \",num)\n",
    "print(type(num))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2bc406cc-d509-44af-9f1e-b4ca6680241a",
   "metadata": {},
   "source": [
    "- `Dimentions in Array:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "00f6c410-fbec-4749-9bb0-bff210b72f23",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[11]\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "a = np.array([11])\n",
    "print(a)\n",
    "print(a.ndim)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bced8b3d-b971-4a7f-a313-948338dd5a36",
   "metadata": {},
   "source": [
    "- `1 Dimention | Uni-Dimention Array:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "11564e71-6887-4fca-ad6f-3dbc9ce537c9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5]\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1,2,3,4,5])\n",
    "print(a)\n",
    "print(a.ndim) # Return Dimentions."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b00c1ebd-fd11-4a53-b6ce-4c88e6f72cd3",
   "metadata": {},
   "source": [
    "- `2-Dimention Array:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "aa7c28bf-cfee-449b-920d-ed7bb08d5e08",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3  4  5]\n",
      " [ 6  7  8  9 10]]\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1,2,3,4,5],[6,7,8,9,10]])\n",
    "print(a)\n",
    "print(a.ndim) # row (x) - column (y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abafab83-3bf6-42a0-837e-6199f774a513",
   "metadata": {},
   "source": [
    "- `3-Dimention Array:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "78cee6e7-8e51-478f-84db-9bcc050da6c9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[ 1  2  3]\n",
      "  [ 4  5  6]]\n",
      "\n",
      " [[ 7  8  9]\n",
      "  [11 12 13]]\n",
      "\n",
      " [[14 15 16]\n",
      "  [17 18 19]]]\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[[1,2,3],[4,5,6]],[[7,8,9],[11,12,13]],[[14,15,16],[17,18,19]]])\n",
    "print(a)\n",
    "print(a.ndim) # 3D (x)-(y)-(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "794ac10b-7fcb-4b06-953d-91a6b3610191",
   "metadata": {},
   "source": [
    "- `Index And Length:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "74374ce0-7aca-45a1-ac58-a893f3112155",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[11 22 33 44 55]\n",
      "1\n",
      "11\n",
      "33\n",
      "55\n"
     ]
    }
   ],
   "source": [
    "a = np.array([11,22,33,44,55])\n",
    "print(a)\n",
    "print(a.ndim)\n",
    "print(a[0])\n",
    "print(a[2])\n",
    "print(a[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "e4115c82-0acf-4f54-b9ae-c01f67ff1d04",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[11 22 33]\n",
      " [44 55 66]\n",
      " [77 88 99]]\n",
      "2\n",
      "[11 22 33]\n",
      "[77 88 99]\n",
      "11\n",
      "55\n",
      "33\n",
      "77\n",
      "154\n",
      "1452\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[11,22,33],[44,55,66],[77,88,99]])\n",
    "print(a)\n",
    "print(a.ndim)\n",
    "print(a[0])\n",
    "print(a[2])\n",
    "print(a[0,0])\n",
    "print(a[1,1])\n",
    "print(a[0,-1])\n",
    "print(a[-1,0])\n",
    "print(a[1,1]+a[2,2])\n",
    "print(a[0,1]*a[1,2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "de43ab33-ddc9-4340-b83b-d211426fa60b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[ 1  2  3]\n",
      "  [ 4  5  6]]\n",
      "\n",
      " [[10 20 30]\n",
      "  [40 50 60]]\n",
      "\n",
      " [[25 35 45]\n",
      "  [55 65 75]]]\n",
      "3\n",
      "1\n",
      "25\n",
      "75\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "value = np.array([[[1,2,3],[4,5,6,]],[[10,20,30],[40,50,60]],[[25,35,45],[55,65,75]]])\n",
    "print(value)\n",
    "print(value.ndim)\n",
    "print(value[0,0,0])\n",
    "print(value[2,0,0])\n",
    "print(value[-1,-1,-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c15190b-26c3-4cb7-8a5c-67676e67f5f1",
   "metadata": {},
   "source": [
    "- `Slicing:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "3aeca2dd-6f34-4c57-9d0b-e62b230c0e7e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[17 18 19 20 21 22 23 24 25]\n",
      "1\n",
      "[17 18 19 20 21 22 23 24 25]\n",
      "[17 18 19 20 21 22 23]\n",
      "[17 19 21 23]\n",
      "[17 20 23]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([17,18,19,20,21,22,23,24,25])\n",
    "print(a)\n",
    "print(a.ndim)\n",
    "print(a[0:])\n",
    "print(a[:7])\n",
    "print(a[0:8:2]) #steps\n",
    "print(a[0:8:3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "559296db-1c11-43fe-8dcc-0bab8407cc5e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[11 12 13]\n",
      " [14 15 16]\n",
      " [17 18 19]]\n",
      "2\n",
      "[[11 12 13]\n",
      " [14 15 16]\n",
      " [17 18 19]]\n",
      "[[11 12 13]\n",
      " [14 15 16]]\n",
      "[[11 12 13]\n",
      " [14 15 16]] 2\n",
      "[[14 15 16]\n",
      " [17 18 19]]\n",
      "[[17 18 19]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[11,12,13],[14,15,16],[17,18,19]])\n",
    "print(a)\n",
    "print(a.ndim)\n",
    "print(a[0:])\n",
    "print(a[0:2])\n",
    "print(a[0:2],2) # 2 is normal value\n",
    "print(a[1:3])\n",
    "print(a[-1:])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a92ea0e5-f0fe-4020-a3a4-1e13a54e29ee",
   "metadata": {},
   "source": [
    "- `sort & searchsorted:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "08847a84-6845-413b-801f-7d7903662a0b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[22 29 48 56  1  3  9]\n",
      "1\n",
      "[ 1  3  9 22 29 48 56]\n",
      "2\n",
      "5\n",
      "[ 1  3  9 22 29 43 56]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([22,29,48,56,1,3,9])\n",
    "print(a)\n",
    "print(a.ndim)\n",
    "num = np.sort(a)\n",
    "print(num)\n",
    "value = np.searchsorted(num,7)\n",
    "print(value) #Sorted value index number\n",
    "value = np.searchsorted(num,43)\n",
    "print(value)\n",
    "num[5] = 43\n",
    "print(num) # It will replace the value"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e61bbb4-c78e-438f-8965-e97450b298b7",
   "metadata": {},
   "source": [
    "## `Polymorphism And Exception Handling `"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "668a426a-78c4-4bc5-a92c-c5f95ff8454b",
   "metadata": {},
   "source": [
    "### `Polymorphism`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d810b672-7716-4565-92f9-32adbcb8afc8",
   "metadata": {},
   "source": [
    "- `Method Overloading : Python does not support method overloading directly. However, we can achieve it using default arguments or variable-length arguments` (`*args` and `**kwargs`). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "7dd3db11-4d02-468f-b52e-3e3a74cff356",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "33\n",
      "Hello\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "class Data:\n",
    "    def m(self, num1=None, num2=None):\n",
    "        if num1 is not None and num2 is not None:\n",
    "            return num1 + num2;\n",
    "        elif num1 is not None:\n",
    "            return num1;\n",
    "        else:\n",
    "            return \"Hello\"\n",
    "obj = Data()\n",
    "print(obj.m(11,22))\n",
    "print(obj.m())\n",
    "print(obj.m(7))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4a29b75-a582-443e-909b-171447b5a9ec",
   "metadata": {},
   "source": [
    "- `Constructor Overloading:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "9c8eb349-9a83-4111-8ccb-a08664a58db2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "33\n",
      "Hello\n",
      "11\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<__main__.Data at 0x2bc5db77290>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Data:\n",
    "    def __init__(self, num1=None, num2=None):\n",
    "        if num1 is not None and num2 is not None:\n",
    "            print(num1+num2)\n",
    "        elif num1 is not None:\n",
    "            print(num1)\n",
    "        else:\n",
    "            print(\"Hello\")\n",
    "Data(11,22)\n",
    "Data()\n",
    "Data(11)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "501a46e0-f6a5-4c55-83f1-363b7a5a1a2f",
   "metadata": {},
   "source": [
    "- `Method Overridding`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "95781e8a-9d97-4819-8179-2ff872fc8fed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "Hi\n",
      "Bye\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    def m1(self):\n",
    "        print(\"Hello\")\n",
    "class B(A):\n",
    "    # Overriding the parent method\n",
    "    def m1(self):\n",
    "        print(\"Hi\")\n",
    "class C(B):\n",
    "    # Overriding the parent method\n",
    "    def m1(self):\n",
    "        print(\"Bye\")\n",
    "        \n",
    "# Creating objects\n",
    "a = A()\n",
    "b = B()\n",
    "c = C()\n",
    "\n",
    "# Calling the method\n",
    "a.m1()\n",
    "b.m1()\n",
    "c.m1()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad718cad-4fb8-4570-a6db-8cc92054840d",
   "metadata": {},
   "source": [
    "- `super() Method: Required Inheritance`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "4d828f6f-88d4-4923-a747-47bccae99eec",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bye\n",
      "Hi\n",
      "Hello\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    def m1(self):\n",
    "        print(\"Hello\")\n",
    "class B(A):\n",
    "    def m1(self):\n",
    "        print(\"Hi\")\n",
    "        super().m1()\n",
    "class C(B):\n",
    "    def m1(self):\n",
    "        print(\"Bye\")\n",
    "        super().m1()\n",
    "obj = C()\n",
    "obj.m1()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6309b3bb-e4e0-4f1c-aa40-eb43d7063590",
   "metadata": {},
   "source": [
    "- `Exception Handling:`\n",
    "    1. `ZeroDivisionError:`  `eg,.96/0`\n",
    "    2. `IndexError:`  `List out of bound eg,.a[7], range out of list eg,.(len(a)+2)`\n",
    "    3. `NameError:`  `Function Misspelled eg,.(data2()), Not Defined | Undefined Variable eg,.(print(a2))` \n",
    "    4. `keyError:`  `Dictionary eg,.(data[7])`\n",
    "    5. `TypeError:` `String and Float Concatination eg,.(\"Pratik\"+7), Iterate String on Integer eg,.(for Pratik in 1234567) pass`\n",
    "    6. `ValueError:` `Type Conversion eg,.(name = float(\"Hello\")), Unboxing the List eg,.(p,q,r,s,t = data)` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "b00befe5-e625-45cd-b1fd-5b6d52c6c25a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Result is:  47.0\n",
      "executed\n"
     ]
    }
   ],
   "source": [
    "class Data():\n",
    "    def logic(self):\n",
    "        a = 94\n",
    "        b = 2\n",
    "        res = a/b\n",
    "        print(\"Result is: \",res)\n",
    "obj = Data()\n",
    "obj.logic()\n",
    "print(\"Executed\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6276dffa-f35b-4b80-b4ba-02413b77f63c",
   "metadata": {},
   "source": [
    "- `96/0 - Zero Division Error - division by zero`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "2ce2e673-0b57-4d2f-958e-507c966f6ea8",
   "metadata": {},
   "outputs": [
    {
     "ename": "ZeroDivisionError",
     "evalue": "division by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[38], line 8\u001b[0m\n\u001b[0;32m      6\u001b[0m         \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mResult is: \u001b[39m\u001b[38;5;124m\"\u001b[39m,res)\n\u001b[0;32m      7\u001b[0m obj \u001b[38;5;241m=\u001b[39m Data()\n\u001b[1;32m----> 8\u001b[0m \u001b[43mobj\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlogic\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m      9\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mExecuted\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
      "Cell \u001b[1;32mIn[38], line 5\u001b[0m, in \u001b[0;36mData.logic\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m      3\u001b[0m a \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m94\u001b[39m\n\u001b[0;32m      4\u001b[0m b \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0\u001b[39m\n\u001b[1;32m----> 5\u001b[0m res \u001b[38;5;241m=\u001b[39m \u001b[43ma\u001b[49m\u001b[38;5;241;43m/\u001b[39;49m\u001b[43mb\u001b[49m\n\u001b[0;32m      6\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mResult is: \u001b[39m\u001b[38;5;124m\"\u001b[39m,res)\n",
      "\u001b[1;31mZeroDivisionError\u001b[0m: division by zero"
     ]
    }
   ],
   "source": [
    "class Data():\n",
    "    def logic(self):\n",
    "        a = 94\n",
    "        b = 0\n",
    "        res = a/b\n",
    "        print(\"Result is: \",res)\n",
    "obj = Data()\n",
    "obj.logic()\n",
    "print(\"Executed\")\n",
    "# Exception = division by zero"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "851c3f48-4979-4a6e-8300-86b235dd0be2",
   "metadata": {},
   "source": [
    "- `96/0 - Zero Division Error - division by zero`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "7e0c5503-ee31-43bc-af6f-f757f422767d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Division by zero not Possible.\n",
      "Executed\n"
     ]
    }
   ],
   "source": [
    "class Data:\n",
    "    def logic(self):\n",
    "        try:\n",
    "            a = 96\n",
    "            b = 0\n",
    "            res = a / b\n",
    "        except ZeroDivisionError:\n",
    "            print(\"Division by zero not Possible.\")\n",
    "obj = Data()\n",
    "obj.logic()\n",
    "print(\"Executed\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d9f918b-ad35-4978-ad92-fe59076efc8c",
   "metadata": {},
   "source": [
    "- `List - Index Error - list index out of range`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b80a07b2-f196-44af-a030-e68adf660c18",
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[1], line 6\u001b[0m\n\u001b[0;32m      4\u001b[0m         \u001b[38;5;28mprint\u001b[39m(a[\u001b[38;5;241m7\u001b[39m])\n\u001b[0;32m      5\u001b[0m obj \u001b[38;5;241m=\u001b[39m Data()\n\u001b[1;32m----> 6\u001b[0m \u001b[43mobj\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlogic\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m      7\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mExecuted\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
      "Cell \u001b[1;32mIn[1], line 4\u001b[0m, in \u001b[0;36mData.logic\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mlogic\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[0;32m      3\u001b[0m     a \u001b[38;5;241m=\u001b[39m [\u001b[38;5;241m11\u001b[39m,\u001b[38;5;241m22\u001b[39m,\u001b[38;5;241m33\u001b[39m,\u001b[38;5;241m44\u001b[39m]\n\u001b[1;32m----> 4\u001b[0m     \u001b[38;5;28mprint\u001b[39m(\u001b[43ma\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m7\u001b[39;49m\u001b[43m]\u001b[49m)\n",
      "\u001b[1;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "class Data:\n",
    "    def logic(self):\n",
    "        a = [11,22,33,44]\n",
    "        print(a[7])\n",
    "obj = Data()\n",
    "obj.logic()\n",
    "print(\"Executed\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3f64324-cf24-4cba-b326-ebe506732d76",
   "metadata": {},
   "source": [
    "- `List - Index Error - list index out of range`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "de0df910-0ed9-4474-9a22-068f495b019d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Invalid Index\n",
      "Executed\n"
     ]
    }
   ],
   "source": [
    "class Data:\n",
    "    def logic(self):\n",
    "        try:\n",
    "            a = [11,22,33,44]\n",
    "            print(a[7])\n",
    "        except IndexError:\n",
    "            print(\"Invalid Index\")\n",
    "obj = Data()\n",
    "obj.logic()\n",
    "print(\"Executed\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2056947-4ba2-48f7-8db8-d9cdc0252df0",
   "metadata": {},
   "source": [
    "- `List - Index Error - list index out of range`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "c3a42638-fb30-4d78-9db3-1332d033d17b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n",
      "22\n",
      "33\n",
      "44\n",
      "55\n"
     ]
    },
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[97], line 3\u001b[0m\n\u001b[0;32m      1\u001b[0m a \u001b[38;5;241m=\u001b[39m [\u001b[38;5;241m11\u001b[39m,\u001b[38;5;241m22\u001b[39m,\u001b[38;5;241m33\u001b[39m,\u001b[38;5;241m44\u001b[39m,\u001b[38;5;241m55\u001b[39m]\n\u001b[0;32m      2\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;28mlen\u001b[39m(a)\u001b[38;5;241m+\u001b[39m\u001b[38;5;241m2\u001b[39m):\n\u001b[1;32m----> 3\u001b[0m     \u001b[38;5;28mprint\u001b[39m(\u001b[43ma\u001b[49m\u001b[43m[\u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m)\n",
      "\u001b[1;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "a = [11,22,33,44,55]\n",
    "for i in range(len(a)+2):\n",
    "    print(a[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1761b48b-7eb8-42f0-ad4d-de1a0360e453",
   "metadata": {},
   "source": [
    "- `List - Index Error - list index out of range`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "0c76188b-ba39-46bc-91ee-9119142dda45",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n",
      "22\n",
      "33\n",
      "44\n",
      "55\n",
      "Index out of Bound.\n",
      "Executed.\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    b = [11,22,33,44,55]\n",
    "    for i in range(len(b)+22):\n",
    "        # pass\n",
    "        print(b[i])\n",
    "except IndexError:\n",
    "    print(\"Index out of Bound.\")\n",
    "print(\"Executed.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad610c79-b174-47b8-88c3-2bd5cd5f845f",
   "metadata": {},
   "source": [
    "- `variable - Name Error`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "c48fd4e1-952b-4152-800c-d83be92aba23",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Undefined Variable.\n",
      "Executed\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    print(a2)\n",
    "except NameError:\n",
    "    print(\"Undefined Variable.\")\n",
    "# print(a2)\n",
    "print(\"Executed\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eafe5b01-2598-4696-9759-6d7cfecd0908",
   "metadata": {},
   "source": [
    "- `Function - Name Error`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "01c27b10-5da7-4f34-bb57-e60e4a876a43",
   "metadata": {},
   "outputs": [],
   "source": [
    "def data():\n",
    "    print(\"Hello\")\n",
    "try:\n",
    "    data2()\n",
    "except NameError:\n",
    "    print(\"Misspell Function.\")\n",
    "print(\"Executed.\")\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3404aec1-791f-429f-aa87-3a537ed4309b",
   "metadata": {},
   "source": [
    "- `4/0 - Zero Division Error`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "75066ce5-1af5-4140-acb3-87584dac26cf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index out of bound Error.\n",
      "Executed\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    a = 4\n",
    "    b = 0\n",
    "    res = int(a/b)\n",
    "    print(res)\n",
    "except ZeroDivisionError:\n",
    "    print(\"Index out of bound Error.\")\n",
    "print(\"Executed\")\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bfbcbbf3-681a-47d5-b00f-1e3370958824",
   "metadata": {},
   "source": [
    "- `Function - Name Error`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "13838a70-c12a-4c94-925b-ad335992c315",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NameError\n",
      "Executed\n"
     ]
    }
   ],
   "source": [
    "def pandu():\n",
    "    print(\"Talking\")\n",
    "\n",
    "try:\n",
    "    pandi()\n",
    "except NameError:\n",
    "    print(\"NameError\")\n",
    "print(\"Executed\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0328d9b3-6a4b-48b1-b6be-4be7bd153bd5",
   "metadata": {},
   "source": [
    "- `List - Index Error`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "e5f9012e-3c53-4326-b390-9d66b0f98066",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "IndexError\n",
      "Executed\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    a = [11,22,33,44,55]\n",
    "    print(a[5])\n",
    "except IndexError:\n",
    "    print(\"IndexError\")\n",
    "print(\"Executed\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8c2509f-7eb5-4785-abc3-69290359226e",
   "metadata": {},
   "source": [
    "- `Dictionary - Key Error`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "dc3377c4-a855-4e2c-8330-8f0ccf91c4cf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python\n"
     ]
    },
    {
     "ename": "KeyError",
     "evalue": "5",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[7], line 3\u001b[0m\n\u001b[0;32m      1\u001b[0m data \u001b[38;5;241m=\u001b[39m {\u001b[38;5;241m1\u001b[39m:\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mPython\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;241m2\u001b[39m:\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mJava\u001b[39m\u001b[38;5;124m\"\u001b[39m,\u001b[38;5;241m3\u001b[39m:\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mC#\u001b[39m\u001b[38;5;124m\"\u001b[39m,\u001b[38;5;241m4\u001b[39m:\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mKotlin\u001b[39m\u001b[38;5;124m\"\u001b[39m}\n\u001b[0;32m      2\u001b[0m \u001b[38;5;28mprint\u001b[39m(data[\u001b[38;5;241m1\u001b[39m])\n\u001b[1;32m----> 3\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mdata\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m5\u001b[39;49m\u001b[43m]\u001b[49m)\n",
      "\u001b[1;31mKeyError\u001b[0m: 5"
     ]
    }
   ],
   "source": [
    "data = {1:\"Python\", 2:\"Java\",3:\"C#\",4:\"Kotlin\"}\n",
    "print(data[1])\n",
    "print(data[5]) # KeyError"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac380e90-afa0-460d-8b97-359f5ebe7cbd",
   "metadata": {},
   "source": [
    "- `Dictionary - Key Error`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "c927999c-c6dd-4b9b-aa89-97686b14e4c0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python\n",
      "key Error.\n",
      "Executed.\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    data = {1:\"Python\", 2:\"Java\",3:\"C#\",4:\"Kotlin\"}\n",
    "    print(data[1])\n",
    "    print(data[5]) # KeyError\n",
    "except KeyError:\n",
    "    print(\"key Error.\")\n",
    "print(\"Executed.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a62d06e0-64e5-4ba2-bd31-055b994da506",
   "metadata": {},
   "source": [
    "- `'int' and 'str' - Type Error - unsupported operand type(s) for +: 'int' and 'str' - Miss Match Data type Error`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "8e644a8b-a855-4d35-a753-0f6c7c649863",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[10], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[38;5;28msum\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[38;5;241;43m23\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mPython\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\n\u001b[0;32m      2\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;28msum\u001b[39m)\n",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "sum = 23 + \"Python\"\n",
    "print(sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d30cfa55-b729-4ac2-a29e-bf040b887056",
   "metadata": {},
   "source": [
    "- `'int' and 'str' - Type Error - unsupported operand type(s) for +: 'int' and 'str' - Miss Match Data type Error`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "9892198f-52c3-437e-9144-cad88bd3c2ad",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Miss Match Data Type Error.\n",
      "Executed\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    sum = 23 + \"Python\"\n",
    "    print(sum)\n",
    "except TypeError:\n",
    "    print(\"Miss Match Data Type Error.\")\n",
    "print(\"Executed\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fabfe67c-2377-44ff-8094-e2114ccba520",
   "metadata": {},
   "source": [
    "- `'str' object is not callable - TypeError`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "1017f9da-8579-4f06-88c4-bb4edf899bdb",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'str' object is not callable",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[13], line 2\u001b[0m\n\u001b[0;32m      1\u001b[0m data \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mPython\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m----> 2\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mdata\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m)\n",
      "\u001b[1;31mTypeError\u001b[0m: 'str' object is not callable"
     ]
    }
   ],
   "source": [
    "data = \"Python\"\n",
    "print(data())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "4891fefc-5cbf-4ffb-9254-30a3af3e8a9f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Miss Match Type Error.\n",
      "Executed.\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    data = \"Python\"\n",
    "    print(data())\n",
    "except:\n",
    "    print(\"Miss Match Type Error.\")\n",
    "print(\"Executed.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75200215-6083-4fe2-a419-c74a4fa393e7",
   "metadata": {},
   "source": [
    "- `Itrating string on integer - TypeError - 'int' object is not iterable`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "01235cff-7826-4bd9-a01c-c3308b4da3f0",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'int' object is not iterable",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[17], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mpython\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;241;43m12345678\u001b[39;49m\u001b[43m:\u001b[49m\n\u001b[0;32m      2\u001b[0m \u001b[43m    \u001b[49m\u001b[38;5;28;43;01mpass\u001b[39;49;00m\n",
      "\u001b[1;31mTypeError\u001b[0m: 'int' object is not iterable"
     ]
    }
   ],
   "source": [
    "for python in 12345678:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "649df1cc-087d-4ca4-b16e-66a7a1e16412",
   "metadata": {},
   "source": [
    "- `Itrating string on Integer - TypeError - 'int' object is not iterable`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "a9767393-a5e5-45cc-b7e7-68df2268c401",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'int' object is not iterable\n",
      "Executed\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    for python in 12345678:\n",
    "        pass\n",
    "except:\n",
    "    print(\"'int' object is not iterable\")\n",
    "print(\"Executed\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8feced32-801d-45c9-a544-74bfe1b0c34f",
   "metadata": {},
   "source": [
    "- `Int to Float Conversion - Type Conversion`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "19b61085-be16-4937-9532-8cfbcea900f0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "43.0\n"
     ]
    }
   ],
   "source": [
    "num = 43\n",
    "print(float(num))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3855d191-adc0-4987-9db7-511b152bd8ff",
   "metadata": {},
   "source": [
    "- `String to Float Conversion - ValueError - could not convert string to float: 'Python'`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "8a73f021-87b5-4e95-81b4-ed0b01e45c84",
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "could not convert string to float: 'Python'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[24], line 2\u001b[0m\n\u001b[0;32m      1\u001b[0m num \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mPython\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m----> 2\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;28;43mfloat\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mnum\u001b[49m\u001b[43m)\u001b[49m)\n",
      "\u001b[1;31mValueError\u001b[0m: could not convert string to float: 'Python'"
     ]
    }
   ],
   "source": [
    "num = \"Python\"\n",
    "print(float(num))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4dede5d-1218-42cc-9f25-fd2d4ad93c2c",
   "metadata": {},
   "source": [
    "- `String to Float Conversion - ValueError - could not convert string to float: 'Python' - Incompatible Value.`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "2b353269-ba03-448e-84af-f6384aa770d6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Incompatible Value.\n",
      "Executed.\n"
     ]
    }
   ],
   "source": [
    "try: \n",
    "    num = \"Python\"\n",
    "    print(float(num))\n",
    "except:\n",
    "    print(\"Incompatible Value.\")\n",
    "print(\"Executed.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "73cb30ae-b7d6-48fd-b798-b8ef1d19e622",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[11, 22, 33, 44, 55]\n",
      "11\n",
      "22\n",
      "33\n",
      "44\n",
      "55\n"
     ]
    }
   ],
   "source": [
    "data = [11,22,33,44,55]\n",
    "print(data)\n",
    "# Unboxing the List : Storing Indivisual elements into the Variable.\n",
    "p,q,r,s,t = data \n",
    "print(p)\n",
    "print(q)\n",
    "print(r)\n",
    "print(s)\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4a1808a-3efe-4610-9956-8a3308c34910",
   "metadata": {},
   "source": [
    "- `not enough values to unpack (expected 6, got 5)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "30881afa-41c2-41d7-ac98-bc63ba1ffe2f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[11, 22, 33, 44, 55]\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "not enough values to unpack (expected 6, got 5)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[30], line 4\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[38;5;28mprint\u001b[39m(data)\n\u001b[0;32m      3\u001b[0m \u001b[38;5;66;03m# Unboxing the List : Storing Indivisual elements into the Variable.\u001b[39;00m\n\u001b[1;32m----> 4\u001b[0m p,q,r,s,t,u \u001b[38;5;241m=\u001b[39m data \n\u001b[0;32m      5\u001b[0m \u001b[38;5;28mprint\u001b[39m(p)\n\u001b[0;32m      6\u001b[0m \u001b[38;5;28mprint\u001b[39m(q)\n",
      "\u001b[1;31mValueError\u001b[0m: not enough values to unpack (expected 6, got 5)"
     ]
    }
   ],
   "source": [
    "data = [11,22,33,44,55]\n",
    "print(data)\n",
    "# Unboxing the List : Storing Indivisual elements into the Variable.\n",
    "p,q,r,s,t,u = data \n",
    "print(p)\n",
    "print(q)\n",
    "print(r)\n",
    "print(s)\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4bfd0dc3-ece3-4ab2-b09d-2501357b9ad0",
   "metadata": {},
   "source": [
    "- `too many values to unpack (expected 4)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "ce43b48c-caea-4a59-922b-7622120340ad",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[11, 22, 33, 44, 55]\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "too many values to unpack (expected 4)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[31], line 4\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[38;5;28mprint\u001b[39m(data)\n\u001b[0;32m      3\u001b[0m \u001b[38;5;66;03m# Unboxing the List : Storing Indivisual elements into the Variable.\u001b[39;00m\n\u001b[1;32m----> 4\u001b[0m p,q,r,s \u001b[38;5;241m=\u001b[39m data \n\u001b[0;32m      5\u001b[0m \u001b[38;5;28mprint\u001b[39m(p)\n\u001b[0;32m      6\u001b[0m \u001b[38;5;28mprint\u001b[39m(q)\n",
      "\u001b[1;31mValueError\u001b[0m: too many values to unpack (expected 4)"
     ]
    }
   ],
   "source": [
    "data = [11,22,33,44,55]\n",
    "print(data)\n",
    "# Unboxing the List : Storing Indivisual elements into the Variable.\n",
    "p,q,r,s = data \n",
    "print(p)\n",
    "print(q)\n",
    "print(r)\n",
    "print(s)\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93d5a2e8-9301-4704-8aa3-bff74ea2958b",
   "metadata": {},
   "source": [
    "- `Unboxing the List - Value Error - Storing Indivisual elements into the Indivisual Variable.`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "6ad25680-45ea-461e-bd06-e5f480b7b42e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[11, 22, 33, 44, 55]\n",
      "Value Error.\n",
      "Executed.\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    data = [11,22,33,44,55]\n",
    "    print(data)\n",
    "    # Unboxing the List : Storing Indivisual elements into the Variable.\n",
    "    p,q,r,s = data \n",
    "    print(p)\n",
    "    print(q)\n",
    "    print(r)\n",
    "    print(s)\n",
    "    print(t)\n",
    "except ValueError:\n",
    "    print(\"Value Error.\")\n",
    "print(\"Executed.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "763f9820-b81c-4180-90c7-6946fcb141a0",
   "metadata": {},
   "source": [
    "### `Exception Handling : try, except, else, finally`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe14a4d9-7462-4786-8be5-0367b6a5a5bc",
   "metadata": {},
   "source": [
    "- `eg., ZeroDivisionError`\n",
    "- `Except block executed : When exception throw by try block.`\n",
    "- `Else block executed : When Exception not throw by try block.`\n",
    "- `Finnaly block executed : Whether Exception throw or not throw by try block.`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "5c51bc63-91e8-49db-bbf2-a4d0b7a94473",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "48.0\n"
     ]
    }
   ],
   "source": [
    "a = 96\n",
    "b = 2\n",
    "res = a/b\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "82cb61f6-5a35-4348-9213-efc23cebb74b",
   "metadata": {},
   "outputs": [
    {
     "ename": "ZeroDivisionError",
     "evalue": "division by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[48], line 3\u001b[0m\n\u001b[0;32m      1\u001b[0m a \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m96\u001b[39m\n\u001b[0;32m      2\u001b[0m b \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0\u001b[39m\n\u001b[1;32m----> 3\u001b[0m res \u001b[38;5;241m=\u001b[39m \u001b[43ma\u001b[49m\u001b[38;5;241;43m/\u001b[39;49m\u001b[43mb\u001b[49m\n\u001b[0;32m      4\u001b[0m \u001b[38;5;28mprint\u001b[39m(res)\n",
      "\u001b[1;31mZeroDivisionError\u001b[0m: division by zero"
     ]
    }
   ],
   "source": [
    "a = 96\n",
    "b = 0\n",
    "res = a/b\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "41962e16-e5ef-430c-b6fa-d264b22ea943",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "48\n",
      "Executed\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    a = 96\n",
    "    b = 2\n",
    "    res = int(a/b)\n",
    "    print(res)\n",
    "except ZeroDivisionError:\n",
    "    print(\"Zero Division Error.\")\n",
    "print(\"Executed\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "76bec8c0-e60b-4685-8971-e8327d14df7a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Zero Division Error.\n",
      "Executed\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    a = 96\n",
    "    b = 0\n",
    "    res = a/b\n",
    "    print(res)\n",
    "except ZeroDivisionError:\n",
    "    print(\"Zero Division Error.\")\n",
    "print(\"Executed\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "b46b8455-737e-4df9-a754-62742aca42d9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Zero Division Error.\n",
      "Executed\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    a = 96\n",
    "    b = 0\n",
    "    res = a/b\n",
    "    print(res)\n",
    "except ZeroDivisionError:\n",
    "    print(\"Zero Division Error.\")\n",
    "else:\n",
    "    print(\"Code Successfully Execued.\")\n",
    "print(\"Executed\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "a121b15d-08af-451a-8d2a-2621df64a677",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "48.0\n",
      "Code Successfully Execued.\n",
      "Executed\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    a = 96\n",
    "    b = 2\n",
    "    res = a/b\n",
    "    print(res)\n",
    "except ZeroDivisionError:\n",
    "    print(\"Zero Division Error.\")\n",
    "else:\n",
    "    print(\"Code Successfully Execued.\")\n",
    "print(\"Executed\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "dde38a52-5070-44f0-9b1f-5a54acb62730",
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "expected 'except' or 'finally' block (4237408777.py, line 8)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  Cell \u001b[1;32mIn[54], line 8\u001b[1;36m\u001b[0m\n\u001b[1;33m    else:\u001b[0m\n\u001b[1;37m    ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m expected 'except' or 'finally' block\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    a = 96\n",
    "    b = 2\n",
    "    res = a/b\n",
    "    print(res)\n",
    "# except ZeroDivisionError:\n",
    "    # print(\"Zero Division Error.\")\n",
    "else:\n",
    "    print(\"Code Successfully Execued.\")\n",
    "print(\"Executed\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "de23c596-2a84-47af-adbd-af8f6bd41955",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "48.0\n",
      "Code Successfully Execued.\n",
      "Important Code Executed.\n",
      "Executed\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    a = 96\n",
    "    b = 2\n",
    "    res = a/b\n",
    "    print(res)\n",
    "except ZeroDivisionError:\n",
    "    print(\"Zero Division Error.\")\n",
    "else:\n",
    "    print(\"Code Successfully Execued.\")\n",
    "finally:\n",
    "    print(\"Important Code Executed.\")\n",
    "print(\"Executed\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "e63ed53f-28ff-452c-b12f-1fbc35dd3f1b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Zero Division Error.\n",
      "Important Code Executed.\n",
      "Executed\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    a = 96\n",
    "    b = 0\n",
    "    res = a/b\n",
    "    print(res)\n",
    "except ZeroDivisionError:\n",
    "    print(\"Zero Division Error.\")\n",
    "else:\n",
    "    print(\"Code Successfully Execued.\")\n",
    "finally:\n",
    "    print(\"Important Code Executed.\")\n",
    "print(\"Executed\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.3"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}