python_assignment.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "e558d53b-4a88-484e-9d61-3977b1be383f",
   "metadata": {},
   "source": [
    "# Python Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35f86336-3ba4-4510-8bbf-10542b32d6b9",
   "metadata": {},
   "source": [
    "## Example 1: Simple function with no arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "2efad624-f7d6-4e62-8d65-a943863a9b00",
   "metadata": {},
   "outputs": [],
   "source": [
    "def greet():\n",
    "    print(\"Hello, world!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "cff49123-0f74-4268-8209-3af31c7dea4a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, world!\n"
     ]
    }
   ],
   "source": [
    "greet()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b110852e-ae1a-4dbe-9d0c-bf5956fb2e4e",
   "metadata": {},
   "source": [
    "## Example 2: Function with arguments and a `return` statement (and a use of a docstring)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "43dd3c06-f3c4-4e5e-82a1-d8ac6f4150a2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def add(a, b):\n",
    "    \"\"\"\n",
    "    Takes two number variable inputs using two arguments: a, b.\n",
    "    Returns the sum of the two numbers.\n",
    "    \"\"\"\n",
    "    return a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9a2fac8d-d525-489f-af8a-648014e1d82a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "c = add(1, 2)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "add2f7ea-6c65-4823-879a-1f6fa4bd8995",
   "metadata": {},
   "source": [
    "## Example 3: Function with a default argument"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "93f19bdd-340b-4896-9514-4a1e8276ebec",
   "metadata": {},
   "outputs": [],
   "source": [
    "def greet_user(name = \"User\"):\n",
    "    print(f\"Hello, {name}!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "87ad6bb7-0a4b-445c-ab92-74de48591622",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Abhishek!\n",
      "Hello, User!\n"
     ]
    }
   ],
   "source": [
    "greet_user(\"Abhishek\")\n",
    "greet_user()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5182ca34-46d5-4fb1-8b8a-e8d483800396",
   "metadata": {},
   "source": [
    "## Example 4: Function returning multiple values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "f02eee6b-3264-4e9f-a640-e450aca1ab8e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def divide(a, b):\n",
    "    quotient = a // b\n",
    "    remainder = a % b\n",
    "    return quotient, remainder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "cca37bd7-44d1-4c53-bc87-2c80f99bc5bc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Quotient:  3\n",
      "Remainder:  1\n"
     ]
    }
   ],
   "source": [
    "q, r = divide(10, 3)\n",
    "print(\"Quotient: \", q)\n",
    "print(\"Remainder: \", r)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "046e961e-d183-4f7a-8b30-c6105b1c7bdd",
   "metadata": {},
   "source": [
    "## Example 5: Recursive Function (Factorial)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "f19fe84f-6356-49e6-b75c-410781be4a88",
   "metadata": {},
   "outputs": [],
   "source": [
    "def factorial(n):\n",
    "    if n == 0 or n == 1:\n",
    "        return 1\n",
    "    else:\n",
    "        return n * factorial(n - 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "d2d51a51-4f0a-4dd2-b868-92eae2a6e2fc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Factorial of 5 is 120.\n"
     ]
    }
   ],
   "source": [
    "print(f\"Factorial of 5 is {factorial(5)}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c76cf86e-3374-4658-a6f5-9e32916fa20e",
   "metadata": {},
   "source": [
    "## Example 6: Function scope and variable accessibility"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "df1bf071-7474-4582-8127-b21de4f28643",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 10\n",
    "def outer_function():\n",
    "    y = 20\n",
    "    print(f\"Inside outer_funciton, x (global): {x}\")\n",
    "    def inner_function():\n",
    "        z = 30\n",
    "        print(f\"Inside inner_function, x (global): {x}\")\n",
    "        print(f\"Inside inner_function, y (enclosing scope): {y}\")\n",
    "        print(f\"Inside inner_function, z (local): {z}\")\n",
    "    inner_function()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "c918003f-4722-49ec-93a8-1902b6fb4a16",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Inside outer_funciton, x (global): 10\n",
      "Inside inner_function, x (global): 10\n",
      "Inside inner_function, y (enclosing scope): 20\n",
      "Inside inner_function, z (local): 30\n"
     ]
    }
   ],
   "source": [
    "outer_function()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8bca0377-93e1-4940-954c-96972855289d",
   "metadata": {},
   "source": [
    "# `lambda` Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e09ba16c-4e48-4e7e-aa54-325d2cf2d1c2",
   "metadata": {},
   "source": [
    "## Example 1: Simple `lambda` function to add two numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "7466de28-d674-4cbb-8437-b7ffd7644c94",
   "metadata": {},
   "outputs": [],
   "source": [
    "add = lambda x, y: x + y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "d939d506-e434-4b84-91bd-4604ec98eef5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "print(add(1, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1ce17f7-d882-4b7b-8a52-ef583da2fa22",
   "metadata": {},
   "source": [
    "## Example 2: Comparing the above `lambda` function to a regular function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "96ea40fa-91ed-476c-8ba3-e964b6215aa1",
   "metadata": {},
   "outputs": [],
   "source": [
    "def regular_add(a, b):\n",
    "    return a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "6b211e55-3bdd-4e0a-a876-eb362395a2b5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "print (regular_add(1, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e134692-c693-4a17-9804-271d0b1a5aa1",
   "metadata": {},
   "source": [
    "## Example 3: `lambda` function with conditional satements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "ceb3b54b-b47e-4b43-80f6-476c1272316e",
   "metadata": {},
   "outputs": [],
   "source": [
    "is_even = lambda x: True if x % 2 == 0 else False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "d3c81913-0e96-4010-8c50-3b56fb6b9fcd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(is_even(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b49c275b-49d0-4e4c-bf07-0ac25c58b06a",
   "metadata": {},
   "source": [
    "## Example 4: `lambda` function for string length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "2235bfd3-8d1d-4664-b76e-2c3cfb5bb429",
   "metadata": {},
   "outputs": [],
   "source": [
    "length_of_string = lambda s: len(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "b0c02b99-3cb9-417a-9d95-ea3f102f5ef8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n"
     ]
    }
   ],
   "source": [
    "print(length_of_string(\"Hello, world!\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1c96c41-7193-4c17-9e6e-dff34bba98e3",
   "metadata": {},
   "source": [
    "## Example 5: `lambda` function to square a number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "c5b2b5ce-427b-4193-8fd1-ea051af3983a",
   "metadata": {},
   "outputs": [],
   "source": [
    "square = lambda x: x ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "784405b5-6fd8-452b-b437-f2aa2bc5d8ce",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Square of 2 is: 4\n"
     ]
    }
   ],
   "source": [
    "print(f\"Square of 2 is: {square(2)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f576df92-86bc-4ea6-933d-81cc6f80a9b6",
   "metadata": {},
   "source": [
    "## Example 6: Using `lambda` inside a `map()` function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "34f92852-1e56-415a-9097-33b7716aaa76",
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [1, 2, 3, 4, 5]\n",
    "squared_numbers = list(map(lambda x: x ** 2, numbers))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "590709fd-5a22-44df-99e1-6cc323425f0b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "print(squared_numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34f5b5c2-6558-4d15-8ac4-dd00166d42b1",
   "metadata": {},
   "source": [
    "## Example 7: Using `lambda` inside a `filter()` function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "8e9a4db1-3ec6-4ea9-950a-4aeaaf594f8a",
   "metadata": {},
   "outputs": [],
   "source": [
    "even_numbers = list(filter(lambda x: x % 2 == 0, numbers))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "9e803f79-4e16-422b-8e86-3b39910d963e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4]\n"
     ]
    }
   ],
   "source": [
    "print(even_numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "917af2c0-15eb-4586-a246-dfc1667deebb",
   "metadata": {},
   "source": [
    "## Example 8: Using `lambda` inside a `reduce()` funciton"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "af41761c-6344-46b8-94c5-6d888cd5aaec",
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import reduce\n",
    "product = reduce(lambda x, y: x * y, numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "6d413b45-e73a-436f-a02d-41077f5ef0f4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "120\n"
     ]
    }
   ],
   "source": [
    "print(product)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19b92b48-5b5e-4199-907e-03cae3661d60",
   "metadata": {},
   "source": [
    "# Numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "d0627cc9-0893-4d9d-9e17-6def01547fc3",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d019e6cc-abc0-462f-9195-77f8dac11d23",
   "metadata": {},
   "source": [
    "## Example 1: Numpy array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "d50bdb91-03b4-4024-940c-f9ea5e309f77",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4]\n",
      "<class 'numpy.ndarray'>\n",
      "(4,)\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([1, 2, 3, 4])\n",
    "print(arr)\n",
    "print(type(arr))\n",
    "print(arr.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba9e564d-5a1d-407d-89f5-083a28e41ffd",
   "metadata": {},
   "source": [
    "## Example 2: Numpy 2D array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "8889616d-d3ed-46b7-b2b0-1fc0d177c338",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3 4]\n",
      " [5 6 7 8]]\n"
     ]
    }
   ],
   "source": [
    "arr_2d = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])\n",
    "print(arr_2d)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3a6113e-3b48-4b9f-9955-0c499a650e13",
   "metadata": {},
   "source": [
    "## Example 3: Numpy 3D array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "8f1de7c0-a8a6-42c1-9437-1499a5dd96c8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[1 2]\n",
      "  [3 4]]\n",
      "\n",
      " [[5 6]\n",
      "  [7 8]]]\n"
     ]
    }
   ],
   "source": [
    "arr_3d = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])\n",
    "print(arr_3d)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae78f762-8da2-42bc-aa72-cd40eb02618c",
   "metadata": {},
   "source": [
    "## Example 4: Numpy array with zeros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "3e34c83b-ce0d-4715-8fa9-784572f5ca4f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 0.]\n",
      " [0. 0. 0.]\n",
      " [0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "zeros = np.zeros((3, 3))\n",
    "print(zeros)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "75094ea3-97bc-48ef-9c1e-a43a72d136a5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 1. 1.]\n",
      " [1. 1. 1.]\n",
      " [1. 1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "matrix_of_ones = zeros + 1\n",
    "print(matrix_of_ones)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0892fd7c-9c2a-4959-997f-577590e954bd",
   "metadata": {},
   "source": [
    "## Example 5: Numpy array with random values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "50df8efa-e703-4ffc-bc68-df3680b48f4d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.86414023 0.34150218 0.79939835]\n",
      " [0.67788923 0.6155338  0.51734658]\n",
      " [0.17102768 0.03436858 0.93412088]]\n"
     ]
    }
   ],
   "source": [
    "random_arr = np.random.rand(3, 3)\n",
    "print(random_arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "4aaeced0-a9f2-4778-bf58-e8cf63253b85",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[8.64140227 3.41502177 7.99398352]\n",
      " [6.77889229 6.155338   5.17346577]\n",
      " [1.71027678 0.34368578 9.34120881]]\n"
     ]
    }
   ],
   "source": [
    "scaled_random_arr = random_arr * 10\n",
    "print(scaled_random_arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "1043b393-3c29-4878-b953-5e4087dd583b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[3 2 5]\n",
      " [1 2 5]\n",
      " [5 9 4]]\n"
     ]
    }
   ],
   "source": [
    "random_integers = np.random.randint(0, 10, size=(3, 3))\n",
    "print(random_integers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "8cbd6c5b-7f6c-4161-97a0-d55e23c3c23f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-0.78749556  0.84225378  0.55873971]\n",
      " [ 0.53414162  0.74321116  0.9189213 ]\n",
      " [ 0.35409317  1.36541717 -0.61056056]]\n"
     ]
    }
   ],
   "source": [
    "random_normal = np.random.randn(3, 3) # Random numbers for normal distribution\n",
    "print(random_normal)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "72836797-75a9-4003-932b-810931e98417",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.37454012 0.95071431 0.73199394]\n",
      " [0.59865848 0.15601864 0.15599452]\n",
      " [0.05808361 0.86617615 0.60111501]]\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(42)  # Setting a seed ensures reproducibility\n",
    "random_seeded = np.random.rand(3, 3)\n",
    "print(random_seeded)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "f6502ff5-eb37-44d2-b16d-a9171fc17af9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5 4 1 2 3]\n"
     ]
    }
   ],
   "source": [
    "arr_to_shuffle = np.array([1, 2, 3, 4, 5])\n",
    "np.random.shuffle(arr_to_shuffle) # Suffling arrays\n",
    "print(arr_to_shuffle)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9239b32-63bd-4d30-84a1-26b096c6b982",
   "metadata": {},
   "source": [
    "## Example 6: Reshaping a Numpy array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "b55f09aa-fa35-45b0-bd8d-14bf34e13250",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n"
     ]
    }
   ],
   "source": [
    "reshaped_arr = np.reshape(arr, (2, 2))\n",
    "print(reshaped_arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "f1f38a51-8182-4cfb-a857-5e147c7f4de2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1]\n",
      " [2]\n",
      " [3]\n",
      " [4]]\n"
     ]
    }
   ],
   "source": [
    "column_vector = np.reshape(arr, (4, 1))\n",
    "print(column_vector)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5fbbcef-5695-4d8c-a19f-09c91c15d269",
   "metadata": {},
   "source": [
    "## Example 7: Element-wise Operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "220243c1-16eb-4ec4-93aa-3765db101447",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 6  8 10 12]\n"
     ]
    }
   ],
   "source": [
    "arr2 = np.array([5, 6, 7, 8])\n",
    "sum_arr = arr + arr2\n",
    "print(sum_arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "3d741db7-6e5b-43f2-a4bb-9f5f8657b0ed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 5 12 21 32]\n"
     ]
    }
   ],
   "source": [
    "product_arr = arr * arr2\n",
    "print(product_arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6c27ace-a05b-4957-a736-f9e4026b54cd",
   "metadata": {},
   "source": [
    "## Eample 8: Scalar Addition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "47f8927c-ac39-4e25-8515-47a0be780aab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[11 12 13 14]\n"
     ]
    }
   ],
   "source": [
    "scalar_addition = arr + 10\n",
    "print(scalar_addition)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1f10f43-2069-466c-92f7-2c2a60b1c22f",
   "metadata": {},
   "source": [
    "## Example 9: Accessing elements in a Numpy array using indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "47716bb1-8157-438f-9b09-7b627512f415",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "7\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "print(arr[2])\n",
    "print(arr_2d[1, 2])\n",
    "print(arr_3d[1, 0, 1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf67c734-ee56-4557-b782-ff130c66a101",
   "metadata": {},
   "source": [
    "## Example 10: Slicing Numpy arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "d3547dcc-7370-4cff-882a-6b5e904c9c70",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 3 4]\n",
      "[[1 2]\n",
      " [5 6]]\n"
     ]
    }
   ],
   "source": [
    "print(arr[1:4])\n",
    "print(arr_2d[:2, :2])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0337b80-1af6-4603-947c-3252a348e10a",
   "metadata": {},
   "source": [
    "## Example 11: Transposing a Numpy array (flipping rows and columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "f8b2f031-e2cf-47a9-b0f5-eeafe5c5a6f1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 5]\n",
      " [2 6]\n",
      " [3 7]\n",
      " [4 8]]\n"
     ]
    }
   ],
   "source": [
    "transposed = arr_2d.T\n",
    "print(transposed)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c38c65d4-1c30-4f8a-ab3f-c77712da31be",
   "metadata": {},
   "source": [
    "## Example 12: Concatenating Numpy arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "71e02e18-c176-4cb5-a250-21f21ee004ce",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6 7 8]\n"
     ]
    }
   ],
   "source": [
    "concatenated = np.concatenate((arr, arr2))\n",
    "print(concatenated)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "7684d933-e751-4438-91ff-41ed56344313",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3 4]\n",
      " [5 6 7 8]\n",
      " [1 2 3 4]\n",
      " [5 6 7 8]]\n"
     ]
    }
   ],
   "source": [
    "concatenated_2d = np.concatenate((arr_2d, arr_2d), axis = 0)\n",
    "print(concatenated_2d)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de95b35e-5d15-4ff9-97d6-3de0259e59db",
   "metadata": {},
   "source": [
    "# Pandas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "1285b77e-3f22-4869-9585-f5eab07e1a02",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48926efd-884c-4bfb-999f-d4034822a79a",
   "metadata": {},
   "source": [
    "## Example 1: Creating a DataFrame from a Dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "3a1af7a8-f74d-45e6-87f3-f3a70977ee30",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      Name  Age\n",
      "0    Alice   25\n",
      "1      Bob   30\n",
      "2  Charlie   35\n"
     ]
    }
   ],
   "source": [
    "data = {\"Name\": [\"Alice\", \"Bob\", \"Charlie\"], \"Age\": [25, 30, 35, ]}\n",
    "df = pd.DataFrame(data)\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b35c3e7d-0d11-47f6-8066-b84776c197ff",
   "metadata": {},
   "source": [
    "## Example 2: Reading a CSV file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "d94ef955-a241-4d1c-a260-dfb38ea971b4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      Name  Age\n",
      "0    Alice   25\n",
      "1      Bob   30\n",
      "2  Charlie   35\n"
     ]
    }
   ],
   "source": [
    "df2 = pd.read_csv(\"data.csv\")\n",
    "print(df2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63df5b52-b3c0-4c18-8b42-3568001c338b",
   "metadata": {},
   "source": [
    "## Example 3: Descriptive statistics of a DataFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "79aed353-720c-4c75-8278-5b349cad0c88",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Age</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>30.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>5.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>25.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>27.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>30.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>32.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>35.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        Age\n",
       "count   3.0\n",
       "mean   30.0\n",
       "std     5.0\n",
       "min    25.0\n",
       "25%    27.5\n",
       "50%    30.0\n",
       "75%    32.5\n",
       "max    35.0"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "d5e20c0b-c9e9-40b2-85d1-a75383c62e1e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "        Age\n",
      "count   3.0\n",
      "mean   30.0\n",
      "std     5.0\n",
      "min    25.0\n",
      "25%    27.5\n",
      "50%    30.0\n",
      "75%    32.5\n",
      "max    35.0\n"
     ]
    }
   ],
   "source": [
    "print(df.describe())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "008141f3-1096-457f-ac75-1e9d4024ff6f",
   "metadata": {},
   "source": [
    "## Example 4: Selecting specific columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "df04b67c-8ae5-4e5d-b77d-a5502b2ceca7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0      Alice\n",
      "1        Bob\n",
      "2    Charlie\n",
      "Name: Name, dtype: object\n"
     ]
    }
   ],
   "source": [
    "names = df[\"Name\"]\n",
    "print(names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "d0603d86-b92a-407a-bcef-ef5133c83b43",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      Name  Age\n",
      "0    Alice   25\n",
      "1      Bob   30\n",
      "2  Charlie   35\n"
     ]
    }
   ],
   "source": [
    "selected_columns = df[[\"Name\", \"Age\"]]\n",
    "print(selected_columns)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ea104e9-e588-425a-9aaa-ac453998406d",
   "metadata": {},
   "source": [
    "## Example 5: Filtering data based on conditions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "2ef9f9f4-06a3-4024-83b4-06956de80aa6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      Name  Age\n",
      "1      Bob   30\n",
      "2  Charlie   35\n"
     ]
    }
   ],
   "source": [
    "filtered_df = df[df[\"Age\"] > 25]\n",
    "print(filtered_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "e2ee5349-31cc-45e9-bd2f-4496685b2477",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      Name  Age\n",
      "2  Charlie   35\n"
     ]
    }
   ],
   "source": [
    "filtered_df2 = df[(df[\"Age\"] > 25) & (df[\"Name\"].str.startswith('C'))]\n",
    "print(filtered_df2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2b02027-8787-462d-be21-9b736d2c8702",
   "metadata": {},
   "source": [
    "## Example 6: Reading a CSV with a custom delimiter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "0ed4cffd-f543-4f8f-8e11-6dffdc34ce73",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      Name  Age\n",
      "0    Alice   25\n",
      "1      Bob   30\n",
      "2  Charlie   35\n"
     ]
    }
   ],
   "source": [
    "df3 = pd.read_csv(\"data.csv\", delimiter = ',')\n",
    "print(df3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f872356-7332-432c-999b-6cadad7177a4",
   "metadata": {},
   "source": [
    "## Exampel 7: Reading CSV and selecting columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "4bc1ea50-8c8b-4c9b-826f-381444a034b1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      Name  Age\n",
      "0    Alice   25\n",
      "1      Bob   30\n",
      "2  Charlie   35\n"
     ]
    }
   ],
   "source": [
    "df4 = pd.read_csv(\"data.csv\", usecols=[\"Name\", \"Age\"])\n",
    "print(df4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a26b9431-1105-4c16-84c7-1db000c9e0b1",
   "metadata": {},
   "source": [
    "## Example 8: Reading a CSV and checking only the first few columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "1afc4bac-c48e-4a85-9fc1-4f8ddbabe54e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      Name  Age\n",
      "0    Alice   25\n",
      "1      Bob   30\n",
      "2  Charlie   35\n"
     ]
    }
   ],
   "source": [
    "print(df2.head()) # Prints only the first 5 rows."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65800ce2-cb86-4e9f-9619-0c75dc2b2e8a",
   "metadata": {},
   "source": [
    "## Example 9: Reading a CSV with specific data types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "c8ff034a-7c2f-453e-a935-4d5e3d62dd83",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      Name  Age\n",
      "0    Alice   25\n",
      "1      Bob   30\n",
      "2  Charlie   35\n"
     ]
    }
   ],
   "source": [
    "df5 = pd.read_csv(\"data.csv\", dtype={\"Age\": \"int\"})\n",
    "print(df5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce85a0bd-d568-4756-875a-022b7cc21269",
   "metadata": {},
   "source": [
    "## Example 10: Grouping data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "acea5364-cc22-4206-92cb-052feea5d9d1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     Name\n",
      "Age      \n",
      "25      1\n",
      "30      1\n",
      "35      1\n"
     ]
    }
   ],
   "source": [
    "grouped_df = df.groupby(\"Age\").count()\n",
    "print(grouped_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ec62a77-497e-472f-a03a-0a3f4196dcf9",
   "metadata": {},
   "source": [
    "## Example 11: Pivot tables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "911a5ce8-53d0-428d-b2b6-22e2f94b2c27",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "          Age\n",
      "Name         \n",
      "Alice    25.0\n",
      "Bob      30.0\n",
      "Charlie  35.0\n"
     ]
    }
   ],
   "source": [
    "pivot_table = df.pivot_table(values=\"Age\", index=\"Name\")\n",
    "print(pivot_table)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "851de823-ee51-4aa4-97cc-bfc1a81f23a7",
   "metadata": {},
   "source": [
    "## Example 12: Skipping rows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "5fd4142f-a372-42e7-9cf1-1e3dd66217d5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "       Bob  30\n",
      "0  Charlie  35\n"
     ]
    }
   ],
   "source": [
    "df6 = pd.read_csv(\"data.csv\", skiprows=2) # Skipping first two rows\n",
    "print(df6)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6ce8fad-2e07-4f7c-8c5c-bb67f31d3f5a",
   "metadata": {},
   "source": [
    "## Example 13: Specifying rows to use as column names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "ae0dfdee-aab9-402b-84a3-e1dae0b728bc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "       Bob  30\n",
      "0  Charlie  35\n"
     ]
    }
   ],
   "source": [
    "df7 = pd.read_csv(\"data.csv\", header=2) # Using the third row, index 2, as the header row\n",
    "print(df7)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3243c213-770c-41dd-a51f-b54874981a5c",
   "metadata": {},
   "source": [
    "## Example 14: Filling missing values with a default value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "4d7e1dec-9613-4313-92e7-f11e2a353598",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "       Name   Age\n",
      "0     Alice  25.0\n",
      "1       Bob  30.0\n",
      "2   Charlie  35.0\n",
      "3  Abhishek   0.0\n",
      "4       Bob  30.0\n"
     ]
    }
   ],
   "source": [
    "df8 = pd.read_csv(\"data2.csv\")\n",
    "df_filled = df8.fillna(0)\n",
    "print(df_filled)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1e901ba-8a3e-4659-b7a4-f57ea488324f",
   "metadata": {},
   "source": [
    "## Example 15: Dropping rows with missing data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "1837b487-65e2-4e55-8710-f82582a8552d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      Name   Age\n",
      "0    Alice  25.0\n",
      "1      Bob  30.0\n",
      "2  Charlie  35.0\n",
      "4      Bob  30.0\n"
     ]
    }
   ],
   "source": [
    "df_cleaned = df8.dropna()\n",
    "print(df_cleaned)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e26f1534-7682-4f53-8c57-04eae78437c0",
   "metadata": {},
   "source": [
    "## Example 16: Removing Duplicates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "651b86c1-41db-493a-85ab-1641d528608b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "       Name   Age\n",
      "0     Alice  25.0\n",
      "1       Bob  30.0\n",
      "2   Charlie  35.0\n",
      "3  Abhishek   NaN\n"
     ]
    }
   ],
   "source": [
    "df_no_duplicates = df8.drop_duplicates()\n",
    "print(df_no_duplicates)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0cbf981-d066-4c60-a762-e8cceca7aea1",
   "metadata": {},
   "source": [
    "## Example 17: Renaming columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "8905b400-e67a-459a-9d98-5005fd1524b6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Full Name  Years\n",
      "0     Alice     25\n",
      "1       Bob     30\n",
      "2   Charlie     35\n"
     ]
    }
   ],
   "source": [
    "df_renamed = df2.rename(columns={\"Name\": \"Full Name\", \"Age\": \"Years\"})\n",
    "print(df_renamed)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4bdc52f-adb4-4013-b895-99ef5402d95d",
   "metadata": {},
   "source": [
    "# `if` statements"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "020431bf-29d2-42e8-873a-3acba84d0fe2",
   "metadata": {},
   "source": [
    "## Example 1: Simple `if` statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "af8ebc63-e506-4d4a-91c7-1c2ed648fc90",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number is greater than 5.\n"
     ]
    }
   ],
   "source": [
    "# x = float(input(\"Enter any number: \"))\n",
    "x = 10\n",
    "if x > 5:\n",
    "    print(\"The number is greater than 5.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f7b63ef0-7b4d-428c-bbdd-715771a0876e",
   "metadata": {},
   "source": [
    "## Example 2: `if`-`else` statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "f17645a3-d26b-497b-a447-b01ecf08452f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number is not greater than 5.\n"
     ]
    }
   ],
   "source": [
    "# y = float(input(\"Enter any number: \"))\n",
    "y = 4\n",
    "if y > 5:\n",
    "    print(\"The number is greater than 5.\")\n",
    "else:\n",
    "    print(\"The number is not greater than 5.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "775eca47-25ee-4db6-8b95-34f349175c47",
   "metadata": {},
   "source": [
    "## Example 3: `if`-`elif`-`else` statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "325db165-7781-4f91-8095-7dd7ff116423",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number is greater than 5.\n"
     ]
    }
   ],
   "source": [
    "# z = float(input(\"Enter any number: \"))\n",
    "z = 15\n",
    "if z > 5:\n",
    "    print(\"The number is greater than 5.\")\n",
    "elif z == 5:\n",
    "    print(\"The number is 5.\")\n",
    "else:\n",
    "    print(\"The number is less than 5.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7829b8d7-42cf-4da7-8ff0-56e46ddf2212",
   "metadata": {},
   "source": [
    "## Example 4: Nested `if` statements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "5c8fabd6-bc5a-4bec-9a4b-1bb6d87fc534",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number is between 10 and 30.\n"
     ]
    }
   ],
   "source": [
    "# a = float(input(\"Enter any number: \"))\n",
    "a = 15\n",
    "if a >= 10:\n",
    "    if a <= 30:\n",
    "        print(\"The number is between 10 and 30.\")\n",
    "else:\n",
    "    print(\"The number is not between 10 and 30.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d820d248-85d9-4127-ac8e-331d868f1fc4",
   "metadata": {},
   "source": [
    "## Example 5: Using `if` statements with logical operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "eaa55cb2-4083-4bd7-9218-bb0ac08b099f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number is between 10 and 30.\n"
     ]
    }
   ],
   "source": [
    "# b = float(input(\"Enter any number: \"))\n",
    "b = 15\n",
    "if b >= 10 and b <= 30:\n",
    "    print(\"The number is between 10 and 30.\")\n",
    "elif b > 30:\n",
    "    print(\"The number is greater than 30.\")\n",
    "else:\n",
    "    print(\"The number is less than 10.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9abc1916-77d1-4473-8907-299a1a6a7787",
   "metadata": {},
   "source": [
    "# Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e0df766-05e8-497f-a87b-1f63a4a2b6c5",
   "metadata": {},
   "source": [
    "## `for` Loop"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d66db3a3-0f82-44c7-9bf6-a6d675c5a2fc",
   "metadata": {},
   "source": [
    "### Example 1: Simple `for` loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "e8e6c545-b567-445f-889f-16ff691a5c23",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d37cdd8-caf5-48db-870c-80026e07d5fe",
   "metadata": {},
   "source": [
    "### Example 2: `for` loop over a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "4f43c46b-e2d1-4d3f-bd6c-19c6793f2d39",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "20\n",
      "30\n",
      "40\n"
     ]
    }
   ],
   "source": [
    "numbers = [10, 20, 30, 40]\n",
    "for number in numbers:\n",
    "    print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d68369e-c4c0-456d-9866-df9921da2af4",
   "metadata": {},
   "source": [
    "### Example 3: `for` loop with an index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "db7e33ca-9e33-4139-ac03-8ebe617e32db",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index 0: Apple\n",
      "Index 1: Banana\n",
      "Index 2: Cherry\n"
     ]
    }
   ],
   "source": [
    "fruits = [\"Apple\", \"Banana\", \"Cherry\"]\n",
    "for i in range(len(fruits)):\n",
    "    print(f\"Index {i}: {fruits[i]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9eff8f8a-c937-493b-90f5-cd6bdda20d36",
   "metadata": {},
   "source": [
    "### Example 4: Nested `for` loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "64232d14-4651-493e-ad15-10d82768e356",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i = 1, j = 1\n",
      "i = 1, j = 2\n",
      "i = 1, j = 3\n",
      "i = 2, j = 1\n",
      "i = 2, j = 2\n",
      "i = 2, j = 3\n",
      "i = 3, j = 1\n",
      "i = 3, j = 2\n",
      "i = 3, j = 3\n"
     ]
    }
   ],
   "source": [
    "for i in range(1, 4):\n",
    "    for j in range(1, 4):\n",
    "        print(f\"i = {i}, j = {j}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2903ec98-5e8e-48e9-a0f2-0e79d31f22d8",
   "metadata": {},
   "source": [
    "### Example 5: `for` loop with `else`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "30f55fb8-f623-4740-9c49-af008dce712c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "Loop finished!\n"
     ]
    }
   ],
   "source": [
    "for i in range(3):\n",
    "    print(i)\n",
    "else:\n",
    "    print(\"Loop finished!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44782e7b-1bf1-4fab-aeff-7203ee2bb9f8",
   "metadata": {},
   "source": [
    "### Example 6: `for` loop with `break`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "f347974b-fc11-4f38-bf00-451c46b849ba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    if i == 5:\n",
    "        break\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc29213a-26be-4533-94e6-7585ddf27b63",
   "metadata": {},
   "source": [
    "## `while` Loop"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "017d0648-4865-428b-bd81-24ba9b15e1c5",
   "metadata": {},
   "source": [
    "### Example 1: Simple `while` loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "837b356e-8d39-4989-9f96-3f71c14a3825",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "count = 0\n",
    "while count < 5:\n",
    "    print(count)\n",
    "    count += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b85b597-1fba-4bc5-874f-e04ab0fe6529",
   "metadata": {},
   "source": [
    "### Example 2: `while` loop with user `input`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "0f53b8d1-bc8a-4409-ad7d-e5528b944ab5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter password:  secret\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Access granted!\n"
     ]
    }
   ],
   "source": [
    "password = \"secret\"\n",
    "enter_password = \"\"\n",
    "while enter_password != password:\n",
    "    enter_password = input(\"Enter password: \")\n",
    "print(\"Access granted!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0bbe76e6-75b7-4f0d-8b8b-da9386197596",
   "metadata": {},
   "source": [
    "### Example 3: `while` loop with `break`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "d789d201-875a-4324-ad11-689622d0858d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "while x < 10:\n",
    "    if x == 5:\n",
    "        break\n",
    "    print(x)\n",
    "    x += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51472487-f166-497e-b3b0-2c19a1847239",
   "metadata": {},
   "source": [
    "### Example 4: `while` loop with `continue`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "2c38d8f3-186f-4319-8d72-dfff4a3c5242",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "5\n",
      "7\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "while x < 10:\n",
    "    x += 1\n",
    "    if x % 2 == 0:\n",
    "        continue\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0315b0ed-be6d-4a35-9313-c876578f742c",
   "metadata": {},
   "source": [
    "### Example 5: Infinite `while` loop with `break`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "5fbd22aa-82ac-4142-b311-9ae4377b28d7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while True:\n",
    "    print(i)\n",
    "    i += 1\n",
    "    if i >= 3:\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8373e877-416a-44e0-9404-e8a83cc62657",
   "metadata": {},
   "source": [
    "# Lists, Tuples, Sets and Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e74a74e8-c122-4f85-89f0-b8bd7f954ae4",
   "metadata": {},
   "source": [
    "## Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "207f15d9-04b4-4e40-8a92-264c113f8f7e",
   "metadata": {},
   "source": [
    "### Example 1: Creating a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "0b30fd82-e06a-41f3-b5e8-668a868862eb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Apple', 'Banana', 'Cherry']\n"
     ]
    }
   ],
   "source": [
    "fruits = [\"Apple\", \"Banana\", \"Cherry\"]\n",
    "print(fruits)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b46a86f-c0c9-43f2-8a17-c302af12b1a9",
   "metadata": {},
   "source": [
    "### Example 2: Appending to a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "040238d1-6657-4ac3-8e2b-021fbe4845fd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Apple', 'Banana', 'Cherry', 'Orange']\n"
     ]
    }
   ],
   "source": [
    "fruits.append(\"Orange\")\n",
    "print(fruits)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "479d13d1-768a-41c4-b746-d78f2b609cc0",
   "metadata": {},
   "source": [
    "### Example 3: Accessing list elements by index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "c5536d37-142f-4814-b5f9-90b06a843bfd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Apple\n",
      "Orange\n"
     ]
    }
   ],
   "source": [
    "print(fruits[0])\n",
    "print(fruits[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1525039b-c59c-423e-ae23-2c77f1e7cb84",
   "metadata": {},
   "source": [
    "### Example 4: Removing elements from a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "31a6ada4-84c0-44bb-8dd1-2e42c59a10b9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Apple', 'Cherry', 'Orange']\n"
     ]
    }
   ],
   "source": [
    "fruits.remove(\"Banana\")\n",
    "print(fruits)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed33aca4-f412-4fe5-b520-9b4915288a50",
   "metadata": {},
   "source": [
    "### Example 5: Slicing a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "772674c9-0b97-4883-b902-7c3390988d9a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Cherry', 'Orange']\n",
      "['Apple', 'Cherry', 'Orange']\n"
     ]
    }
   ],
   "source": [
    "print(fruits[1:3])\n",
    "print(fruits)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c69585d-b25a-4910-af7c-3b0484f025ce",
   "metadata": {},
   "source": [
    "## Tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b1b1693-08ea-4809-bafc-558848be2c94",
   "metadata": {},
   "source": [
    "### Example 1: Creating a tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "0cd5fb80-5e61-4206-97cd-ce303aa8953b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10, 20)\n"
     ]
    }
   ],
   "source": [
    "coordinates = (10, 20)\n",
    "print(coordinates)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb8241c2-2827-4cbe-8e42-6b1c8d9492eb",
   "metadata": {},
   "source": [
    "### Example 2: Accessing tuple elements by index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "823a1dd5-a5b4-4cc7-bbb6-01bb583d09f5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "print(coordinates[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d549a65-5942-4ad2-ae11-45565bd54cc6",
   "metadata": {},
   "source": [
    "### Example 3: Nested tupels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "7d03c8e7-71c0-4822-8c01-a22f19c245d8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "((1, 2), (3, 4))\n"
     ]
    }
   ],
   "source": [
    "nested_tuple = ((1, 2), (3, 4))\n",
    "print(nested_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "799913c1-a610-4e6c-8ef0-e5179486cd7f",
   "metadata": {},
   "source": [
    "### Example 4: Immutable nature of tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "3ca80933-3678-495d-8191-a7b8aeb8a4cc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# coordinates[0] = 15\n",
    "# This would raise a \"TypeError\" because tuples are immutable."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06d5975a-d3ba-4f36-a417-8f2a4306c357",
   "metadata": {},
   "source": [
    "### Example 5: Tuple unpacking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "2fb63006-32ed-4724-aa35-842aa8ba75c7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 20\n"
     ]
    }
   ],
   "source": [
    "x, y = coordinates\n",
    "print(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5c504b7-3c03-4093-b430-66260bc57501",
   "metadata": {},
   "source": [
    "## Sets"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ce3f2a8-c2fb-48bb-abbd-e1698a5673c9",
   "metadata": {},
   "source": [
    "### Example 1: Creating a set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "29ce44ed-4b25-4c77-98e5-b1c4b0b0b731",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4}\n"
     ]
    }
   ],
   "source": [
    "unique_numbers = {1, 2, 3, 3, 4}\n",
    "print(unique_numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0bfa01ec-08e1-446b-bf2e-9733521b8c3e",
   "metadata": {},
   "source": [
    "### Example 2: Adding an element to a set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "63fcae46-a902-442c-aaf6-c701c0cd44e8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "unique_numbers.add(5)\n",
    "print(unique_numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c0198b5-14fb-4611-89bd-851240509788",
   "metadata": {},
   "source": [
    "### Example 3: Set union"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "df939927-865b-4eea-94b4-3162e4d5cdb1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "set_a = {1, 2, 3}\n",
    "set_b = {3, 4, 5}\n",
    "union_set = set_a.union(set_b)\n",
    "print(union_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eee69895-eeda-46c2-be7f-8f788091ea7f",
   "metadata": {},
   "source": [
    "### Example 4: Set intersection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "ba664efb-bf5a-43ed-9f64-3d63b2bd56dd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{3}\n"
     ]
    }
   ],
   "source": [
    "intersection_set = set_a.intersection(set_b)\n",
    "print(intersection_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12169559-bd15-47c7-8677-59b66beb8547",
   "metadata": {},
   "source": [
    "### Example 5: Removing an element from a set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "2c31f498-1343-4311-934e-a1f1c1a1fc2c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "unique_numbers.remove(2)\n",
    "print(unique_numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78abaf17-bab5-4c33-bda8-b4bdcf9049aa",
   "metadata": {},
   "source": [
    "## Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63f11bb5-63d4-4561-a7a7-94499b4d9738",
   "metadata": {},
   "source": [
    "### Example 1: Creating a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "a41740e4-5872-43cc-bf02-95ecfd1c1efe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'Alice', 'age': 25}\n"
     ]
    }
   ],
   "source": [
    "person = {\"name\": \"Alice\", \"age\": 25}\n",
    "print(person)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62709628-a3b3-489f-8bf0-1df26f429179",
   "metadata": {},
   "source": [
    "### Example 2: Accessing dictionary values by keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "24b6f366-8a26-4e7c-ad23-ac4360722b17",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Alice\n"
     ]
    }
   ],
   "source": [
    "print(person[\"name\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78cb1f88-199b-4756-9b66-7dab226670d5",
   "metadata": {},
   "source": [
    "### Example 3: Adding a new key-value pair to the dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "2e34284d-c866-4ccf-8405-ee53874cb7d5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'Alice', 'age': 25, 'city': 'New York'}\n"
     ]
    }
   ],
   "source": [
    "person[\"city\"] = \"New York\"\n",
    "print(person)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f66e35e5-867c-4071-b8d9-f0fadfab33db",
   "metadata": {},
   "source": [
    "### Example 4: Updating a dictionary value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "dd925aa9-a960-4632-8afd-2738a4f77ac4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'Alice', 'age': 30, 'city': 'New York'}\n"
     ]
    }
   ],
   "source": [
    "person[\"age\"] = 30\n",
    "print(person)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "daddaaf5-8f26-489a-9ea3-1a3bea7cb165",
   "metadata": {},
   "source": [
    "### Example 5: Looping over a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "91a5e2b7-c660-41e2-8c69-82a3b109d7a3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name: Alice\n",
      "age: 30\n",
      "city: New York\n"
     ]
    }
   ],
   "source": [
    "for key, value in person.items():\n",
    "    print(f\"{key}: {value}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50c8c0e7-ff36-4dd2-8b54-60f7576e2a78",
   "metadata": {},
   "source": [
    "# Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2226dde2-730c-4652-b3c7-b930976b4599",
   "metadata": {},
   "source": [
    "## Arithmetic Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46931844-a526-469f-93ec-fa22da7b0099",
   "metadata": {},
   "source": [
    "### Example 1: Addition and Subtraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "25f2397f-e7fa-4124-9eb5-d1d785e13067",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "y = 5\n",
    "add = x + y\n",
    "subtract = x - y\n",
    "print(add)\n",
    "print(subtract)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed21b2a4-d9ac-4fa7-bb71-ac2f41386753",
   "metadata": {},
   "source": [
    "### Example 2: Multiplication and Division"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "958e9527-6cc9-4c22-b1c2-6c3643328d6d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50\n",
      "2.0\n"
     ]
    }
   ],
   "source": [
    "product = x * y\n",
    "division = x / y\n",
    "print(product)\n",
    "print(division)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28d1af26-619c-4e64-8d32-88060af9f5a3",
   "metadata": {},
   "source": [
    "### Example 3: Modulus"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "1e2a6ea7-fd2d-4913-9aec-ecb288ee9e9f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "remainder = x % y\n",
    "print(remainder)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f07d529-a6ca-445b-bafb-ecdc3cd1fdb8",
   "metadata": {},
   "source": [
    "### Example 4: Quotient (Floor Division)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "976ff8dd-f9ec-425e-a42c-2a2e26cd2b9d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "quotient = x // y\n",
    "print(quotient)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28997dff-bee8-4338-89e0-658c21a810bb",
   "metadata": {},
   "source": [
    "### Example 5: Exponentiation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "99856de6-1ba1-4715-a780-0ef2dfe42526",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n"
     ]
    }
   ],
   "source": [
    "power = x ** 2\n",
    "print(power)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43f32222-26ea-42da-966f-5a070a6ca34e",
   "metadata": {},
   "source": [
    "### Example 6: Operator precedance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "0041ac19-cd0b-4353-b729-0c1e57d8af2a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Result:  9.0\n"
     ]
    }
   ],
   "source": [
    "result = 10 + 2 * 3 ** 2 / 6 - 4\n",
    "print(\"Result: \", result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "id": "34326b98-4817-436d-9a52-59dedb14186c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Result2:  -30.693005156311102\n"
     ]
    }
   ],
   "source": [
    "result2 = (10 +2) * (3 ** (2/6) - 4)\n",
    "print(\"Result2: \", result2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b908d36-2fa7-4c2c-982b-b030d79e9bee",
   "metadata": {},
   "source": [
    "## Comparison Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4bea9b6-fd31-4333-bb13-67f4ff81ba11",
   "metadata": {},
   "source": [
    "### Example 1: Equals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "c8482994-850f-45e9-b545-ffbd9da96291",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "is_equal = (x == y)\n",
    "print(is_equal)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c5a6ea0-5305-410b-a9c1-bdc054a6a1e7",
   "metadata": {},
   "source": [
    "### Example 2: Does not equal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "13f36168-f0ef-4fd2-a06e-232277ae3927",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "is_not_equal = (x != y)\n",
    "print(is_not_equal)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a2584e9-3c98-4caf-b291-cee2c105169a",
   "metadata": {},
   "source": [
    "### Example 3: Greater than"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "7827a36d-d3e2-4c95-a527-0bef2e4bd086",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "is_greater = (x > y)\n",
    "print(is_greater)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73b5940e-f159-422f-b7ad-e85af57cc563",
   "metadata": {},
   "source": [
    "### Example 4: Less than or equal to"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "5937918a-c818-48e7-aacc-ab10435c20bc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "is_less_or_equal = (x <= y)\n",
    "print(is_less_or_equal)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a8d3a39-20c7-4161-a742-97d45c503393",
   "metadata": {},
   "source": [
    "### Example 5: Greater than or equal to"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "id": "fdf12919-16f7-4ed1-b696-7c84723436d3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "is_greater_or_equal = (x >= y)\n",
    "print(is_greater_or_equal)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a26b976a-fb83-4208-b0e9-62705d67fb73",
   "metadata": {},
   "source": [
    "## Logical Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bdf88776-589c-467b-8c5a-87273199780d",
   "metadata": {},
   "source": [
    "### Example 1: `and` operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "5a14a0f4-5045-4cf6-9b54-a36c851d8252",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "and_result = (x > 5 and y < 10)\n",
    "print(and_result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b48fb517-cdc7-4a04-9444-3fdafcf5adf5",
   "metadata": {},
   "source": [
    "### Example 2: `or` operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "id": "e6ed415d-2283-4edd-9c09-136da0b73bbb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "or_result = (x > 15 or y == 5)\n",
    "print(or_result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf22d89f-afd9-4ffa-ac07-519a7b2268a0",
   "metadata": {},
   "source": [
    "### Example 3: `not` operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "54150891-53c4-439c-92dc-1641a427c1e4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "not_result = not(x == y)\n",
    "print(not_result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c29a3d41-1d58-4211-801b-4a9902c9786f",
   "metadata": {},
   "source": [
    "### Example 4: Combining `and` and `or` operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "ec67efbb-01d7-45ce-9635-0d4a5021832c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "combined_logic = (x > 5 and y ==5) or (y > 10)\n",
    "print(combined_logic)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ec22924-bb3e-4d5f-8fe2-6a15539deb07",
   "metadata": {},
   "source": [
    "### Example 5: Nested logical operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "id": "fa5705b0-9aae-4f9d-b6c2-374f8c58c239",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "nested_result = ((x > 5 or y > 5) and (x < 20))\n",
    "print(nested_result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37c6bf00-014b-4c5d-9821-d6390ff9855e",
   "metadata": {},
   "source": [
    "## Assignment Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0f5dd31-a6d0-486a-8176-9f6f5d596e96",
   "metadata": {},
   "source": [
    "### Example 1: Assignment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "id": "f6249a5e-d9a0-4bd0-9920-fe892e5e57da",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5d46775-e5e6-48d0-b723-7cfa351e559c",
   "metadata": {},
   "source": [
    "### Example 2: Addition Assignment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "id": "3700f4a0-036f-4e0c-8e66-5bbed9ca5e3e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n"
     ]
    }
   ],
   "source": [
    "x += 5\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a81689e8-eca3-4961-aaa8-1246df24905e",
   "metadata": {},
   "source": [
    "### Example 3: Subtraction Assignment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "id": "d1039b47-ee6b-49bd-b03f-881038555c10",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n"
     ]
    }
   ],
   "source": [
    "x -= 3\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b5bf2a8-2827-44ba-9513-e8caade0a62a",
   "metadata": {},
   "source": [
    "### Example 4: Multiplication Assignment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "2ff33b8a-b132-425c-9c7d-549af52857e8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24\n"
     ]
    }
   ],
   "source": [
    "x *= 2\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7c651ab-e790-4e5b-b97c-cc0bbc8127cd",
   "metadata": {},
   "source": [
    "### Example 5: Division Assignment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "id": "6060b005-8fc7-4fd4-b00c-be9dac686638",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12.0\n"
     ]
    }
   ],
   "source": [
    "x /= 2\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8af92a64-219d-4c2b-979b-98c2cfb511be",
   "metadata": {},
   "source": [
    "### Example 6: Modulus Assignment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "id": "48264897-e1a5-46fb-ad5b-2df5d9fca68e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0\n"
     ]
    }
   ],
   "source": [
    "x %= 3\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da0c39d7-3f64-4b48-95dd-034303592885",
   "metadata": {},
   "source": [
    "## Identity Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f153c6b8-a19a-4ad0-bfff-e297e0650bbb",
   "metadata": {},
   "source": [
    "### Example 1: `is` operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "id": "a2c4f244-257a-4da8-bd34-ce2810a3f9a0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "a = 10\n",
    "b = 10\n",
    "is_same = (a is b) # They point to the same object in the memory.\n",
    "print(is_same)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26710018-aec8-4416-ac0f-2a8e4abe0230",
   "metadata": {},
   "source": [
    "### Exampel 2: `is not` operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "id": "6b264675-6e33-49cd-bf67-b667cddd7ec3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3]\n",
    "b = [1, 2, 3]\n",
    "is_not_same = (a is not b) # They point to different objects in the memory.\n",
    "print(is_not_same)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bad68a23-d3e1-4fd5-853e-a131d25c48a4",
   "metadata": {},
   "source": [
    "### Example 3: Using `is` with `None`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "id": "ae28ab18-0f91-4aea-ac4b-45252ab46c5a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "result = None\n",
    "is_none = (result is None)\n",
    "print(is_none)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97935b46-9da3-4203-83ce-54a1420713c5",
   "metadata": {},
   "source": [
    "### Example 4: Comparing mutable objects with `is`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "id": "c5764f61-8ee1-4ab0-a860-4248cd294e00",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "list1 = [1, 2, 3]\n",
    "list2 = list1\n",
    "is_same_list = (list1 is list2) # They point to the same object in the memory.\n",
    "print(is_same_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1335932-3c65-41a2-9194-19709773aca6",
   "metadata": {},
   "source": [
    "### Example 5: Comparing large integers with `is`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "2cdb590d-a37d-4469-bb17-197bfc419a6b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "x = 1000\n",
    "y = 1000\n",
    "print(x is y) # Large integers are allocated with separate memories."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ceae6d8-03d6-4d0d-bcb4-6f2f0b7f0c1c",
   "metadata": {},
   "source": [
    "# Reading CSV Files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "22b3632e-7ef1-4ced-9aee-01011174142f",
   "metadata": {},
   "outputs": [],
   "source": [
    "import csv"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1403e26d-7448-498e-8d1b-12efb6637c38",
   "metadata": {},
   "source": [
    "## Example 1: Basic CSV file reading"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "id": "eb70b6cb-f70b-4fff-a690-b09c6379d138",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Name', 'Age']\n",
      "['Alice', '25']\n",
      "['Bob', '30']\n",
      "['Charlie', '35']\n"
     ]
    }
   ],
   "source": [
    "with open(\"data.csv\", 'r') as file:\n",
    "    reader = csv.reader(file)\n",
    "    for row in reader:\n",
    "        print(row)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a503551-477b-4871-8ecc-0d041866814a",
   "metadata": {},
   "source": [
    "## Example 2: Reading CSV and splitting by a custom delimiter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "id": "e8486837-fe65-40cd-9fd1-75492de44549",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Name', 'Age']\n",
      "['Alice', '25']\n",
      "['Bob', '30']\n",
      "['Charlie', '35']\n"
     ]
    }
   ],
   "source": [
    "with open(\"data.csv\", 'r') as file:\n",
    "    reader = csv.reader(file, delimiter = ',')\n",
    "    for row in reader:\n",
    "        print(row)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67d25baf-f862-4b50-ab3a-9cfb0ecdcc49",
   "metadata": {},
   "source": [
    "## Example 3: Reading specific columns by index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "id": "98a712ad-e5a4-4164-a5e7-1f2cd87a9ed4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Name, Age: Age\n",
      "Name: Alice, Age: 25\n",
      "Name: Bob, Age: 30\n",
      "Name: Charlie, Age: 35\n"
     ]
    }
   ],
   "source": [
    "with open(\"data.csv\", 'r') as file:\n",
    "    reader = csv.reader(file)\n",
    "    for row in reader:\n",
    "        print(f\"Name: {row[0]}, Age: {row[1]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39e9c591-8bbf-4f0e-b380-3f470cdf7195",
   "metadata": {},
   "source": [
    "## Example 4: Skipping the header row"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "id": "46328e2c-c113-4f5a-91c3-6dcadb8f86ff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Alice', '25']\n",
      "['Bob', '30']\n",
      "['Charlie', '35']\n"
     ]
    }
   ],
   "source": [
    "with open(\"data.csv\", 'r') as file:\n",
    "    reader = csv.reader(file)\n",
    "    next(reader)\n",
    "    for row in reader:\n",
    "        print(row)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "644ab23d-657f-4b9b-ab65-8f4575af3971",
   "metadata": {},
   "source": [
    "## Example 5: Reading CSV into a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "id": "042ed0e6-f476-4bcd-822e-499eab743379",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Name': 'Alice', 'Age': '25'}\n",
      "{'Name': 'Bob', 'Age': '30'}\n",
      "{'Name': 'Charlie', 'Age': '35'}\n"
     ]
    }
   ],
   "source": [
    "with open(\"data.csv\", 'r') as file:\n",
    "    reader = csv.DictReader(file)\n",
    "    for row in reader:\n",
    "        print(dict(row))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0dc4246d-af5a-4a88-8e43-02a8fe21a7bd",
   "metadata": {},
   "source": [
    "# Python String Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50e39b13-9e90-4770-aa3c-02d601de770c",
   "metadata": {},
   "source": [
    "## Example 1: Case conversion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "id": "94a1c71e-99f0-4fcf-93a3-f27d16295132",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HELLO, WORLD!\n"
     ]
    }
   ],
   "source": [
    "text = \"Hello, world!\"\n",
    "print(text.upper())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "id": "9b3a8bd8-e410-4b4a-9628-59cf043c12b0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello, world!\n"
     ]
    }
   ],
   "source": [
    "print(text.lower())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "id": "2c2647b5-1f5c-4531-a527-b7321988ca1c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n"
     ]
    }
   ],
   "source": [
    "print(text.title())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af4e9227-81e8-440c-a63c-3facd270993f",
   "metadata": {},
   "source": [
    "## Example 2: String splitting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "id": "9878ae7f-4c0d-4e2f-8783-72e3ed1a244b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Hello,', 'world!']\n"
     ]
    }
   ],
   "source": [
    "words = text.split()\n",
    "print(words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "id": "67f1b294-1f3c-4cff-a80a-80c7600b6f8d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Hello', ' world!']\n"
     ]
    }
   ],
   "source": [
    "print(text.split(\",\")) # Splitting text using a custom delimiter"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ba85990-c7c4-4ae8-93bc-ccc48102c480",
   "metadata": {},
   "source": [
    "## Example 3: String replacement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "id": "663bfa50-0375-47e9-8b97-62ddd3d1f0ea",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Python!\n"
     ]
    }
   ],
   "source": [
    "new_text = text.replace(\"world\", \"Python\")\n",
    "print(new_text)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8eae030c-5e8b-40af-aed1-44ece76da65f",
   "metadata": {},
   "source": [
    "## Example 4: String stripping (removing leading and trailing whitespaces)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "id": "8770c023-e1f6-4a94-8e4d-cd91015c9695",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, world!\n"
     ]
    }
   ],
   "source": [
    "text2 = \"     Hello, world!   \"\n",
    "print(text2.strip())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "id": "f2c13109-0abf-42bf-a644-d23b68f7cadc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, world!   \n"
     ]
    }
   ],
   "source": [
    "print(text2.lstrip())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "id": "1f7dd6f2-58c2-4490-b33c-95d579f68bc2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     Hello, world!\n"
     ]
    }
   ],
   "source": [
    "print(text2.rstrip())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c26d337-0fde-4d30-89f7-8a962090540c",
   "metadata": {},
   "source": [
    "## Example 5: String concatenation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "id": "918ac890-d801-416f-aef0-c36f6497c2d7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, world!\n"
     ]
    }
   ],
   "source": [
    "greeting = \"Hello, \" + \"world!\"\n",
    "print(greeting)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51df2a31-0120-49c5-8487-ea6c2abf3c53",
   "metadata": {},
   "source": [
    "## Example 6: Finding the first occurrence of a substring"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "id": "3bf229f8-abed-48c3-b645-3f8d99116de4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "index = text.find(\"world!\")\n",
    "print(index)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "027d40dd-80ca-4136-9f1e-bb6bb354fb28",
   "metadata": {},
   "source": [
    "## Example 7: Counting the number of occurences of a substring in a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "id": "d99895f6-ed8e-4225-a40f-ee1fd05919ad",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "count = text.count('o')\n",
    "print(count)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6488f9f1-4af1-45fa-b944-e25bbbcce7a9",
   "metadata": {},
   "source": [
    "## Example 8: Checking if a stirng starts or ends with a certain substring"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "id": "3ab30318-1f87-4664-b78b-48cfd23a5dda",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(text.startswith(\"Hello\"))\n",
    "print(text.endswith(\"world!\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a63c62a-6738-4e26-9e22-025122163bef",
   "metadata": {},
   "source": [
    "## Example 9: String slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "id": "12c4e7a8-97f0-496d-a4a4-37ad7fb82921",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lo\n"
     ]
    }
   ],
   "source": [
    "sliced_text = text[3:5]\n",
    "print(sliced_text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "285c0183-b777-4ddb-bb6e-aa93333dc34a",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}