assignment_2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "9ab7acb3",
   "metadata": {},
   "source": [
    "# Python Assignment - 2\n",
    "### Carries - 30 marks"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4122e1a",
   "metadata": {},
   "source": [
    "## What is List? How will you reverse a list?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ef44f9e9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 4, 3, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "#my_list = [1, 2, 3, 4, 5]\n",
    "#list  is iterable objects in python \n",
    "\n",
    "original_list = [1, 2, 3, 4, 5]\n",
    "reversed_list = []\n",
    "\n",
    "for item in original_list:\n",
    "    reversed_list.insert(0, item)\n",
    "\n",
    "print(reversed_list)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69255251",
   "metadata": {},
   "source": [
    "# How will you compare two lists?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ee751ef2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The lists are not equal.\n"
     ]
    }
   ],
   "source": [
    "list1 = [1, 2, 3]\n",
    "list2 = [1, 5, 3]\n",
    "\n",
    "\n",
    "if list1 == list2:\n",
    "    print(\"The lists are equal.\")\n",
    "else:\n",
    "    print(\"The lists are not equal.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "367150d6",
   "metadata": {},
   "source": [
    "###  How will you remove last object from a list? Suppose list1 is [2, 33, 222, 14, and 25], what is list1 [-1]? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "9364a001",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 33, 222, 14]\n"
     ]
    }
   ],
   "source": [
    "list1 = [2, 33, 222, 14, 25]\n",
    "list1 = list1[:-1]\n",
    "print(list1)  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ad2912e",
   "metadata": {},
   "source": [
    "### Differentiate between append () and extend () methods? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9f0d5d58",
   "metadata": {},
   "outputs": [],
   "source": [
    "append() Method:\n",
    "append() is used to add a single element to the end of a list.\n",
    "It takes one argument, which is the element you want to add to the list.\n",
    "After append() is called, the list will have the new element as its last item.\n",
    "It does not modify the original element in any way; it simply adds the element itself to the list.\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "extend() Method:\n",
    "\n",
    "extend() is used to append elements from an iterable (e.g., another list, tuple, string) to the end of a list.\n",
    "It takes one argument, which should be an iterable containing elements to be added to the list.\n",
    "It unpacks the elements from the iterable and adds them individually to the end of the list.\n",
    "It can be used to concatenate two or more lists or add multiple elements from any iterable."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f8c10ed",
   "metadata": {},
   "source": [
    "### Write a Python program to find the second smallest number in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "79acc6a9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "l1=[4,1,5,6,7,8,9]\n",
    "sm=float('inf')#smallest  number\n",
    "ssm=float('inf')#second smallest number \n",
    "\n",
    "for i in l1:\n",
    "    if i < sm:\n",
    "        ssm=sm\n",
    "        sm=i\n",
    "    elif i < ssm and i != sm:\n",
    "        ssm=i\n",
    "print(ssm)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ded1b65",
   "metadata": {},
   "source": [
    "### Write a Python program to find the length of a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "61cfffe0",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_tuple = (1, 2, 3, 4, 5)\n",
    "\n",
    "tuple_length = len(my_tuple)\n",
    "\n",
    "print(\"The length of the tuple is:\", tuple_length)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86d7bc5d",
   "metadata": {},
   "source": [
    "## Write a Python program to reverse a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "678ce2c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "original_tuple = (1, 2, 3, 4, 5)\n",
    "\n",
    "reversed_tuple = tuple(reversed(original_tuple))\n",
    "\n",
    "print(\"Original Tuple:\", original_tuple)\n",
    "print(\"Reversed Tuple:\", reversed_tuple)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a982267",
   "metadata": {},
   "source": [
    "### Write a Python program to remove duplicates from a list. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "94d4beb8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original List: [1, 2, 2, 3, 4, 4, 5]\n",
      "List with Duplicates Removed: [1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "l1 = [1, 2, 2, 3, 4, 4, 5]\n",
    "\n",
    "l2 = []\n",
    "\n",
    "for i in l1:\n",
    "\n",
    "    if i not in l2:\n",
    "        l2.append(i)\n",
    "\n",
    "\n",
    "print(\"Original List:\", l1)\n",
    "print(\"List with Duplicates Removed:\", l2)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2573940b",
   "metadata": {},
   "source": [
    "## Write a Python function that takes a list and returns a new list with unique elements of the first list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "6c34b94a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List with Unique Elements: [1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "def unique_elements(input_list):\n",
    "    unique_list = []\n",
    "\n",
    "    for item in input_list:\n",
    "        if item not in unique_list:\n",
    "            unique_list.append(item)\n",
    "\n",
    "    return unique_list\n",
    "my_list = [1, 2, 2, 3, 4, 4, 5]\n",
    "result = unique_elements(my_list)\n",
    "print(\"List with Unique Elements:\", result)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "569027d9",
   "metadata": {},
   "source": [
    "###  Write a Python program to check a list is empty or not. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "fd71c169",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The list is not empty.\n"
     ]
    }
   ],
   "source": [
    "def is_empty(input_list):\n",
    "    if not input_list:  \n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "\n",
    "\n",
    "my_list = [1,2,3] \n",
    "result = is_empty(my_list)\n",
    "\n",
    "if result:\n",
    "    print(\"The list is empty.\")\n",
    "else:\n",
    "    print(\"The list is not empty.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c64d9e48",
   "metadata": {},
   "source": [
    "### Write a Python function to get the largest number, smallest num and sum of all from a list. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "155dd0e4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Largest number: 10\n",
      "Smallest number: 2\n",
      "Sum of all numbers: 35\n"
     ]
    }
   ],
   "source": [
    "def get_stats(input_list):\n",
    "    if not input_list:\n",
    "        return None  # Return None for an empty list\n",
    "    \n",
    "    smallest = min(input_list)\n",
    "    largest = max(input_list)\n",
    "    total = sum(input_list)\n",
    "    \n",
    "    return largest, smallest, total\n",
    "\n",
    "my_list = [10, 5, 7, 2, 8, 3]\n",
    "result = get_stats(my_list)\n",
    "\n",
    "if result is not None:\n",
    "    largest, smallest, total = result\n",
    "    print(\"Largest number:\", largest)\n",
    "    print(\"Smallest number:\", smallest)\n",
    "    print(\"Sum of all numbers:\", total)\n",
    "else:\n",
    "    print(\"The list is empty.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80f8354d",
   "metadata": {},
   "source": [
    "### Write a Python program to get unique values from a list "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "c7ab6392",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List with Unique Values: [1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, 2, 2, 3, 4, 4, 5]\n",
    "\n",
    "unique_list = []\n",
    "\n",
    "for item in my_list:\n",
    "    if item not in unique_list:\n",
    "        unique_list.append(item)\n",
    "\n",
    "\n",
    "print(\"List with Unique Values:\", unique_list)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a62c3d8c",
   "metadata": {},
   "source": [
    "### Write a Python program to split a list into different variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "25bb05a2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Variable 1: 1\n",
      "Variable 2: 2\n",
      "Variable 3: 3\n",
      "Variable 4: 4\n",
      "Variable 5: 5\n"
     ]
    }
   ],
   "source": [
    "# Original list\n",
    "my_list = [1, 2, 3, 4, 5]\n",
    "\n",
    "# Split the list into variables\n",
    "var1, var2, var3, var4, var5 = my_list\n",
    "\n",
    "# Print the variables\n",
    "print(\"Variable 1:\", var1)\n",
    "print(\"Variable 2:\", var2)\n",
    "print(\"Variable 3:\", var3)\n",
    "print(\"Variable 4:\", var4)\n",
    "print(\"Variable 5:\", var5)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f85589f9",
   "metadata": {},
   "source": [
    "### Write a Python program to check whether an element exists within a tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "84d3d847",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_tuple = (1, 2, 3, 4, 5)\n",
    "\n",
    "element_to_check = 3\n",
    "\n",
    "if element_to_check in my_tuple:\n",
    "    print(element_to_check, \"exists in the tuple.\")\n",
    "else:\n",
    "    print(element_to_check, \"does not exist in the tuple.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9fdf431",
   "metadata": {},
   "source": [
    "### Write a Python program to convert a list to a tuple. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "55b39659",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List: [1, 2, 3, 4, 5]\n",
      "Tuple: (1, 2, 3, 4, 5)\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, 2, 3, 4, 5]\n",
    "\n",
    "my_tuple = tuple(my_list)\n",
    "\n",
    "print(\"List:\", my_list)\n",
    "print(\"Tuple:\", my_tuple)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b882e05",
   "metadata": {},
   "source": [
    "### Write a Python program to find the repeated items of a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "9b81129e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Repeated Items: [2, 4]\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (1, 2, 2, 3, 4, 4, 5)\n",
    "\n",
    "repeated_items = []\n",
    "\n",
    "for item in my_tuple:\n",
    "\n",
    "    if my_tuple.count(item) > 1 and item not in repeated_items:\n",
    "        repeated_items.append(item)\n",
    "\n",
    "print(\"Repeated Items:\", repeated_items)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4b253d1",
   "metadata": {},
   "source": [
    "###  Write a Python program to remove an empty tuple(s) from a list of tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b573974",
   "metadata": {},
   "outputs": [],
   "source": [
    "list_of_tuples = [(1, 2), (), (3, 4), (), (), (5, 6)]\n",
    "\n",
    "filtered_list = []\n",
    "\n",
    "for tup in list_of_tuples:\n",
    "    if len(tup) > 0:\n",
    "        filtered_list.append(tup)\n",
    "\n",
    "print(\"List after removing empty tuples:\", filtered_list)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4b2114c",
   "metadata": {},
   "source": [
    "### Write a Python program to unzip a list of tuples into individual lists. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1b624da0",
   "metadata": {},
   "outputs": [],
   "source": [
    "list_of_tuples = [(1, 'a'), (2, 'b'), (3, 'c')]\n",
    "\n",
    "unzipped_lists = list(zip(*list_of_tuples))\n",
    "\n",
    "for i, lst in enumerate(unzipped_lists, start=1):\n",
    "    print(f\"List {i}: {lst}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6c16416",
   "metadata": {},
   "source": [
    "### Write a Python function to check whether a number is in a given range"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5c2e1e91",
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_number_in_range(number, start, end):\n",
    "\n",
    "    return start <= number <= end\n",
    "\n",
    "\n",
    "number_to_check = 5\n",
    "start_range = 1\n",
    "end_range = 10\n",
    "\n",
    "if is_number_in_range(number_to_check, start_range, end_range):\n",
    "    print(f\"{number_to_check} is in the range [{start_range}, {end_range}]\")\n",
    "else:\n",
    "    print(f\"{number_to_check} is NOT in the range [{start_range}, {end_range}]\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca38d306",
   "metadata": {},
   "source": [
    "### Write a Python function that checks whether a passed string is palindrome or not "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "e20061fb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "racecar is a palindrome.\n",
      "hello is not a palindrome.\n",
      "A man a plan a canal Panama is a palindrome.\n"
     ]
    }
   ],
   "source": [
    "def is_palindrome(input_string):\n",
    "    cleaned_string = input_string.replace(\" \", \"\").lower()\n",
    "   \n",
    "    return cleaned_string == cleaned_string[::-1]\n",
    "\n",
    "test_string1 = \"racecar\"\n",
    "test_string2 = \"hello\"\n",
    "test_string3 = \"A man a plan a canal Panama\"\n",
    "\n",
    "if is_palindrome(test_string1):\n",
    "    print(f\"{test_string1} is a palindrome.\")\n",
    "else:\n",
    "    print(f\"{test_string1} is not a palindrome.\")\n",
    "\n",
    "if is_palindrome(test_string2):\n",
    "    print(f\"{test_string2} is a palindrome.\")\n",
    "else:\n",
    "    print(f\"{test_string2} is not a palindrome.\")\n",
    "\n",
    "if is_palindrome(test_string3):\n",
    "    print(f\"{test_string3} is a palindrome.\")\n",
    "else:\n",
    "    print(f\"{test_string3} is not a palindrome.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19e7c4e5",
   "metadata": {},
   "source": [
    "### Write a Python program to returns sum of all divisors of a number "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5fd0d815",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sum_of_divisors(number):\n",
    "\n",
    "    divisors_sum = 0\n",
    "    \n",
    "    \n",
    "    for i in range(1, number + 1):\n",
    "        \n",
    "        if number % i == 0:\n",
    "            divisors_sum += i  \n",
    "    \n",
    "    return divisors_sum\n",
    "\n",
    "input_number = 12\n",
    "result = sum_of_divisors(input_number)\n",
    "print(f\"Sum of divisors of {input_number} is {result}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e64676e6",
   "metadata": {},
   "source": [
    "### Write a Python program to find the maximum and minimum numbers from the specified decimal numbers. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "119282e9",
   "metadata": {},
   "outputs": [],
   "source": [
    "decimal_numbers = [3.14, 2.71, 1.618, 0.577, 4.669]\n",
    "\n",
    "maximum_number = max(decimal_numbers)\n",
    "minimum_number = min(decimal_numbers)\n",
    "\n",
    "print(\"Maximum Number:\", maximum_number)\n",
    "print(\"Minimum Number:\", minimum_number)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "afc120de",
   "metadata": {},
   "source": [
    "### Write a Python program to calculate the area of a parallelogram "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0d4e61b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "base = float(input(\"Enter the base of the parallelogram: \"))\n",
    "height = float(input(\"Enter the height of the parallelogram: \"))\n",
    "\n",
    "area = base * height\n",
    "\n",
    "print(f\"The area of the parallelogram is {area}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23ab496f",
   "metadata": {},
   "source": [
    "### Write a Python function to check whether a number is perfect or not. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2d7e8da7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_perfect_number(number):\n",
    "    if number <= 0:\n",
    "        return False\n",
    "    \n",
    "    divisors_sum = 0\n",
    "    \n",
    "    for i in range(1, number):\n",
    "        if number % i == 0:\n",
    "            divisors_sum += i\n",
    "            \n",
    "    return divisors_sum == number\n",
    "\n",
    "test_number = 28  \n",
    "result = is_perfect_number(test_number)\n",
    "\n",
    "if result:\n",
    "    print(f\"{test_number} is a perfect number.\")\n",
    "else:\n",
    "    print(f\"{test_number} is not a perfect number.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e41e219",
   "metadata": {},
   "source": [
    "### Write a Python program to convert degree to radian"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "87fb8406",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the degree value: 5\n",
      "5.0 degrees is equal to 0.08726646259971647 radians\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "degrees = float(input(\"Enter the degree value: \"))\n",
    "\n",
    "radians = degrees * (math.pi / 180)\n",
    "\n",
    "print(f\"{degrees} degrees is equal to {radians} radians\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "368bba70",
   "metadata": {},
   "source": [
    "###  Write a Python program to calculate the area of a trapezoid "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "34ef44e0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the length of the first base (a): 5\n",
      "Enter the length of the second base (b): 5\n",
      "Enter the height (h): 8\n",
      "The area of the trapezoid is 40.0\n"
     ]
    }
   ],
   "source": [
    "a = float(input(\"Enter the length of the first base (a): \"))\n",
    "b = float(input(\"Enter the length of the second base (b): \"))\n",
    "h = float(input(\"Enter the height (h): \"))\n",
    "\n",
    "area = ((a + b) / 2) * h\n",
    "\n",
    "\n",
    "print(f\"The area of the trapezoid is {area}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8bf811b7",
   "metadata": {},
   "source": [
    "## Write a Python program to calculate surface volume and area of a cylinder "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "f5fc9dfb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the radius of the cylinder (r): 2\n",
      "Enter the height of the cylinder (h): 9\n",
      "Surface Area of the Cylinder: 138.23007675795088\n",
      "Volume of the Cylinder: 113.09733552923255\n",
      "Lateral Surface Area of the Cylinder: 113.09733552923255\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "r = float(input(\"Enter the radius of the cylinder (r): \"))\n",
    "h = float(input(\"Enter the height of the cylinder (h): \"))\n",
    "\n",
    "\n",
    "surface_area = 2 * math.pi * r * h + 2 * math.pi * r**2\n",
    "\n",
    "volume = math.pi * r**2 * h\n",
    "\n",
    "\n",
    "lateral_surface_area = 2 * math.pi * r * h\n",
    "\n",
    "print(f\"Surface Area of the Cylinder: {surface_area}\")\n",
    "print(f\"Volume of the Cylinder: {volume}\")\n",
    "print(f\"Lateral Surface Area of the Cylinder: {lateral_surface_area}\")\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "28cae912",
   "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.11.3"
  },
  "vscode": {
   "interpreter": {
    "hash": "5ae58900cfbb8c43ab3495913814b7cf26024f51651a94ce8bf64d6111688e8d"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}